

Para recursos semelhantes aos do Amazon Timestream para, considere o Amazon Timestream LiveAnalytics para InfluxDB. Ele oferece ingestão de dados simplificada e tempos de resposta de consulta de um dígito em milissegundos para análises em tempo real. Saiba mais [aqui](https://docs.aws.amazon.com//timestream/latest/developerguide/timestream-for-influxdb.html).

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Suporte a SQL
<a name="supported-sql-constructs"></a>

O Timestream for LiveAnalytics suporta algumas construções SQL comuns. Você pode ler mais abaixo.

**Topics**
+ [

# SELECT
](supported-sql-constructs.SELECT.md)
+ [

# Suporte de subconsultas
](supported-sql-constructs.subquery-support.md)
+ [

# Declaração SHOW
](supported-sql-constructs.SHOW.md)
+ [

# Declarações DESCRIBE
](supported-sql-constructs.DESCRIBE.md)
+ [

# UNLOAD
](supported-sql-constructs.UNLOAD.md)

# SELECT
<a name="supported-sql-constructs.SELECT"></a>

As declarações **SELECT** podem ser usadas para recuperar dados de uma ou mais tabelas. A linguagem de consulta do Timestream suporta a seguinte sintaxe para declarações **SELECT**:

```
[ WITH with_query [, ...] ]
            SELECT [ ALL | DISTINCT ] select_expr [, ...]
            [ function (expression) OVER (
            [ PARTITION BY partition_expr_list ]
            [ ORDER BY order_list ]
            [ frame_clause ] )
            [ FROM from_item [, ...] ]
            [ WHERE condition ]
            [ GROUP BY [ ALL | DISTINCT ] grouping_element [, ...] ]
            [ HAVING condition]
            [ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ]
            [ ORDER BY order_list ]
            [ LIMIT [ count | ALL ] ]
```

para onde 
+ `function (expression)` é uma das [funções de janela](window-functions.md) suportadas.
+ `partition_expr_list` é:

  ```
  expression | column_name [, expr_list ]
  ```
+ `order_list` é:

  ```
  expression | column_name [ ASC | DESC ] 
  [ NULLS FIRST | NULLS LAST ]
  [, order_list ]
  ```
+ `frame_clause` é:

  ```
  ROWS | RANGE
  { UNBOUNDED PRECEDING | expression PRECEDING | CURRENT ROW } |
  {BETWEEN
  { UNBOUNDED PRECEDING | expression { PRECEDING | FOLLOWING } |
  CURRENT ROW}
  AND
  { UNBOUNDED FOLLOWING | expression { PRECEDING | FOLLOWING } |
  CURRENT ROW }}
  ```
+ `from_item` é um dos seguintes:

  ```
  table_name [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
  from_item join_type from_item [ ON join_condition | USING ( join_column [, ...] ) ]
  ```
+ `join_type` é um dos seguintes:

  ```
  [ INNER ] JOIN
  LEFT [ OUTER ] JOIN
  RIGHT [ OUTER ] JOIN
  FULL [ OUTER ] JOIN
  ```
+ `grouping_element` é um dos seguintes:

  ```
  ()
  expression
  ```

# Suporte de subconsultas
<a name="supported-sql-constructs.subquery-support"></a>

 O Timestream suporta subconsultas no `EXISTS` e em predicados `IN`. O predicado `EXISTS` determina se uma subconsulta retorna alguma linha. O predicado `IN` determina se os valores produzidos pela subconsulta correspondem aos valores ou à expressão da cláusula IN. A linguagem de consulta do Timestream oferece suporte a subconsultas correlacionadas e outras. 

```
SELECT t.c1
FROM (VALUES 1, 2, 3, 4, 5) AS t(c1)
WHERE EXISTS
(SELECT t.c2
 FROM (VALUES 1, 2, 3) AS t(c2)
 WHERE t.c1= t.c2
)
ORDER BY t.c1
```


| c1 | 
| --- | 
|  1  | 
|  2  | 
|  3  | 

```
SELECT t.c1
FROM (VALUES 1, 2, 3, 4, 5) AS t(c1)
WHERE t.c1 IN
(SELECT t.c2
 FROM (VALUES 2, 3, 4) AS t(c2)
)
ORDER BY t.c1
```


| c1 | 
| --- | 
|  2  | 
|  3  | 
|  4  | 

# Declaração SHOW
<a name="supported-sql-constructs.SHOW"></a>

Você pode visualizar todos os bancos de dados em uma conta usando a declaração `SHOW DATABASES`. A sintaxe é a seguinte:

```
SHOW DATABASES [LIKE pattern]
```

onde a cláusula `LIKE` pode ser usada para filtrar nomes de bancos de dados.

Você pode ver todas as tabelas em uma conta usando a declaração `SHOW TABLES`. A sintaxe é a seguinte:

```
SHOW TABLES [FROM database] [LIKE pattern]
```

onde a `FROM` cláusula pode ser usada para filtrar nomes de bancos de dados e a cláusula `LIKE` pode ser usada para filtrar nomes de tabelas.

Você pode visualizar todas as medidas de uma tabela usando a declaração `SHOW MEASURES`. A sintaxe é a seguinte:

```
SHOW MEASURES FROM database.table [LIKE pattern]
```

onde a cláusula `FROM` será usada para especificar o nome do banco de dados e da tabela e a cláusula `LIKE` poderá ser usada para filtrar nomes de medidas.

# Declarações DESCRIBE
<a name="supported-sql-constructs.DESCRIBE"></a>

Você pode visualizar os metadados de uma tabela usando a declaração `DESCRIBE`. A sintaxe é a seguinte:

```
DESCRIBE database.table
```

onde `table` contém o nome da tabela. A declaração describe retorna os nomes das colunas e os tipos de dados da tabela.

# UNLOAD
<a name="supported-sql-constructs.UNLOAD"></a>

O Timestream for LiveAnalytics suporta um `UNLOAD` comando como uma extensão de seu suporte a SQL. Os tipos de dados suportados pelo `UNLOAD` estão descritos em [Tipos de dados compatíveis](supported-data-types.md). Os tipos `time` e `unknown` não se aplicam ao `UNLOAD`.

```
UNLOAD (SELECT statement)
 TO 's3://bucket-name/folder'
 WITH ( option = expression [, ...] )
```

onde a opção é

```
{ partitioned_by = ARRAY[ col_name[,…] ] 
 | format = [ '{ CSV | PARQUET }' ] 
 | compression = [ '{ GZIP | NONE }' ]
 | encryption = [ '{ SSE_KMS | SSE_S3 }' ]
 | kms_key = '<string>'
 | field_delimiter ='<character>'
 | escaped_by = '<character>'
 | include_header = ['{true, false}']
 | max_file_size = '<value>'
}
```

Instrução SELECT  
A instrução de consulta usada para selecionar e recuperar dados de um ou mais Timestream para tabelas. LiveAnalytics   

```
(SELECT column 1, column 2, column 3 from database.table
      where measure_name = "ABC" and timestamp between ago (1d) and now() )
```

Cláusula TO  

```
TO 's3://bucket-name/folder'
```
or  

```
TO 's3://access-point-alias/folder'
```
A cláusula `TO` na instrução `UNLOAD` especifica o destino para a saída dos resultados da consulta. Você precisa fornecer o caminho completo, incluindo o nome do bucket do Amazon S3 ou o Amazon S3 com a access-point-alias localização da pasta no Amazon S3, onde o Timestream grava os objetos do arquivo de saída. LiveAnalytics O bucket do S3 deve ser de propriedade da mesma conta e da mesma região. Além do conjunto de resultados da consulta, o Timestream for LiveAnalytics grava os arquivos de manifesto e metadados na pasta de destino especificada. 

Cláusula PARTITIONED\$1BY  

```
partitioned_by = ARRAY [col_name[,…] , (default: none)
```
A cláusula `partitioned_by` é usada em consultas para agrupar e analisar dados em um nível granular. Ao exportar os resultados da consulta para o bucket do S3, você pode optar por particionar os dados com base em uma ou mais colunas na consulta selecionada. Ao particionar os dados, os dados exportados são divididos em subconjuntos com base na coluna de partição e cada subconjunto é armazenado em uma pasta separada. Na pasta de resultados que contém os dados exportados, uma subpasta `folder/results/partition column = partition value/` é criada automaticamente. No entanto, observe que as colunas particionadas não estão incluídas no arquivo de saída.   
`partitioned_by` não é uma cláusula obrigatória na sintaxe. Se você optar por exportar os dados sem nenhum particionamento, poderá excluir a cláusula na sintaxe.   

**Example**  
Supondo que você esteja monitorando os dados do fluxo de cliques do seu site e tenha 5 canais de tráfego, que seriam `direct`, `Social Media`, `Organic Search`, `Other` e `Referral`. Ao exportar os dados, você pode optar por particioná-los usando a coluna `Channel`. Em sua pasta de dados `s3://bucketname/results` você terá cinco pastas, cada uma com o nome do respectivo canal. Por exemplo, `s3://bucketname/results/channel=Social Media/.`. Nessa pasta, você encontrará os dados de todos os clientes que acessaram seu site por meio do canal `Social Media`. Da mesma forma, você terá outras pastas para os canais restantes.
Dados exportados particionados pela coluna Canal  

![\[Folder structure showing channels: Direct, Organic search, Other, Referral, and Social media.\]](http://docs.aws.amazon.com/pt_br/timestream/latest/developerguide/images/unload-results.png)


FORMAT  

```
format = [ '{ CSV | PARQUET }' , default: CSV
```
As palavras-chave para especificar o formato dos resultados da consulta gravados em seu bucket do S3. Você pode exportar os dados como um valor separado por vírgula (CSV) usando uma vírgula (,) como delimitador padrão ou no formato Apache Parquet, um formato de armazenamento em colunas abertas eficiente para análise. 

COMPRESSION  

```
compression = [ '{ GZIP | NONE }' ], default: GZIP
```
Você pode compactar os dados exportados usando o algoritmo de compactação GZIP ou descompactá-los especificando a opção `NONE`.

ENCRYPTION  

```
encryption = [ '{ SSE_KMS | SSE_S3 }' ], default: SSE_S3
```
Os arquivos de saída no Amazon S3 são criptografados usando a opção de criptografia selecionada. Além dos seus dados, os arquivos de manifesto e metadados também são criptografados com base na opção de criptografia selecionada. Atualmente, oferecemos suporte à criptografia SSE\$1S3 e SSE\$1KMS. O SSE\$1S3 é uma criptografia do lado do servidor com o Amazon S3 criptografando os dados usando criptografia padrão de criptografia avançada (AES) de 256 bits. O SSE\$1KMS é uma criptografia do lado do servidor para criptografar dados usando chaves gerenciadas pelo cliente.

KMS\$1KEY  

```
kms_key = '<string>'
```
A chave KMS é uma chave definida pelo cliente para criptografar os resultados da consulta exportada. A chave KMS é gerenciada com segurança pelo AWS Key Management Service (AWS KMS) e usada para criptografar arquivos de dados no Amazon S3.

FIELD\$1DELIMITER  

```
field_delimiter ='<character>' , default: (,)
```
Ao exportar dados no formato CSV, este campo especifica o único caractere ASCII usado para separar campos no arquivo de saída, como um caractere de barra vertical (\$1), uma vírgula (,) ou uma tabulação (\$1t). O delimitador padrão para arquivos CSV é uma vírgula. Se um valor em seus dados contiver o delimitador escolhido, o delimitador será citado com um caractere de aspa. Por exemplo, se o valor em seus dados contiver `Time,stream`, esse valor será cotado como `"Time,stream"` nos dados exportados. O caractere de aspas usado pelo Timestream para LiveAnalytics são aspas duplas (“).  
Evite especificar o caractere de retorno do carro (ASCII 13, hexadecimal `0D`, texto '\$1r') ou o caractere de quebra de linha (ASCII 10, hexadecimal 0A, texto '\$1n') como `FIELD_DELIMITER` se você quiser incluir cabeçalhos no CSV, pois isso impedirá que muitos analisadores consigam analisar os cabeçalhos corretamente na saída CSV resultante.

ESCAPED\$1BY  

```
escaped_by = '<character>', default: (\)
```
Ao exportar os dados no formato CSV, esse campo especifica o caractere que deve ser tratado como um caractere de escape no arquivo de dados gravado no bucket do S3. O escape acontece nos seguintes cenários:  

1. Se o valor em si contiver o caractere de aspa (“), ele será escapado usando um caractere de escape. Por exemplo, se o valor for `Time"stream`, onde (\$1) é o caractere de escape configurado, ele será escapado como `Time\"stream`. 

1. Se o valor contiver o caractere de escape configurado, ele será escapado. Por exemplo, se o valor for `Time\stream`, ele será escapado como `Time\\stream`. 
Se a saída exportada contiver tipos de dados complexos, como matrizes, linhas ou séries temporais, ela será serializada como uma string JSON. Veja um exemplo a seguir.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/timestream/latest/developerguide/supported-sql-constructs.UNLOAD.html)

INCLUDE\$1HEADER  

```
include_header = 'true' , default: 'false'
```
Ao exportar os dados no formato CSV, esse campo permite incluir nomes de colunas como a primeira linha dos arquivos de dados CSV exportados.  
Os valores aceitos são 'true' e 'false' e o valor padrão é 'false'. Opções de transformação de texto, como `escaped_by` e `field_delimiter`, também se aplicam aos cabeçalhos.  
Ao incluir cabeçalhos, é importante que você não selecione um caractere de retorno de carro (ASCII 13, hexadecimal 0D, texto '\$1r') ou um caractere de quebra de linha (ASCII 10, hexadecimal 0A, texto '\$1n') como o `FIELD_DELIMITER`, pois isso impedirá que muitos analisadores consigam analisar os cabeçalhos corretamente na saída CSV resultante.

MAX\$1FILE\$1SIZE  

```
max_file_size = 'X[MB|GB]' , default: '78GB'
```
Esse campo especifica o tamanho máximo dos arquivos que a declaração `UNLOAD` cria no Amazon S3. A declaração `UNLOAD` pode criar vários arquivos, mas o tamanho máximo de cada arquivo gravado no Amazon S3 será aproximadamente o especificado nesse campo.  
O valor do campo deve ser de 16 MB a 78 GB, inclusive. Isso pode ser especificado em números inteiros como `12GB`, ou em decimais como `0.5GB` ou `24.7MB`. O valor padrão é 78 GB.  
O tamanho real do arquivo é aproximado quando o arquivo está sendo gravado, então o tamanho máximo real pode não ser exatamente igual ao número especificado.