`
Se for consultar o Amazon S3 ou o Security Lake, use: `SELECT Body , Operation FROM table_name`
Se você estiver consultando CloudWatch registros, use: `SELECT Body , Operation FROM `LogGroupA``
| Command | Description | CloudWatch Registros | Amazon S3 | Lago de Segurança | Exemplo de comando da |
| --- | --- | --- | --- | --- | --- |
| [Cláusula SELECT](#supported-sql-select) | Exibe os valores projetados. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
method,
status
FROM
|
| [Cláusula WHERE](#supported-sql-where) | Filtra eventos de log com base nos critérios de campo fornecidos. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
*
FROM
WHERE
status = 100
|
| [Cláusula GROUP BY](#supported-sql-group-by) | Agrupa eventos de log com base na categoria e encontra a média com base nas estatísticas. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
method,
status,
COUNT(*) AS request_count,
SUM(bytes) AS total_bytes
FROM
GROUP BY
method,
status
|
| [Cláusula HAVING](#supported-sql-having) | Filtra os resultados com base em condições de agrupamento. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
method,
status,
COUNT(*) AS request_count,
SUM(bytes) AS total_bytes
FROM
GROUP BY
method,
status
HAVING
COUNT(*) > 5
|
| [Cláusula ORDER BY](#supported-sql-order-by) | Ordena os resultados com base em campos da cláusula de classificação. É possível classificar em ordem crescente ou decrescente. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
*
FROM
ORDER BY
status DESC
|
| [Cláusula JOIN](#supported-sql-join) ( `INNER` \$1 `CROSS` \$1 `LEFT` `OUTER` ) | Une os resultados de duas tabelas com base em campos comuns. | Compatível com ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) (é necessário usar as palavras-chave `Inner` e `Left Outer` para união. Apenas uma operação JOIN é aceita em uma instrução SELECT) | Compatível com ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) (é necessário usar as palavras-chave Inner, Left Outer e Cross para unir) | Compatível com ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) (é necessário usar as palavras-chave Inner, Left Outer e Cross para unir) | SELECT
A.Body,
B.Timestamp
FROM
AS A
INNER JOIN
AS B
ON A.`requestId` = B.`requestId`
|
| [Cláusula LIMIT](#supported-sql-limit) | Restringe os resultados às primeiras N linhas. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
*
FROM
LIMIT
10
|
| [Cláusula CASE](#supported-sql-case) | Avalia as condições e retorna um valor quando a primeira condição é atendida. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
method,
status,
CASE
WHEN status BETWEEN 100 AND 199 THEN 'Informational'
WHEN status BETWEEN 200 AND 299 THEN 'Success'
WHEN status BETWEEN 300 AND 399 THEN 'Redirection'
WHEN status BETWEEN 400 AND 499 THEN 'Client Error'
WHEN status BETWEEN 500 AND 599 THEN 'Server Error'
ELSE 'Unknown Status'
END AS status_category,
CASE method
WHEN 'GET' THEN 'Read Operation'
WHEN 'POST' THEN 'Create Operation'
WHEN 'PUT' THEN 'Update Operation'
WHEN 'PATCH' THEN 'Partial Update Operation'
WHEN 'DELETE' THEN 'Delete Operation'
ELSE 'Other Operation'
END AS operation_type,
bytes,
datetime
FROM
|
| [Expressão de tabela comum](#supported-sql-cte) | Cria um conjunto de resultados temporário nomeados em uma instrução SELECT, INSERT, UPDATE, DELETE ou MERGE. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/negative_icon.svg) não compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | WITH RequestStats AS (
SELECT
method,
status,
bytes,
COUNT(*) AS request_count
FROM
tableName
GROUP BY
method,
status,
bytes
)
SELECT
method,
status,
bytes,
request_count
FROM
RequestStats
WHERE
bytes > 1000
|
| [EXPLAIN](#supported-sql-explain) | Exibe o plano de execução de uma instrução SQL sem executá-la de fato. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/negative_icon.svg) não compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | EXPLAIN
SELECT
k,
SUM(v)
FROM
VALUES
(1, 2),
(1, 3) AS t(k, v)
GROUP BY
k
|
| [Cláusula LATERAL SUBQUERY](#supported-sql-lateral-subquery) | Permite que uma subconsulta na cláusula FROM referencie colunas de itens precedentes na mesma cláusula FROM. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/negative_icon.svg) não compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
*
FROM
tableName
LATERAL (
SELECT
*
FROM
t2
WHERE
t1.c1 = t2.c1
)
|
| [Cláusula LATERAL VIEW](#supported-sql-lateral-view) | Gera uma tabela virtual aplicando uma função geradora de tabela a cada linha de uma tabela básica. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/negative_icon.svg) não compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
*
FROM
tableName
LATERAL VIEW
EXPLODE(ARRAY(30, 60)) tableName AS c_age
LATERAL VIEW
EXPLODE(ARRAY(40, 80)) AS d_age
|
| [Predicado LIKE](#supported-sql-like-predicate) | Compara uma string com um padrão usando caracteres curinga. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
method,
status,
request,
host
FROM
WHERE
method LIKE 'D%'
|
| [OFFSET](#supported-sql-offset) | Especifica o número de linhas a serem ignoradas antes de começar a retornar as linhas da consulta. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível quando usado em conjunto com uma cláusula LIMIT em uma consulta. Por exemplo:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/supported-directquery-sql.html) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
method,
status,
bytes,
datetime
FROM
ORDER BY
datetime
OFFSET
10
|
| [Cláusula PIVOT](#supported-sql-pivot) | Transforma linhas em colunas, girando os dados de um formato baseado em linhas para um formato baseado em colunas. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/negative_icon.svg) não compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
*
FROM
(
SELECT
method,
status,
bytes
FROM
) AS SourceTable
PIVOT
(
SUM(bytes)
FOR method IN ('GET', 'POST', 'PATCH', 'PUT', 'DELETE')
) AS PivotTable
|
| [Configurar operadores](#supported-sql-set) | Combina os resultados de duas ou mais instruções SELECT (por exemplo, UNION, INTERSECT, EXCEPT). | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
method,
status,
bytes
FROM
WHERE
status = '416'
UNION
SELECT
method,
status,
bytes
FROM
WHERE
bytes > 20000
|
| [Cláusula SORT BY](#supported-sql-sort-by) | Especifica a ordem em que os resultados da consulta devem ser retornados. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
method,
status,
bytes
FROM
SORT BY
bytes DESC
|
| [UNPIVOT](#supported-sql-unpivot) | Transforma colunas em linhas, girando dados de um formato baseado em colunas para um formato baseado em linhas. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/negative_icon.svg) não compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
status,
REPLACE(method, '_bytes', '') AS request_method,
bytes,
datetime
FROM
PivotedData
UNPIVOT
(
bytes
FOR method IN
(
GET_bytes,
POST_bytes,
PATCH_bytes,
PUT_bytes,
DELETE_bytes
)
) AS UnpivotedData
|
## Funções
**nota**
No exemplo de coluna de comandos, substitua `` conforme necessário, dependendo da fonte de dados que você for consultar.
Exemplo de comando: `SELECT Body , Operation FROM `
Se for consultar o Amazon S3 ou o Security Lake, use: `SELECT Body , Operation FROM table_name`
Se você estiver consultando CloudWatch registros, use: `SELECT Body , Operation FROM `LogGroupA``
| Gramática SQL disponível | Description | CloudWatch Registros | Amazon S3 | Lago de Segurança | Exemplo de comando da |
| --- | --- | --- | --- | --- | --- |
| [Funções de string](#supported-sql-string) | Funções integradas SQL que podem manipular e transformar dados em string e texto em consultas SQL. Por exemplo, converter maiúsculas e minúsculas, combinar strings, extrair partes e apagar texto. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
UPPER(method) AS upper_method,
LOWER(host) AS lower_host
FROM
|
| [Perfis de data e hora](#supported-sql-date-time) | Funções integradas para tratar e transformar dados de data e timestamp em consultas. Por exemplo, **date\$1add**, **date\$1format**, **datediff** e **current\$1date**. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
TO_TIMESTAMP(datetime) AS timestamp,
TIMESTAMP_SECONDS(UNIX_TIMESTAMP(datetime)) AS from_seconds,
UNIX_TIMESTAMP(datetime) AS to_unix,
FROM_UTC_TIMESTAMP(datetime, 'PST') AS to_pst,
TO_UTC_TIMESTAMP(datetime, 'EST') AS from_est
FROM
|
| [Funções agregadas](#supported-sql-aggregate) | Funções integradas que realizam cálculos em várias linhas para produzir um único valor resumido. Por exemplo: **sum**, **count**, **avg**, **max** e **min**. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg)Suportado | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
COUNT(*) AS total_records,
COUNT(DISTINCT method) AS unique_methods,
SUM(bytes) AS total_bytes,
AVG(bytes) AS avg_bytes,
MIN(bytes) AS min_bytes,
MAX(bytes) AS max_bytes
FROM
|
| [Funções condicionais](#supported-sql-conditional) | Funções integradas que realizam ações com base em condições especificadas ou que avaliam expressões condicionalmente. Por exemplo: **CASE** e **IF**. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
CASE
WHEN method = 'GET' AND bytes < 1000 THEN 'Small Read'
WHEN method = 'POST' AND bytes > 10000 THEN 'Large Write'
WHEN status >= 400 OR bytes = 0 THEN 'Problem'
ELSE 'Normal'
END AS request_type
FROM
|
| [Funções JSON](#supported-sql-json) | Funções integradas para analisar, extrair, modificar e consultar dados formatados em JSON em consultas SQL (por exemplo, from\$1json, to\$1json, get\$1json\$1object, json\$1tuple), permitindo a manipulação de estruturas JSON em conjuntos de dados. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
FROM_JSON(
@message,
'STRUCT<
host: STRING,
user-identifier: STRING,
datetime: STRING,
method: STRING,
status: INT,
bytes: INT
>'
) AS parsed_json
FROM
|
| [Funções de array](#supported-sql-array) | Funções integradas para trabalhar com colunas do tipo array em consultas SQL, permitindo operações como acessar, modificar e analisar dados matriciais (por exemplo, size, explode, array\$1contains). | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
scores,
size(scores) AS length,
array_contains(scores, 90) AS has_90
FROM
|
| [Funções de janela](#supported-sql-window) | Funções integradas que realizam cálculos em um conjunto específico de linhas relacionadas à linha atual (janela), permitindo operações como classificação, totalização e médias móveis (por exemplo, ROW\$1NUMBER, RANK, LAG, LEAD) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
field1,
field2,
RANK() OVER (ORDER BY field2 DESC) AS field2Rank
FROM
|
| [Funções de conversão](#supported-sql-conversion) | Funções integradas para converter dados de um tipo para outro em consultas SQL, permitindo transformações de tipos de dados e conversões de formato (por exemplo, CAST, TO\$1DATE, TO\$1TIMESTAMP, BINARY) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
CAST('123' AS INT) AS converted_number,
CAST(123 AS STRING) AS converted_string
FROM
|
| [Funções de predicado](#supported-sql-predicate) | Funções integradas que avaliam condições e retornam valores booleanos (verdadeiro/falso) com base em critérios ou padrões especificados (por exemplo, IN, LIKE, BETWEEN, IS NULL, EXISTS) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
*
FROM
WHERE
id BETWEEN 50000 AND 75000
|
| [Funções de mapa](#supported-sql-map) | Aplica uma função específica a cada elemento de um conjunto, transformando os dados em um novo conjunto de valores. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/negative_icon.svg) não compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
MAP_FILTER(
MAP(
'method', method,
'status', CAST(status AS STRING),
'bytes', CAST(bytes AS STRING)
),
(k, v) -> k IN ('method', 'status') AND v != 'null'
) AS filtered_map
FROM
WHERE
status = 100
|
| [Funções matemáticas](#supported-sql-math) | Executa operações matemáticas em dados numéricos, como calcular médias, somas ou valores trigonométricos. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
bytes,
bytes + 1000 AS added,
bytes - 1000 AS subtracted,
bytes * 2 AS doubled,
bytes / 1024 AS kilobytes,
bytes % 1000 AS remainder
FROM
|
| [Funções de vários grupos de logs](#multi-log-queries) | Permite que os usuários especifiquem vários grupos de logs em uma instrução SQL SELECT | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | Não aplicável | Não aplicável | SELECT
lg1.Column1,
lg1.Column2
FROM
`logGroups(logGroupIdentifier: ['LogGroup1', 'LogGroup2'])` AS lg1
WHERE
lg1.Column3 = "Success"
|
| [Funções geradoras](#supported-sql-generator) | Cria um objeto iterador que gera uma sequência de valores, permitindo o uso eficiente da memória em grandes conjuntos de dados. | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/negative_icon.svg) não compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/success_icon.svg) compatível | SELECT
explode(array(10, 20))
|
## Restrições gerais do SQL
As restrições a seguir se aplicam ao usar OpenSearch SQL com CloudWatch Logs, Amazon S3 e Security Lake.
1. Você pode usar apenas um único JOIN em uma instrução SELECT.
1. Somente um nível de sub-consultas aninhadas é suportado.
1. Consultas com várias instruções separadas por ponto e vírgula não são compatíveis.
1. Consultas contendo nomes de campo idênticos, mas que diferem somente em maiúsculas e minúsculas (como field1 e FIELD1) não são suportadas.
Por exemplo, as seguintes consultas não são compatíveis:
```
Select AWSAccountId, awsaccountid from LogGroup
```
No entanto, a seguinte consulta é compatível porque o nome do campo (@logStream) é idêntico em ambos os grupos de logs:
```
Select a.`@logStream`, b.`@logStream` from Table A INNER Join Table B on a.id = b.id
```
1. Funções e expressões devem operar em nomes de campo e fazer parte de uma instrução SELECT com um grupo de logs especificado na cláusula FROM.
Por exemplo, esta consulta não é compatível:
```
SELECT cos(10) FROM LogGroup
```
Esta consulta é compatível:
```
SELECT cos(field1) FROM LogGroup
```
## Informações adicionais para usuários do CloudWatch Logs Insights que usam OpenSearch SQL
CloudWatch O Logs oferece suporte a consultas OpenSearch SQL no console, na API e na CLI do Logs Insights. Ele é compatível com a maioria dos comandos, incluindo SELECT, FROM, WHERE, GROUP BY, HAVING, JOINS e consultas aninhadas, além de funções JSON, matemáticas, string e condicionais. No entanto, o CloudWatch Logs suporta somente operações de leitura, portanto, não permite instruções DDL ou DML. Consulte as tabelas das seções anteriores para obter uma lista completa dos comandos e funções compatíveis.
### Funções de vários grupos de logs
CloudWatch O Logs Insights oferece suporte à capacidade de consultar vários grupos de registros. Para lidar com esse caso de uso no SQL, você pode usar o comando `logGroups`. Esse comando é específico para consultar dados no CloudWatch Logs Insights envolvendo um ou mais grupos de registros. Use essa sintaxe para consultar vários grupos de logs especificando-os no comando, em vez de escrever uma consulta para cada grupo de logs e combiná-los com um comando `UNION`.
Sintaxe:
```
`logGroups(
logGroupIdentifier: ['LogGroup1','LogGroup2', ...'LogGroupn']
)
```
Nessa sintaxe, é possível especificar até 50 grupos de logs no parâmetro `logGroupIndentifier`. Para referenciar grupos de registros em uma conta de monitoramento, use ARNs em vez de `LogGroup` nomes.
Consulta de exemplo:
```
SELECT LG1.Column1, LG1.Column2 from `logGroups(
logGroupIdentifier: ['LogGroup1', 'LogGroup2']
)` as LG1
WHERE LG1.Column1 = 'ABC'
```
A sintaxe a seguir, envolvendo vários grupos de registros após a `FROM` declaração, não é compatível com a consulta CloudWatch de registros:
```
SELECT Column1, Column2 FROM 'LogGroup1', 'LogGroup2', ...'LogGroupn'
WHERE Column1 = 'ABC'
```
### Restrições
Ao usar comandos SQL ou PPL, coloque certos campos entre acentos graves para consultá-los. Acentos graves são obrigatórios em campos com caracteres especiais (não alfabéticos e não numéricos). Por exemplo, coloque `@message`, `Operation.Export,` e `Test::Field` entre acentos graves. Não é necessário colocar entre acentos graves campos com nomes puramente alfabéticos.
Exemplo de consulta com campos simples:
```
SELECT SessionToken, Operation, StartTime FROM `LogGroup-A`
LIMIT 1000;
```
Mesma consulta com acentos graves acrescentados:
```
SELECT `SessionToken`, `Operation`, `StartTime` FROM `LogGroup-A`
LIMIT 1000;
```
Para ver outras restrições gerais que não são específicas CloudWatch dos registros, consulte[Restrições gerais do SQL](#general-sql-restrictions).
### Exemplos de consultas e cotas
**nota**
O seguinte se aplica tanto aos usuários do CloudWatch Logs Insights quanto OpenSearch aos usuários que consultam CloudWatch dados.
Para exemplos de consultas SQL que você pode usar em CloudWatch Logs, consulte **Consultas salvas e amostras** no console Amazon CloudWatch Logs Insights para ver exemplos.
Para obter informações sobre os limites que se aplicam ao consultar CloudWatch registros do OpenSearch serviço, consulte [Cotas de CloudWatch registros no Guia](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html) do usuário do Amazon CloudWatch Logs. Os limites envolvem o número de grupos de CloudWatch registros que você pode consultar, o máximo de consultas simultâneas que você pode executar, o tempo máximo de execução da consulta e o número máximo de linhas retornadas nos resultados. Os limites são os mesmos, independentemente da linguagem usada para consultar CloudWatch os registros (ou seja, OpenSearch PPL, SQL e Logs Insights).
### Comandos SQL
**Topics**
+ [Funções de string](#supported-sql-string)
+ [Perfis de data e hora](#supported-sql-date-time)
+ [Funções agregadas](#supported-sql-aggregate)
+ [Funções condicionais](#supported-sql-conditional)
+ [Funções JSON](#supported-sql-json)
+ [Funções de array](#supported-sql-array)
+ [Funções de janela](#supported-sql-window)
+ [Funções de conversão](#supported-sql-conversion)
+ [Funções de predicado](#supported-sql-predicate)
+ [Funções de mapa](#supported-sql-map)
+ [Funções matemáticas](#supported-sql-math)
+ [Funções geradoras](#supported-sql-generator)
+ [Cláusula SELECT](#supported-sql-select)
+ [Cláusula WHERE](#supported-sql-where)
+ [Cláusula GROUP BY](#supported-sql-group-by)
+ [Cláusula HAVING](#supported-sql-having)
+ [Cláusula ORDER BY](#supported-sql-order-by)
+ [Cláusula JOIN](#supported-sql-join)
+ [Cláusula LIMIT](#supported-sql-limit)
+ [Cláusula CASE](#supported-sql-case)
+ [Expressão de tabela comum](#supported-sql-cte)
+ [EXPLAIN](#supported-sql-explain)
+ [Cláusula LATERAL SUBQUERY](#supported-sql-lateral-subquery)
+ [Cláusula LATERAL VIEW](#supported-sql-lateral-view)
+ [Predicado LIKE](#supported-sql-like-predicate)
+ [OFFSET](#supported-sql-offset)
+ [Cláusula PIVOT](#supported-sql-pivot)
+ [Configurar operadores](#supported-sql-set)
+ [Cláusula SORT BY](#supported-sql-sort-by)
+ [UNPIVOT](#supported-sql-unpivot)
#### Funções de string
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
****
| Função | Description |
| --- | --- |
| ascii(str) | Retorna o valor numérico do primeiro caractere de str. |
| base64(bin) | Converte o argumento de um binário bin em uma string de base 64. |
| bit\$1length(expr) | Retorna o comprimento em bits dos dados de string ou o número de bits de dados binários. |
| btrim(str) | Remove os caracteres de espaço antes e depois de str. |
| btrim(str, trimStr) | Remove os caracteres trimStr antes e depois de str. |
| char(expr) | Retorna o caractere ASCII com o binário equivalente a. expr Se n for maior do que 256, o resultado será equivalente a chr(n % 256) |
| char\$1length(expr) | Retorna o comprimento em caracteres dos dados de string ou o número de bits de dados binários. O comprimento dos dados de string inclui os espaços no fim. O comprimento dos dados binários inclui os zeros binários. |
| character\$1length(expr) | Retorna o comprimento em caracteres dos dados de string ou o número de bits de dados binários. O comprimento dos dados de string inclui os espaços no fim. O comprimento dos dados binários inclui os zeros binários. |
| chr(expr) | Retorna o caractere ASCII com o binário equivalente a. expr Se n for maior do que 256, o resultado será equivalente a chr(n % 256) |
| concat\$1ws(sep[, str \$1 array(str)]\$1) | Retorna a concatenação das strings separadas por sep, ignorando os valores nulos. |
| contains(left, right) | Retorna um booleano. O valor será Verdadeiro se direita estiver dentro de esquerda. Retornará NULL se uma das expressões de entrada for NULL. Caso contrário, retorna Falso. Tanto esquerda quanto direita devem ser do tipo STRING ou BINARY. |
| decode(bin, charset) | Decodifica o primeiro argumento usando o conjunto de caracteres do segundo argumento. |
| decode(expr, search, result [, search, result ] ... [, default]) | Compara expr a cada valor de pesquisa em ordem. Se expr for igual a um valor de pesquisa, decode retornará o resultado correspondente. Se nenhuma correspondência for encontrada, retornará o padrão. Se o padrão for omitido, retornará nulo. |
| elt(n, input1, input2, ...) | Retorna a enésima entrada, por exemplo, retorna input2 quando n é 2. |
| encode(str, charset) | Codifica o primeiro argumento usando o conjunto de caracteres do segundo argumento. |
| endswith(left, right) | Retorna um booleano. O valor será verdadeiro se esquerda terminar com direita. Retornará NULL se uma das expressões de entrada for NULL. Caso contrário, retorna Falso. Tanto esquerda quanto direita devem ser do tipo STRING ou BINARY. |
| find\$1in\$1set(str, str\$1array) | Retorna o índice (na base 1) da string fornecida (str) na lista delimitada por vírgula (str\$1array). Retornará 0, se a string não foi encontrada ou se a string fornecida (str) contiver uma vírgula. |
| format\$1number(expr1, expr2) | Formata o número expr1 como “\$1, \$1\$1\$1, \$1\$1\$1.\$1\$1”, arredondado para expr2 casas decimais. Se expr2 for 0, o resultado não terá ponto decimal ou parte fracionária. expr2 também aceitam um formato especificado pelo usuário. Deve funcionar como o FORMAT do MySQL. |
| format\$1string(strfmt, obj, ...) | Retorna uma string formatada a partir das strings com formato printf-style. |
| initcap(str) | Retorna str com a primeira letra de cada palavra em maiúscula. Todas as outras letras são em minúsculas. As palavras são delimitadas por espaço em branco. |
| instr(str, substr) | Retorna o índice (na base 1) da primeira ocorrência de substr em str. |
| lcase(str) | Retorna str com todos os caracteres convertidos em minúsculas. |
| left(str, len) | Retorna os caracteres len (len pode ser do tipo string) mais à esquerda da string str; se len for menor ou igual a 0, o resultado será uma string vazia. |
| len(expr) | Retorna o comprimento em caracteres dos dados de string ou o número de bits de dados binários. O comprimento dos dados de string inclui os espaços no fim. O comprimento dos dados binários inclui os zeros binários. |
| length(expr) | Retorna o comprimento em caracteres dos dados de string ou o número de bits de dados binários. O comprimento dos dados de string inclui os espaços no fim. O comprimento dos dados binários inclui os zeros binários. |
| levenshtein(str1, str2[, threshold]) | Retorna a distância de Levenshtein entre as duas strings fornecidas. Se o limite for definido e a distância for maior que ele, retornará -1. |
| locate(substr, str[, pos]) | Retorna a posição da primeira ocorrência de substr em str depois da posição pos. O pos fornecido e o valor retornado são na base 1. |
| lower(str) | Retorna str com todos os caracteres convertidos em minúsculas. |
| lpad(str, len[, pad]) | Retorna str, preenchido à esquerda com pad até um comprimento de len. Se str tiver mais que len, o valor retornado será encurtado para len caracteres ou bytes. Se pad não for especificado, str será preenchido à esquerda com caracteres de espaço se for uma string de caracteres e com zeros se for uma sequência de bytes. |
| ltrim(str) | Remove os caracteres de espaço antes de str. |
| luhn\$1check(str ) | Verifica se uma string e dígitos é válida de acordo com o algoritmo de Luhn. Essa função de soma de verificação é amplamente aplicada em números de cartão de crédito e números de identificação governamental para distinguir números válidos de números com erros de digitação e incorretos. |
| mask(input[, upperChar, lowerChar, digitChar, otherChar]) | mascara o valor de string fornecido. A função substitui caracteres por “X” ou “x” e números por “n”. Isso pode ser útil para criar copiar tabelas com informações sensíveis removidas. |
| octet\$1length(expr) | Retorna o comprimento em bytes dos dados de string ou o número de bits de dados binários. |
| overlay(input, replace, pos[, len]) | Substitui input por replace que começa em pos e tem o comprimento len. |
| position(substr, str[, pos]) | Retorna a posição da primeira ocorrência de substr em str depois da posição pos. O pos fornecido e o valor retornado são na base 1. |
| printf(strfmt, obj, ...) | Retorna uma string formatada a partir das strings com formato printf-style. |
| regexp\$1count(str, regexp) | Retorna quantas vezes que o padrão de expressão regular regexp ocorre na string str. |
| regexp\$1extract (str, regexp [, idx]) | Extrai a primeira string na str que corresponde à expressão regexp e ao índice do grupo regex. |
| regexp\$1extract\$1all(str, regexp[, idx]) | Extrai todas as strings na str que correspondem à expressão regexp e ao índice do grupo regex. |
| regexp\$1instr(str, regexp) | Pesquisa uma string para uma expressão regular e retorna um inteiro que indica a posição inicial da string correspondente. As posições são baseadas em 1, não em 0. Se nenhuma correspondência for encontrada, retornará 0. |
| regexp\$1replace(str, regexp, rep[, position]) | Substitui todas as substrings str que correspondem a regexp por rep. |
| regexp\$1substr(str, regexp) | Retorna a substring que corresponde à expressão regular regexp na string str. Se a expressão regular não for encontrada, o resultado será nulo. |
| repeat(str, n) | Retorna a string que repete o valor da string fornecido n vezes. |
| replace(str, search[, replace]) | Substitui todas as ocorrências de search por replace. |
| right(str, len) | Retorna os caracteres len (len pode ser do tipo string) mais à direita da string str; se len for menor ou igual a 0, o resultado será uma string vazia. |
| rpad(str, len[, pad]) | Retorna str, preenchido à direita com pad até um comprimento de len. Se str tiver mais que len, o valor retornado será encurtado para len caracteres. Se pad não for especificado, str será preenchido à direita com caracteres de espaço se for uma string de caracteres e com zeros se for uma string binária. |
| rtrim(str) | Remove os caracteres de espaço depois de str. |
| sentences(str[, lang, country]) | Divide str em uma matriz de palavras. |
| soundex(str) | Retorna o código Soundex da string. |
| space(n) | Retorna uma string que consiste em n espaços. |
| split(str, regex, limit) | Divide str em torno de ocorrências que coincidem com regex e retorna uma matriz com um comprimento máximo de limit |
| split\$1part(str, delimiter, partNum) | Divide str por delimitador e retorna a parte da divisão solicitada (com base 1). Se alguma entrada for nula, retornará nulo. Se partNum estiver fora do intervalo de partes divididas, retornará uma string vazia. Se partNum for 0, gerará erro. Se partNum for negativo, as partes serão contadas de trás para a frente a partir do fim da string. Se delimiter for uma string vazia, str não será dividida. |
| startswith(left, right) | Retorna um booleano. O valor será verdadeiro se esquerda começar com a direita. Retornará NULL se uma das expressões de entrada for NULL. Caso contrário, retorna Falso. Tanto esquerda quanto direita devem ser do tipo STRING ou BINARY. |
| substr(str, pos[, len]) | Retorna a substring de str que começa em pos e tem comprimento de len, ou a fatia da matriz de bytes que começa em pos e tem o comprimento de len. |
| substr(str FROM pos[ FOR len]]) | Retorna a substring de str que começa em pos e tem comprimento de len, ou a fatia da matriz de bytes que começa em pos e tem o comprimento de len. |
| substring(str, pos[, len]) | Retorna a substring de str que começa em pos e tem comprimento de len, ou a fatia da matriz de bytes que começa em pos e tem o comprimento de len. |
| substring(str FROM pos[ FOR len]]) | Retorna a substring de str que começa em pos e tem comprimento de len, ou a fatia da matriz de bytes que começa em pos e tem o comprimento de len. |
| substring\$1index(str, delim, count) | Retorna a substring de str antes de count ocorrências do delimitador delim. Se count for positivo, tudo à esquerda do delimitador final (contado a partir da esquerda) será retornado. Se count for negativo, tudo à esquerda do delimitador final (contado a partir da esquerda) será retornado. A função substring\$1index executa uma correspondência com distinção entre maiúsculas e minúsculas ao pesquisar delim. |
| to\$1binary(str[, fmt]) | Converte a entrada str em um valor binário com base no fmt dado. fmt pode ser uma string literal sem distinção entre maiúsculas e minúsculas de “hex”, “utf-8”, “utf8” ou “base64”. Por padrão, o formato binário para conversão será “hex” se fmt for omitido. A função retornará NULL se pelo menos um dos parâmetros de entrada for NULL. |
| to\$1char(numberExpr, formatExpr) | Converte numberExpr em uma string baseada em formatExpr. Gerará uma exceção se houver falha na conversão. O formato pode consistir nos seguintes caracteres, sem distinção entre maiúsculas e minúsculas: “0” ou “9”: especifica um dígito esperado entre 0 e 9. Uma sequência de 0 ou 9 na string de formato corresponde a uma sequência de dígitos no valor da entrada, gerando uma string de resultado com o mesmo comprimento da sequência correspondente na string de formato. A string do resultado será preenchida à esquerda com zeros se a string 0/9 incluir mais dígitos do que a parte correspondente do valor decimal, começar com 0 e vier antes do ponto decimal. Caso contrário, será preenchida com espaços. “.” ou “D”: especifica a posição do ponto decimal (opcional, permitido apenas uma vez). “,” ou “G”: especifica a posição do separador de agrupamento (milhares) (,). Deve haver um 0 ou 9 à esquerda e à direita de cada separador de agrupamento. ' |
| to\$1number(expr, fmt) | Converte a string “expr” em um número com base no formato de string “fmt”. Gerará uma exceção se houver falha na conversão. O formato pode consistir nos seguintes caracteres, sem distinção entre maiúsculas e minúsculas: “0” ou “9”: especifica um dígito esperado entre 0 e 9. Uma sequência de 0 ou 9 na string de formato corresponde a uma sequência de dígitos na string de entrada. Se a sequência 0/9 começar com 0 e vier antes do ponto decimal, ela só poderá corresponder a uma sequência de dígitos do mesmo tamanho. Caso contrário, se a sequência começar com 9 ou vier depois do ponto decimal, ela poderá corresponder a uma sequência de dígitos do mesmo tamanho ou menor. “.” ou “D”: especifica a posição do ponto decimal (opcional, permitido apenas uma vez). “,” ou “G”: especifica a posição do separador de agrupamento (milhares) (,). Deve haver um 0 ou 9 à esquerda e à direita de cada separador de agrupamento. “expr” deve corresponder ao separador de agrupamento relevante para o tamanho do número. ' |
| to\$1varchar(numberExpr, formatExpr) | Converte numberExpr em uma string baseada em formatExpr. Gerará uma exceção se houver falha na conversão. O formato pode consistir nos seguintes caracteres, sem distinção entre maiúsculas e minúsculas: “0” ou “9”: especifica um dígito esperado entre 0 e 9. Uma sequência de 0 ou 9 na string de formato corresponde a uma sequência de dígitos no valor da entrada, gerando uma string de resultado com o mesmo comprimento da sequência correspondente na string de formato. A string do resultado será preenchida à esquerda com zeros se a string 0/9 incluir mais dígitos do que a parte correspondente do valor decimal, começar com 0 e vier antes do ponto decimal. Caso contrário, será preenchida com espaços. “.” ou “D”: especifica a posição do ponto decimal (opcional, permitido apenas uma vez). “,” ou “G”: especifica a posição do separador de agrupamento (milhares) (,). Deve haver um 0 ou 9 à esquerda e à direita de cada separador de agrupamento. ' |
| translate(input, from, to) | Traduz a string input substituindo os caracteres encontrados na string from pelos caracteres correspondentes da string to. |
| trim(str) | Remove os caracteres de espaço antes e depois de str. |
| trim(BOTH FROM str) | Remove os caracteres de espaço antes e depois de str. |
| trim(LEADING FROM str) | Remove os caracteres de espaço antes de str. |
| trim(TRAILING FROM str) | Remove os caracteres de espaço depois de str. |
| trim(trimStr FROM str) | Remove os caracteres trimStr antes e depois de str. |
| trim(BOTH trimStr FROM str) | Remove os caracteres trimStr antes e depois de str. |
| trim(LEADING trimStr FROM str) | Remove os caracteres trimStr iniciais de str. |
| trim(TRAILING trimStr FROM str) | Remove os caracteres trimStr depois de str. |
| try\$1to\$1binary(str[, fmt]) | Essa é uma versão especial de to\$1binary que realiza a mesma operação, mas retorna um valor NULL em vez de gerar um erro quando a conversão não pode ser executada. |
| try\$1to\$1number(expr, fmt) | Converte a string “expr” em um número com base no formato de string fmt. Retornará NULL se a string “expr” não corresponder ao formato esperado. O formato segue a mesma semântica que a função to\$1number. |
| ucase(str) | Retorna str com todos os caracteres convertidos em maiúsculas. |
| unbase64(str) | Converte o argumento de uma string de base 64 str em um binário. |
| upper(str) | Retorna str com todos os caracteres convertidos em maiúsculas. |
**Exemplos**
```
-- ascii
SELECT ascii('222');
+----------+
|ascii(222)|
+----------+
| 50|
+----------+
SELECT ascii(2);
+--------+
|ascii(2)|
+--------+
| 50|
+--------+
-- base64
SELECT base64('Feathers');
+-----------------+
|base64(Feathers)|
+-----------------+
| RmVhdGhlcnM=|
+-----------------+
SELECT base64(x'537061726b2053514c');
+-----------------------------+
|base64(X'537061726B2053514C')|
+-----------------------------+
| U3BhcmsgU1FM|
+-----------------------------+
-- bit_length
SELECT bit_length('Feathers');
+---------------------+
|bit_length(Feathers)|
+---------------------+
| 64|
+---------------------+
SELECT bit_length(x'537061726b2053514c');
+---------------------------------+
|bit_length(X'537061726B2053514C')|
+---------------------------------+
| 72|
+---------------------------------+
-- btrim
SELECT btrim(' Feathers ');
+----------------------+
|btrim( Feathers )|
+----------------------+
| Feathers|
+----------------------+
SELECT btrim(encode(' Feathers ', 'utf-8'));
+-------------------------------------+
|btrim(encode( Feathers , utf-8))|
+-------------------------------------+
| Feathers|
+-------------------------------------+
SELECT btrim('Feathers', 'Fe');
+---------------------+
|btrim(Alphabet, Al)|
+---------------------+
| athers|
+---------------------+
SELECT btrim(encode('Feathers', 'utf-8'), encode('Al', 'utf-8'));
+---------------------------------------------------+
|btrim(encode(Feathers, utf-8), encode(Al, utf-8))|
+---------------------------------------------------+
| athers|
+---------------------------------------------------+
-- char
SELECT char(65);
+--------+
|char(65)|
+--------+
| A|
+--------+
-- char_length
SELECT char_length('Feathers ');
+-----------------------+
|char_length(Feathers )|
+-----------------------+
| 9 |
+-----------------------+
SELECT char_length(x'537061726b2053514c');
+----------------------------------+
|char_length(X'537061726B2053514C')|
+----------------------------------+
| 9|
+----------------------------------+
SELECT CHAR_LENGTH('Feathers ');
+-----------------------+
|char_length(Feathers )|
+-----------------------+
| 9|
+-----------------------+
SELECT CHARACTER_LENGTH('Feathers ');
+----------------------------+
|character_length(Feathers )|
+----------------------------+
| 9|
+----------------------------+
-- character_length
SELECT character_length('Feathers ');
+----------------------------+
|character_length(Feathers )|
+----------------------------+
| 9|
+----------------------------+
SELECT character_length(x'537061726b2053514c');
+---------------------------------------+
|character_length(X'537061726B2053514C')|
+---------------------------------------+
| 9|
+---------------------------------------+
SELECT CHAR_LENGTH('Feathers ');
+-----------------------+
|char_length(Feathers )|
+-----------------------+
| 9|
+-----------------------+
SELECT CHARACTER_LENGTH('Feathers ');
+----------------------------+
|character_length(Feathers )|
+----------------------------+
| 9|
+----------------------------+
-- chr
SELECT chr(65);
+-------+
|chr(65)|
+-------+
| A|
+-------+
-- concat_ws
SELECT concat_ws(' ', 'Fea', 'thers');
+------------------------+
|concat_ws( , Fea, thers)|
+------------------------+
| Feathers|
+------------------------+
SELECT concat_ws('s');
+------------+
|concat_ws(s)|
+------------+
| |
+------------+
SELECT concat_ws('/', 'foo', null, 'bar');
+----------------------------+
|concat_ws(/, foo, NULL, bar)|
+----------------------------+
| foo/bar|
+----------------------------+
SELECT concat_ws(null, 'Fea', 'thers');
+---------------------------+
|concat_ws(NULL, Fea, thers)|
+---------------------------+
| NULL|
+---------------------------+
-- contains
SELECT contains('Feathers', 'Fea');
+--------------------------+
|contains(Feathers, Fea)|
+--------------------------+
| true|
+--------------------------+
SELECT contains('Feathers', 'SQL');
+--------------------------+
|contains(Feathers, SQL)|
+--------------------------+
| false|
+--------------------------+
SELECT contains('Feathers', null);
+-------------------------+
|contains(Feathers, NULL)|
+-------------------------+
| NULL|
+-------------------------+
SELECT contains(x'537061726b2053514c', x'537061726b');
+----------------------------------------------+
|contains(X'537061726B2053514C', X'537061726B')|
+----------------------------------------------+
| true|
+----------------------------------------------+
-- decode
SELECT decode(encode('abc', 'utf-8'), 'utf-8');
+---------------------------------+
|decode(encode(abc, utf-8), utf-8)|
+---------------------------------+
| abc|
+---------------------------------+
SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic');
+----------------------------------------------------------------------------------+
|decode(2, 1, Southlake, 2, San Francisco, 3, New Jersey, 4, Seattle, Non domestic)|
+----------------------------------------------------------------------------------+
| San Francisco|
+----------------------------------------------------------------------------------+
SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic');
+----------------------------------------------------------------------------------+
|decode(6, 1, Southlake, 2, San Francisco, 3, New Jersey, 4, Seattle, Non domestic)|
+----------------------------------------------------------------------------------+
| Non domestic|
+----------------------------------------------------------------------------------+
SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle');
+--------------------------------------------------------------------+
|decode(6, 1, Southlake, 2, San Francisco, 3, New Jersey, 4, Seattle)|
+--------------------------------------------------------------------+
| NULL|
+--------------------------------------------------------------------+
SELECT decode(null, 6, 'Fea', NULL, 'thers', 4, 'rock');
+-------------------------------------------+
|decode(NULL, 6, Fea, NULL, thers, 4, rock)|
+-------------------------------------------+
| thers|
+-------------------------------------------+
-- elt
SELECT elt(1, 'scala', 'java');
+-------------------+
|elt(1, scala, java)|
+-------------------+
| scala|
+-------------------+
SELECT elt(2, 'a', 1);
+------------+
|elt(2, a, 1)|
+------------+
| 1|
+------------+
-- encode
SELECT encode('abc', 'utf-8');
+------------------+
|encode(abc, utf-8)|
+------------------+
| [61 62 63]|
+------------------+
-- endswith
SELECT endswith('Feathers', 'ers');
+------------------------+
|endswith(Feathers, ers)|
+------------------------+
| true|
+------------------------+
SELECT endswith('Feathers', 'SQL');
+--------------------------+
|endswith(Feathers, SQL)|
+--------------------------+
| false|
+--------------------------+
SELECT endswith('Feathers', null);
+-------------------------+
|endswith(Feathers, NULL)|
+-------------------------+
| NULL|
+-------------------------+
SELECT endswith(x'537061726b2053514c', x'537061726b');
+----------------------------------------------+
|endswith(X'537061726B2053514C', X'537061726B')|
+----------------------------------------------+
| false|
+----------------------------------------------+
SELECT endswith(x'537061726b2053514c', x'53514c');
+------------------------------------------+
|endswith(X'537061726B2053514C', X'53514C')|
+------------------------------------------+
| true|
+------------------------------------------+
-- find_in_set
SELECT find_in_set('ab','abc,b,ab,c,def');
+-------------------------------+
|find_in_set(ab, abc,b,ab,c,def)|
+-------------------------------+
| 3|
+-------------------------------+
-- format_number
SELECT format_number(12332.123456, 4);
+------------------------------+
|format_number(12332.123456, 4)|
+------------------------------+
| 12,332.1235|
+------------------------------+
SELECT format_number(12332.123456, '##################.###');
+---------------------------------------------------+
|format_number(12332.123456, ##################.###)|
+---------------------------------------------------+
| 12332.123|
+---------------------------------------------------+
-- format_string
SELECT format_string("Hello World %d %s", 100, "days");
+-------------------------------------------+
|format_string(Hello World %d %s, 100, days)|
+-------------------------------------------+
| Hello World 100 days|
+-------------------------------------------+
-- initcap
SELECT initcap('Feathers');
+------------------+
|initcap(Feathers)|
+------------------+
| Feathers|
+------------------+
-- instr
SELECT instr('Feathers', 'ers');
+--------------------+
|instr(Feathers, ers)|
+--------------------+
| 6|
+--------------------+
-- lcase
SELECT lcase('Feathers');
+---------------+
|lcase(Feathers)|
+---------------+
| feathers|
+---------------+
-- left
SELECT left('Feathers', 3);
+------------------+
|left(Feathers, 3)|
+------------------+
| Fea|
+------------------+
SELECT left(encode('Feathers', 'utf-8'), 3);
+---------------------------------+
|left(encode(Feathers, utf-8), 3)|
+---------------------------------+
| [RmVh]|
+---------------------------------+
-- len
SELECT len('Feathers ');
+---------------+
|len(Feathers )|
+---------------+
| 9|
+---------------+
SELECT len(x'537061726b2053514c');
+--------------------------+
|len(X'537061726B2053514C')|
+--------------------------+
| 9|
+--------------------------+
SELECT CHAR_LENGTH('Feathers ');
+-----------------------+
|char_length(Feathers )|
+-----------------------+
| 9|
+-----------------------+
SELECT CHARACTER_LENGTH('Feathers ');
+----------------------------+
|character_length(Feathers )|
+----------------------------+
| 9|
+----------------------------+
-- length
SELECT length('Feathers ');
+------------------+
|length(Feathers )|
+------------------+
| 9|
+------------------+
SELECT length(x'537061726b2053514c');
+-----------------------------+
|length(X'537061726B2053514C')|
+-----------------------------+
| 9|
+-----------------------------+
SELECT CHAR_LENGTH('Feathers ');
+-----------------------+
|char_length(Feathers )|
+-----------------------+
| 9|
+-----------------------+
SELECT CHARACTER_LENGTH('Feathers ');
+----------------------------+
|character_length(Feathers )|
+----------------------------+
| 9|
+----------------------------+
-- levenshtein
SELECT levenshtein('kitten', 'sitting');
+----------------------------+
|levenshtein(kitten, sitting)|
+----------------------------+
| 3|
+----------------------------+
SELECT levenshtein('kitten', 'sitting', 2);
+-------------------------------+
|levenshtein(kitten, sitting, 2)|
+-------------------------------+
| -1|
+-------------------------------+
-- locate
SELECT locate('bar', 'foobarbar');
+-------------------------+
|locate(bar, foobarbar, 1)|
+-------------------------+
| 4|
+-------------------------+
SELECT locate('bar', 'foobarbar', 5);
+-------------------------+
|locate(bar, foobarbar, 5)|
+-------------------------+
| 7|
+-------------------------+
SELECT POSITION('bar' IN 'foobarbar');
+-------------------------+
|locate(bar, foobarbar, 1)|
+-------------------------+
| 4|
+-------------------------+
-- lower
SELECT lower('Feathers');
+---------------+
|lower(Feathers)|
+---------------+
| feathers|
+---------------+
-- lpad
SELECT lpad('hi', 5, '??');
+---------------+
|lpad(hi, 5, ??)|
+---------------+
| ???hi|
+---------------+
SELECT lpad('hi', 1, '??');
+---------------+
|lpad(hi, 1, ??)|
+---------------+
| h|
+---------------+
SELECT lpad('hi', 5);
+--------------+
|lpad(hi, 5, )|
+--------------+
| hi|
+--------------+
SELECT hex(lpad(unhex('aabb'), 5));
+--------------------------------+
|hex(lpad(unhex(aabb), 5, X'00'))|
+--------------------------------+
| 000000AABB|
+--------------------------------+
SELECT hex(lpad(unhex('aabb'), 5, unhex('1122')));
+--------------------------------------+
|hex(lpad(unhex(aabb), 5, unhex(1122)))|
+--------------------------------------+
| 112211AABB|
+--------------------------------------+
-- ltrim
SELECT ltrim(' Feathers ');
+----------------------+
|ltrim( Feathers )|
+----------------------+
| Feathers |
+----------------------+
-- luhn_check
SELECT luhn_check('8112189876');
+----------------------+
|luhn_check(8112189876)|
+----------------------+
| true|
+----------------------+
SELECT luhn_check('79927398713');
+-----------------------+
|luhn_check(79927398713)|
+-----------------------+
| true|
+-----------------------+
SELECT luhn_check('79927398714');
+-----------------------+
|luhn_check(79927398714)|
+-----------------------+
| false|
+-----------------------+
-- mask
SELECT mask('abcd-EFGH-8765-4321');
+----------------------------------------+
|mask(abcd-EFGH-8765-4321, X, x, n, NULL)|
+----------------------------------------+
| xxxx-XXXX-nnnn-nnnn|
+----------------------------------------+
SELECT mask('abcd-EFGH-8765-4321', 'Q');
+----------------------------------------+
|mask(abcd-EFGH-8765-4321, Q, x, n, NULL)|
+----------------------------------------+
| xxxx-QQQQ-nnnn-nnnn|
+----------------------------------------+
SELECT mask('AbCD123-@$#', 'Q', 'q');
+--------------------------------+
|mask(AbCD123-@$#, Q, q, n, NULL)|
+--------------------------------+
| QqQQnnn-@$#|
+--------------------------------+
SELECT mask('AbCD123-@$#');
+--------------------------------+
|mask(AbCD123-@$#, X, x, n, NULL)|
+--------------------------------+
| XxXXnnn-@$#|
+--------------------------------+
SELECT mask('AbCD123-@$#', 'Q');
+--------------------------------+
|mask(AbCD123-@$#, Q, x, n, NULL)|
+--------------------------------+
| QxQQnnn-@$#|
+--------------------------------+
SELECT mask('AbCD123-@$#', 'Q', 'q');
+--------------------------------+
|mask(AbCD123-@$#, Q, q, n, NULL)|
+--------------------------------+
| QqQQnnn-@$#|
+--------------------------------+
SELECT mask('AbCD123-@$#', 'Q', 'q', 'd');
+--------------------------------+
|mask(AbCD123-@$#, Q, q, d, NULL)|
+--------------------------------+
| QqQQddd-@$#|
+--------------------------------+
SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', 'o');
+-----------------------------+
|mask(AbCD123-@$#, Q, q, d, o)|
+-----------------------------+
| QqQQdddoooo|
+-----------------------------+
SELECT mask('AbCD123-@$#', NULL, 'q', 'd', 'o');
+--------------------------------+
|mask(AbCD123-@$#, NULL, q, d, o)|
+--------------------------------+
| AqCDdddoooo|
+--------------------------------+
SELECT mask('AbCD123-@$#', NULL, NULL, 'd', 'o');
+-----------------------------------+
|mask(AbCD123-@$#, NULL, NULL, d, o)|
+-----------------------------------+
| AbCDdddoooo|
+-----------------------------------+
SELECT mask('AbCD123-@$#', NULL, NULL, NULL, 'o');
+--------------------------------------+
|mask(AbCD123-@$#, NULL, NULL, NULL, o)|
+--------------------------------------+
| AbCD123oooo|
+--------------------------------------+
SELECT mask(NULL, NULL, NULL, NULL, 'o');
+-------------------------------+
|mask(NULL, NULL, NULL, NULL, o)|
+-------------------------------+
| NULL|
+-------------------------------+
SELECT mask(NULL);
+-------------------------+
|mask(NULL, X, x, n, NULL)|
+-------------------------+
| NULL|
+-------------------------+
SELECT mask('AbCD123-@$#', NULL, NULL, NULL, NULL);
+-----------------------------------------+
|mask(AbCD123-@$#, NULL, NULL, NULL, NULL)|
+-----------------------------------------+
| AbCD123-@$#|
+-----------------------------------------+
-- octet_length
SELECT octet_length('Feathers');
+-----------------------+
|octet_length(Feathers)|
+-----------------------+
| 8|
+-----------------------+
SELECT octet_length(x'537061726b2053514c');
+-----------------------------------+
|octet_length(X'537061726B2053514C')|
+-----------------------------------+
| 9|
+-----------------------------------+
-- overlay
SELECT overlay('Feathers' PLACING '_' FROM 6);
+----------------------------+
|overlay(Feathers, _, 6, -1)|
+----------------------------+
| Feathe_ers|
+----------------------------+
SELECT overlay('Feathers' PLACING 'ures' FROM 5);
+-------------------------------+
|overlay(Feathers, ures, 5, -1)|
+-------------------------------+
| Features |
+-------------------------------+
-- position
SELECT position('bar', 'foobarbar');
+---------------------------+
|position(bar, foobarbar, 1)|
+---------------------------+
| 4|
+---------------------------+
SELECT position('bar', 'foobarbar', 5);
+---------------------------+
|position(bar, foobarbar, 5)|
+---------------------------+
| 7|
+---------------------------+
SELECT POSITION('bar' IN 'foobarbar');
+-------------------------+
|locate(bar, foobarbar, 1)|
+-------------------------+
| 4|
+-------------------------+
-- printf
SELECT printf("Hello World %d %s", 100, "days");
+------------------------------------+
|printf(Hello World %d %s, 100, days)|
+------------------------------------+
| Hello World 100 days|
+------------------------------------+
-- regexp_count
SELECT regexp_count('Steven Jones and Stephen Smith are the best players', 'Ste(v|ph)en');
+------------------------------------------------------------------------------+
|regexp_count(Steven Jones and Stephen Smith are the best players, Ste(v|ph)en)|
+------------------------------------------------------------------------------+
| 2|
+------------------------------------------------------------------------------+
SELECT regexp_count('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
+--------------------------------------------------+
|regexp_count(abcdefghijklmnopqrstuvwxyz, [a-z]{3})|
+--------------------------------------------------+
| 8|
+--------------------------------------------------+
-- regexp_extract
SELECT regexp_extract('100-200', '(\\d+)-(\\d+)', 1);
+---------------------------------------+
|regexp_extract(100-200, (\d+)-(\d+), 1)|
+---------------------------------------+
| 100|
+---------------------------------------+
-- regexp_extract_all
SELECT regexp_extract_all('100-200, 300-400', '(\\d+)-(\\d+)', 1);
+----------------------------------------------------+
|regexp_extract_all(100-200, 300-400, (\d+)-(\d+), 1)|
+----------------------------------------------------+
| [100, 300]|
+----------------------------------------------------+
-- regexp_instr
SELECT regexp_instr('user@opensearch.org', '@[^.]*');
+----------------------------------------------+
|regexp_instr(user@opensearch.org, @[^.]*, 0)|
+----------------------------------------------+
| 5|
+----------------------------------------------+
-- regexp_replace
SELECT regexp_replace('100-200', '(\\d+)', 'num');
+--------------------------------------+
|regexp_replace(100-200, (\d+), num, 1)|
+--------------------------------------+
| num-num|
+--------------------------------------+
-- regexp_substr
SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', 'Ste(v|ph)en');
+-------------------------------------------------------------------------------+
|regexp_substr(Steven Jones and Stephen Smith are the best players, Ste(v|ph)en)|
+-------------------------------------------------------------------------------+
| Steven|
+-------------------------------------------------------------------------------+
SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', 'Jeck');
+------------------------------------------------------------------------+
|regexp_substr(Steven Jones and Stephen Smith are the best players, Jeck)|
+------------------------------------------------------------------------+
| NULL|
+------------------------------------------------------------------------+
-- repeat
SELECT repeat('123', 2);
+--------------+
|repeat(123, 2)|
+--------------+
| 123123|
+--------------+
-- replace
SELECT replace('ABCabc', 'abc', 'DEF');
+-------------------------+
|replace(ABCabc, abc, DEF)|
+-------------------------+
| ABCDEF|
+-------------------------+
-- right
SELECT right('Feathers', 3);
+-------------------+
|right(Feathers, 3)|
+-------------------+
| ers|
+-------------------+
-- rpad
SELECT rpad('hi', 5, '??');
+---------------+
|rpad(hi, 5, ??)|
+---------------+
| hi???|
+---------------+
SELECT rpad('hi', 1, '??');
+---------------+
|rpad(hi, 1, ??)|
+---------------+
| h|
+---------------+
SELECT rpad('hi', 5);
+--------------+
|rpad(hi, 5, )|
+--------------+
| hi |
+--------------+
SELECT hex(rpad(unhex('aabb'), 5));
+--------------------------------+
|hex(rpad(unhex(aabb), 5, X'00'))|
+--------------------------------+
| AABB000000|
+--------------------------------+
SELECT hex(rpad(unhex('aabb'), 5, unhex('1122')));
+--------------------------------------+
|hex(rpad(unhex(aabb), 5, unhex(1122)))|
+--------------------------------------+
| AABB112211|
+--------------------------------------+
-- rtrim
SELECT rtrim(' Feathers ');
+----------------------+
|rtrim( Feathers )|
+----------------------+
| Feathers|
+----------------------+
-- sentences
SELECT sentences('Hi there! Good morning.');
+--------------------------------------+
|sentences(Hi there! Good morning., , )|
+--------------------------------------+
| [[Hi, there], [Go...|
+--------------------------------------+
-- soundex
SELECT soundex('Miller');
+---------------+
|soundex(Miller)|
+---------------+
| M460|
+---------------+
-- space
SELECT concat(space(2), '1');
+-------------------+
|concat(space(2), 1)|
+-------------------+
| 1|
+-------------------+
-- split
SELECT split('oneAtwoBthreeC', '[ABC]');
+--------------------------------+
|split(oneAtwoBthreeC, [ABC], -1)|
+--------------------------------+
| [one, two, three, ]|
+--------------------------------+
SELECT split('oneAtwoBthreeC', '[ABC]', -1);
+--------------------------------+
|split(oneAtwoBthreeC, [ABC], -1)|
+--------------------------------+
| [one, two, three, ]|
+--------------------------------+
SELECT split('oneAtwoBthreeC', '[ABC]', 2);
+-------------------------------+
|split(oneAtwoBthreeC, [ABC], 2)|
+-------------------------------+
| [one, twoBthreeC]|
+-------------------------------+
-- split_part
SELECT split_part('11.12.13', '.', 3);
+--------------------------+
|split_part(11.12.13, ., 3)|
+--------------------------+
| 13|
+--------------------------+
-- startswith
SELECT startswith('Feathers', 'Fea');
+----------------------------+
|startswith(Feathers, Fea)|
+----------------------------+
| true|
+----------------------------+
SELECT startswith('Feathers', 'SQL');
+--------------------------+
|startswith(Feathers, SQL)|
+--------------------------+
| false|
+--------------------------+
SELECT startswith('Feathers', null);
+---------------------------+
|startswith(Feathers, NULL)|
+---------------------------+
| NULL|
+---------------------------+
SELECT startswith(x'537061726b2053514c', x'537061726b');
+------------------------------------------------+
|startswith(X'537061726B2053514C', X'537061726B')|
+------------------------------------------------+
| true|
+------------------------------------------------+
SELECT startswith(x'537061726b2053514c', x'53514c');
+--------------------------------------------+
|startswith(X'537061726B2053514C', X'53514C')|
+--------------------------------------------+
| false|
+--------------------------------------------+
-- substr
SELECT substr('Feathers', 5);
+--------------------------------+
|substr(Feathers, 5, 2147483647)|
+--------------------------------+
| hers |
+--------------------------------+
SELECT substr('Feathers', -3);
+---------------------------------+
|substr(Feathers, -3, 2147483647)|
+---------------------------------+
| ers|
+---------------------------------+
SELECT substr('Feathers', 5, 1);
+-----------------------+
|substr(Feathers, 5, 1)|
+-----------------------+
| h|
+-----------------------+
SELECT substr('Feathers' FROM 5);
+-----------------------------------+
|substring(Feathers, 5, 2147483647)|
+-----------------------------------+
| hers |
+-----------------------------------+
SELECT substr('Feathers' FROM -3);
+------------------------------------+
|substring(Feathers, -3, 2147483647)|
+------------------------------------+
| ers|
+------------------------------------+
SELECT substr('Feathers' FROM 5 FOR 1);
+--------------------------+
|substring(Feathers, 5, 1)|
+--------------------------+
| h|
+--------------------------+
-- substring
SELECT substring('Feathers', 5);
+-----------------------------------+
|substring(Feathers, 5, 2147483647)|
+-----------------------------------+
| hers |
+-----------------------------------+
SELECT substring('Feathers', -3);
+------------------------------------+
|substring(Feathers, -3, 2147483647)|
+------------------------------------+
| ers|
+------------------------------------+
SELECT substring('Feathers', 5, 1);
+--------------------------+
|substring(Feathers, 5, 1)|
+--------------------------+
| h|
+--------------------------+
SELECT substring('Feathers' FROM 5);
+-----------------------------------+
|substring(Feathers, 5, 2147483647)|
+-----------------------------------+
| hers |
+-----------------------------------+
SELECT substring('Feathers' FROM -3);
+------------------------------------+
|substring(Feathers, -3, 2147483647)|
+------------------------------------+
| ers|
+------------------------------------+
SELECT substring('Feathers' FROM 5 FOR 1);
+--------------------------+
|substring(Feathers, 5, 1)|
+--------------------------+
| h|
+--------------------------+
-- substring_index
SELECT substring_index('www.apache.org', '.', 2);
+-------------------------------------+
|substring_index(www.apache.org, ., 2)|
+-------------------------------------+
| www.apache|
+-------------------------------------+
-- to_binary
SELECT to_binary('abc', 'utf-8');
+---------------------+
|to_binary(abc, utf-8)|
+---------------------+
| [61 62 63]|
+---------------------+
-- to_char
SELECT to_char(454, '999');
+-----------------+
|to_char(454, 999)|
+-----------------+
| 454|
+-----------------+
SELECT to_char(454.00, '000D00');
+-----------------------+
|to_char(454.00, 000D00)|
+-----------------------+
| 454.00|
+-----------------------+
SELECT to_char(12454, '99G999');
+----------------------+
|to_char(12454, 99G999)|
+----------------------+
| 12,454|
+----------------------+
SELECT to_char(78.12, '$99.99');
+----------------------+
|to_char(78.12, $99.99)|
+----------------------+
| $78.12|
+----------------------+
SELECT to_char(-12454.8, '99G999D9S');
+----------------------------+
|to_char(-12454.8, 99G999D9S)|
+----------------------------+
| 12,454.8-|
+----------------------------+
-- to_number
SELECT to_number('454', '999');
+-------------------+
|to_number(454, 999)|
+-------------------+
| 454|
+-------------------+
SELECT to_number('454.00', '000.00');
+-------------------------+
|to_number(454.00, 000.00)|
+-------------------------+
| 454.00|
+-------------------------+
SELECT to_number('12,454', '99,999');
+-------------------------+
|to_number(12,454, 99,999)|
+-------------------------+
| 12454|
+-------------------------+
SELECT to_number('$78.12', '$99.99');
+-------------------------+
|to_number($78.12, $99.99)|
+-------------------------+
| 78.12|
+-------------------------+
SELECT to_number('12,454.8-', '99,999.9S');
+-------------------------------+
|to_number(12,454.8-, 99,999.9S)|
+-------------------------------+
| -12454.8|
+-------------------------------+
-- to_varchar
SELECT to_varchar(454, '999');
+-----------------+
|to_char(454, 999)|
+-----------------+
| 454|
+-----------------+
SELECT to_varchar(454.00, '000D00');
+-----------------------+
|to_char(454.00, 000D00)|
+-----------------------+
| 454.00|
+-----------------------+
SELECT to_varchar(12454, '99G999');
+----------------------+
|to_char(12454, 99G999)|
+----------------------+
| 12,454|
+----------------------+
SELECT to_varchar(78.12, '$99.99');
+----------------------+
|to_char(78.12, $99.99)|
+----------------------+
| $78.12|
+----------------------+
SELECT to_varchar(-12454.8, '99G999D9S');
+----------------------------+
|to_char(-12454.8, 99G999D9S)|
+----------------------------+
| 12,454.8-|
+----------------------------+
-- translate
SELECT translate('AaBbCc', 'abc', '123');
+---------------------------+
|translate(AaBbCc, abc, 123)|
+---------------------------+
| A1B2C3|
+---------------------------+
-- try_to_binary
SELECT try_to_binary('abc', 'utf-8');
+-------------------------+
|try_to_binary(abc, utf-8)|
+-------------------------+
| [61 62 63]|
+-------------------------+
select try_to_binary('a!', 'base64');
+-------------------------+
|try_to_binary(a!, base64)|
+-------------------------+
| NULL|
+-------------------------+
select try_to_binary('abc', 'invalidFormat');
+---------------------------------+
|try_to_binary(abc, invalidFormat)|
+---------------------------------+
| NULL|
+---------------------------------+
-- try_to_number
SELECT try_to_number('454', '999');
+-----------------------+
|try_to_number(454, 999)|
+-----------------------+
| 454|
+-----------------------+
SELECT try_to_number('454.00', '000.00');
+-----------------------------+
|try_to_number(454.00, 000.00)|
+-----------------------------+
| 454.00|
+-----------------------------+
SELECT try_to_number('12,454', '99,999');
+-----------------------------+
|try_to_number(12,454, 99,999)|
+-----------------------------+
| 12454|
+-----------------------------+
SELECT try_to_number('$78.12', '$99.99');
+-----------------------------+
|try_to_number($78.12, $99.99)|
+-----------------------------+
| 78.12|
+-----------------------------+
SELECT try_to_number('12,454.8-', '99,999.9S');
+-----------------------------------+
|try_to_number(12,454.8-, 99,999.9S)|
+-----------------------------------+
| -12454.8|
+-----------------------------------+
-- ucase
SELECT ucase('Feathers');
+---------------+
|ucase(Feathers)|
+---------------+
| FEATHERS|
+---------------+
-- unbase64
SELECT unbase64('U3BhcmsgU1FM');
+----------------------+
|unbase64(U3BhcmsgU1FM)|
+----------------------+
| [53 70 61 72 6B 2...|
+----------------------+
-- upper
SELECT upper('Feathers');
+---------------+
|upper(Feathers)|
+---------------+
| FEATHERS|
+---------------+
```
#### Perfis de data e hora
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
****
| Função | Description |
| --- | --- |
| add\$1months(start\$1date, num\$1months) | Retorna a data que é num\$1months depois de start\$1date. |
| convert\$1timezone([sourceTz, ]targetTz, sourceTs) | Converte o timestamp sem fuso horário sourceTs do fuso horário sourceTz para o fuso horário targetTz. |
| curdate() | Retorna a data atual no início da avaliação da consulta. Todas as chamadas de curdate na mesma consulta retornam o mesmo valor. |
| current\$1date() | Retorna a data atual no início da avaliação da consulta. Todas as chamadas de current\$1date na mesma consulta retornam o mesmo valor. |
| current\$1date | Retorna a data atual no início da avaliação da consulta. |
| current\$1timestamp() | Retorna o timestamp atual no início da avaliação da consulta. Todas as chamadas de current\$1timestamp na mesma consulta retornam o mesmo valor. |
| current\$1timestamp | Retorna o timestamp atual no início da avaliação da consulta. |
| current\$1timezone() | Retorna o fuso horário local da sessão atual. |
| date\$1add(start\$1date, num\$1days) | Retorna a data que é num\$1days depois de start\$1date. |
| date\$1diff(endDate, startDate) | Retorna o número de dias de startDate a endDate. |
| date\$1format(timestamp, fmt) | Converte timestamp em um valor de string no formato especificado pelo formato de data fmt. |
| date\$1from\$1unix\$1date(days) | Cria uma data a partir do número de dias desde 1/01/1970. |
| date\$1part(field, source) | Extrai uma parte da fonte date/timestamp ou do intervalo. |
| date\$1sub(start\$1date, num\$1days) | Retorna a data que é num\$1days antes de start\$1date. |
| date\$1trunc(fmt, ts) | Retorna o timestamp ts truncado para a unidade especificada pelo modelo de formato fmt. |
| dateadd(start\$1date, num\$1days) | Retorna a data que é num\$1days depois de start\$1date. |
| datediff(endDate, startDate) | Retorna o número de dias de startDate a endDate. |
| datepart(field, source) | Extrai uma parte da fonte date/timestamp ou do intervalo. |
| day(date) | Retorna o dia do mês do date/timestamp. |
| dayofmonth(date) | Retorna o dia do mês do date/timestamp. |
| dayofweek(date) | Retorna o dia da semana para date/timestamp (1 = domingo, 2 = segunda-feira,..., 7 = sábado). |
| dayofyear(date) | Retorna o dia do ano do date/timestamp. |
| extract(field FROM source) | Extrai uma parte da fonte date/timestamp ou do intervalo. |
| from\$1unixtime(unix\$1time[, fmt]) | Retorna unix\$1time no fmt especificado. |
| from\$1utc\$1timestamp(timestamp, timezone) | Com um timestamp como “2017-07-14 02:40:00.0”, é interpretado como uma hora em UTC e processa essa hora como um timestamp no fuso horário fornecido. Por exemplo, “GMT\$11” produziria “2017-07-14 03:40:00.0”. |
| hour(timestamp) | Retorna o componente de hora da string/timestamp. |
| last\$1day(date) | Retorna o último dia do mês ao qual a data pertence. |
| localtimestamp() | Retorna o timestamp atual sem o fuso horário no início da avaliação da consulta. Todas as chamadas de localtimestamp na mesma consulta retornam o mesmo valor. |
| localtimestamp | Retorna a data/hora atual no fuso horário da sessão no início da avaliação da consulta. |
| make\$1date(year, month, day) | Cria a data a partir dos campos de ano, mês e dia. |
| make\$1dt\$1interval([days[, hours[, mins[, secs]]]]) | Faça a DayTimeIntervalType duração de dias, horas, minutos e segundos. |
| make\$1interval([years[, months[, weeks[, days[, hours[, mins[, secs]]]]]]]) | Gera o intervalo a partir de anos, menos, semanas, dias, horas minutos e segundos. |
| make\$1timestamp(year, month, day, hour, min, sec[, timezone]) | Cria um timestamp a partir dos campos de ano, mês, dia, hora, minuto, segundo e fuso horário. |
| make\$1timestamp\$1ltz(year, month, day, hour, min, sec[, timezone]) | Cria o timestamp atual com o fuso horário local a partir dos campos de ano, mês, dia, hora, minuto, segundo e fuso horário. |
| make\$1timestamp\$1ntz(year, month, day, hour, min, sec) | Cria a data/hora local a partir dos campos de ano, mês, dia, hora, minuto, segundo. |
| make\$1ym\$1interval([years[, months]]) | Gera um intervalo ano-mês a partir de anos, meses. |
| minute(timestamp) | Retorna o componente de minuto da string/timestamp. |
| month(date) | Retorna o componente de mês da date/timestamp. |
| months\$1between(timestamp1, timestamp2[, roundOff]) | Se timestamp1 for posterior a timestamp2, o resultado será positivo. Se timestamp1 e timestamp2 forem no mesmo dia do mês, ou se ambos forem o último dia do mês, a hora do dia será ignorada. Caso contrário, a diferença será calculada com base em 31 dias por mês e arredondada para 8 dígitos, a menos que roundOff=false. |
| next\$1day(start\$1date, day\$1of\$1week) | Retorna a primeira data posterior a start\$1date e nomeada como indicado. A função retornará NULL se pelo menos um dos parâmetros de entrada for NULL. |
| now() | Retorna o timestamp atual no início da avaliação da consulta. |
| quarter(date) | Retorna o trimestre do ano para a data, no intervalo de 1 a 4. |
| second(timestamp) | Retorna o componente de segundo da string/timestamp. |
| session\$1window(time\$1column, gap\$1duration) | Gera uma janela de sessão com um timestamp especificando a coluna e a duração do intervalo. Consulte “Types of time windows” no documento Structured Streaming guide para obter explicações e exemplos detalhados. |
| timestamp\$1micros(microseconds) | Cria um timestamp a partir do número de microssegundos desde a UTC epoch. |
| timestamp\$1millis(milliseconds) | Cria um timestamp a partir do número de milissegundos desde a UTC epoch. |
| timestamp\$1seconds(seconds) | Cria um timestamp a partir do número de segundos (pode ser fracionário) desde UTC epoch. |
| to\$1date(date\$1str[, fmt]) | Analisa a expressão date\$1str com a expressão fmt para uma data. Retorna nulo com entrada inválida. Por padrão, segue as regras de conversão em data, se fmt for omitido. |
| to\$1timestamp(timestamp\$1str[, fmt]) | Analisa a expressão timestamp\$1str com a expressão fmt para um timestamp. Retorna nulo com entrada inválida. Por padrão, seguirá as regras de conversão em timestamp, se fmt for omitido. |
| to\$1timestamp\$1ltz(timestamp\$1str[, fmt]) | Analisa a expressão timestamp\$1str com a expressão fmt para um timestamp com o fuso horário local. Retorna nulo com entrada inválida. Por padrão, seguirá as regras de conversão em timestamp, se fmt for omitido. |
| to\$1timestamp\$1ntz(timestamp\$1str[, fmt]) | Analisa a expressão timestamp\$1str com a expressão fmt para um timestamp sem fuso horário local. Retorna nulo com entrada inválida. Por padrão, seguirá as regras de conversão em timestamp, se fmt for omitido. |
| to\$1unix\$1timestamp(timeExp[, fmt]) | Retorna o timestamp UNIX da hora fornecida. |
| to\$1utc\$1timestamp(timestamp, timezone) | Fornecido um timestamp como “2017-07-14 02:40:00.0 ”, interpreta-o como uma hora em UTC e processa essa hora como um timestamp em UTC. Por exemplo, “GMT\$11” produziria “2017-07-14 01:40:00.0”. |
| trunc(date, fmt) | Retorna date com a parte de hora do dia truncada para a unidade especificada pelo modelo de formato fmt. |
| try\$1to\$1timestamp(timestamp\$1str[, fmt]) | Analisa a expressão timestamp\$1str com a expressão fmt para um timestamp. |
| unix\$1date(date) | Retorna o número de dias desde 1/01/1970. |
| unix\$1micros(timestamp) | Retorna o número de microssegundos desde 1/01/1970 00:00:00 UTC. |
| unix\$1millis(timestamp) | Retorna o número de milissegundos desde 1/01/1970 00:00:00 UTC. Trunca níveis mais altos de precisão. |
| unix\$1seconds(timestamp) | Retorna o número de segundos desde 1/01/1970 00:00:00 UTC. Trunca níveis mais altos de precisão. |
| unix\$1timestamp([timeExp[, fmt]]) | Retorna o timestamp UNIX da hora atual ou da hora especificada. |
| weekday(date) | Retorna o dia da semana para date/timestamp (0 = segunda-feira, 1 = terça-feira,..., 6 = domingo). |
| weekofyear(date) | Retorna a semana do ano da data fornecida. Considera-se que uma semana começa na segunda-feira e a semana 1 é a primeira semana com mais de 3 dias. |
| window(time\$1column, window\$1duration[, slide\$1duration[, start\$1time]]) | Fornecido um timestamp, agrupa linhas em uma ou mais janelas de tempo. O início da janela é inclusivo, mas o fim da janelas é exclusivo, por exemplo, 12:05 está na janela [12:05,12:10), mas não em [12:00,12:05). As janelas são compatíveis com uma precisão de microssegundos. Janelas da ordem de meses não são compatíveis. Consulte “Window Operations on Event Time” no documento Structured Streaming guide para obter explicações e exemplos detalhados. |
| window\$1time(window\$1column) | Extraia o valor da hora da coluna da time/session janela que pode ser usada para o valor da hora do evento da janela. A hora extraída é (window.end - 1), o que reflete o fato de que as janelas de agregação têm um limite superior exclusivo - [start, end). Consulte “Window Operations on Event Time” no documento Structured Streaming guide para obter explicações e exemplos detalhados. |
| year(date) | Retorna o componente de ano da date/timestamp. |
**Exemplos**
```
-- add_months
SELECT add_months('2016-08-31', 1);
+-------------------------+
|add_months(2016-08-31, 1)|
+-------------------------+
| 2016-09-30|
+-------------------------+
-- convert_timezone
SELECT convert_timezone('Europe/Brussels', 'America/Los_Angeles', timestamp_ntz'2021-12-06 00:00:00');
+-------------------------------------------------------------------------------------------+
|convert_timezone(Europe/Brussels, America/Los_Angeles, TIMESTAMP_NTZ '2021-12-06 00:00:00')|
+-------------------------------------------------------------------------------------------+
| 2021-12-05 15:00:00|
+-------------------------------------------------------------------------------------------+
SELECT convert_timezone('Europe/Brussels', timestamp_ntz'2021-12-05 15:00:00');
+------------------------------------------------------------------------------------------+
|convert_timezone(current_timezone(), Europe/Brussels, TIMESTAMP_NTZ '2021-12-05 15:00:00')|
+------------------------------------------------------------------------------------------+
| 2021-12-05 07:00:00|
+------------------------------------------------------------------------------------------+
-- curdate
SELECT curdate();
+--------------+
|current_date()|
+--------------+
| 2024-02-24|
+--------------+
-- current_date
SELECT current_date();
+--------------+
|current_date()|
+--------------+
| 2024-02-24|
+--------------+
SELECT current_date;
+--------------+
|current_date()|
+--------------+
| 2024-02-24|
+--------------+
-- current_timestamp
SELECT current_timestamp();
+--------------------+
| current_timestamp()|
+--------------------+
|2024-02-24 16:36:...|
+--------------------+
SELECT current_timestamp;
+--------------------+
| current_timestamp()|
+--------------------+
|2024-02-24 16:36:...|
+--------------------+
-- current_timezone
SELECT current_timezone();
+------------------+
|current_timezone()|
+------------------+
| Asia/Seoul|
+------------------+
-- date_add
SELECT date_add('2016-07-30', 1);
+-----------------------+
|date_add(2016-07-30, 1)|
+-----------------------+
| 2016-07-31|
+-----------------------+
-- date_diff
SELECT date_diff('2009-07-31', '2009-07-30');
+---------------------------------+
|date_diff(2009-07-31, 2009-07-30)|
+---------------------------------+
| 1|
+---------------------------------+
SELECT date_diff('2009-07-30', '2009-07-31');
+---------------------------------+
|date_diff(2009-07-30, 2009-07-31)|
+---------------------------------+
| -1|
+---------------------------------+
-- date_format
SELECT date_format('2016-04-08', 'y');
+--------------------------+
|date_format(2016-04-08, y)|
+--------------------------+
| 2016|
+--------------------------+
-- date_from_unix_date
SELECT date_from_unix_date(1);
+----------------------+
|date_from_unix_date(1)|
+----------------------+
| 1970-01-02|
+----------------------+
-- date_part
SELECT date_part('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456');
+-------------------------------------------------------+
|date_part(YEAR, TIMESTAMP '2019-08-12 01:00:00.123456')|
+-------------------------------------------------------+
| 2019|
+-------------------------------------------------------+
SELECT date_part('week', timestamp'2019-08-12 01:00:00.123456');
+-------------------------------------------------------+
|date_part(week, TIMESTAMP '2019-08-12 01:00:00.123456')|
+-------------------------------------------------------+
| 33|
+-------------------------------------------------------+
SELECT date_part('doy', DATE'2019-08-12');
+---------------------------------+
|date_part(doy, DATE '2019-08-12')|
+---------------------------------+
| 224|
+---------------------------------+
SELECT date_part('SECONDS', timestamp'2019-10-01 00:00:01.000001');
+----------------------------------------------------------+
|date_part(SECONDS, TIMESTAMP '2019-10-01 00:00:01.000001')|
+----------------------------------------------------------+
| 1.000001|
+----------------------------------------------------------+
SELECT date_part('days', interval 5 days 3 hours 7 minutes);
+-------------------------------------------------+
|date_part(days, INTERVAL '5 03:07' DAY TO MINUTE)|
+-------------------------------------------------+
| 5|
+-------------------------------------------------+
SELECT date_part('seconds', interval 5 hours 30 seconds 1 milliseconds 1 microseconds);
+-------------------------------------------------------------+
|date_part(seconds, INTERVAL '05:00:30.001001' HOUR TO SECOND)|
+-------------------------------------------------------------+
| 30.001001|
+-------------------------------------------------------------+
SELECT date_part('MONTH', INTERVAL '2021-11' YEAR TO MONTH);
+--------------------------------------------------+
|date_part(MONTH, INTERVAL '2021-11' YEAR TO MONTH)|
+--------------------------------------------------+
| 11|
+--------------------------------------------------+
SELECT date_part('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND);
+---------------------------------------------------------------+
|date_part(MINUTE, INTERVAL '123 23:55:59.002001' DAY TO SECOND)|
+---------------------------------------------------------------+
| 55|
+---------------------------------------------------------------+
-- date_sub
SELECT date_sub('2016-07-30', 1);
+-----------------------+
|date_sub(2016-07-30, 1)|
+-----------------------+
| 2016-07-29|
+-----------------------+
-- date_trunc
SELECT date_trunc('YEAR', '2015-03-05T09:32:05.359');
+-----------------------------------------+
|date_trunc(YEAR, 2015-03-05T09:32:05.359)|
+-----------------------------------------+
| 2015-01-01 00:00:00|
+-----------------------------------------+
SELECT date_trunc('MM', '2015-03-05T09:32:05.359');
+---------------------------------------+
|date_trunc(MM, 2015-03-05T09:32:05.359)|
+---------------------------------------+
| 2015-03-01 00:00:00|
+---------------------------------------+
SELECT date_trunc('DD', '2015-03-05T09:32:05.359');
+---------------------------------------+
|date_trunc(DD, 2015-03-05T09:32:05.359)|
+---------------------------------------+
| 2015-03-05 00:00:00|
+---------------------------------------+
SELECT date_trunc('HOUR', '2015-03-05T09:32:05.359');
+-----------------------------------------+
|date_trunc(HOUR, 2015-03-05T09:32:05.359)|
+-----------------------------------------+
| 2015-03-05 09:00:00|
+-----------------------------------------+
SELECT date_trunc('MILLISECOND', '2015-03-05T09:32:05.123456');
+---------------------------------------------------+
|date_trunc(MILLISECOND, 2015-03-05T09:32:05.123456)|
+---------------------------------------------------+
| 2015-03-05 09:32:...|
+---------------------------------------------------+
-- dateadd
SELECT dateadd('2016-07-30', 1);
+-----------------------+
|date_add(2016-07-30, 1)|
+-----------------------+
| 2016-07-31|
+-----------------------+
-- datediff
SELECT datediff('2009-07-31', '2009-07-30');
+--------------------------------+
|datediff(2009-07-31, 2009-07-30)|
+--------------------------------+
| 1|
+--------------------------------+
SELECT datediff('2009-07-30', '2009-07-31');
+--------------------------------+
|datediff(2009-07-30, 2009-07-31)|
+--------------------------------+
| -1|
+--------------------------------+
-- datepart
SELECT datepart('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456');
+----------------------------------------------------------+
|datepart(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456')|
+----------------------------------------------------------+
| 2019|
+----------------------------------------------------------+
SELECT datepart('week', timestamp'2019-08-12 01:00:00.123456');
+----------------------------------------------------------+
|datepart(week FROM TIMESTAMP '2019-08-12 01:00:00.123456')|
+----------------------------------------------------------+
| 33|
+----------------------------------------------------------+
SELECT datepart('doy', DATE'2019-08-12');
+------------------------------------+
|datepart(doy FROM DATE '2019-08-12')|
+------------------------------------+
| 224|
+------------------------------------+
SELECT datepart('SECONDS', timestamp'2019-10-01 00:00:01.000001');
+-------------------------------------------------------------+
|datepart(SECONDS FROM TIMESTAMP '2019-10-01 00:00:01.000001')|
+-------------------------------------------------------------+
| 1.000001|
+-------------------------------------------------------------+
SELECT datepart('days', interval 5 days 3 hours 7 minutes);
+----------------------------------------------------+
|datepart(days FROM INTERVAL '5 03:07' DAY TO MINUTE)|
+----------------------------------------------------+
| 5|
+----------------------------------------------------+
SELECT datepart('seconds', interval 5 hours 30 seconds 1 milliseconds 1 microseconds);
+----------------------------------------------------------------+
|datepart(seconds FROM INTERVAL '05:00:30.001001' HOUR TO SECOND)|
+----------------------------------------------------------------+
| 30.001001|
+----------------------------------------------------------------+
SELECT datepart('MONTH', INTERVAL '2021-11' YEAR TO MONTH);
+-----------------------------------------------------+
|datepart(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH)|
+-----------------------------------------------------+
| 11|
+-----------------------------------------------------+
SELECT datepart('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND);
+------------------------------------------------------------------+
|datepart(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND)|
+------------------------------------------------------------------+
| 55|
+------------------------------------------------------------------+
-- day
SELECT day('2009-07-30');
+---------------+
|day(2009-07-30)|
+---------------+
| 30|
+---------------+
-- dayofmonth
SELECT dayofmonth('2009-07-30');
+----------------------+
|dayofmonth(2009-07-30)|
+----------------------+
| 30|
+----------------------+
-- dayofweek
SELECT dayofweek('2009-07-30');
+---------------------+
|dayofweek(2009-07-30)|
+---------------------+
| 5|
+---------------------+
-- dayofyear
SELECT dayofyear('2016-04-09');
+---------------------+
|dayofyear(2016-04-09)|
+---------------------+
| 100|
+---------------------+
-- extract
SELECT extract(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456');
+---------------------------------------------------------+
|extract(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456')|
+---------------------------------------------------------+
| 2019|
+---------------------------------------------------------+
SELECT extract(week FROM timestamp'2019-08-12 01:00:00.123456');
+---------------------------------------------------------+
|extract(week FROM TIMESTAMP '2019-08-12 01:00:00.123456')|
+---------------------------------------------------------+
| 33|
+---------------------------------------------------------+
SELECT extract(doy FROM DATE'2019-08-12');
+-----------------------------------+
|extract(doy FROM DATE '2019-08-12')|
+-----------------------------------+
| 224|
+-----------------------------------+
SELECT extract(SECONDS FROM timestamp'2019-10-01 00:00:01.000001');
+------------------------------------------------------------+
|extract(SECONDS FROM TIMESTAMP '2019-10-01 00:00:01.000001')|
+------------------------------------------------------------+
| 1.000001|
+------------------------------------------------------------+
SELECT extract(days FROM interval 5 days 3 hours 7 minutes);
+---------------------------------------------------+
|extract(days FROM INTERVAL '5 03:07' DAY TO MINUTE)|
+---------------------------------------------------+
| 5|
+---------------------------------------------------+
SELECT extract(seconds FROM interval 5 hours 30 seconds 1 milliseconds 1 microseconds);
+---------------------------------------------------------------+
|extract(seconds FROM INTERVAL '05:00:30.001001' HOUR TO SECOND)|
+---------------------------------------------------------------+
| 30.001001|
+---------------------------------------------------------------+
SELECT extract(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH);
+----------------------------------------------------+
|extract(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH)|
+----------------------------------------------------+
| 11|
+----------------------------------------------------+
SELECT extract(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND);
+-----------------------------------------------------------------+
|extract(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND)|
+-----------------------------------------------------------------+
| 55|
+-----------------------------------------------------------------+
-- from_unixtime
SELECT from_unixtime(0, 'yyyy-MM-dd HH:mm:ss');
+-------------------------------------+
|from_unixtime(0, yyyy-MM-dd HH:mm:ss)|
+-------------------------------------+
| 1970-01-01 09:00:00|
+-------------------------------------+
SELECT from_unixtime(0);
+-------------------------------------+
|from_unixtime(0, yyyy-MM-dd HH:mm:ss)|
+-------------------------------------+
| 1970-01-01 09:00:00|
+-------------------------------------+
-- from_utc_timestamp
SELECT from_utc_timestamp('2016-08-31', 'Asia/Seoul');
+------------------------------------------+
|from_utc_timestamp(2016-08-31, Asia/Seoul)|
+------------------------------------------+
| 2016-08-31 09:00:00|
+------------------------------------------+
-- hour
SELECT hour('2009-07-30 12:58:59');
+-------------------------+
|hour(2009-07-30 12:58:59)|
+-------------------------+
| 12|
+-------------------------+
-- last_day
SELECT last_day('2009-01-12');
+--------------------+
|last_day(2009-01-12)|
+--------------------+
| 2009-01-31|
+--------------------+
-- localtimestamp
SELECT localtimestamp();
+--------------------+
| localtimestamp()|
+--------------------+
|2024-02-24 16:36:...|
+--------------------+
-- make_date
SELECT make_date(2013, 7, 15);
+----------------------+
|make_date(2013, 7, 15)|
+----------------------+
| 2013-07-15|
+----------------------+
SELECT make_date(2019, 7, NULL);
+------------------------+
|make_date(2019, 7, NULL)|
+------------------------+
| NULL|
+------------------------+
-- make_dt_interval
SELECT make_dt_interval(1, 12, 30, 01.001001);
+-------------------------------------+
|make_dt_interval(1, 12, 30, 1.001001)|
+-------------------------------------+
| INTERVAL '1 12:30...|
+-------------------------------------+
SELECT make_dt_interval(2);
+-----------------------------------+
|make_dt_interval(2, 0, 0, 0.000000)|
+-----------------------------------+
| INTERVAL '2 00:00...|
+-----------------------------------+
SELECT make_dt_interval(100, null, 3);
+----------------------------------------+
|make_dt_interval(100, NULL, 3, 0.000000)|
+----------------------------------------+
| NULL|
+----------------------------------------+
-- make_interval
SELECT make_interval(100, 11, 1, 1, 12, 30, 01.001001);
+----------------------------------------------+
|make_interval(100, 11, 1, 1, 12, 30, 1.001001)|
+----------------------------------------------+
| 100 years 11 mont...|
+----------------------------------------------+
SELECT make_interval(100, null, 3);
+----------------------------------------------+
|make_interval(100, NULL, 3, 0, 0, 0, 0.000000)|
+----------------------------------------------+
| NULL|
+----------------------------------------------+
SELECT make_interval(0, 1, 0, 1, 0, 0, 100.000001);
+-------------------------------------------+
|make_interval(0, 1, 0, 1, 0, 0, 100.000001)|
+-------------------------------------------+
| 1 months 1 days 1...|
+-------------------------------------------+
-- make_timestamp
SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887);
+-------------------------------------------+
|make_timestamp(2014, 12, 28, 6, 30, 45.887)|
+-------------------------------------------+
| 2014-12-28 06:30:...|
+-------------------------------------------+
SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887, 'CET');
+------------------------------------------------+
|make_timestamp(2014, 12, 28, 6, 30, 45.887, CET)|
+------------------------------------------------+
| 2014-12-28 14:30:...|
+------------------------------------------------+
SELECT make_timestamp(2019, 6, 30, 23, 59, 60);
+---------------------------------------+
|make_timestamp(2019, 6, 30, 23, 59, 60)|
+---------------------------------------+
| 2019-07-01 00:00:00|
+---------------------------------------+
SELECT make_timestamp(2019, 6, 30, 23, 59, 1);
+--------------------------------------+
|make_timestamp(2019, 6, 30, 23, 59, 1)|
+--------------------------------------+
| 2019-06-30 23:59:01|
+--------------------------------------+
SELECT make_timestamp(null, 7, 22, 15, 30, 0);
+--------------------------------------+
|make_timestamp(NULL, 7, 22, 15, 30, 0)|
+--------------------------------------+
| NULL|
+--------------------------------------+
-- make_timestamp_ltz
SELECT make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887);
+-----------------------------------------------+
|make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887)|
+-----------------------------------------------+
| 2014-12-28 06:30:...|
+-----------------------------------------------+
SELECT make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887, 'CET');
+----------------------------------------------------+
|make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887, CET)|
+----------------------------------------------------+
| 2014-12-28 14:30:...|
+----------------------------------------------------+
SELECT make_timestamp_ltz(2019, 6, 30, 23, 59, 60);
+-------------------------------------------+
|make_timestamp_ltz(2019, 6, 30, 23, 59, 60)|
+-------------------------------------------+
| 2019-07-01 00:00:00|
+-------------------------------------------+
SELECT make_timestamp_ltz(null, 7, 22, 15, 30, 0);
+------------------------------------------+
|make_timestamp_ltz(NULL, 7, 22, 15, 30, 0)|
+------------------------------------------+
| NULL|
+------------------------------------------+
-- make_timestamp_ntz
SELECT make_timestamp_ntz(2014, 12, 28, 6, 30, 45.887);
+-----------------------------------------------+
|make_timestamp_ntz(2014, 12, 28, 6, 30, 45.887)|
+-----------------------------------------------+
| 2014-12-28 06:30:...|
+-----------------------------------------------+
SELECT make_timestamp_ntz(2019, 6, 30, 23, 59, 60);
+-------------------------------------------+
|make_timestamp_ntz(2019, 6, 30, 23, 59, 60)|
+-------------------------------------------+
| 2019-07-01 00:00:00|
+-------------------------------------------+
SELECT make_timestamp_ntz(null, 7, 22, 15, 30, 0);
+------------------------------------------+
|make_timestamp_ntz(NULL, 7, 22, 15, 30, 0)|
+------------------------------------------+
| NULL|
+------------------------------------------+
-- make_ym_interval
SELECT make_ym_interval(1, 2);
+----------------------+
|make_ym_interval(1, 2)|
+----------------------+
| INTERVAL '1-2' YE...|
+----------------------+
SELECT make_ym_interval(1, 0);
+----------------------+
|make_ym_interval(1, 0)|
+----------------------+
| INTERVAL '1-0' YE...|
+----------------------+
SELECT make_ym_interval(-1, 1);
+-----------------------+
|make_ym_interval(-1, 1)|
+-----------------------+
| INTERVAL '-0-11' ...|
+-----------------------+
SELECT make_ym_interval(2);
+----------------------+
|make_ym_interval(2, 0)|
+----------------------+
| INTERVAL '2-0' YE...|
+----------------------+
-- minute
SELECT minute('2009-07-30 12:58:59');
+---------------------------+
|minute(2009-07-30 12:58:59)|
+---------------------------+
| 58|
+---------------------------+
-- month
SELECT month('2016-07-30');
+-----------------+
|month(2016-07-30)|
+-----------------+
| 7|
+-----------------+
-- months_between
SELECT months_between('1997-02-28 10:30:00', '1996-10-30');
+-----------------------------------------------------+
|months_between(1997-02-28 10:30:00, 1996-10-30, true)|
+-----------------------------------------------------+
| 3.94959677|
+-----------------------------------------------------+
SELECT months_between('1997-02-28 10:30:00', '1996-10-30', false);
+------------------------------------------------------+
|months_between(1997-02-28 10:30:00, 1996-10-30, false)|
+------------------------------------------------------+
| 3.9495967741935485|
+------------------------------------------------------+
-- next_day
SELECT next_day('2015-01-14', 'TU');
+------------------------+
|next_day(2015-01-14, TU)|
+------------------------+
| 2015-01-20|
+------------------------+
-- now
SELECT now();
+--------------------+
| now()|
+--------------------+
|2024-02-24 16:36:...|
+--------------------+
-- quarter
SELECT quarter('2016-08-31');
+-------------------+
|quarter(2016-08-31)|
+-------------------+
| 3|
+-------------------+
-- second
SELECT second('2009-07-30 12:58:59');
+---------------------------+
|second(2009-07-30 12:58:59)|
+---------------------------+
| 59|
+---------------------------+
-- session_window
SELECT a, session_window.start, session_window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:10:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, session_window(b, '5 minutes') ORDER BY a, start;
+---+-------------------+-------------------+---+
| a| start| end|cnt|
+---+-------------------+-------------------+---+
| A1|2021-01-01 00:00:00|2021-01-01 00:09:30| 2|
| A1|2021-01-01 00:10:00|2021-01-01 00:15:00| 1|
| A2|2021-01-01 00:01:00|2021-01-01 00:06:00| 1|
+---+-------------------+-------------------+---+
SELECT a, session_window.start, session_window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:10:00'), ('A2', '2021-01-01 00:01:00'), ('A2', '2021-01-01 00:04:30') AS tab(a, b) GROUP by a, session_window(b, CASE WHEN a = 'A1' THEN '5 minutes' WHEN a = 'A2' THEN '1 minute' ELSE '10 minutes' END) ORDER BY a, start;
+---+-------------------+-------------------+---+
| a| start| end|cnt|
+---+-------------------+-------------------+---+
| A1|2021-01-01 00:00:00|2021-01-01 00:09:30| 2|
| A1|2021-01-01 00:10:00|2021-01-01 00:15:00| 1|
| A2|2021-01-01 00:01:00|2021-01-01 00:02:00| 1|
| A2|2021-01-01 00:04:30|2021-01-01 00:05:30| 1|
+---+-------------------+-------------------+---+
-- timestamp_micros
SELECT timestamp_micros(1230219000123123);
+----------------------------------+
|timestamp_micros(1230219000123123)|
+----------------------------------+
| 2008-12-26 00:30:...|
+----------------------------------+
-- timestamp_millis
SELECT timestamp_millis(1230219000123);
+-------------------------------+
|timestamp_millis(1230219000123)|
+-------------------------------+
| 2008-12-26 00:30:...|
+-------------------------------+
-- timestamp_seconds
SELECT timestamp_seconds(1230219000);
+-----------------------------+
|timestamp_seconds(1230219000)|
+-----------------------------+
| 2008-12-26 00:30:00|
+-----------------------------+
SELECT timestamp_seconds(1230219000.123);
+---------------------------------+
|timestamp_seconds(1230219000.123)|
+---------------------------------+
| 2008-12-26 00:30:...|
+---------------------------------+
-- to_date
SELECT to_date('2009-07-30 04:17:52');
+----------------------------+
|to_date(2009-07-30 04:17:52)|
+----------------------------+
| 2009-07-30|
+----------------------------+
SELECT to_date('2016-12-31', 'yyyy-MM-dd');
+-------------------------------+
|to_date(2016-12-31, yyyy-MM-dd)|
+-------------------------------+
| 2016-12-31|
+-------------------------------+
-- to_timestamp
SELECT to_timestamp('2016-12-31 00:12:00');
+---------------------------------+
|to_timestamp(2016-12-31 00:12:00)|
+---------------------------------+
| 2016-12-31 00:12:00|
+---------------------------------+
SELECT to_timestamp('2016-12-31', 'yyyy-MM-dd');
+------------------------------------+
|to_timestamp(2016-12-31, yyyy-MM-dd)|
+------------------------------------+
| 2016-12-31 00:00:00|
+------------------------------------+
-- to_timestamp_ltz
SELECT to_timestamp_ltz('2016-12-31 00:12:00');
+-------------------------------------+
|to_timestamp_ltz(2016-12-31 00:12:00)|
+-------------------------------------+
| 2016-12-31 00:12:00|
+-------------------------------------+
SELECT to_timestamp_ltz('2016-12-31', 'yyyy-MM-dd');
+----------------------------------------+
|to_timestamp_ltz(2016-12-31, yyyy-MM-dd)|
+----------------------------------------+
| 2016-12-31 00:00:00|
+----------------------------------------+
-- to_timestamp_ntz
SELECT to_timestamp_ntz('2016-12-31 00:12:00');
+-------------------------------------+
|to_timestamp_ntz(2016-12-31 00:12:00)|
+-------------------------------------+
| 2016-12-31 00:12:00|
+-------------------------------------+
SELECT to_timestamp_ntz('2016-12-31', 'yyyy-MM-dd');
+----------------------------------------+
|to_timestamp_ntz(2016-12-31, yyyy-MM-dd)|
+----------------------------------------+
| 2016-12-31 00:00:00|
+----------------------------------------+
-- to_unix_timestamp
SELECT to_unix_timestamp('2016-04-08', 'yyyy-MM-dd');
+-----------------------------------------+
|to_unix_timestamp(2016-04-08, yyyy-MM-dd)|
+-----------------------------------------+
| 1460041200|
+-----------------------------------------+
-- to_utc_timestamp
SELECT to_utc_timestamp('2016-08-31', 'Asia/Seoul');
+----------------------------------------+
|to_utc_timestamp(2016-08-31, Asia/Seoul)|
+----------------------------------------+
| 2016-08-30 15:00:00|
+----------------------------------------+
-- trunc
SELECT trunc('2019-08-04', 'week');
+-----------------------+
|trunc(2019-08-04, week)|
+-----------------------+
| 2019-07-29|
+-----------------------+
SELECT trunc('2019-08-04', 'quarter');
+--------------------------+
|trunc(2019-08-04, quarter)|
+--------------------------+
| 2019-07-01|
+--------------------------+
SELECT trunc('2009-02-12', 'MM');
+---------------------+
|trunc(2009-02-12, MM)|
+---------------------+
| 2009-02-01|
+---------------------+
SELECT trunc('2015-10-27', 'YEAR');
+-----------------------+
|trunc(2015-10-27, YEAR)|
+-----------------------+
| 2015-01-01|
+-----------------------+
-- try_to_timestamp
SELECT try_to_timestamp('2016-12-31 00:12:00');
+-------------------------------------+
|try_to_timestamp(2016-12-31 00:12:00)|
+-------------------------------------+
| 2016-12-31 00:12:00|
+-------------------------------------+
SELECT try_to_timestamp('2016-12-31', 'yyyy-MM-dd');
+----------------------------------------+
|try_to_timestamp(2016-12-31, yyyy-MM-dd)|
+----------------------------------------+
| 2016-12-31 00:00:00|
+----------------------------------------+
SELECT try_to_timestamp('foo', 'yyyy-MM-dd');
+---------------------------------+
|try_to_timestamp(foo, yyyy-MM-dd)|
+---------------------------------+
| NULL|
+---------------------------------+
-- unix_date
SELECT unix_date(DATE("1970-01-02"));
+---------------------+
|unix_date(1970-01-02)|
+---------------------+
| 1|
+---------------------+
-- unix_micros
SELECT unix_micros(TIMESTAMP('1970-01-01 00:00:01Z'));
+---------------------------------+
|unix_micros(1970-01-01 00:00:01Z)|
+---------------------------------+
| 1000000|
+---------------------------------+
-- unix_millis
SELECT unix_millis(TIMESTAMP('1970-01-01 00:00:01Z'));
+---------------------------------+
|unix_millis(1970-01-01 00:00:01Z)|
+---------------------------------+
| 1000|
+---------------------------------+
-- unix_seconds
SELECT unix_seconds(TIMESTAMP('1970-01-01 00:00:01Z'));
+----------------------------------+
|unix_seconds(1970-01-01 00:00:01Z)|
+----------------------------------+
| 1|
+----------------------------------+
-- unix_timestamp
SELECT unix_timestamp();
+--------------------------------------------------------+
|unix_timestamp(current_timestamp(), yyyy-MM-dd HH:mm:ss)|
+--------------------------------------------------------+
| 1708760216|
+--------------------------------------------------------+
SELECT unix_timestamp('2016-04-08', 'yyyy-MM-dd');
+--------------------------------------+
|unix_timestamp(2016-04-08, yyyy-MM-dd)|
+--------------------------------------+
| 1460041200|
+--------------------------------------+
-- weekday
SELECT weekday('2009-07-30');
+-------------------+
|weekday(2009-07-30)|
+-------------------+
| 3|
+-------------------+
-- weekofyear
SELECT weekofyear('2008-02-20');
+----------------------+
|weekofyear(2008-02-20)|
+----------------------+
| 8|
+----------------------+
-- window
SELECT a, window.start, window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '5 minutes') ORDER BY a, start;
+---+-------------------+-------------------+---+
| a| start| end|cnt|
+---+-------------------+-------------------+---+
| A1|2021-01-01 00:00:00|2021-01-01 00:05:00| 2|
| A1|2021-01-01 00:05:00|2021-01-01 00:10:00| 1|
| A2|2021-01-01 00:00:00|2021-01-01 00:05:00| 1|
+---+-------------------+-------------------+---+
SELECT a, window.start, window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '10 minutes', '5 minutes') ORDER BY a, start;
+---+-------------------+-------------------+---+
| a| start| end|cnt|
+---+-------------------+-------------------+---+
| A1|2020-12-31 23:55:00|2021-01-01 00:05:00| 2|
| A1|2021-01-01 00:00:00|2021-01-01 00:10:00| 3|
| A1|2021-01-01 00:05:00|2021-01-01 00:15:00| 1|
| A2|2020-12-31 23:55:00|2021-01-01 00:05:00| 1|
| A2|2021-01-01 00:00:00|2021-01-01 00:10:00| 1|
+---+-------------------+-------------------+---+
-- window_time
SELECT a, window.start as start, window.end as end, window_time(window), cnt FROM (SELECT a, window, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '5 minutes') ORDER BY a, window.start);
+---+-------------------+-------------------+--------------------+---+
| a| start| end| window_time(window)|cnt|
+---+-------------------+-------------------+--------------------+---+
| A1|2021-01-01 00:00:00|2021-01-01 00:05:00|2021-01-01 00:04:...| 2|
| A1|2021-01-01 00:05:00|2021-01-01 00:10:00|2021-01-01 00:09:...| 1|
| A2|2021-01-01 00:00:00|2021-01-01 00:05:00|2021-01-01 00:04:...| 1|
+---+-------------------+-------------------+--------------------+---+
-- year
SELECT year('2016-07-30');
+----------------+
|year(2016-07-30)|
+----------------+
| 2016|
+----------------+
```
#### Funções agregadas
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
As funções agregadas operam em valores em linhas para realizar cálculos matemáticos, como soma, média, contagem, minimum/maximum valores, desvio padrão e estimativa, bem como algumas operações não matemáticas.
**Sintaxe**
```
aggregate_function(input1 [, input2, ...]) FILTER (WHERE boolean_expression)
```
**Parâmetros**
+ `boolean_expression`: especifica qualquer expressão que é avaliada como um resultado do tipo booleano. Duas ou mais expressões podem ser combinadas usando os operadores lógicos (AND, OR).
**Funções de agregação em conjunto ordenado**
Essas funções de agregação usam uma sintaxe diferente das outras funções de agregação para especificar uma expressão (normalmente um nome de coluna) segundo a qual os valores serão ordenados.
**Sintaxe**
```
{ PERCENTILE_CONT | PERCENTILE_DISC }(percentile) WITHIN GROUP (ORDER BY { order_by_expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] }) FILTER (WHERE boolean_expression)
```
**Parâmetros**
+ `percentile`: o percentil do valor que você deseja encontrar. O percentil deve ser uma constante entre 0,0 e 1,0.
+ `order_by_expression`: a expressão (normalmente um nome de coluna) segundo a qual os valores serão ordenados antes de serem agregados.
+ `boolean_expression`: especifica qualquer expressão que é avaliada como um resultado do tipo booleano. Duas ou mais expressões podem ser combinadas usando os operadores lógicos (AND, OR).
**Exemplos**
```
CREATE OR REPLACE TEMPORARY VIEW basic_pays AS SELECT * FROM VALUES
('Jane Doe','Accounting',8435),
('Akua Mansa','Accounting',9998),
('John Doe','Accounting',8992),
('Juan Li','Accounting',8870),
('Carlos Salazar','Accounting',11472),
('Arnav Desai','Accounting',6627),
('Saanvi Sarkar','IT',8113),
('Shirley Rodriguez','IT',5186),
('Nikki Wolf','Sales',9181),
('Alejandro Rosalez','Sales',9441),
('Nikhil Jayashankar','Sales',6660),
('Richard Roe','Sales',10563),
('Pat Candella','SCM',10449),
('Gerard Hernandez','SCM',6949),
('Pamela Castillo','SCM',11303),
('Paulo Santos','SCM',11798),
('Jorge Souza','SCM',10586)
AS basic_pays(employee_name, department, salary);
SELECT * FROM basic_pays;
+-------------------+----------+------+
| employee_name |department|salary|
+-------------------+----------+------+
| Arnav Desai |Accounting| 6627|
| Jorge Souza | SCM| 10586|
| Jane Doe |Accounting| 8435|
| Nikhil Jayashankar| Sales| 6660|
| Diego Vanauf | Sales| 10563|
| Carlos Salazar |Accounting| 11472|
| Gerard Hernandez | SCM| 6949|
| John Doe |Accounting| 8992|
| Nikki Wolf | Sales| 9181|
| Paulo Santos | SCM| 11798|
| Saanvi Sarkar | IT| 8113|
| Shirley Rodriguez | IT| 5186|
| Pat Candella | SCM| 10449|
| Akua Mansa |Accounting| 9998|
| Pamela Castillo | SCM| 11303|
| Alejandro Rosalez | Sales| 9441|
| Juan Li |Accounting| 8870|
+-------------------+----------+------+
SELECT
department,
percentile_cont(0.25) WITHIN GROUP (ORDER BY salary) AS pc1,
percentile_cont(0.25) WITHIN GROUP (ORDER BY salary) FILTER (WHERE employee_name LIKE '%Bo%') AS pc2,
percentile_cont(0.25) WITHIN GROUP (ORDER BY salary DESC) AS pc3,
percentile_cont(0.25) WITHIN GROUP (ORDER BY salary DESC) FILTER (WHERE employee_name LIKE '%Bo%') AS pc4,
percentile_disc(0.25) WITHIN GROUP (ORDER BY salary) AS pd1,
percentile_disc(0.25) WITHIN GROUP (ORDER BY salary) FILTER (WHERE employee_name LIKE '%Bo%') AS pd2,
percentile_disc(0.25) WITHIN GROUP (ORDER BY salary DESC) AS pd3,
percentile_disc(0.25) WITHIN GROUP (ORDER BY salary DESC) FILTER (WHERE employee_name LIKE '%Bo%') AS pd4
FROM basic_pays
GROUP BY department
ORDER BY department;
+----------+-------+--------+-------+--------+-----+-----+-----+-----+
|department| pc1| pc2| pc3| pc4| pd1| pd2| pd3| pd4|
+----------+-------+--------+-------+--------+-----+-----+-----+-----+
|Accounting|8543.75| 7838.25| 9746.5|10260.75| 8435| 6627| 9998|11472|
| IT|5917.75| NULL|7381.25| NULL| 5186| NULL| 8113| NULL|
| Sales|8550.75| NULL| 9721.5| NULL| 6660| NULL|10563| NULL|
| SCM|10449.0|10786.25|11303.0|11460.75|10449|10449|11303|11798|
+----------+-------+--------+-------+--------+-----+-----+-----+-----+
```
#### Funções condicionais
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
****
| Função | Description |
| --- | --- |
| coalesce(expr1, expr2, ...) | Retornará o primeiro argumento não nulo, se existir. Caso contrário, nulo. |
| if(expr1, expr2, expr3) | Se expr1 for avaliado como verdadeiro, retornará expr2; caso contrário, retornará expr3. |
| ifnulo(expr1, expr2) | Retornará expr2 se expr1 for nulo, caso contrário, retornará expr1. |
| nanvl(expr1, expr2) | Retornará expr1 se for NaN, caso contrário, retornará expr2. |
| nuloif(expr1, expr2) | Retornará nulo se expr1 for igual a expr2, caso contrário retornará expr1. |
| nvl(expr1, expr2) | Retornará expr2 se expr1 for nulo, caso contrário, retornará expr1. |
| nvl2(expr1, expr2, expr3) | Retornará expr2 se expr1 não for nulo, caso contrário, retornará expr3. |
| CASE WHEN expr1 THEN expr2 [WHEN expr3 THEN expr4]\$1 [ELSE expr5] END | Quando expr1 = verdadeiro, retorna expr2; senão, quando expr3 = verdadeiro , retorna expr4; caso contrário, retorna expr5. |
**Exemplos**
```
-- coalesce
SELECT coalesce(NULL, 1, NULL);
+-----------------------+
|coalesce(NULL, 1, NULL)|
+-----------------------+
| 1|
+-----------------------+
-- if
SELECT if(1 < 2, 'a', 'b');
+-------------------+
|(IF((1 < 2), a, b))|
+-------------------+
| a|
+-------------------+
-- ifnull
SELECT ifnull(NULL, array('2'));
+----------------------+
|ifnull(NULL, array(2))|
+----------------------+
| [2]|
+----------------------+
-- nanvl
SELECT nanvl(cast('NaN' as double), 123);
+-------------------------------+
|nanvl(CAST(NaN AS DOUBLE), 123)|
+-------------------------------+
| 123.0|
+-------------------------------+
-- nullif
SELECT nullif(2, 2);
+------------+
|nullif(2, 2)|
+------------+
| NULL|
+------------+
-- nvl
SELECT nvl(NULL, array('2'));
+-------------------+
|nvl(NULL, array(2))|
+-------------------+
| [2]|
+-------------------+
-- nvl2
SELECT nvl2(NULL, 2, 1);
+----------------+
|nvl2(NULL, 2, 1)|
+----------------+
| 1|
+----------------+
-- when
SELECT CASE WHEN 1 > 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END;
+-----------------------------------------------------------+
|CASE WHEN (1 > 0) THEN 1 WHEN (2 > 0) THEN 2.0 ELSE 1.2 END|
+-----------------------------------------------------------+
| 1.0|
+-----------------------------------------------------------+
SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END;
+-----------------------------------------------------------+
|CASE WHEN (1 < 0) THEN 1 WHEN (2 > 0) THEN 2.0 ELSE 1.2 END|
+-----------------------------------------------------------+
| 2.0|
+-----------------------------------------------------------+
SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 < 0 THEN 2.0 END;
+--------------------------------------------------+
|CASE WHEN (1 < 0) THEN 1 WHEN (2 < 0) THEN 2.0 END|
+--------------------------------------------------+
| NULL|
+--------------------------------------------------+
```
#### Funções JSON
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
****
| Função | Description |
| --- | --- |
| from\$1json(jsonStr, schema[, options]) | Retorna um valor de estrutura com o `jsonStr`e o `schema` fornecidos. |
| get\$1json\$1object(json\$1txt, path) | Extrai um objeto json de `path`. |
| json\$1array\$1length(jsonArray) | Retorna o número de elementos na matriz JSON mais externa. |
| json\$1object\$1keys(json\$1object) | Retorna todas as chaves do objeto JSON mais externo como uma matriz. |
| json\$1tuple(jsonStr, p1, p2, ..., pn) | Retorna uma tupla como a função get\$1json\$1object, mas aceita vários nomes. Os tipos de todos os parâmetros de entrada e colunas de saída são strings. |
| schema\$1of\$1json(json[, options]) | Retorna esquema no formato DDL de string JSON. |
| to\$1json(expr[, options]) | Retorna uma string JSON com um valor de estrutura fornecido |
**Exemplos**
```
-- from_json
SELECT from_json('{"a":1, "b":0.8}', 'a INT, b DOUBLE');
+---------------------------+
| from_json({"a":1, "b":0.8}) |
+---------------------------+
| {1, 0.8} |
+---------------------------+
SELECT from_json('{"time":"26/08/2015"}', 'time Timestamp', map('timestampFormat', 'dd/MM/yyyy'));
+--------------------------------+
| from_json({"time":"26/08/2015"}) |
+--------------------------------+
| {2015-08-26 00:00... |
+--------------------------------+
SELECT from_json('{"teacher": "Alice", "student": [{"name": "Bob", "rank": 1}, {"name": "Charlie", "rank": 2}]}', 'STRUCT>>');
+--------------------------------------------------------------------------------------------------------+
| from_json({"teacher": "Alice", "student": [{"name": "Bob", "rank": 1}, {"name": "Charlie", "rank": 2}]}) |
+--------------------------------------------------------------------------------------------------------+
| {Alice, [{Bob, 1}... |
+--------------------------------------------------------------------------------------------------------+
-- get_json_object
SELECT get_json_object('{"a":"b"}', '$.a');
+-------------------------------+
| get_json_object({"a":"b"}, $.a) |
+-------------------------------+
| b |
+-------------------------------+
-- json_array_length
SELECT json_array_length('[1,2,3,4]');
+----------------------------+
| json_array_length([1,2,3,4]) |
+----------------------------+
| 4 |
+----------------------------+
SELECT json_array_length('[1,2,3,{"f1":1,"f2":[5,6]},4]');
+------------------------------------------------+
| json_array_length([1,2,3,{"f1":1,"f2":[5,6]},4]) |
+------------------------------------------------+
| 5 |
+------------------------------------------------+
SELECT json_array_length('[1,2');
+-----------------------+
| json_array_length([1,2) |
+-----------------------+
| NULL |
+-----------------------+
-- json_object_keys
SELECT json_object_keys('{}');
+--------------------+
| json_object_keys({}) |
+--------------------+
| [] |
+--------------------+
SELECT json_object_keys('{"key": "value"}');
+----------------------------------+
| json_object_keys({"key": "value"}) |
+----------------------------------+
| [key] |
+----------------------------------+
SELECT json_object_keys('{"f1":"abc","f2":{"f3":"a", "f4":"b"}}');
+--------------------------------------------------------+
| json_object_keys({"f1":"abc","f2":{"f3":"a", "f4":"b"}}) |
+--------------------------------------------------------+
| [f1, f2] |
+--------------------------------------------------------+
-- json_tuple
SELECT json_tuple('{"a":1, "b":2}', 'a', 'b');
+---+---+
| c0| c1|
+---+---+
| 1| 2|
+---+---+
-- schema_of_json
SELECT schema_of_json('[{"col":0}]');
+---------------------------+
| schema_of_json([{"col":0}]) |
+---------------------------+
| ARRAY
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
****
| Função | Description |
| --- | --- |
| array(expr, ...) | Retorna uma matriz com os elementos fornecidos. |
| array\$1append(array, element) | Adiciona o elemento no final da matriz passada como primeiro argumento. O tipo de elemento deve ser semelhante ao tipo dos elementos da matriz. O elemento nulo também é acrescentado à matriz. Mas se a matriz for passada for NULL, a saída será NULL |
| array\$1compact(array) | Remove valores nulos da matriz. |
| array\$1contains(array, value) | Retornará verdadeiro se a matriz contiver o valor. |
| array\$1distinct(array) | Remove valores duplicados da matriz. |
| array\$1except(array1, array2) | Retorna uma matriz dos elementos em array1 mas não em array2 sem duplicações. |
| array\$1insert(x, pos, val) | Insere val no índice pos da matriz x. Os índices da matriz começam em 1. O índice negativo máximo é -1 para o qual a função insere um novo elemento após o último elemento atual. O índice acima do tamanho da matriz ou acrescenta elementos “nulos” ao início da matriz, ou ao fim da matriz se o índice for negativo. |
| array\$1intersect(array1, array2) | Retorna uma matriz dos elementos na interseção de array1 e array2, sem duplicações. |
| array\$1join(array, delimiter[, nuloReplacement]) | Concatena os elementos da matriz fornecida usando o delimitador e uma string opcional para substituir nulos. Se nenhum valor for definido para nullReplacement, todo valor nulo será filtrado. |
| array\$1max(array) | Retorna o valor máximo na matriz. NaN é maior do que qualquer elemento não NaN para o double/float tipo. Os elementos NULL são ignorados. |
| array\$1min(array) | Retorna o valor mínimo na matriz. NaN é maior do que qualquer elemento não NaN para o double/float tipo. Os elementos NULL são ignorados. |
| array\$1position(array, element) | Retorna o índice (de base 1) do primeiro elemento correspondente da matriz do mesmo tamanho ou 0 se nenhuma correspondência for encontrada. |
| array\$1prepend(array, element) | Adiciona o elemento no início da matriz passada como primeiro argumento. O tipo de elemento deve ser do mesmo tipo dos elementos da matriz. O elemento nulo também é incluído no início da matriz. Mas se a matriz for passada for NULL, a saída será NULL |
| array\$1remove(array, element) | Remove todos os elementos iguais ao elemento da matriz. |
| array\$1repeat(element, count) | Retorna a matriz contendo o número de vezes que o elemento ocorre. |
| array\$1union(array1, array2) | Retorna uma matriz dos elementos na união de array1 e array2, sem duplicações. |
| arrays\$1overlap(a1, a2) | Retornará verdadeiro se a1 contiver pelo menos um elemento não nulo presente também em a2. Se as matrizes não tiverem nenhum elemento em comum e ambas não forem vazias e uma delas contiver um elemento nulo, nulo será retornado, caso contrário, false será retornado. |
| arrays\$1zip(a1, a2, ...) | Retorna uma matriz mesclada de estruturas na qual a enésima estrutura contém todos os enésimos valores das matrizes inseridas. |
| achatar () arrayOfArrays | Transforma uma matriz de arrays em um único array. |
| get(array, index) | Retorna elemento de matriz no índice (baseado em 0) fornecido. Se o índice apontar para fora dos limites da matriz, essa função retornará NULL. |
| sequence(start, stop, step) | Gera uma matriz de elementos de iniciar até parar (inclusive), em incrementos. O tipo dos elementos retornados é igual ao tipo das expressões de argumento. Os tipos compatíveis são: byte, short, integer, long, date, timestamp. As expressões de iniciar e parar devem ser resolvidas para o mesmo tipo. Se as expressões de início e fim forem resolvidas para o tipo “date” ou “timestamp”, a expressão de etapa deverá ser resolvida para o tipo “interval”, “year-month interval” ou “day-time interval”, caso contrário, para o mesmo tipo das expressões de início e fim. |
| shuffle(array) | Retorna uma permutação aleatória da matriz fornecida. |
| slice(x, start, length) | Subdefine a matriz x começando do início do índice (os índices de matriz começam em 1 ou do fim se o início for negativo) com o comprimento especificado. |
| sort\$1array(array[, ascendingOrder]) | Classifica a matriz de entrada em ordem crescente ou decrescente de acordo com a ordem natural dos elementos da matriz. NaN é maior do que qualquer elemento não NaN para o double/float tipo. Os elementos nulos serão colocados no início da matriz retornada em ordem crescente ou no fim da matriz retornada em ordem decrescente. |
**Exemplos**
```
-- array
SELECT array(1, 2, 3);
+--------------+
|array(1, 2, 3)|
+--------------+
| [1, 2, 3]|
+--------------+
-- array_append
SELECT array_append(array('b', 'd', 'c', 'a'), 'd');
+----------------------------------+
|array_append(array(b, d, c, a), d)|
+----------------------------------+
| [b, d, c, a, d]|
+----------------------------------+
SELECT array_append(array(1, 2, 3, null), null);
+----------------------------------------+
|array_append(array(1, 2, 3, NULL), NULL)|
+----------------------------------------+
| [1, 2, 3, NULL, N...|
+----------------------------------------+
SELECT array_append(CAST(null as Array), 2);
+---------------------+
|array_append(NULL, 2)|
+---------------------+
| NULL|
+---------------------+
-- array_compact
SELECT array_compact(array(1, 2, 3, null));
+-----------------------------------+
|array_compact(array(1, 2, 3, NULL))|
+-----------------------------------+
| [1, 2, 3]|
+-----------------------------------+
SELECT array_compact(array("a", "b", "c"));
+-----------------------------+
|array_compact(array(a, b, c))|
+-----------------------------+
| [a, b, c]|
+-----------------------------+
-- array_contains
SELECT array_contains(array(1, 2, 3), 2);
+---------------------------------+
|array_contains(array(1, 2, 3), 2)|
+---------------------------------+
| true|
+---------------------------------+
-- array_distinct
SELECT array_distinct(array(1, 2, 3, null, 3));
+---------------------------------------+
|array_distinct(array(1, 2, 3, NULL, 3))|
+---------------------------------------+
| [1, 2, 3, NULL]|
+---------------------------------------+
-- array_except
SELECT array_except(array(1, 2, 3), array(1, 3, 5));
+--------------------------------------------+
|array_except(array(1, 2, 3), array(1, 3, 5))|
+--------------------------------------------+
| [2]|
+--------------------------------------------+
-- array_insert
SELECT array_insert(array(1, 2, 3, 4), 5, 5);
+-------------------------------------+
|array_insert(array(1, 2, 3, 4), 5, 5)|
+-------------------------------------+
| [1, 2, 3, 4, 5]|
+-------------------------------------+
SELECT array_insert(array(5, 4, 3, 2), -1, 1);
+--------------------------------------+
|array_insert(array(5, 4, 3, 2), -1, 1)|
+--------------------------------------+
| [5, 4, 3, 2, 1]|
+--------------------------------------+
SELECT array_insert(array(5, 3, 2, 1), -4, 4);
+--------------------------------------+
|array_insert(array(5, 3, 2, 1), -4, 4)|
+--------------------------------------+
| [5, 4, 3, 2, 1]|
+--------------------------------------+
-- array_intersect
SELECT array_intersect(array(1, 2, 3), array(1, 3, 5));
+-----------------------------------------------+
|array_intersect(array(1, 2, 3), array(1, 3, 5))|
+-----------------------------------------------+
| [1, 3]|
+-----------------------------------------------+
-- array_join
SELECT array_join(array('hello', 'world'), ' ');
+----------------------------------+
|array_join(array(hello, world), )|
+----------------------------------+
| hello world|
+----------------------------------+
SELECT array_join(array('hello', null ,'world'), ' ');
+----------------------------------------+
|array_join(array(hello, NULL, world), )|
+----------------------------------------+
| hello world|
+----------------------------------------+
SELECT array_join(array('hello', null ,'world'), ' ', ',');
+-------------------------------------------+
|array_join(array(hello, NULL, world), , ,)|
+-------------------------------------------+
| hello , world|
+-------------------------------------------+
-- array_max
SELECT array_max(array(1, 20, null, 3));
+--------------------------------+
|array_max(array(1, 20, NULL, 3))|
+--------------------------------+
| 20|
+--------------------------------+
-- array_min
SELECT array_min(array(1, 20, null, 3));
+--------------------------------+
|array_min(array(1, 20, NULL, 3))|
+--------------------------------+
| 1|
+--------------------------------+
-- array_position
SELECT array_position(array(312, 773, 708, 708), 708);
+----------------------------------------------+
|array_position(array(312, 773, 708, 708), 708)|
+----------------------------------------------+
| 3|
+----------------------------------------------+
SELECT array_position(array(312, 773, 708, 708), 414);
+----------------------------------------------+
|array_position(array(312, 773, 708, 708), 414)|
+----------------------------------------------+
| 0|
+----------------------------------------------+
-- array_prepend
SELECT array_prepend(array('b', 'd', 'c', 'a'), 'd');
+-----------------------------------+
|array_prepend(array(b, d, c, a), d)|
+-----------------------------------+
| [d, b, d, c, a]|
+-----------------------------------+
SELECT array_prepend(array(1, 2, 3, null), null);
+-----------------------------------------+
|array_prepend(array(1, 2, 3, NULL), NULL)|
+-----------------------------------------+
| [NULL, 1, 2, 3, N...|
+-----------------------------------------+
SELECT array_prepend(CAST(null as Array), 2);
+----------------------+
|array_prepend(NULL, 2)|
+----------------------+
| NULL|
+----------------------+
-- array_remove
SELECT array_remove(array(1, 2, 3, null, 3), 3);
+----------------------------------------+
|array_remove(array(1, 2, 3, NULL, 3), 3)|
+----------------------------------------+
| [1, 2, NULL]|
+----------------------------------------+
-- array_repeat
SELECT array_repeat('123', 2);
+--------------------+
|array_repeat(123, 2)|
+--------------------+
| [123, 123]|
+--------------------+
-- array_union
SELECT array_union(array(1, 2, 3), array(1, 3, 5));
+-------------------------------------------+
|array_union(array(1, 2, 3), array(1, 3, 5))|
+-------------------------------------------+
| [1, 2, 3, 5]|
+-------------------------------------------+
-- arrays_overlap
SELECT arrays_overlap(array(1, 2, 3), array(3, 4, 5));
+----------------------------------------------+
|arrays_overlap(array(1, 2, 3), array(3, 4, 5))|
+----------------------------------------------+
| true|
+----------------------------------------------+
-- arrays_zip
SELECT arrays_zip(array(1, 2, 3), array(2, 3, 4));
+------------------------------------------+
|arrays_zip(array(1, 2, 3), array(2, 3, 4))|
+------------------------------------------+
| [{1, 2}, {2, 3}, ...|
+------------------------------------------+
SELECT arrays_zip(array(1, 2), array(2, 3), array(3, 4));
+-------------------------------------------------+
|arrays_zip(array(1, 2), array(2, 3), array(3, 4))|
+-------------------------------------------------+
| [{1, 2, 3}, {2, 3...|
+-------------------------------------------------+
-- flatten
SELECT flatten(array(array(1, 2), array(3, 4)));
+----------------------------------------+
|flatten(array(array(1, 2), array(3, 4)))|
+----------------------------------------+
| [1, 2, 3, 4]|
+----------------------------------------+
-- get
SELECT get(array(1, 2, 3), 0);
+----------------------+
|get(array(1, 2, 3), 0)|
+----------------------+
| 1|
+----------------------+
SELECT get(array(1, 2, 3), 3);
+----------------------+
|get(array(1, 2, 3), 3)|
+----------------------+
| NULL|
+----------------------+
SELECT get(array(1, 2, 3), -1);
+-----------------------+
|get(array(1, 2, 3), -1)|
+-----------------------+
| NULL|
+-----------------------+
-- sequence
SELECT sequence(1, 5);
+---------------+
| sequence(1, 5)|
+---------------+
|[1, 2, 3, 4, 5]|
+---------------+
SELECT sequence(5, 1);
+---------------+
| sequence(5, 1)|
+---------------+
|[5, 4, 3, 2, 1]|
+---------------+
SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval 1 month);
+----------------------------------------------------------------------+
|sequence(to_date(2018-01-01), to_date(2018-03-01), INTERVAL '1' MONTH)|
+----------------------------------------------------------------------+
| [2018-01-01, 2018...|
+----------------------------------------------------------------------+
SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval '0-1' year to month);
+--------------------------------------------------------------------------------+
|sequence(to_date(2018-01-01), to_date(2018-03-01), INTERVAL '0-1' YEAR TO MONTH)|
+--------------------------------------------------------------------------------+
| [2018-01-01, 2018...|
+--------------------------------------------------------------------------------+
-- shuffle
SELECT shuffle(array(1, 20, 3, 5));
+---------------------------+
|shuffle(array(1, 20, 3, 5))|
+---------------------------+
| [5, 1, 20, 3]|
+---------------------------+
SELECT shuffle(array(1, 20, null, 3));
+------------------------------+
|shuffle(array(1, 20, NULL, 3))|
+------------------------------+
| [1, NULL, 20, 3]|
+------------------------------+
-- slice
SELECT slice(array(1, 2, 3, 4), 2, 2);
+------------------------------+
|slice(array(1, 2, 3, 4), 2, 2)|
+------------------------------+
| [2, 3]|
+------------------------------+
SELECT slice(array(1, 2, 3, 4), -2, 2);
+-------------------------------+
|slice(array(1, 2, 3, 4), -2, 2)|
+-------------------------------+
| [3, 4]|
+-------------------------------+
-- sort_array
SELECT sort_array(array('b', 'd', null, 'c', 'a'), true);
+-----------------------------------------+
|sort_array(array(b, d, NULL, c, a), true)|
+-----------------------------------------+
| [NULL, a, b, c, d]|
+-----------------------------------------+
```
#### Funções de janela
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
As funções de janelas operam em um grupo de linhas, chamado de janela, e calculam um valor de retorno para cada linha com base no grupo de linhas. As funções de janela são úteis para processar tarefas, como calcular uma média móvel, computar uma estatística cumulativa ou acessar o valor das linhas com base na posição relativa da linha atual.
**Sintaxe**
```
window_function [ nulls_option ] OVER ( [ { PARTITION | DISTRIBUTE } BY partition_col_name = partition_col_val ( [ , ... ] ) ] { ORDER | SORT } BY expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] [ window_frame ] )
```
**Parâmetros**
+
window\$1function
Funções de classificação
Sintaxe: `RANK | DENSE_RANK | PERCENT_RANK | NTILE | ROW_NUMBER `
Funções analíticas
Sintaxe: `CUME_DIST | LAG | LEAD | NTH_VALUE | FIRST_VALUE | LAST_VALUE `
Funções agregadas
Sintaxe: `MAX | MIN | COUNT | SUM | AVG | ... `
+ `nulls_option`: especifica se os valores nulos devem ou não ser ignorados ao avaliar a função de janela. RESPECT NULLS significa não pular valores nulos, enquanto IGNORE NULLS significa ignorá-los. Se não especificado, o padrão será RESPECT NULLS.
Sintaxe: `{ IGNORE | RESPECT } NULLS `
Observação: `Only LAG` \$1 `LEAD` \$1 `NTH_VALUE` \$1 `FIRST_VALUE` \$1 `LAST_VALUE` podem ser usadas com `IGNORE NULLS`.
+ `window_frame`: especifica em qual linha começar a janela e onde terminá-la.
Sintaxe: `{ RANGE | ROWS } { frame_start | BETWEEN frame_start AND frame_end }`
frame\$1start e frame\$1end têm a seguinte sintaxe:
Sintaxe: `UNBOUNDED PRECEDING | offset PRECEDING | CURRENT ROW | offset FOLLOWING | UNBOUNDED FOLLOWING `
offset: especifica o deslocamento da posição da linha atual.
**Observação:** se frame\$1end for omitido, o padrão CURRENT ROW será usado.
**Exemplos**
```
CREATE TABLE employees (name STRING, dept STRING, salary INT, age INT);
INSERT INTO employees VALUES ("Lisa", "Sales", 10000, 35);
INSERT INTO employees VALUES ("Evan", "Sales", 32000, 38);
INSERT INTO employees VALUES ("Fred", "Engineering", 21000, 28);
INSERT INTO employees VALUES ("Alex", "Sales", 30000, 33);
INSERT INTO employees VALUES ("Tom", "Engineering", 23000, 33);
INSERT INTO employees VALUES ("Jane", "Marketing", 29000, 28);
INSERT INTO employees VALUES ("Jeff", "Marketing", 35000, 38);
INSERT INTO employees VALUES ("Paul", "Engineering", 29000, 23);
INSERT INTO employees VALUES ("Chloe", "Engineering", 23000, 25);
SELECT * FROM employees;
+-----+-----------+------+-----+
| name| dept|salary| age|
+-----+-----------+------+-----+
|Chloe|Engineering| 23000| 25|
| Fred|Engineering| 21000| 28|
| Paul|Engineering| 29000| 23|
|Helen| Marketing| 29000| 40|
| Tom|Engineering| 23000| 33|
| Jane| Marketing| 29000| 28|
| Jeff| Marketing| 35000| 38|
| Evan| Sales| 32000| 38|
| Lisa| Sales| 10000| 35|
| Alex| Sales| 30000| 33|
+-----+-----------+------+-----+
SELECT name, dept, salary, RANK() OVER (PARTITION BY dept ORDER BY salary) AS rank FROM employees;
+-----+-----------+------+----+
| name| dept|salary|rank|
+-----+-----------+------+----+
| Lisa| Sales| 10000| 1|
| Alex| Sales| 30000| 2|
| Evan| Sales| 32000| 3|
| Fred|Engineering| 21000| 1|
| Tom|Engineering| 23000| 2|
|Chloe|Engineering| 23000| 2|
| Paul|Engineering| 29000| 4|
|Helen| Marketing| 29000| 1|
| Jane| Marketing| 29000| 1|
| Jeff| Marketing| 35000| 3|
+-----+-----------+------+----+
SELECT name, dept, salary, DENSE_RANK() OVER (PARTITION BY dept ORDER BY salary ROWS BETWEEN
UNBOUNDED PRECEDING AND CURRENT ROW) AS dense_rank FROM employees;
+-----+-----------+------+----------+
| name| dept|salary|dense_rank|
+-----+-----------+------+----------+
| Lisa| Sales| 10000| 1|
| Alex| Sales| 30000| 2|
| Evan| Sales| 32000| 3|
| Fred|Engineering| 21000| 1|
| Tom|Engineering| 23000| 2|
|Chloe|Engineering| 23000| 2|
| Paul|Engineering| 29000| 3|
|Helen| Marketing| 29000| 1|
| Jane| Marketing| 29000| 1|
| Jeff| Marketing| 35000| 2|
+-----+-----------+------+----------+
SELECT name, dept, age, CUME_DIST() OVER (PARTITION BY dept ORDER BY age
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS cume_dist FROM employees;
+-----+-----------+------+------------------+
| name| dept|age | cume_dist|
+-----+-----------+------+------------------+
| Alex| Sales| 33|0.3333333333333333|
| Lisa| Sales| 35|0.6666666666666666|
| Evan| Sales| 38| 1.0|
| Paul|Engineering| 23| 0.25|
|Chloe|Engineering| 25| 0.75|
| Fred|Engineering| 28| 0.25|
| Tom|Engineering| 33| 1.0|
| Jane| Marketing| 28|0.3333333333333333|
| Jeff| Marketing| 38|0.6666666666666666|
|Helen| Marketing| 40| 1.0|
+-----+-----------+------+------------------+
SELECT name, dept, salary, MIN(salary) OVER (PARTITION BY dept ORDER BY salary) AS min
FROM employees;
+-----+-----------+------+-----+
| name| dept|salary| min|
+-----+-----------+------+-----+
| Lisa| Sales| 10000|10000|
| Alex| Sales| 30000|10000|
| Evan| Sales| 32000|10000|
|Helen| Marketing| 29000|29000|
| Jane| Marketing| 29000|29000|
| Jeff| Marketing| 35000|29000|
| Fred|Engineering| 21000|21000|
| Tom|Engineering| 23000|21000|
|Chloe|Engineering| 23000|21000|
| Paul|Engineering| 29000|21000|
+-----+-----------+------+-----+
SELECT name, salary,
LAG(salary) OVER (PARTITION BY dept ORDER BY salary) AS lag,
LEAD(salary, 1, 0) OVER (PARTITION BY dept ORDER BY salary) AS lead
FROM employees;
+-----+-----------+------+-----+-----+
| name| dept|salary| lag| lead|
+-----+-----------+------+-----+-----+
| Lisa| Sales| 10000|NULL |30000|
| Alex| Sales| 30000|10000|32000|
| Evan| Sales| 32000|30000| 0|
| Fred|Engineering| 21000| NULL|23000|
|Chloe|Engineering| 23000|21000|23000|
| Tom|Engineering| 23000|23000|29000|
| Paul|Engineering| 29000|23000| 0|
|Helen| Marketing| 29000| NULL|29000|
| Jane| Marketing| 29000|29000|35000|
| Jeff| Marketing| 35000|29000| 0|
+-----+-----------+------+-----+-----+
SELECT id, v,
LEAD(v, 0) IGNORE NULLS OVER w lead,
LAG(v, 0) IGNORE NULLS OVER w lag,
NTH_VALUE(v, 2) IGNORE NULLS OVER w nth_value,
FIRST_VALUE(v) IGNORE NULLS OVER w first_value,
LAST_VALUE(v) IGNORE NULLS OVER w last_value
FROM test_ignore_null
WINDOW w AS (ORDER BY id)
ORDER BY id;
+--+----+----+----+---------+-----------+----------+
|id| v|lead| lag|nth_value|first_value|last_value|
+--+----+----+----+---------+-----------+----------+
| 0|NULL|NULL|NULL| NULL| NULL| NULL|
| 1| x| x| x| NULL| x| x|
| 2|NULL|NULL|NULL| NULL| x| x|
| 3|NULL|NULL|NULL| NULL| x| x|
| 4| y| y| y| y| x| y|
| 5|NULL|NULL|NULL| y| x| y|
| 6| z| z| z| y| x| z|
| 7| v| v| v| y| x| v|
| 8|NULL|NULL|NULL| y| x| v|
+--+----+----+----+---------+-----------+----------+
```
#### Funções de conversão
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
****
| Função | Description |
| --- | --- |
| bigint(expr) | Converte o valor `expr` no tipo de dados de destino `bigint`. |
| binary(expr) | Converte o valor `expr` no tipo de dados de destino `binary`. |
| boolean(expr) | Converte o valor `expr` no tipo de dados de destino `boolean`. |
| cast(expr AS type) | Converte o valor `expr` no tipo de dados de destino `type`. |
| date(expr) | Converte o valor `expr` no tipo de dados de destino `date`. |
| decimal(expr) | Converte o valor `expr` no tipo de dados de destino `decimal`. |
| double(expr) | Converte o valor `expr` no tipo de dados de destino `double`. |
| float(expr) | Converte o valor `expr` no tipo de dados de destino `float`. |
| int(expr) | Converte o valor `expr` no tipo de dados de destino `int`. |
| smallint(expr) | Converte o valor `expr` no tipo de dados de destino `smallint`. |
| string(expr) | Converte o valor `expr` no tipo de dados de destino `string`. |
| timestamp(expr) | Converte o valor `expr` no tipo de dados de destino `timestamp`. |
| tinyint(expr) | Converte o valor `expr` no tipo de dados de destino `tinyint`. |
**Exemplos**
```
-- cast
SELECT cast(field as int);
+---------------+
|CAST(field AS INT)|
+---------------+
| 10|
+---------------+
```
#### Funções de predicado
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
****
| Função | Description |
| --- | --- |
| \$1 expr | Lógico que não. |
| expr1 < expr2 | Retornará verdadeiro se `expr1` for menor que `expr2`. |
| expr1 <= expr2 | Retornará verdadeiro se `expr1` for menor que ou igual a `expr2`. |
| expr1 <=> expr2 | Retorna o mesmo resultado que o operador EQUAL (=) para operandos não nulos, mas retornará verdadeiro, se ambos forem nulos, e falso se um deles for nulo. |
| expr1 = expr2 | Retornará verdadeiro se `expr1` for igual a `expr2`, caso contrário, retornará falso. |
| expr1 == expr2 | Retornará verdadeiro se `expr1` for igual a `expr2`, caso contrário, retornará falso. |
| expr1 > expr2 | Retornará verdadeiro se `expr1` for maior que `expr2`. |
| expr1 >= expr2 | Retornará verdadeiro se `expr1` for maior ou igual a `expr2`. |
| expr1 e expr2 | AND lógico. |
| str ilike pattern[ ESCAPE escape] | Retornará verdadeiro se str corresponder a `pattern` com `escape` sem distinção entre maiúsculas e minúsculas, nulo se algum argumento for nulo, caso contrário, falso. |
| expr1 in(expr2, expr3, ...) | Retornará verdadeiro se `expr` for igual a qualquer valN. |
| isnan(expr) | Retornará verdadeiro se `expr` for NaN, caso contrário, retornará falso. |
| isnotnulo(expr) | Retornará verdadeiro se `expr` não for nulo, caso contrário, retornará falso. |
| isnulo(expr) | Retornará verdadeiro se `expr` for nulo, caso contrário, retornará falso. |
| str like pattern[ ESCAPE escape] | Retornará verdadeiro se str corresponder a `pattern` com `escape`, nulo se algum argumento for nulo, caso contrário, retornará falso. |
| not expr | Lógico que não. |
| expr1 ou expr2 | OR lógico. |
| regexp(str, regexp) | Retornará verdadeiro se `str` corresponder a `regexp`, caso contrário, retornará falso. |
| regexp\$1like(str, regexp) | Retornará verdadeiro se `str` corresponder a `regexp`, caso contrário, retornará falso. |
| rlike(str, regexp) | Retornará verdadeiro se `str` corresponder a `regexp`, caso contrário, retornará falso. |
**Exemplos**
```
-- !
SELECT ! true;
+----------+
|(NOT true)|
+----------+
| false|
+----------+
SELECT ! false;
+-----------+
|(NOT false)|
+-----------+
| true|
+-----------+
SELECT ! NULL;
+----------+
|(NOT NULL)|
+----------+
| NULL|
+----------+
-- <
SELECT to_date('2009-07-30 04:17:52') < to_date('2009-07-30 04:17:52');
+-------------------------------------------------------------+
|(to_date(2009-07-30 04:17:52) < to_date(2009-07-30 04:17:52))|
+-------------------------------------------------------------+
| false|
+-------------------------------------------------------------+
SELECT to_date('2009-07-30 04:17:52') < to_date('2009-08-01 04:17:52');
+-------------------------------------------------------------+
|(to_date(2009-07-30 04:17:52) < to_date(2009-08-01 04:17:52))|
+-------------------------------------------------------------+
| true|
+-------------------------------------------------------------+
SELECT 1 < NULL;
+----------+
|(1 < NULL)|
+----------+
| NULL|
+----------+
-- <=
SELECT 2 <= 2;
+--------+
|(2 <= 2)|
+--------+
| true|
+--------+
SELECT 1.0 <= '1';
+----------+
|(1.0 <= 1)|
+----------+
| true|
+----------+
SELECT to_date('2009-07-30 04:17:52') <= to_date('2009-07-30 04:17:52');
+--------------------------------------------------------------+
|(to_date(2009-07-30 04:17:52) <= to_date(2009-07-30 04:17:52))|
+--------------------------------------------------------------+
| true|
+--------------------------------------------------------------+
SELECT to_date('2009-07-30 04:17:52') <= to_date('2009-08-01 04:17:52');
+--------------------------------------------------------------+
|(to_date(2009-07-30 04:17:52) <= to_date(2009-08-01 04:17:52))|
+--------------------------------------------------------------+
| true|
+--------------------------------------------------------------+
SELECT 1 <= NULL;
+-----------+
|(1 <= NULL)|
+-----------+
| NULL|
+-----------+
-- <=>
SELECT 2 <=> 2;
+---------+
|(2 <=> 2)|
+---------+
| true|
+---------+
SELECT 1 <=> '1';
+---------+
|(1 <=> 1)|
+---------+
| true|
+---------+
SELECT true <=> NULL;
+---------------+
|(true <=> NULL)|
+---------------+
| false|
+---------------+
SELECT NULL <=> NULL;
+---------------+
|(NULL <=> NULL)|
+---------------+
| true|
+---------------+
-- =
SELECT 2 = 2;
+-------+
|(2 = 2)|
+-------+
| true|
+-------+
SELECT 1 = '1';
+-------+
|(1 = 1)|
+-------+
| true|
+-------+
SELECT true = NULL;
+-------------+
|(true = NULL)|
+-------------+
| NULL|
+-------------+
SELECT NULL = NULL;
+-------------+
|(NULL = NULL)|
+-------------+
| NULL|
+-------------+
-- ==
SELECT 2 == 2;
+-------+
|(2 = 2)|
+-------+
| true|
+-------+
SELECT 1 == '1';
+-------+
|(1 = 1)|
+-------+
| true|
+-------+
SELECT true == NULL;
+-------------+
|(true = NULL)|
+-------------+
| NULL|
+-------------+
SELECT NULL == NULL;
+-------------+
|(NULL = NULL)|
+-------------+
| NULL|
+-------------+
-- >
SELECT 2 > 1;
+-------+
|(2 > 1)|
+-------+
| true|
+-------+
SELECT 2 > 1.1;
+-------+
|(2 > 1)|
+-------+
| true|
+-------+
SELECT to_date('2009-07-30 04:17:52') > to_date('2009-07-30 04:17:52');
+-------------------------------------------------------------+
|(to_date(2009-07-30 04:17:52) > to_date(2009-07-30 04:17:52))|
+-------------------------------------------------------------+
| false|
+-------------------------------------------------------------+
SELECT to_date('2009-07-30 04:17:52') > to_date('2009-08-01 04:17:52');
+-------------------------------------------------------------+
|(to_date(2009-07-30 04:17:52) > to_date(2009-08-01 04:17:52))|
+-------------------------------------------------------------+
| false|
+-------------------------------------------------------------+
SELECT 1 > NULL;
+----------+
|(1 > NULL)|
+----------+
| NULL|
+----------+
-- >=
SELECT 2 >= 1;
+--------+
|(2 >= 1)|
+--------+
| true|
+--------+
SELECT 2.0 >= '2.1';
+------------+
|(2.0 >= 2.1)|
+------------+
| false|
+------------+
SELECT to_date('2009-07-30 04:17:52') >= to_date('2009-07-30 04:17:52');
+--------------------------------------------------------------+
|(to_date(2009-07-30 04:17:52) >= to_date(2009-07-30 04:17:52))|
+--------------------------------------------------------------+
| true|
+--------------------------------------------------------------+
SELECT to_date('2009-07-30 04:17:52') >= to_date('2009-08-01 04:17:52');
+--------------------------------------------------------------+
|(to_date(2009-07-30 04:17:52) >= to_date(2009-08-01 04:17:52))|
+--------------------------------------------------------------+
| false|
+--------------------------------------------------------------+
SELECT 1 >= NULL;
+-----------+
|(1 >= NULL)|
+-----------+
| NULL|
+-----------+
-- and
SELECT true and true;
+---------------+
|(true AND true)|
+---------------+
| true|
+---------------+
SELECT true and false;
+----------------+
|(true AND false)|
+----------------+
| false|
+----------------+
SELECT true and NULL;
+---------------+
|(true AND NULL)|
+---------------+
| NULL|
+---------------+
SELECT false and NULL;
+----------------+
|(false AND NULL)|
+----------------+
| false|
+----------------+
-- ilike
SELECT ilike('Wagon', '_Agon');
+-------------------+
|ilike(Wagon, _Agon)|
+-------------------+
| true|
+-------------------+
SELECT '%SystemDrive%\Users\John' ilike '\%SystemDrive\%\\users%';
+--------------------------------------------------------+
|ilike(%SystemDrive%\Users\John, \%SystemDrive\%\\users%)|
+--------------------------------------------------------+
| true|
+--------------------------------------------------------+
SELECT '%SystemDrive%\\USERS\\John' ilike '\%SystemDrive\%\\\\Users%';
+--------------------------------------------------------+
|ilike(%SystemDrive%\USERS\John, \%SystemDrive\%\\Users%)|
+--------------------------------------------------------+
| true|
+--------------------------------------------------------+
SELECT '%SystemDrive%/Users/John' ilike '/%SYSTEMDrive/%//Users%' ESCAPE '/';
+--------------------------------------------------------+
|ilike(%SystemDrive%/Users/John, /%SYSTEMDrive/%//Users%)|
+--------------------------------------------------------+
| true|
+--------------------------------------------------------+
-- in
SELECT 1 in(1, 2, 3);
+----------------+
|(1 IN (1, 2, 3))|
+----------------+
| true|
+----------------+
SELECT 1 in(2, 3, 4);
+----------------+
|(1 IN (2, 3, 4))|
+----------------+
| false|
+----------------+
SELECT named_struct('a', 1, 'b', 2) in(named_struct('a', 1, 'b', 1), named_struct('a', 1, 'b', 3));
+----------------------------------------------------------------------------------+
|(named_struct(a, 1, b, 2) IN (named_struct(a, 1, b, 1), named_struct(a, 1, b, 3)))|
+----------------------------------------------------------------------------------+
| false|
+----------------------------------------------------------------------------------+
SELECT named_struct('a', 1, 'b', 2) in(named_struct('a', 1, 'b', 2), named_struct('a', 1, 'b', 3));
+----------------------------------------------------------------------------------+
|(named_struct(a, 1, b, 2) IN (named_struct(a, 1, b, 2), named_struct(a, 1, b, 3)))|
+----------------------------------------------------------------------------------+
| true|
+----------------------------------------------------------------------------------+
-- isnan
SELECT isnan(cast('NaN' as double));
+--------------------------+
|isnan(CAST(NaN AS DOUBLE))|
+--------------------------+
| true|
+--------------------------+
-- isnotnull
SELECT isnotnull(1);
+---------------+
|(1 IS NOT NULL)|
+---------------+
| true|
+---------------+
-- isnull
SELECT isnull(1);
+-----------+
|(1 IS NULL)|
+-----------+
| false|
+-----------+
-- like
SELECT like('Wagon', '_Agon');
+----------------+
|Wagon LIKE _Agon|
+----------------+
| true|
+----------------+
-- not
SELECT not true;
+----------+
|(NOT true)|
+----------+
| false|
+----------+
SELECT not false;
+-----------+
|(NOT false)|
+-----------+
| true|
+-----------+
SELECT not NULL;
+----------+
|(NOT NULL)|
+----------+
| NULL|
+----------+
-- or
SELECT true or false;
+---------------+
|(true OR false)|
+---------------+
| true|
+---------------+
SELECT false or false;
+----------------+
|(false OR false)|
+----------------+
| false|
+----------------+
SELECT true or NULL;
+--------------+
|(true OR NULL)|
+--------------+
| true|
+--------------+
SELECT false or NULL;
+---------------+
|(false OR NULL)|
+---------------+
| NULL|
+---------------+
```
#### Funções de mapa
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
****
| Função | Description |
| --- | --- |
| element\$1at(array, index) | Retorna elemento de matriz no índice (baseado em 1) fornecido. |
| element\$1at(map, key) | Retorna o valor da chave fornecida. A função retornará NULL se a chave não estiver contida no mapa. |
| map(key0, value0, key1, value1, ...) | Cria um mapa com os key/value pares fornecidos. |
| map\$1concat(map, ...) | Retorna a união de todos os mapas fornecidos |
| map\$1contains\$1key(map, key) | Retornará verdadeiro se o mapa contiver a chave. |
| map\$1entries(map) | Retorna uma matriz não ordenada de todas as entradas no mapa fornecido. |
| map\$1from\$1arrays(keys, values) | Cria um mapa com um par das key/value matrizes fornecidas. Todos os elementos nas chaves não podem ser nulos |
| map\$1from\$1entries () arrayOfEntries | Retorna um mapa criado a partir de uma matriz de entradas fornecida. |
| map\$1keys(map) | Retorna uma matriz não ordenada contendo as chaves do mapa. |
| map\$1values(map) | Retorna uma matriz não ordenada contendo os valores do mapa. |
| str\$1to\$1map (texto [, pairDelim [,]]) keyValueDelim | Cria um mapa depois de dividir o texto em pares de chave/valor usando delimitadores. Os delimitadores padrão são ',' para `pairDelim` e ':' para ``. keyValueDelim Tanto `PairDelim` quanto `keyValueDelim` são tratados como expressões regulares. |
| try\$1element\$1at(array, index) | Retorna elemento de matriz no índice (baseado em 1) fornecido. Se o Índice for 0, o sistema gerará um erro. Se o índice for < 0, acessará os elementos do último para o primeiro. A função sempre retornará NULL se o índice exceder o comprimento da matriz. |
| try\$1element\$1at(map, key) | Retorna o valor da chave fornecida. A função sempre retornará NULL se a chave não estiver contida no mapa. |
**Exemplos**
```
-- element_at
SELECT element_at(array(1, 2, 3), 2);
+-----------------------------+
|element_at(array(1, 2, 3), 2)|
+-----------------------------+
| 2|
+-----------------------------+
SELECT element_at(map(1, 'a', 2, 'b'), 2);
+------------------------------+
|element_at(map(1, a, 2, b), 2)|
+------------------------------+
| b|
+------------------------------+
-- map
SELECT map(1.0, '2', 3.0, '4');
+--------------------+
| map(1.0, 2, 3.0, 4)|
+--------------------+
|{1.0 -> 2, 3.0 -> 4}|
+--------------------+
-- map_concat
SELECT map_concat(map(1, 'a', 2, 'b'), map(3, 'c'));
+--------------------------------------+
|map_concat(map(1, a, 2, b), map(3, c))|
+--------------------------------------+
| {1 -> a, 2 -> b, ...|
+--------------------------------------+
-- map_contains_key
SELECT map_contains_key(map(1, 'a', 2, 'b'), 1);
+------------------------------------+
|map_contains_key(map(1, a, 2, b), 1)|
+------------------------------------+
| true|
+------------------------------------+
SELECT map_contains_key(map(1, 'a', 2, 'b'), 3);
+------------------------------------+
|map_contains_key(map(1, a, 2, b), 3)|
+------------------------------------+
| false|
+------------------------------------+
-- map_entries
SELECT map_entries(map(1, 'a', 2, 'b'));
+----------------------------+
|map_entries(map(1, a, 2, b))|
+----------------------------+
| [{1, a}, {2, b}]|
+----------------------------+
-- map_from_arrays
SELECT map_from_arrays(array(1.0, 3.0), array('2', '4'));
+---------------------------------------------+
|map_from_arrays(array(1.0, 3.0), array(2, 4))|
+---------------------------------------------+
| {1.0 -> 2, 3.0 -> 4}|
+---------------------------------------------+
-- map_from_entries
SELECT map_from_entries(array(struct(1, 'a'), struct(2, 'b')));
+---------------------------------------------------+
|map_from_entries(array(struct(1, a), struct(2, b)))|
+---------------------------------------------------+
| {1 -> a, 2 -> b}|
+---------------------------------------------------+
-- map_keys
SELECT map_keys(map(1, 'a', 2, 'b'));
+-------------------------+
|map_keys(map(1, a, 2, b))|
+-------------------------+
| [1, 2]|
+-------------------------+
-- map_values
SELECT map_values(map(1, 'a', 2, 'b'));
+---------------------------+
|map_values(map(1, a, 2, b))|
+---------------------------+
| [a, b]|
+---------------------------+
-- str_to_map
SELECT str_to_map('a:1,b:2,c:3', ',', ':');
+-----------------------------+
|str_to_map(a:1,b:2,c:3, ,, :)|
+-----------------------------+
| {a -> 1, b -> 2, ...|
+-----------------------------+
SELECT str_to_map('a');
+-------------------+
|str_to_map(a, ,, :)|
+-------------------+
| {a -> NULL}|
+-------------------+
-- try_element_at
SELECT try_element_at(array(1, 2, 3), 2);
+---------------------------------+
|try_element_at(array(1, 2, 3), 2)|
+---------------------------------+
| 2|
+---------------------------------+
SELECT try_element_at(map(1, 'a', 2, 'b'), 2);
+----------------------------------+
|try_element_at(map(1, a, 2, b), 2)|
+----------------------------------+
| b|
+----------------------------------+
```
#### Funções matemáticas
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
****
| Função | Description |
| --- | --- |
| expr1 % expr2 | Retorna o resto após `expr1`/`expr2`. |
| expr1 \$1 expr2 | Retorna `expr1`\$1`expr2`. |
| expr1 \$1 expr2 | Retorna `expr1`\$1`expr2`. |
| expr1 - expr2 | Retorna `expr1`-`expr2`. |
| expr1 / expr2 | Retorna expr1 / expr2. Sempre realiza divisão de ponto flutuante. |
| abs(expr) | Retorna o valor absoluto do valor numérico ou do valor do intervalo. |
| acos(expr) | Retorna o cosseno inverso (também conhecido como arco cosseno) de `expr`, como se computado por `java.lang.Math.acos`. |
| acosh(expr) | Retorna o cosseno hiperbólico inverso de `expr`. |
| asin(expr) | Retorna o seno inverso (também conhecido como arco seno) de `expr`, como se computado por `java.lang.Math.asin`. |
| asinh(expr) | Retorna o seno hiperbólico inverso de `expr`. |
| atan(expr) | Retorna a tangente inversa (também conhecida como arco tangente) de `expr`, como se computada por `java.lang.Math.atan` |
| atan2(exprY, exprX) | Retorna o ângulo em radianos entre o eixo x positivo de um plano e o ponto dado pelas coordenadas (`exprX`, `exprY`), como se computado por `java.lang.Math.atan2`. |
| atanh(expr) | Retorna a tangente hiperbólica inversa de `expr`. |
| bin(expr) | Retorna a representação em string do valor longo `expr` representado em binário. |
| bround(expr, d) | Retorna `expr` arredondado para `d` casas decimais usando o modo de arredondamento HALF\$1EVEN. |
| cbrt(expr) | Retorna a raiz cúbica de `expr`. |
| ceil(expr[, scale]) | Retorna o menor número após o arredondamento que não seja menor que `expr`. Um parâmetro opcional `scale` pode ser especificado para controlar o comportamento do arredondamento. |
| ceiling(expr[, scale]) | Retorna o menor número após o arredondamento que não seja menor que `expr`. Um parâmetro opcional `scale` pode ser especificado para controlar o comportamento do arredondamento. |
| conv(num, from\$1base, to\$1base) | Converte `num` de `from\$1base` para `to\$1base`. |
| cos(expr) | Retorna o cosseno de `expr`, como se computado por `java.lang.Math.cos`. |
| cosh(expr) | Retorna o cosseno hiperbólico de `expr`, como se computado por `java.lang.math.cosh`. |
| cot(expr) | Retorna a cotangente de `expr`, como se computada por `1/java.lang.Math.tan`. |
| csc(expr) | Retorna a cossecante de `expr`,como se computada por `1/java.lang.Math.sin`. |
| degrees(expr) | Converte radianos em graus. |
| expr1 div expr2 | Divide `expr1` por `expr2`. Retornará NULL se um operando for NULL ou `expr2` se for 0. O resultado é convertido em longo. |
| e() | Retorna o número de Euler, e. |
| exp(expr) | Retorna e à potência de `expr`. |
| expm1(expr): returna exp(`expr`) | 1 |
| factorial(expr) | Retorna o fatorial de `expr`. `expr` é [0..20]. Caso contrário, nulo. |
| floor(expr[, scale]) | Retorna o maior número após o arredondamento para baixo que não seja maior que `expr`. Um parâmetro opcional `scale` pode ser especificado para controlar o comportamento do arredondamento. |
| greatest(expr, ...) | Retorna o maior valor de todos os parâmetros, ignorando valores nulos. |
| hex(expr) | Converte `expr` em hexadecimal. |
| hypot(expr1, expr2) | Retorna sqrt(`expr1`\$1\$12 \$1 `expr2`\$1\$12). |
| least(expr, ...) | Retorna o menor valor de todos os parâmetros, ignorando valores nulos. |
| ln(expr) | Retorna o logaritmo natural (base e) de `expr`. |
| log(base, expr) | Retorna o logaritmo de `expr` com `base`. |
| log10(expr) | Retorna o logaritmo de `expr` com base 10. |
| log1p(expr) | Retorna log(1 \$1 `expr`). |
| log2(expr) | Retorna o logaritmo de `expr` com base 2. |
| expr1 mod expr2 | Retorna o resto após `expr1`/`expr2`. |
| negative(expr) | Retorna o valor negado de `expr`. |
| pi() | Retorna pi. |
| pmod(expr1, expr2) | Retorna o valor positivo de `expr1` mod `expr2`. |
| positive(expr) | Retorna o valor de `expr`. |
| pow(expr1, expr2) | Eleva `expr1` à potência de `expr2`. |
| power(expr1, expr2) | Eleva `expr1` à potência de `expr2`. |
| radians(expr) | Converte graus em radianos. |
| rand([seed]) | Retorna um valor aleatório com valores independentes e identicamente distribuídos (i.i.d.) uniformemente distribuídos em [0, 1). |
| randn([seed]) | Retorna um valor aleatório com valores independentes e distribuídos de forma idêntica (i.i.d.) extraídos da distribuição normal padrão. |
| random([seed]) | Retorna um valor aleatório com valores independentes e identicamente distribuídos (i.i.d.) uniformemente distribuídos em [0, 1). |
| rint(expr) | Retorna o valor duplo mais próximo em valor ao argumento e igual a um inteiro matemático. |
| round(expr, d) | Retorna `expr` arredondado para `d` casas decimais usando o modo de arredondamento HALF\$1UP. |
| sec(expr) | Retorna a secante de `expr`, como se computada por `1/java.lang.Math.cos`. |
| shiftleft(base, expr) | Deslocamento à esquerda em nível de bits. |
| sign(expr) | Retorna -1,0, 0,0 ou 1,0 quando `expr` é negativa, 0 ou positiva. |
| signum(expr) | Retorna -1,0, 0,0 ou 1,0 quando `expr` é negativa, 0 ou positiva. |
| sin(expr) | Retorna o seno de `expr`, como se computado por `java.lang.Math.sin`. |
| sinh(expr) | Retorna o seno hiperbólico de `expr`, como se computado por `java.lang.Math.sinh`. |
| sqrt(expr) | Retorna a raiz quadrada de `expr`. |
| tan(expr) | Retorna a tangente de `expr`, como se computada por `java.lang.Math.tan`. |
| tanh(expr) | Retorna a tangente hiperbólica de `expr`, como se computada por `java.lang.Math.tanh`. |
| try\$1add(expr1, expr2) | Retorna a soma de `expr1`e `expr2`, e o resultado é nulo em caso de estouro. Os tipos de entrada aceitáveis são os mesmos com o operador `\$1`. |
| try\$1divide(dividend, divisor) | Retorna `dividend`/`divisor`. Sempre realiza divisão de ponto flutuante. Seu resultado será sempre nulo se `expr2` for 0. `dividendo` deve ser numérico ou um intervalo. `divisor` deve ser numérico. |
| try\$1multiply(expr1, expr2) | Retorna `expr1`\$1`expr2` e o resultado é nulo em caso de estouro. Os tipos de entrada aceitáveis são os mesmos com o operador `\$1`. |
| try\$1subtract(expr1, expr2) | Retorna `expr1`-`expr2` e o resultado é nulo em caso de estouro. Os tipos de entrada aceitáveis são os mesmos com o operador `-`. |
| unhex(expr) | Converte `expr` hexadecimal em binário. |
| width\$1bucket(value, min\$1value, max\$1value, num\$1bucket) | Retorna o número do bucketao qual `value` seria atribuído em um histograma de equilargura com `num\$1bucket` buckets, no intervalo de `min\$1value` a `max\$1value`.” |
**Exemplos**
```
-- %
SELECT 2 % 1.8;
+---------+
|(2 % 1.8)|
+---------+
| 0.2|
+---------+
SELECT MOD(2, 1.8);
+-----------+
|mod(2, 1.8)|
+-----------+
| 0.2|
+-----------+
-- *
SELECT 2 * 3;
+-------+
|(2 * 3)|
+-------+
| 6|
+-------+
-- +
SELECT 1 + 2;
+-------+
|(1 + 2)|
+-------+
| 3|
+-------+
-- -
SELECT 2 - 1;
+-------+
|(2 - 1)|
+-------+
| 1|
+-------+
-- /
SELECT 3 / 2;
+-------+
|(3 / 2)|
+-------+
| 1.5|
+-------+
SELECT 2L / 2L;
+-------+
|(2 / 2)|
+-------+
| 1.0|
+-------+
-- abs
SELECT abs(-1);
+-------+
|abs(-1)|
+-------+
| 1|
+-------+
SELECT abs(INTERVAL -'1-1' YEAR TO MONTH);
+----------------------------------+
|abs(INTERVAL '-1-1' YEAR TO MONTH)|
+----------------------------------+
| INTERVAL '1-1' YE...|
+----------------------------------+
-- acos
SELECT acos(1);
+-------+
|ACOS(1)|
+-------+
| 0.0|
+-------+
SELECT acos(2);
+-------+
|ACOS(2)|
+-------+
| NaN|
+-------+
-- acosh
SELECT acosh(1);
+--------+
|ACOSH(1)|
+--------+
| 0.0|
+--------+
SELECT acosh(0);
+--------+
|ACOSH(0)|
+--------+
| NaN|
+--------+
-- asin
SELECT asin(0);
+-------+
|ASIN(0)|
+-------+
| 0.0|
+-------+
SELECT asin(2);
+-------+
|ASIN(2)|
+-------+
| NaN|
+-------+
-- asinh
SELECT asinh(0);
+--------+
|ASINH(0)|
+--------+
| 0.0|
+--------+
-- atan
SELECT atan(0);
+-------+
|ATAN(0)|
+-------+
| 0.0|
+-------+
-- atan2
SELECT atan2(0, 0);
+-----------+
|ATAN2(0, 0)|
+-----------+
| 0.0|
+-----------+
-- atanh
SELECT atanh(0);
+--------+
|ATANH(0)|
+--------+
| 0.0|
+--------+
SELECT atanh(2);
+--------+
|ATANH(2)|
+--------+
| NaN|
+--------+
-- bin
SELECT bin(13);
+-------+
|bin(13)|
+-------+
| 1101|
+-------+
SELECT bin(-13);
+--------------------+
| bin(-13)|
+--------------------+
|11111111111111111...|
+--------------------+
SELECT bin(13.3);
+---------+
|bin(13.3)|
+---------+
| 1101|
+---------+
-- bround
SELECT bround(2.5, 0);
+--------------+
|bround(2.5, 0)|
+--------------+
| 2|
+--------------+
SELECT bround(25, -1);
+--------------+
|bround(25, -1)|
+--------------+
| 20|
+--------------+
-- cbrt
SELECT cbrt(27.0);
+----------+
|CBRT(27.0)|
+----------+
| 3.0|
+----------+
-- ceil
SELECT ceil(-0.1);
+----------+
|CEIL(-0.1)|
+----------+
| 0|
+----------+
SELECT ceil(5);
+-------+
|CEIL(5)|
+-------+
| 5|
+-------+
SELECT ceil(3.1411, 3);
+---------------+
|ceil(3.1411, 3)|
+---------------+
| 3.142|
+---------------+
SELECT ceil(3.1411, -3);
+----------------+
|ceil(3.1411, -3)|
+----------------+
| 1000|
+----------------+
-- ceiling
SELECT ceiling(-0.1);
+-------------+
|ceiling(-0.1)|
+-------------+
| 0|
+-------------+
SELECT ceiling(5);
+----------+
|ceiling(5)|
+----------+
| 5|
+----------+
SELECT ceiling(3.1411, 3);
+------------------+
|ceiling(3.1411, 3)|
+------------------+
| 3.142|
+------------------+
SELECT ceiling(3.1411, -3);
+-------------------+
|ceiling(3.1411, -3)|
+-------------------+
| 1000|
+-------------------+
-- conv
SELECT conv('100', 2, 10);
+----------------+
|conv(100, 2, 10)|
+----------------+
| 4|
+----------------+
SELECT conv(-10, 16, -10);
+------------------+
|conv(-10, 16, -10)|
+------------------+
| -16|
+------------------+
-- cos
SELECT cos(0);
+------+
|COS(0)|
+------+
| 1.0|
+------+
-- cosh
SELECT cosh(0);
+-------+
|COSH(0)|
+-------+
| 1.0|
+-------+
-- cot
SELECT cot(1);
+------------------+
| COT(1)|
+------------------+
|0.6420926159343306|
+------------------+
-- csc
SELECT csc(1);
+------------------+
| CSC(1)|
+------------------+
|1.1883951057781212|
+------------------+
-- degrees
SELECT degrees(3.141592653589793);
+--------------------------+
|DEGREES(3.141592653589793)|
+--------------------------+
| 180.0|
+--------------------------+
-- div
SELECT 3 div 2;
+---------+
|(3 div 2)|
+---------+
| 1|
+---------+
SELECT INTERVAL '1-1' YEAR TO MONTH div INTERVAL '-1' MONTH;
+------------------------------------------------------+
|(INTERVAL '1-1' YEAR TO MONTH div INTERVAL '-1' MONTH)|
+------------------------------------------------------+
| -13|
+------------------------------------------------------+
-- e
SELECT e();
+-----------------+
| E()|
+-----------------+
|2.718281828459045|
+-----------------+
-- exp
SELECT exp(0);
+------+
|EXP(0)|
+------+
| 1.0|
+------+
-- expm1
SELECT expm1(0);
+--------+
|EXPM1(0)|
+--------+
| 0.0|
+--------+
-- factorial
SELECT factorial(5);
+------------+
|factorial(5)|
+------------+
| 120|
+------------+
-- floor
SELECT floor(-0.1);
+-----------+
|FLOOR(-0.1)|
+-----------+
| -1|
+-----------+
SELECT floor(5);
+--------+
|FLOOR(5)|
+--------+
| 5|
+--------+
SELECT floor(3.1411, 3);
+----------------+
|floor(3.1411, 3)|
+----------------+
| 3.141|
+----------------+
SELECT floor(3.1411, -3);
+-----------------+
|floor(3.1411, -3)|
+-----------------+
| 0|
+-----------------+
-- greatest
SELECT greatest(10, 9, 2, 4, 3);
+------------------------+
|greatest(10, 9, 2, 4, 3)|
+------------------------+
| 10|
+------------------------+
-- hex
SELECT hex(17);
+-------+
|hex(17)|
+-------+
| 11|
+-------+
SELECT hex('SQL');
+------------------+
| hex(SQL)|
+------------------+
|53514C|
+------------------+
-- hypot
SELECT hypot(3, 4);
+-----------+
|HYPOT(3, 4)|
+-----------+
| 5.0|
+-----------+
-- least
SELECT least(10, 9, 2, 4, 3);
+---------------------+
|least(10, 9, 2, 4, 3)|
+---------------------+
| 2|
+---------------------+
-- ln
SELECT ln(1);
+-----+
|ln(1)|
+-----+
| 0.0|
+-----+
-- log
SELECT log(10, 100);
+------------+
|LOG(10, 100)|
+------------+
| 2.0|
+------------+
-- log10
SELECT log10(10);
+---------+
|LOG10(10)|
+---------+
| 1.0|
+---------+
-- log1p
SELECT log1p(0);
+--------+
|LOG1P(0)|
+--------+
| 0.0|
+--------+
-- log2
SELECT log2(2);
+-------+
|LOG2(2)|
+-------+
| 1.0|
+-------+
-- mod
SELECT 2 % 1.8;
+---------+
|(2 % 1.8)|
+---------+
| 0.2|
+---------+
SELECT MOD(2, 1.8);
+-----------+
|mod(2, 1.8)|
+-----------+
| 0.2|
+-----------+
-- negative
SELECT negative(1);
+-----------+
|negative(1)|
+-----------+
| -1|
+-----------+
-- pi
SELECT pi();
+-----------------+
| PI()|
+-----------------+
|3.141592653589793|
+-----------------+
-- pmod
SELECT pmod(10, 3);
+-----------+
|pmod(10, 3)|
+-----------+
| 1|
+-----------+
SELECT pmod(-10, 3);
+------------+
|pmod(-10, 3)|
+------------+
| 2|
+------------+
-- positive
SELECT positive(1);
+-----+
|(+ 1)|
+-----+
| 1|
+-----+
-- pow
SELECT pow(2, 3);
+---------+
|pow(2, 3)|
+---------+
| 8.0|
+---------+
-- power
SELECT power(2, 3);
+-----------+
|POWER(2, 3)|
+-----------+
| 8.0|
+-----------+
-- radians
SELECT radians(180);
+-----------------+
| RADIANS(180)|
+-----------------+
|3.141592653589793|
+-----------------+
-- rand
SELECT rand();
+------------------+
| rand()|
+------------------+
|0.7211420708112387|
+------------------+
SELECT rand(0);
+------------------+
| rand(0)|
+------------------+
|0.7604953758285915|
+------------------+
SELECT rand(null);
+------------------+
| rand(NULL)|
+------------------+
|0.7604953758285915|
+------------------+
-- randn
SELECT randn();
+-------------------+
| randn()|
+-------------------+
|-0.8175603217732732|
+-------------------+
SELECT randn(0);
+------------------+
| randn(0)|
+------------------+
|1.6034991609278433|
+------------------+
SELECT randn(null);
+------------------+
| randn(NULL)|
+------------------+
|1.6034991609278433|
+------------------+
-- random
SELECT random();
+-----------------+
| rand()|
+-----------------+
|0.394205008255365|
+-----------------+
SELECT random(0);
+------------------+
| rand(0)|
+------------------+
|0.7604953758285915|
+------------------+
SELECT random(null);
+------------------+
| rand(NULL)|
+------------------+
|0.7604953758285915|
+------------------+
-- rint
SELECT rint(12.3456);
+-------------+
|rint(12.3456)|
+-------------+
| 12.0|
+-------------+
-- round
SELECT round(2.5, 0);
+-------------+
|round(2.5, 0)|
+-------------+
| 3|
+-------------+
-- sec
SELECT sec(0);
+------+
|SEC(0)|
+------+
| 1.0|
+------+
-- shiftleft
SELECT shiftleft(2, 1);
+---------------+
|shiftleft(2, 1)|
+---------------+
| 4|
+---------------+
-- sign
SELECT sign(40);
+--------+
|sign(40)|
+--------+
| 1.0|
+--------+
SELECT sign(INTERVAL -'100' YEAR);
+--------------------------+
|sign(INTERVAL '-100' YEAR)|
+--------------------------+
| -1.0|
+--------------------------+
-- signum
SELECT signum(40);
+----------+
|SIGNUM(40)|
+----------+
| 1.0|
+----------+
SELECT signum(INTERVAL -'100' YEAR);
+----------------------------+
|SIGNUM(INTERVAL '-100' YEAR)|
+----------------------------+
| -1.0|
+----------------------------+
-- sin
SELECT sin(0);
+------+
|SIN(0)|
+------+
| 0.0|
+------+
-- sinh
SELECT sinh(0);
+-------+
|SINH(0)|
+-------+
| 0.0|
+-------+
-- sqrt
SELECT sqrt(4);
+-------+
|SQRT(4)|
+-------+
| 2.0|
+-------+
-- tan
SELECT tan(0);
+------+
|TAN(0)|
+------+
| 0.0|
+------+
-- tanh
SELECT tanh(0);
+-------+
|TANH(0)|
+-------+
| 0.0|
+-------+
-- try_add
SELECT try_add(1, 2);
+-------------+
|try_add(1, 2)|
+-------------+
| 3|
+-------------+
SELECT try_add(2147483647, 1);
+----------------------+
|try_add(2147483647, 1)|
+----------------------+
| NULL|
+----------------------+
SELECT try_add(date'2021-01-01', 1);
+-----------------------------+
|try_add(DATE '2021-01-01', 1)|
+-----------------------------+
| 2021-01-02|
+-----------------------------+
SELECT try_add(date'2021-01-01', interval 1 year);
+---------------------------------------------+
|try_add(DATE '2021-01-01', INTERVAL '1' YEAR)|
+---------------------------------------------+
| 2022-01-01|
+---------------------------------------------+
SELECT try_add(timestamp'2021-01-01 00:00:00', interval 1 day);
+----------------------------------------------------------+
|try_add(TIMESTAMP '2021-01-01 00:00:00', INTERVAL '1' DAY)|
+----------------------------------------------------------+
| 2021-01-02 00:00:00|
+----------------------------------------------------------+
SELECT try_add(interval 1 year, interval 2 year);
+---------------------------------------------+
|try_add(INTERVAL '1' YEAR, INTERVAL '2' YEAR)|
+---------------------------------------------+
| INTERVAL '3' YEAR|
+---------------------------------------------+
-- try_divide
SELECT try_divide(3, 2);
+----------------+
|try_divide(3, 2)|
+----------------+
| 1.5|
+----------------+
SELECT try_divide(2L, 2L);
+----------------+
|try_divide(2, 2)|
+----------------+
| 1.0|
+----------------+
SELECT try_divide(1, 0);
+----------------+
|try_divide(1, 0)|
+----------------+
| NULL|
+----------------+
SELECT try_divide(interval 2 month, 2);
+---------------------------------+
|try_divide(INTERVAL '2' MONTH, 2)|
+---------------------------------+
| INTERVAL '0-1' YE...|
+---------------------------------+
SELECT try_divide(interval 2 month, 0);
+---------------------------------+
|try_divide(INTERVAL '2' MONTH, 0)|
+---------------------------------+
| NULL|
+---------------------------------+
-- try_multiply
SELECT try_multiply(2, 3);
+------------------+
|try_multiply(2, 3)|
+------------------+
| 6|
+------------------+
SELECT try_multiply(-2147483648, 10);
+-----------------------------+
|try_multiply(-2147483648, 10)|
+-----------------------------+
| NULL|
+-----------------------------+
SELECT try_multiply(interval 2 year, 3);
+----------------------------------+
|try_multiply(INTERVAL '2' YEAR, 3)|
+----------------------------------+
| INTERVAL '6-0' YE...|
+----------------------------------+
-- try_subtract
SELECT try_subtract(2, 1);
+------------------+
|try_subtract(2, 1)|
+------------------+
| 1|
+------------------+
SELECT try_subtract(-2147483648, 1);
+----------------------------+
|try_subtract(-2147483648, 1)|
+----------------------------+
| NULL|
+----------------------------+
SELECT try_subtract(date'2021-01-02', 1);
+----------------------------------+
|try_subtract(DATE '2021-01-02', 1)|
+----------------------------------+
| 2021-01-01|
+----------------------------------+
SELECT try_subtract(date'2021-01-01', interval 1 year);
+--------------------------------------------------+
|try_subtract(DATE '2021-01-01', INTERVAL '1' YEAR)|
+--------------------------------------------------+
| 2020-01-01|
+--------------------------------------------------+
SELECT try_subtract(timestamp'2021-01-02 00:00:00', interval 1 day);
+---------------------------------------------------------------+
|try_subtract(TIMESTAMP '2021-01-02 00:00:00', INTERVAL '1' DAY)|
+---------------------------------------------------------------+
| 2021-01-01 00:00:00|
+---------------------------------------------------------------+
SELECT try_subtract(interval 2 year, interval 1 year);
+--------------------------------------------------+
|try_subtract(INTERVAL '2' YEAR, INTERVAL '1' YEAR)|
+--------------------------------------------------+
| INTERVAL '1' YEAR|
+--------------------------------------------------+
-- unhex
SELECT decode(unhex('53514C'), 'UTF-8');
+----------------------------------------+
|decode(unhex(53514C), UTF-8)|
+----------------------------------------+
| SQL|
+----------------------------------------+
-- width_bucket
SELECT width_bucket(5.3, 0.2, 10.6, 5);
+-------------------------------+
|width_bucket(5.3, 0.2, 10.6, 5)|
+-------------------------------+
| 3|
+-------------------------------+
SELECT width_bucket(-2.1, 1.3, 3.4, 3);
+-------------------------------+
|width_bucket(-2.1, 1.3, 3.4, 3)|
+-------------------------------+
| 0|
+-------------------------------+
SELECT width_bucket(8.1, 0.0, 5.7, 4);
+------------------------------+
|width_bucket(8.1, 0.0, 5.7, 4)|
+------------------------------+
| 5|
+------------------------------+
SELECT width_bucket(-0.9, 5.2, 0.5, 2);
+-------------------------------+
|width_bucket(-0.9, 5.2, 0.5, 2)|
+-------------------------------+
| 3|
+-------------------------------+
SELECT width_bucket(INTERVAL '0' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10);
+--------------------------------------------------------------------------+
|width_bucket(INTERVAL '0' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10)|
+--------------------------------------------------------------------------+
| 1|
+--------------------------------------------------------------------------+
SELECT width_bucket(INTERVAL '1' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10);
+--------------------------------------------------------------------------+
|width_bucket(INTERVAL '1' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10)|
+--------------------------------------------------------------------------+
| 2|
+--------------------------------------------------------------------------+
SELECT width_bucket(INTERVAL '0' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10);
+-----------------------------------------------------------------------+
|width_bucket(INTERVAL '0' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10)|
+-----------------------------------------------------------------------+
| 1|
+-----------------------------------------------------------------------+
SELECT width_bucket(INTERVAL '1' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10);
+-----------------------------------------------------------------------+
|width_bucket(INTERVAL '1' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10)|
+-----------------------------------------------------------------------+
| 2|
+-----------------------------------------------------------------------+
```
#### Funções geradoras
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a essas funções SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
****
| Função | Description |
| --- | --- |
| explode(expr) | Separa os elementos da matriz `expr` em várias linhas ou os elementos do mapa `expr em várias linhas e colunas. A menos que especificado de outra forma, usa o nome de coluna padrão `col` para elementos da matriz ou `key` e `value` para os elementos do mapa. |
| explode\$1outer(expr) | Separa os elementos da matriz `expr` em várias linhas ou os elementos do mapa `expr em várias linhas e colunas. A menos que especificado de outra forma, usa o nome de coluna padrão `col` para elementos da matriz ou `key` e `value` para os elementos do mapa. |
| inline(expr) | Explode uma matriz de estruturas em uma tabela. Usa os nomes das colunas col1, col2, etc. por padrão, a menos que especificado de outra forma. |
| inline\$1outer(expr) | Explode uma matriz de estruturas em uma tabela. Usa os nomes das colunas col1, col2, etc. por padrão, a menos que especificado de outra forma. |
| posexplode(expr) | Separa os elementos da matriz `expr` em várias linhas com posições ou os elementos do mapa `expr` em várias linhas e colunas com posições. A menos que especificado de outra forma, usa o nome de coluna padrão `pos` para posição, `col` para os elementos da matriz ou `key` e `value` para os elementos do mapa. |
| posexplode\$1outer(expr) | Separa os elementos da matriz `expr` em várias linhas com posições ou os elementos do mapa `expr` em várias linhas e colunas com posições. A menos que especificado de outra forma, usa o nome de coluna padrão `pos` para posição, `col` para os elementos da matriz ou `key` e `value` para os elementos do mapa. |
| stack(n, expr1, ..., exprk) | Separa `expr1`, ..., `exprk` em `n` linhas. Usa os nomes das colunas col0, col1 etc. por padrão, a menos que especificado de outra forma. |
**Exemplos**
```
-- explode
SELECT explode(array(10, 20));
+---+
|col|
+---+
| 10|
| 20|
+---+
SELECT explode(collection => array(10, 20));
+---+
|col|
+---+
| 10|
| 20|
+---+
SELECT * FROM explode(collection => array(10, 20));
+---+
|col|
+---+
| 10|
| 20|
+---+
-- explode_outer
SELECT explode_outer(array(10, 20));
+---+
|col|
+---+
| 10|
| 20|
+---+
SELECT explode_outer(collection => array(10, 20));
+---+
|col|
+---+
| 10|
| 20|
+---+
SELECT * FROM explode_outer(collection => array(10, 20));
+---+
|col|
+---+
| 10|
| 20|
+---+
-- inline
SELECT inline(array(struct(1, 'a'), struct(2, 'b')));
+----+----+
|col1|col2|
+----+----+
| 1| a|
| 2| b|
+----+----+
-- inline_outer
SELECT inline_outer(array(struct(1, 'a'), struct(2, 'b')));
+----+----+
|col1|col2|
+----+----+
| 1| a|
| 2| b|
+----+----+
-- posexplode
SELECT posexplode(array(10,20));
+---+---+
|pos|col|
+---+---+
| 0| 10|
| 1| 20|
+---+---+
SELECT * FROM posexplode(array(10,20));
+---+---+
|pos|col|
+---+---+
| 0| 10|
| 1| 20|
+---+---+
-- posexplode_outer
SELECT posexplode_outer(array(10,20));
+---+---+
|pos|col|
+---+---+
| 0| 10|
| 1| 20|
+---+---+
SELECT * FROM posexplode_outer(array(10,20));
+---+---+
|pos|col|
+---+---+
| 0| 10|
| 1| 20|
+---+---+
-- stack
SELECT stack(2, 1, 2, 3);
+----+----+
|col0|col1|
+----+----+
| 1| 2|
| 3|NULL|
+----+----+
```
#### Cláusula SELECT
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
OpenSearch O SQL suporta uma `SELECT` instrução usada para recuperar conjuntos de resultados de uma ou mais tabelas. A seção a seguir descreve a sintaxe de consulta em geral e as diferentes construções de uma consulta.
**Sintaxe**
```
select_statement
[ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select_statement, ... ]
[ ORDER BY
{ expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ]
[ , ... ]
}
]
[ SORT BY
{ expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ]
[ , ... ]
}
]
[ WINDOW { named_window [ , WINDOW named_window, ... ] } ]
[ LIMIT { ALL | expression } ]
```
Enquanto `select_statement` é definido como:
```
SELECT [ ALL | DISTINCT ] { [ [ named_expression ] [ , ... ] ] }
FROM { from_item [ , ... ] }
[ PIVOT clause ]
[ UNPIVOT clause ]
[ LATERAL VIEW clause ] [ ... ]
[ WHERE boolean_expression ]
[ GROUP BY expression [ , ... ] ]
[ HAVING boolean_expression ]
```
**Parâmetros**
+ **TUDO**
Seleciona todas as linhas correspondentes da relação e é habilitada por padrão.
+ **DISTINTO**
Seleciona todas as linhas correspondentes da relação após remover as duplicações dos resultados.
+ **named\$1expression **
Uma expressão com um nome atribuído. Em geral, denota uma expressão de coluna.
Sintaxe: `expression [[AS] alias]`
+ **from\$1item **
Relação de tabela
Relação de união
Relação de pivô
Relação de despivô
Funções de valor de tabela
Tabela em linha
`[ LATERAL ] ( Subquery )`
+ **PIVÔ**
A cláusula `PIVOT` é usada para perspectiva de dados. Você pode obter os valores agregados com base no valor específico da coluna.
+ **UNPIVOT**
A cláusula `UNPIVOT` transforma colunas em linhas. É o inverso de `PIVOT`, exceto pela agregação de valores.
+ **LATERAL VIEW **
A cláusula `LATERAL VIEW` é usada em conjunto com funções geradoras, como `EXPLODE`, que gerará uma tabela virtual contendo uma ou mais linhas.
`LATERAL VIEW` aplicará as linhas a cada linha de saída original.
+ **WHERE**
Filtra o resultado da cláusula `FROM` com base nos predicados fornecidos.
+ **AGRUPAR POR**
Especifica as expressões usadas para agrupar as linhas.
Isso é usado em conjunto com funções de agregação (`MIN`, `MAX`, `COUNT`, `SUM`, `AVG` e assim por diante) para agrupar linhas com base nas expressões de agrupamento e agregar os valores de cada grupo.
Quando uma cláusula `FILTER` é anexada a uma função de agregação, somente as linhas correspondentes são passadas para essa função.
+ **TENDO**
Especifica os predicados pelos quais as linhas produzidas por `GROUP BY` são filtradas.
A cláusula `HAVING` é usada para filtrar linhas após o agrupamento ser realizado.
Se `HAVING` for especificada sem `GROUP BY`, indica uma `GROUP BY` sem expressões de agrupamento (agregado global).
+ **ORDER BY**
Especifica a ordem das linhas de todo o conjunto de resultados da consulta.
As linhas de saída são ordenadas entre as partições.
Esse parâmetro é mutuamente exclusivo com `SORT BY` e `DISTRIBUTE BY`, e não podem ser especificados juntos.
+ **SORT BY **
Especifica a ordem em que as linhas são ordenadas em cada partição.
Esse parâmetro é mutuamente exclusivo com `ORDER BY`, não podem ser especificados juntos.
+ **LIMIT**
Especifica o número máximo de linhas que pode ser retornado por uma instrução ou subconsulta.
Essa cláusula é usada principalmente em conjunto com `ORDER BY` para produzir um resultado determinístico.
+ **boolean\$1expression **
Especifica qualquer expressão que é avaliada como um resultado do tipo booleano.
Duas ou mais expressões podem ser combinadas usando os operadores lógicos (`AND`, `OR`).
+ **expressão**
Especifica uma combinação de um ou mais valores, operadores e funções SQL que são avaliadas como um valor.
+ **named\$1window **
Especifica aliases para uma ou mais especificações da janela de origem.
As especificações da janela de origem podem ser referenciadas nas definições da janela na consulta.
#### Cláusula WHERE
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
A cláusula `WHERE` é usada para limitar os resultados da cláusula `FROM` de uma consulta ou subconsulta com base na condição especificada.
**Sintaxe**
```
WHERE boolean_expression
```
**Parâmetros**
+ **boolean\$1expression**
Especifica qualquer expressão que é avaliada como um resultado do tipo booleano.
Duas ou mais expressões podem ser combinadas usando os operadores lógicos (`AND`, `OR`).
**Exemplos**
```
CREATE TABLE person (id INT, name STRING, age INT);
INSERT INTO person VALUES
(100, 'John', 30),
(200, 'Mary', NULL),
(300, 'Mike', 80),
(400, 'Dan', 50);
-- Comparison operator in `WHERE` clause.
SELECT * FROM person WHERE id > 200 ORDER BY id;
+---+----+---+
| id|name|age|
+---+----+---+
|300|Mike| 80|
|400| Dan| 50|
+---+----+---+
-- Comparison and logical operators in `WHERE` clause.
SELECT * FROM person WHERE id = 200 OR id = 300 ORDER BY id;
+---+----+----+
| id|name| age|
+---+----+----+
|200|Mary|null|
|300|Mike| 80|
+---+----+----+
-- IS NULL expression in `WHERE` clause.
SELECT * FROM person WHERE id > 300 OR age IS NULL ORDER BY id;
+---+----+----+
| id|name| age|
+---+----+----+
|200|Mary|null|
|400| Dan| 50|
+---+----+----+
-- Function expression in `WHERE` clause.
SELECT * FROM person WHERE length(name) > 3 ORDER BY id;
+---+----+----+
| id|name| age|
+---+----+----+
|100|John| 30|
|200|Mary|null|
|300|Mike| 80|
+---+----+----+
-- `BETWEEN` expression in `WHERE` clause.
SELECT * FROM person WHERE id BETWEEN 200 AND 300 ORDER BY id;
+---+----+----+
| id|name| age|
+---+----+----+
|200|Mary|null|
|300|Mike| 80|
+---+----+----+
-- Scalar Subquery in `WHERE` clause.
SELECT * FROM person WHERE age > (SELECT avg(age) FROM person);
+---+----+---+
| id|name|age|
+---+----+---+
|300|Mike| 80|
+---+----+---+
-- Correlated Subquery in `WHERE` clause.
SELECT id FROM person
WHERE exists (SELECT id FROM person where id = 200);
+---+----+----+
|id |name|age |
+---+----+----+
|200|Mary|null|
+---+----+----+
```
#### Cláusula GROUP BY
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
A cláusula `GROUP BY` é usada para agrupar as linhas com base em um conjunto de expressões de agrupamento especificadas e computar agregações no grupo de linhas com base em uma ou mais funções de agregação especificadas.
O sistema também faz várias agregações para o mesmo registro de entrada definido pelas cláusulas `GROUPING SETS`, `CUBE` e `ROLLUP`. As expressões de agrupamento e as agregações avançadas podem ser combinadas na cláusula `GROUP BY` e aninhadas em uma cláusula `GROUPING SETS `. Veja mais detalhes na seção `Mixed/Nested Grouping Analytics `.
Quando uma cláusula `FILTER` é anexada a uma função de agregação, somente as linhas correspondentes são passadas para essa função.
**Sintaxe**
```
GROUP BY group_expression [ , group_expression [ , ... ] ] [ WITH { ROLLUP | CUBE } ]
GROUP BY { group_expression | { ROLLUP | CUBE | GROUPING SETS } (grouping_set [ , ...]) } [ , ... ]
```
Embora as funções de agregação sejam definidas como:
```
aggregate_name ( [ DISTINCT ] expression [ , ... ] ) [ FILTER ( WHERE boolean_expression ) ]
```
**Parâmetros**
+ **group\$1expression **
Especifica os critérios com base nos quais as linhas são agrupadas. O agrupamento de linhas é realizado com base nos valores dos resultados das expressões de agrupamento.
Uma expressão de agrupamento pode ser um nome de coluna, como `GROUP BY a`, uma posição de coluna como `GROUP BY 0` ou uma expressão como `GROUP BY a + b`.
+ **grouping\$1set **
Um conjunto de agrupamento é especificado por zero ou mais expressões separadas por vírgula entre parênteses. Quando o conjunto de agrupamento tem somente um elemento, os parênteses podem ser omitidos.
Por exemplo, `GROUPING SETS ((a), (b))` é o mesmo que `GROUPING SETS (a, b)`.
Sintaxe: `{ ( [ expression [ , ... ] ] ) | expression }`
+ **GROUPING SETS**
Agrupa as linhas para cada conjunto de agrupamento especificado depois de `GROUPING SETS`.
Por exemplo, `GROUP BY GROUPING SETS ((warehouse), (product))` é semanticamente equivalente à união dos resultados de `GROUP BY warehouse` e `GROUP BY product`. Essa cláusula é uma abreviação de UNION ALL em que cada etapa do operador `UNION ALL` realiza a agregação de cada conjunto de agrupamento especificado na cláusula `GROUPING SETS`.
Da mesma forma, `GROUP BY GROUPING SETS ((warehouse, product), (product), ())` é semanticamente equivalente à união dos resultados de `GROUP BY warehouse, product, GROUP BY product` e uma agregação global.
+ **ROLLUP**
Especifica vários níveis de agregações em uma única instrução. Essa cláusula é usada para computar agregações com base em vários conjuntos de agrupamentos. `ROLLUP` é uma abreviatura de `GROUPING SETS`.
Por exemplo, `GROUP BY warehouse, product WITH ROLLUP or GROUP BY ROLLUP(warehouse, product)` equivale a `GROUP BY GROUPING SETS((warehouse, product), (warehouse), ())`.
`GROUP BY ROLLUP(warehouse, product, (warehouse, location))` é equivalente a `GROUP BY GROUPING SETS((warehouse, product, location), (warehouse, product), (warehouse), ())`.
Os N elementos de uma especificação ROLLUP resultam em N\$11 GROUPING SETS.
+ **CUBE**
A cláusula CUBE é usada para realizar agregações com base na combinação de colunas de agrupamento especificadas na cláusula GROUP BY. CUBE é uma abreviatura de GROUPING SETS.
Por exemplo, `GROUP BY warehouse, product WITH CUBE or GROUP BY CUBE(warehouse, product)` equivale a `GROUP BY GROUPING SETS((warehouse, product), (warehouse), (product), ())`.
`GROUP BY CUBE(warehouse, product, (warehouse, location))` é equivalente a `GROUP BY GROUPING SETS((warehouse, product, location), (warehouse, product), (warehouse, location), (product, warehouse, location), (warehouse), (product), (warehouse, product), ())`. Os N elementos de uma especificação de `CUBE` resultam em 2^N `GROUPING SETS`.
+ **Analytics de agrupamento misto/aninhado**
Uma cláusula `GROUP BY` pode incluir várias group\$1expressions e vários `CUBE|ROLLUP|GROUPING SETS`. `GROUPING SETS` também podem ter cláusulas `CUBE|ROLLUP|GROUPING SETS` aninhadas, como, `GROUPING SETS(ROLLUP(warehouse, location)`, `CUBE(warehouse, location))`. `GROUPING SETS(warehouse, GROUPING SETS(location, GROUPING SETS(ROLLUP(warehouse, location),` `CUBE(warehouse, location))))`.
`CUBE|ROLLUP` é apenas um açúcar sintático para `GROUPING SETS`. Consulte as seções acima para saber como traduzir `CUBE|ROLLUP` para `GROUPING SETS`. Pode-se tratar `group_expression` como `GROUPING SETS` de grupo único nesse contexto.
Para vários `GROUPING SETS` na cláusula `GROUP BY`, geramos um único `GROUPING SETS` fazendo um produto cartesiano do original `GROUPING SETS`. Para `GROUPING SETS` aninhado na cláusula `GROUPING SETS`, simplesmente pegamos seus conjuntos de agrupamentos e os removemos.
Por exemplo, `GROUP BY warehouse, GROUPING SETS((product), ()), GROUPING SETS((location, size), (location), (size), ()) and GROUP BY warehouse, ROLLUP(product), CUBE(location, size)` equivale a `GROUP BY GROUPING SETS( (warehouse, product, location, size), (warehouse, product, location), (warehouse, product, size), (warehouse, product), (warehouse, location, size), (warehouse, location), (warehouse, size), (warehouse))`.
`GROUP BY GROUPING SETS(GROUPING SETS(warehouse), GROUPING SETS((warehouse, product)))` é equivalente a `GROUP BY GROUPING SETS((warehouse), (warehouse, product))`.
+ **aggregate\$1name **
Especifica um nome de função de agregação (`MIN`, `MAX`, `COUNT`, `SUM`, `AVG` e assim por diante).
+ **DISTINTO**
Remove duplicações nas linhas de entrada antes que elas sejam passadas para funções de agregação.
+ **FILTRO**
Filtra as linhas de entrada para as quais a cláusula `boolean_expression` na cláusula `WHERE` é avaliada como verdadeiro são passadas para a função de agregação; outras linhas são descartadas.
**Exemplos**
```
CREATE TABLE dealer (id INT, city STRING, car_model STRING, quantity INT);
INSERT INTO dealer VALUES
(100, 'Fremont', 'Honda Civic', 10),
(100, 'Fremont', 'Honda Accord', 15),
(100, 'Fremont', 'Honda CRV', 7),
(200, 'Dublin', 'Honda Civic', 20),
(200, 'Dublin', 'Honda Accord', 10),
(200, 'Dublin', 'Honda CRV', 3),
(300, 'San Jose', 'Honda Civic', 5),
(300, 'San Jose', 'Honda Accord', 8);
-- Sum of quantity per dealership. Group by `id`.
SELECT id, sum(quantity) FROM dealer GROUP BY id ORDER BY id;
+---+-------------+
| id|sum(quantity)|
+---+-------------+
|100| 32|
|200| 33|
|300| 13|
+---+-------------+
-- Use column position in GROUP by clause.
SELECT id, sum(quantity) FROM dealer GROUP BY 1 ORDER BY 1;
+---+-------------+
| id|sum(quantity)|
+---+-------------+
|100| 32|
|200| 33|
|300| 13|
+---+-------------+
-- Multiple aggregations.
-- 1. Sum of quantity per dealership.
-- 2. Max quantity per dealership.
SELECT id, sum(quantity) AS sum, max(quantity) AS max FROM dealer GROUP BY id ORDER BY id;
+---+---+---+
| id|sum|max|
+---+---+---+
|100| 32| 15|
|200| 33| 20|
|300| 13| 8|
+---+---+---+
-- Count the number of distinct dealer cities per car_model.
SELECT car_model, count(DISTINCT city) AS count FROM dealer GROUP BY car_model;
+------------+-----+
| car_model|count|
+------------+-----+
| Honda Civic| 3|
| Honda CRV| 2|
|Honda Accord| 3|
+------------+-----+
-- Sum of only 'Honda Civic' and 'Honda CRV' quantities per dealership.
SELECT id, sum(quantity) FILTER (
WHERE car_model IN ('Honda Civic', 'Honda CRV')
) AS `sum(quantity)` FROM dealer
GROUP BY id ORDER BY id;
+---+-------------+
| id|sum(quantity)|
+---+-------------+
|100| 17|
|200| 23|
|300| 5|
+---+-------------+
-- Aggregations using multiple sets of grouping columns in a single statement.
-- Following performs aggregations based on four sets of grouping columns.
-- 1. city, car_model
-- 2. city
-- 3. car_model
-- 4. Empty grouping set. Returns quantities for all city and car models.
SELECT city, car_model, sum(quantity) AS sum FROM dealer
GROUP BY GROUPING SETS ((city, car_model), (city), (car_model), ())
ORDER BY city;
+---------+------------+---+
| city| car_model|sum|
+---------+------------+---+
| null| null| 78|
| null| HondaAccord| 33|
| null| HondaCRV| 10|
| null| HondaCivic| 35|
| Dublin| null| 33|
| Dublin| HondaAccord| 10|
| Dublin| HondaCRV| 3|
| Dublin| HondaCivic| 20|
| Fremont| null| 32|
| Fremont| HondaAccord| 15|
| Fremont| HondaCRV| 7|
| Fremont| HondaCivic| 10|
| San Jose| null| 13|
| San Jose| HondaAccord| 8|
| San Jose| HondaCivic| 5|
+---------+------------+---+
-- Group by processing with `ROLLUP` clause.
-- Equivalent GROUP BY GROUPING SETS ((city, car_model), (city), ())
SELECT city, car_model, sum(quantity) AS sum FROM dealer
GROUP BY city, car_model WITH ROLLUP
ORDER BY city, car_model;
+---------+------------+---+
| city| car_model|sum|
+---------+------------+---+
| null| null| 78|
| Dublin| null| 33|
| Dublin| HondaAccord| 10|
| Dublin| HondaCRV| 3|
| Dublin| HondaCivic| 20|
| Fremont| null| 32|
| Fremont| HondaAccord| 15|
| Fremont| HondaCRV| 7|
| Fremont| HondaCivic| 10|
| San Jose| null| 13|
| San Jose| HondaAccord| 8|
| San Jose| HondaCivic| 5|
+---------+------------+---+
-- Group by processing with `CUBE` clause.
-- Equivalent GROUP BY GROUPING SETS ((city, car_model), (city), (car_model), ())
SELECT city, car_model, sum(quantity) AS sum FROM dealer
GROUP BY city, car_model WITH CUBE
ORDER BY city, car_model;
+---------+------------+---+
| city| car_model|sum|
+---------+------------+---+
| null| null| 78|
| null| HondaAccord| 33|
| null| HondaCRV| 10|
| null| HondaCivic| 35|
| Dublin| null| 33|
| Dublin| HondaAccord| 10|
| Dublin| HondaCRV| 3|
| Dublin| HondaCivic| 20|
| Fremont| null| 32|
| Fremont| HondaAccord| 15|
| Fremont| HondaCRV| 7|
| Fremont| HondaCivic| 10|
| San Jose| null| 13|
| San Jose| HondaAccord| 8|
| San Jose| HondaCivic| 5|
+---------+------------+---+
--Prepare data for ignore nulls example
CREATE TABLE person (id INT, name STRING, age INT);
INSERT INTO person VALUES
(100, 'Mary', NULL),
(200, 'John', 30),
(300, 'Mike', 80),
(400, 'Dan', 50);
--Select the first row in column age
SELECT FIRST(age) FROM person;
+--------------------+
| first(age, false) |
+--------------------+
| NULL |
+--------------------+
--Get the first row in column `age` ignore nulls,last row in column `id` and sum of column `id`.
SELECT FIRST(age IGNORE NULLS), LAST(id), SUM(id) FROM person;
+-------------------+------------------+----------+
| first(age, true) | last(id, false) | sum(id) |
+-------------------+------------------+----------+
| 30 | 400 | 1000 |
+-------------------+------------------+----------+
```
#### Cláusula HAVING
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
A cláusula `HAVING` é usada para filtrar os resultados produzidos por `GROUP BY` com base na condição especificada. É frequentemente usada em conjunto com uma cláusula `GROUP BY`.
**Sintaxe**
```
HAVING boolean_expression
```
**Parâmetros**
+ **boolean\$1expression **
Especifica qualquer expressão que é avaliada como um resultado do tipo booleano. Duas ou mais expressões podem ser combinadas usando os operadores lógicos (`AND`, `OR`).
**Observação** As expressões especificadas na cláusula `HAVING` apenas podem se referir a:
1. Constantes
1. Expressões que aparecem em `GROUP BY`
1. Funções agregadas
**Exemplos**
```
CREATE TABLE dealer (id INT, city STRING, car_model STRING, quantity INT);
INSERT INTO dealer VALUES
(100, 'Fremont', 'Honda Civic', 10),
(100, 'Fremont', 'Honda Accord', 15),
(100, 'Fremont', 'Honda CRV', 7),
(200, 'Dublin', 'Honda Civic', 20),
(200, 'Dublin', 'Honda Accord', 10),
(200, 'Dublin', 'Honda CRV', 3),
(300, 'San Jose', 'Honda Civic', 5),
(300, 'San Jose', 'Honda Accord', 8);
-- `HAVING` clause referring to column in `GROUP BY`.
SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING city = 'Fremont';
+-------+---+
| city|sum|
+-------+---+
|Fremont| 32|
+-------+---+
-- `HAVING` clause referring to aggregate function.
SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING sum(quantity) > 15;
+-------+---+
| city|sum|
+-------+---+
| Dublin| 33|
|Fremont| 32|
+-------+---+
-- `HAVING` clause referring to aggregate function by its alias.
SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING sum > 15;
+-------+---+
| city|sum|
+-------+---+
| Dublin| 33|
|Fremont| 32|
+-------+---+
-- `HAVING` clause referring to a different aggregate function than what is present in
-- `SELECT` list.
SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING max(quantity) > 15;
+------+---+
| city|sum|
+------+---+
|Dublin| 33|
+------+---+
-- `HAVING` clause referring to constant expression.
SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING 1 > 0 ORDER BY city;
+--------+---+
| city|sum|
+--------+---+
| Dublin| 33|
| Fremont| 32|
|San Jose| 13|
+--------+---+
-- `HAVING` clause without a `GROUP BY` clause.
SELECT sum(quantity) AS sum FROM dealer HAVING sum(quantity) > 10;
+---+
|sum|
+---+
| 78|
+---+
```
#### Cláusula ORDER BY
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
A cláusula `ORDER BY` é usada para retornar as linhas de resultados classificados na ordem especificada pelo usuário. Diferentemente da cláusula SORT BY, essa cláusula garante uma ordem total na saída.
**Sintaxe**
```
ORDER BY { expression [ sort_direction | nulls_sort_order ] [ , ... ] }
```
**Parâmetros**
+ **ORDER BY**
Especifica uma lista de expressões separadas por vírgula junto com parâmetros opcionais `sort_direction` e `nulls_sort_order` que são usados para classificar as linhas.
+ **sort\$1direction **
Opcionalmente, especifica se as linhas devem ser classificadas em ordem crescente ou decrescente.
Os valores válidos para a direção de classificação são `ASC` para crescente e `DESC` para decrescente.
Se a direção da classificação não for especificada explicitamente, as linhas serão classificadas em ordem crescente por padrão.
Sintaxe: `[ ASC | DESC ] `
+ **nulos\$1sort\$1order **
Opcionalmente, especifica se `NULL` os valores são retornados valores before/after não NULL.
Se nulo\$1sort\$1order não for especificada, `NULLs` serão classificados primeiro se a ordem de classificação for `ASC` e NULLS serão classificados por último se a ordem de classificação for `DESC`.
1. Se `NULLS FIRST` for especificado, os valores NULL serão retornados primeiro, independentemente da ordem de classificação.
2. Se `NULLS LAST` for especificado, os valores NULL serão retornados por último, independentemente da ordem de classificação.
Sintaxe: `[ NULLS { FIRST | LAST } ]`
**Exemplos**
```
CREATE TABLE person (id INT, name STRING, age INT);
INSERT INTO person VALUES
(100, 'John', 30),
(200, 'Mary', NULL),
(300, 'Mike', 80),
(400, 'Jerry', NULL),
(500, 'Dan', 50);
-- Sort rows by age. By default rows are sorted in ascending manner with NULL FIRST.
SELECT name, age FROM person ORDER BY age;
+-----+----+
| name| age|
+-----+----+
|Jerry|null|
| Mary|null|
| John| 30|
| Dan| 50|
| Mike| 80|
+-----+----+
-- Sort rows in ascending manner keeping null values to be last.
SELECT name, age FROM person ORDER BY age NULLS LAST;
+-----+----+
| name| age|
+-----+----+
| John| 30|
| Dan| 50|
| Mike| 80|
| Mary|null|
|Jerry|null|
+-----+----+
-- Sort rows by age in descending manner, which defaults to NULL LAST.
SELECT name, age FROM person ORDER BY age DESC;
+-----+----+
| name| age|
+-----+----+
| Mike| 80|
| Dan| 50|
| John| 30|
|Jerry|null|
| Mary|null|
+-----+----+
-- Sort rows in ascending manner keeping null values to be first.
SELECT name, age FROM person ORDER BY age DESC NULLS FIRST;
+-----+----+
| name| age|
+-----+----+
|Jerry|null|
| Mary|null|
| Mike| 80|
| Dan| 50|
| John| 30|
+-----+----+
-- Sort rows based on more than one column with each column having different
-- sort direction.
SELECT * FROM person ORDER BY name ASC, age DESC;
+---+-----+----+
| id| name| age|
+---+-----+----+
|500| Dan| 50|
|400|Jerry|null|
|100| John| 30|
|200| Mary|null|
|300| Mike| 80|
+---+-----+----+
```
#### Cláusula JOIN
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
Uma união SQL é usada para combinar linhas de duas relações com base nos critérios de união. A seção a seguir descreve a sintaxe de união em geral e os diferentes tipos de uniões, com exemplos.
**Sintaxe**
```
relation INNER JOIN relation [ join_criteria ]
```
**Parâmetros**
+ **relation **
Especifica a relação a ser unida.
+ **join\$1type**
Especifica o tipo de união.
Sintaxe: `INNER | CROSS | LEFT OUTER`
+ **join\$1criteria **
Especifica como as linhas de uma relação serão combinadas com as linhas de outra relação.
Sintaxe: `ON boolean_expression | USING ( column_name [ , ... ] ) `
+ **boolean\$1expression **
Especifica uma expressão com um retorno do tipo booleano.
**Tipos de união**
+ **União interna**
A união interna precisa ser especificada explicitamente. Ele seleciona linhas que têm valores correspondentes em ambas as relações.
Sintaxe: `relation INNER JOIN relation [ join_criteria ] `
+ **União à esquerda **
Uma união à esquerda retorna todos os valores da relação à esquerda e os valores correspondentes da relação à direita, ou acrescentará NULL se não houver nenhuma correspondência. Também é chamada de união externa à esquerda.
Sintaxe: `relation LEFT OUTER JOIN relation [ join_criteria ]`
+ **União cruzada **
Uma união cruzada retorna o produto cartesiano de duas relações.
Sintaxe: `relation CROSS JOIN relation [ join_criteria ]`
**Exemplos**
```
-- Use employee and department tables to demonstrate different type of joins.
SELECT * FROM employee;
+---+-----+------+
| id| name|deptno|
+---+-----+------+
|105|Chloe| 5|
|103| Paul| 3|
|101| John| 1|
|102| Lisa| 2|
|104| Evan| 4|
|106| Amy| 6|
+---+-----+------+
SELECT * FROM department;
+------+-----------+
|deptno| deptname|
+------+-----------+
| 3|Engineering|
| 2| Sales|
| 1| Marketing|
+------+-----------+
-- Use employee and department tables to demonstrate inner join.
SELECT id, name, employee.deptno, deptname
FROM employee INNER JOIN department ON employee.deptno = department.deptno;
+---+-----+------+-----------|
| id| name|deptno| deptname|
+---+-----+------+-----------|
|103| Paul| 3|Engineering|
|101| John| 1| Marketing|
|102| Lisa| 2| Sales|
+---+-----+------+-----------|
-- Use employee and department tables to demonstrate left join.
SELECT id, name, employee.deptno, deptname
FROM employee LEFT JOIN department ON employee.deptno = department.deptno;
+---+-----+------+-----------|
| id| name|deptno| deptname|
+---+-----+------+-----------|
|105|Chloe| 5| NULL|
|103| Paul| 3|Engineering|
|101| John| 1| Marketing|
|102| Lisa| 2| Sales|
|104| Evan| 4| NULL|
|106| Amy| 6| NULL|
+---+-----+------+-----------|
-- Use employee and department tables to demonstrate cross join.
SELECT id, name, employee.deptno, deptname FROM employee CROSS JOIN department;
+---+-----+------+-----------|
| id| name|deptno| deptname|
+---+-----+------+-----------|
|105|Chloe| 5|Engineering|
|105|Chloe| 5| Marketing|
|105|Chloe| 5| Sales|
|103| Paul| 3|Engineering|
|103| Paul| 3| Marketing|
|103| Paul| 3| Sales|
|101| John| 1|Engineering|
|101| John| 1| Marketing|
|101| John| 1| Sales|
|102| Lisa| 2|Engineering|
|102| Lisa| 2| Marketing|
|102| Lisa| 2| Sales|
|104| Evan| 4|Engineering|
|104| Evan| 4| Marketing|
|104| Evan| 4| Sales|
|106| Amy| 4|Engineering|
|106| Amy| 4| Marketing|
|106| Amy| 4| Sales|
+---+-----+------+-----------|
```
#### Cláusula LIMIT
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
A cláusula `LIMIT` é usada para restringir o número de linhas retornado pela instrução `SELECT`. Em geral, essa cláusula é usada em conjunto com `ORDER BY` para garantir que os resultados sejam determinísticos.
**Sintaxe**
```
LIMIT { ALL | integer_expression }
```
**Parâmetros**
+ **TUDO**
Se especificada, a consulta retornará todas as linhas. Em outras palavras, nenhum limite será aplicado se essa opção for especificada.
+ **integer\$1expression **
Especifica uma expressão redutível que retorna um número inteiro.
**Exemplos**
```
CREATE TABLE person (name STRING, age INT);
INSERT INTO person VALUES
('Jane Doe', 25),
('Pat C', 18),
('Nikki W', 16),
('John D', 25),
('Juan L', 18),
('Jorge S', 16);
-- Select the first two rows.
SELECT name, age FROM person ORDER BY name LIMIT 2;
+-------+---+
| name|age|
+-------+---+
| Pat C| 18|
|Jorge S| 16|
+------+---+
-- Specifying ALL option on LIMIT returns all the rows.
SELECT name, age FROM person ORDER BY name LIMIT ALL;
+--------+---+
| name|age|
+--------+---+
| Pat C| 18|
| Jorge S| 16|
| Juan L| 18|
| John D| 25|
| Nikki W| 16|
|Jane Doe| 25|
+--------+---+
-- A function expression as an input to LIMIT.
SELECT name, age FROM person ORDER BY name LIMIT length('OPENSEARCH');
+-------+---+
| name|age|
+-------+---+
| Pat C| 18|
|Jorge S| 16|
| Juan L| 18|
| John D| 25|
|Nikki W| 16|
+-------+---+
```
#### Cláusula CASE
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
A cláusula `CASE` usa uma regra para retornar um resultado específico com base na condição especificada, semelhante às instruções if/else em outras linguagens de programação.
**Sintaxe**
```
CASE [ expression ] { WHEN boolean_expression THEN then_expression } [ ... ]
[ ELSE else_expression ]
END
```
**Parâmetros**
+ **boolean\$1expression **
Especifica qualquer expressão que é avaliada como um resultado do tipo booleano.
Duas ou mais expressões podem ser combinadas usando os operadores lógicos (`AND`, `OR`).
+ **then\$1expression **
Especifica a expressão then com base na condição de boolean\$1expression.
`then_expression` e `else_expression` devem ser do mesmo tipo ou coercíveis a um tipo comum.
+ **else\$1expression**
Especifica a expressão padrão.
`then_expression` e ` else_expression` devem ser do mesmo tipo ou coercíveis a um tipo comum.
**Exemplos**
```
CREATE TABLE person (id INT, name STRING, age INT);
INSERT INTO person VALUES
(100, 'John', 30),
(200, 'Mary', NULL),
(300, 'Mike', 80),
(400, 'Dan', 50);
SELECT id, CASE WHEN id > 200 THEN 'bigger' ELSE 'small' END FROM person;
+------+--------------------------------------------------+
| id | CASE WHEN (id > 200) THEN bigger ELSE small END |
+------+--------------------------------------------------+
| 100 | small |
| 200 | small |
| 300 | bigger |
| 400 | bigger |
+------+--------------------------------------------------+
SELECT id, CASE id WHEN 100 then 'bigger' WHEN id > 300 THEN '300' ELSE 'small' END FROM person;
+------+-----------------------------------------------------------------------------------------------+
| id | CASE WHEN (id = 100) THEN bigger WHEN (id = CAST((id > 300) AS INT)) THEN 300 ELSE small END |
+------+-----------------------------------------------------------------------------------------------+
| 100 | bigger |
| 200 | small |
| 300 | small |
| 400 | small |
+------+-----------------------------------------------------------------------------------------------+
```
#### Expressão de tabela comum
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
Uma expressão de tabela comum (CTE) define um conjunto de resultados temporários que um usuário pode referenciar várias vezes dentro do escopo de uma instrução SQL. Uma CTE é usada principalmente em um instrução `SELECT`.
**Sintaxe**
```
WITH common_table_expression [ , ... ]
```
Enquanto `common_table_expression` é definido como:
```
Syntexpression_name [ ( column_name [ , ... ] ) ] [ AS ] ( query )
```
**Parâmetros**
+ **expression\$1name **
Especifica um nome para a expressão de tabela comum.
+ **query**
Uma instrução `SELECT`.
**Exemplos**
```
-- CTE with multiple column aliases
WITH t(x, y) AS (SELECT 1, 2)
SELECT * FROM t WHERE x = 1 AND y = 2;
+---+---+
| x| y|
+---+---+
| 1| 2|
+---+---+
-- CTE in CTE definition
WITH t AS (
WITH t2 AS (SELECT 1)
SELECT * FROM t2
)
SELECT * FROM t;
+---+
| 1|
+---+
| 1|
+---+
-- CTE in subquery
SELECT max(c) FROM (
WITH t(c) AS (SELECT 1)
SELECT * FROM t
);
+------+
|max(c)|
+------+
| 1|
+------+
-- CTE in subquery expression
SELECT (
WITH t AS (SELECT 1)
SELECT * FROM t
);
+----------------+
|scalarsubquery()|
+----------------+
| 1|
+----------------+
-- CTE in CREATE VIEW statement
CREATE VIEW v AS
WITH t(a, b, c, d) AS (SELECT 1, 2, 3, 4)
SELECT * FROM t;
SELECT * FROM v;
+---+---+---+---+
| a| b| c| d|
+---+---+---+---+
| 1| 2| 3| 4|
+---+---+---+---+
```
#### EXPLAIN
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
A instrução `EXPLAIN` é usada para fornecer planos lógicos/físicos para uma instrução de entrada. Por padrão, essa cláusula fornece informações somente sobre um plano físico.
**Sintaxe**
```
EXPLAIN [ EXTENDED | CODEGEN | COST | FORMATTED ] statement
```
**Parâmetros**
+ **EXTENDED**
Gera um plano lógico analisado, um plano lógico analisado sintaticamente, um plano lógico otimizado e um plano físico.
O plano lógico analisado sintaticamente é um plano não resolvido que foi extraído da consulta.
Os planos lógicos analisados transformam o que é traduzido como `unresolvedAttribute` e `unresolvedRelation` em objetos totalmente tipificados.
O plano lógico otimizado faz a transformação por meio de um conjunto de regras de otimização, resultando no plano físico.
+ **CODEGEN**
Gera código para a instrução, se existir, e um plano físico.
+ **COST**
Se as estatísticas do nó do plano estiverem disponíveis, gera um plano lógico e as estatísticas.
+ **FORMATTED**
Gera duas seções: um esboço do plano físico e detalhes de nó.
+ **instrução **
Especifica uma instrução SQL a ser explicada.
**Exemplos**
```
-- Default Output
EXPLAIN select k, sum(v) from values (1, 2), (1, 3) t(k, v) group by k;
+----------------------------------------------------+
| plan|
+----------------------------------------------------+
| == Physical Plan ==
*(2) HashAggregate(keys=[k#33], functions=[sum(cast(v#34 as bigint))])
+- Exchange hashpartitioning(k#33, 200), true, [id=#59]
+- *(1) HashAggregate(keys=[k#33], functions=[partial_sum(cast(v#34 as bigint))])
+- *(1) LocalTableScan [k#33, v#34]
|
+----------------------------------------------------
-- Using Extended
EXPLAIN EXTENDED select k, sum(v) from values (1, 2), (1, 3) t(k, v) group by k;
+----------------------------------------------------+
| plan|
+----------------------------------------------------+
| == Parsed Logical Plan ==
'Aggregate ['k], ['k, unresolvedalias('sum('v), None)]
+- 'SubqueryAlias `t`
+- 'UnresolvedInlineTable [k, v], [List(1, 2), List(1, 3)]
== Analyzed Logical Plan ==
k: int, sum(v): bigint
Aggregate [k#47], [k#47, sum(cast(v#48 as bigint)) AS sum(v)#50L]
+- SubqueryAlias `t`
+- LocalRelation [k#47, v#48]
== Optimized Logical Plan ==
Aggregate [k#47], [k#47, sum(cast(v#48 as bigint)) AS sum(v)#50L]
+- LocalRelation [k#47, v#48]
== Physical Plan ==
*(2) HashAggregate(keys=[k#47], functions=[sum(cast(v#48 as bigint))], output=[k#47, sum(v)#50L])
+- Exchange hashpartitioning(k#47, 200), true, [id=#79]
+- *(1) HashAggregate(keys=[k#47], functions=[partial_sum(cast(v#48 as bigint))], output=[k#47, sum#52L])
+- *(1) LocalTableScan [k#47, v#48]
|
+----------------------------------------------------+
-- Using Formatted
EXPLAIN FORMATTED select k, sum(v) from values (1, 2), (1, 3) t(k, v) group by k;
+----------------------------------------------------+
| plan|
+----------------------------------------------------+
| == Physical Plan ==
* HashAggregate (4)
+- Exchange (3)
+- * HashAggregate (2)
+- * LocalTableScan (1)
(1) LocalTableScan [codegen id : 1]
Output: [k#19, v#20]
(2) HashAggregate [codegen id : 1]
Input: [k#19, v#20]
(3) Exchange
Input: [k#19, sum#24L]
(4) HashAggregate [codegen id : 2]
Input: [k#19, sum#24L]
|
+----------------------------------------------------+
```
#### Cláusula LATERAL SUBQUERY
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
`LATERAL SUBQUERY` é uma subconsulta que é precedida pela palavra-chave `LATERAL`. Fornece uma maneira de referenciar colunas na cláusula `FROM` precendente. Sem a palavra-chave `LATERAL`, as subconsultas só podem referenciar colunas na consulta externa, mas não na cláusula `FROM`. `LATERAL SUBQUERY` torna as consultas complicadas mais simples e eficientes.
**Sintaxe**
```
[ LATERAL ] primary_relation [ join_relation ]
```
**Parâmetros**
+ **primary\$1relation **
Especifica a relação primária. Uma das seguintes opções é possível:
1. Relação de tabela
1. Consulta com alias
Sintaxe: `( query ) [ [ AS ] alias ] `
1. Relação com alias
`Syntax: ( relation ) [ [ AS ] alias ]`
**Exemplos**
```
CREATE TABLE t1 (c1 INT, c2 INT);
INSERT INTO t1 VALUES (0, 1), (1, 2);
CREATE TABLE t2 (c1 INT, c2 INT);
INSERT INTO t2 VALUES (0, 2), (0, 3);
SELECT * FROM t1,
LATERAL (SELECT * FROM t2 WHERE t1.c1 = t2.c1);
+--------+-------+--------+-------+
| t1.c1 | t1.c2 | t2.c1 | t2.c2 |
+-------+--------+--------+-------+
| 0 | 1 | 0 | 3 |
| 0 | 1 | 0 | 2 |
+-------+--------+--------+-------+
SELECT a, b, c FROM t1,
LATERAL (SELECT c1 + c2 AS a),
LATERAL (SELECT c1 - c2 AS b),
LATERAL (SELECT a * b AS c);
+--------+-------+--------+
| a | b | c |
+-------+--------+--------+
| 3 | -1 | -3 |
| 1 | -1 | -1 |
+-------+--------+--------+
```
#### Cláusula LATERAL VIEW
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
A cláusula `LATERAL VIEW` é usada em conjunto com funções geradoras, como `EXPLODE`, o que gerará uma tabela virtual contendo uma ou mais linhas. `LATERAL VIEW` aplicará as linhas a cada linha de saída original.
**Sintaxe**
```
LATERAL VIEW [ OUTER ] generator_function ( expression [ , ... ] ) [ table_alias ] AS column_alias [ , ... ]
```
**Parâmetros**
+ **EXTERNO**
Se `OUTER` especificado, retornará null se uma entrada array/map estiver vazia ou nula.
+ **generator\$1function **
Especifica uma função geradora (`EXPLODE`, `INLINE` e assim por diante.).
+ **table\$1alias **
O alias para `generator_function`, que é opcional.
+ **column\$1alias **
Lista os aliases da coluna da `generator_function`, que podem ser usados nas linhas da saída.
Você pode ter vários aliases se `generator_function` tiver várias colunas de saída.
**Exemplos**
```
CREATE TABLE person (id INT, name STRING, age INT, class INT, address STRING);
INSERT INTO person VALUES
(100, 'John', 30, 1, 'Street 1'),
(200, 'Mary', NULL, 1, 'Street 2'),
(300, 'Mike', 80, 3, 'Street 3'),
(400, 'Dan', 50, 4, 'Street 4');
SELECT * FROM person
LATERAL VIEW EXPLODE(ARRAY(30, 60)) tableName AS c_age
LATERAL VIEW EXPLODE(ARRAY(40, 80)) AS d_age;
+------+-------+-------+--------+-----------+--------+--------+
| id | name | age | class | address | c_age | d_age |
+------+-------+-------+--------+-----------+--------+--------+
| 100 | John | 30 | 1 | Street 1 | 30 | 40 |
| 100 | John | 30 | 1 | Street 1 | 30 | 80 |
| 100 | John | 30 | 1 | Street 1 | 60 | 40 |
| 100 | John | 30 | 1 | Street 1 | 60 | 80 |
| 200 | Mary | NULL | 1 | Street 2 | 30 | 40 |
| 200 | Mary | NULL | 1 | Street 2 | 30 | 80 |
| 200 | Mary | NULL | 1 | Street 2 | 60 | 40 |
| 200 | Mary | NULL | 1 | Street 2 | 60 | 80 |
| 300 | Mike | 80 | 3 | Street 3 | 30 | 40 |
| 300 | Mike | 80 | 3 | Street 3 | 30 | 80 |
| 300 | Mike | 80 | 3 | Street 3 | 60 | 40 |
| 300 | Mike | 80 | 3 | Street 3 | 60 | 80 |
| 400 | Dan | 50 | 4 | Street 4 | 30 | 40 |
| 400 | Dan | 50 | 4 | Street 4 | 30 | 80 |
| 400 | Dan | 50 | 4 | Street 4 | 60 | 40 |
| 400 | Dan | 50 | 4 | Street 4 | 60 | 80 |
+------+-------+-------+--------+-----------+--------+--------+
SELECT c_age, COUNT(1) FROM person
LATERAL VIEW EXPLODE(ARRAY(30, 60)) AS c_age
LATERAL VIEW EXPLODE(ARRAY(40, 80)) AS d_age
GROUP BY c_age;
+--------+-----------+
| c_age | count(1) |
+--------+-----------+
| 60 | 8 |
| 30 | 8 |
+--------+-----------+
SELECT * FROM person
LATERAL VIEW EXPLODE(ARRAY()) tableName AS c_age;
+-----+-------+------+--------+----------+--------+
| id | name | age | class | address | c_age |
+-----+-------+------+--------+----------+--------+
+-----+-------+------+--------+----------+--------+
SELECT * FROM person
LATERAL VIEW OUTER EXPLODE(ARRAY()) tableName AS c_age;
+------+-------+-------+--------+-----------+--------+
| id | name | age | class | address | c_age |
+------+-------+-------+--------+-----------+--------+
| 100 | John | 30 | 1 | Street 1 | NULL |
| 200 | Mary | NULL | 1 | Street 2 | NULL |
| 300 | Mike | 80 | 3 | Street 3 | NULL |
| 400 | Dan | 50 | 4 | Street 4 | NULL |
+------+-------+-------+--------+-----------+--------+
```
#### Predicado LIKE
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
Um predicado `LIKE` é usado para pesquisar um padrão específico. Esse predicado também é compatível com vários padrões com quantificadores que incluem `ANY`, `SOME` e `ALL`.
**Sintaxe**
```
[ NOT ] { LIKE search_pattern [ ESCAPE esc_char ] | [ RLIKE | REGEXP ] regex_pattern }
[ NOT ] { LIKE quantifiers ( search_pattern [ , ... ]) }
```
**Parâmetros**
+ **search\$1pattern **
Especifica um padrão de string a ser pesquisado pela cláusula LIKE. Pode conter caracteres especiais correspondentes a um padrão:
+ `%` corresponde a 0 ou mais caracteres.
+ `_` corresponde a exatamente um caractere.
+ **esc\$1char**
Especifica o caractere de escape. O caractere de escape padrão é `\`.
+ **regex\$1pattern **
Especifica um padrão de pesquisa de expressão regular a ser pesquisado pela cláusula `RLIKE` ou `REGEXP`.
+ **quantifiers**
Especifica que os quantificadores de predicado que incluem `ANY` `SOME` e `ALL`.
`ANY` ou `SOME` significa que se um dos padrões corresponder à entrada, verdadeiro será retornado.
`ALL` significa que se todos os padrões corresponderem à entrada, verdadeiro será retornado.
**Exemplos**
```
CREATE TABLE person (id INT, name STRING, age INT);
INSERT INTO person VALUES
(100, 'John', 30),
(200, 'Mary', NULL),
(300, 'Mike', 80),
(400, 'Dan', 50),
(500, 'Evan_w', 16);
SELECT * FROM person WHERE name LIKE 'M%';
+---+----+----+
| id|name| age|
+---+----+----+
|300|Mike| 80|
|200|Mary|null|
+---+----+----+
SELECT * FROM person WHERE name LIKE 'M_ry';
+---+----+----+
| id|name| age|
+---+----+----+
|200|Mary|null|
+---+----+----+
SELECT * FROM person WHERE name NOT LIKE 'M_ry';
+---+------+---+
| id| name|age|
+---+------+---+
|500|Evan_W| 16|
|300| Mike| 80|
|100| John| 30|
|400| Dan| 50|
+---+------+---+
SELECT * FROM person WHERE name RLIKE 'M+';
+---+----+----+
| id|name| age|
+---+----+----+
|300|Mike| 80|
|200|Mary|null|
+---+----+----+
SELECT * FROM person WHERE name REGEXP 'M+';
+---+----+----+
| id|name| age|
+---+----+----+
|300|Mike| 80|
|200|Mary|null|
+---+----+----+
SELECT * FROM person WHERE name LIKE '%\_%';
+---+------+---+
| id| name|age|
+---+------+---+
|500|Evan_W| 16|
+---+------+---+
SELECT * FROM person WHERE name LIKE '%$_%' ESCAPE '$';
+---+------+---+
| id| name|age|
+---+------+---+
|500|Evan_W| 16|
+---+------+---+
SELECT * FROM person WHERE name LIKE ALL ('%an%', '%an');
+---+----+----+
| id|name| age|
+---+----+----+
|400| Dan| 50|
+---+----+----+
SELECT * FROM person WHERE name LIKE ANY ('%an%', '%an');
+---+------+---+
| id| name|age|
+---+------+---+
|400| Dan| 50|
|500|Evan_W| 16|
+---+------+---+
SELECT * FROM person WHERE name LIKE SOME ('%an%', '%an');
+---+------+---+
| id| name|age|
+---+------+---+
|400| Dan| 50|
|500|Evan_W| 16|
+---+------+---+
SELECT * FROM person WHERE name NOT LIKE ALL ('%an%', '%an');
+---+----+----+
| id|name| age|
+---+----+----+
|100|John| 30|
|200|Mary|null|
|300|Mike| 80|
+---+----+----+
SELECT * FROM person WHERE name NOT LIKE ANY ('%an%', '%an');
+---+------+----+
| id| name| age|
+---+------+----+
|100| John| 30|
|200| Mary|null|
|300| Mike| 80|
|500|Evan_W| 16|
+---+------+----+
SELECT * FROM person WHERE name NOT LIKE SOME ('%an%', '%an');
+---+------+----+
| id| name| age|
+---+------+----+
|100| John| 30|
|200| Mary|null|
|300| Mike| 80|
|500|Evan_W| 16|
+---+------+----+
```
#### OFFSET
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
A cláusula `OFFSET` é usada para especificar o número de linhas a serem ignoradas antes de começar a retornar as linhas retornadas pela instrução `SELECT`. Em geral, essa cláusula é usada em conjunto com `ORDER BY` para garantir que os resultados sejam determinísticos.
**Sintaxe**
```
OFFSET integer_expression
```
**Parâmetros**
+ **integer\$1expression **
Especifica uma expressão redutível que retorna um número inteiro.
**Exemplos**
```
CREATE TABLE person (name STRING, age INT);
INSERT INTO person VALUES
('Jane Doe', 25),
('Pat C', 18),
('Nikki W', 16),
('Juan L', 25),
('John D', 18),
('Jorge S', 16);
-- Skip the first two rows.
SELECT name, age FROM person ORDER BY name OFFSET 2;
+-------+---+
| name|age|
+-------+---+
| John D| 18|
| Juan L| 25|
|Nikki W| 16|
|Jane Doe| 25|
+-------+---+
-- Skip the first two rows and returns the next three rows.
SELECT name, age FROM person ORDER BY name LIMIT 3 OFFSET 2;
+-------+---+
| name|age|
+-------+---+
| John D| 18|
| Juan L| 25|
|Nikki W| 16|
+-------+---+
-- A function expression as an input to OFFSET.
SELECT name, age FROM person ORDER BY name OFFSET length('WAGON');
+-------+---+
| name|age|
+-------+---+
|Jane Doe| 25|
+-------+---+
```
#### Cláusula PIVOT
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
A cláusula `PIVOT` é usada para perspectiva de dados. Podemos obter os valores agregados com base em valores de colunas específicos, que serão transformados em várias colunas usadas na cláusula `SELECT`. A cláusula `PIVOT` pode ser especificada depois do nome da tabela ou da subconsulta.
**Sintaxe**
```
PIVOT ( { aggregate_expression [ AS aggregate_expression_alias ] } [ , ... ] FOR column_list IN ( expression_list ) )
```
**Parâmetros**
+ **aggregate\$1expression**
Especifica uma expressão de agregação `(SUM(a)`, `COUNT(DISTINCT b)` etc.).
+ **aggregate\$1expression\$1alias**
Especifica um alias para a expressão de agregação.
+ **column\$1list**
Contém colunas na cláusula `FROM`, que especifica as colunas que você deseja substituir por novas colunas. Você pode colocar as colunas entre colchetes, como `(c1, c2)`.
+ **expression\$1list**
Especifica novas colunas, que são usadas para verificar a correspondência com valores em `column_list` como condição de agregação. Você também pode definir aliases para elas.
**Exemplos**
```
CREATE TABLE person (id INT, name STRING, age INT, class INT, address STRING);
INSERT INTO person VALUES
(100, 'John', 30, 1, 'Street 1'),
(200, 'Mary', NULL, 1, 'Street 2'),
(300, 'Mike', 80, 3, 'Street 3'),
(400, 'Dan', 50, 4, 'Street 4');
SELECT * FROM person
PIVOT (
SUM(age) AS a, AVG(class) AS c
FOR name IN ('John' AS john, 'Mike' AS mike)
);
+------+-----------+---------+---------+---------+---------+
| id | address | john_a | john_c | mike_a | mike_c |
+------+-----------+---------+---------+---------+---------+
| 200 | Street 2 | NULL | NULL | NULL | NULL |
| 100 | Street 1 | 30 | 1.0 | NULL | NULL |
| 300 | Street 3 | NULL | NULL | 80 | 3.0 |
| 400 | Street 4 | NULL | NULL | NULL | NULL |
+------+-----------+---------+---------+---------+---------+
SELECT * FROM person
PIVOT (
SUM(age) AS a, AVG(class) AS c
FOR (name, age) IN (('John', 30) AS c1, ('Mike', 40) AS c2)
);
+------+-----------+-------+-------+-------+-------+
| id | address | c1_a | c1_c | c2_a | c2_c |
+------+-----------+-------+-------+-------+-------+
| 200 | Street 2 | NULL | NULL | NULL | NULL |
| 100 | Street 1 | 30 | 1.0 | NULL | NULL |
| 300 | Street 3 | NULL | NULL | NULL | NULL |
| 400 | Street 4 | NULL | NULL | NULL | NULL |
+------+-----------+-------+-------+-------+-------+
```
#### Configurar operadores
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
Os operadores de conjunto são usados para combinar duas relações de entrada em uma. OpenSearch O SQL oferece suporte a três tipos de operadores de conjunto:
+ `EXCEPT` ou `MINUS`
+ `INTERSECT`
+ `UNION`
As relações de entrada devem ter o mesmo número de colunas e tipos de dados compatíveis com as respectivas colunas.
**EXCETO**
`EXCEPT` e `EXCEPT ALL` retornam as linhas encontradas em uma relação, mas não na outra. `EXCEPT` (como alternativa, `EXCEPT DISTINCT`) usa somente linhas distintas, enquanto `EXCEPT ALL` não remove duplicações das linhas de resultado. Observe que `MINUS` é um alias de `EXCEPT`.
**Sintaxe**
```
[ ( ] relation [ ) ] EXCEPT | MINUS [ ALL | DISTINCT ] [ ( ] relation [ ) ]
```
**Exemplos**
```
-- Use table1 and table2 tables to demonstrate set operators in this page.
SELECT * FROM table1;
+---+
| c|
+---+
| 3|
| 1|
| 2|
| 2|
| 3|
| 4|
+---+
SELECT * FROM table2;
+---+
| c|
+---+
| 5|
| 1|
| 2|
| 2|
+---+
SELECT c FROM table1 EXCEPT SELECT c FROM table2;
+---+
| c|
+---+
| 3|
| 4|
+---+
SELECT c FROM table1 MINUS SELECT c FROM table2;
+---+
| c|
+---+
| 3|
| 4|
+---+
SELECT c FROM table1 EXCEPT ALL (SELECT c FROM table2);
+---+
| c|
+---+
| 3|
| 3|
| 4|
+---+
SELECT c FROM table1 MINUS ALL (SELECT c FROM table2);
+---+
| c|
+---+
| 3|
| 3|
| 4|
+---+
```
**CRUZAR**
`INTERSECT` e `INTERSECT ALL` retornam as linhas encontradas em ambas as relações. `INTERSECT` (como alternativa, `INTERSECT DISTINCT`) usa somente linhas distintas, enquanto `INTERSECT ALL` não remove duplicações das linhas de resultado.
**Sintaxe**
```
[ ( ] relation [ ) ] INTERSECT [ ALL | DISTINCT ] [ ( ] relation [ ) ]
```
**Exemplos**
```
(SELECT c FROM table1) INTERSECT (SELECT c FROM table2);
+---+
| c|
+---+
| 1|
| 2|
+---+
(SELECT c FROM table1) INTERSECT DISTINCT (SELECT c FROM table2);
+---+
| c|
+---+
| 1|
| 2|
+---+
(SELECT c FROM table1) INTERSECT ALL (SELECT c FROM table2);
+---+
| c|
+---+
| 1|
| 2|
| 2|
+---+
```
**UNIÃO**
`UNION` e `UNION ALL` retornam as linhas encontradas em qualquer das duas relações. `UNION` (como alternativa, `UNION DISTINCT`) usa somente linhas distintas, enquanto `UNION ALL` não remove duplicações das linhas de resultado.
**Sintaxe**
```
[ ( ] relation [ ) ] UNION [ ALL | DISTINCT ] [ ( ] relation [ ) ]
```
**Exemplos**
```
(SELECT c FROM table1) UNION (SELECT c FROM table2);
+---+
| c|
+---+
| 1|
| 3|
| 5|
| 4|
| 2|
+---+
(SELECT c FROM table1) UNION DISTINCT (SELECT c FROM table2);
+---+
| c|
+---+
| 1|
| 3|
| 5|
| 4|
| 2|
+---+
SELECT c FROM table1 UNION ALL (SELECT c FROM table2);
+---+
| c|
+---+
| 3|
| 1|
| 2|
| 2|
| 3|
| 4|
| 5|
| 1|
| 2|
| 2|
+---+
```
#### Cláusula SORT BY
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
A cláusula `SORT BY` é usada para retornar as linhas de resultado classificadas em cada partição na ordem especificada pelo usuário. Quando há mais de uma partição, `SORT BY` pode retornar um resultado parcialmente ordenado. Isso é diferente da cláusula `ORDER BY` que garante a ordem total da saída.
**Sintaxe**
```
SORT BY { expression [ sort_direction | nulls_sort_order ] [ , ... ] }
```
**Parâmetros**
+ **SORT BY **
Especifica uma lista de expressões separadas por vírgula junto com parâmetros opcionais sort\$1direction e nulos\$1sort\$1order que são usados para classificar as linhas em cada partição.
+ **sort\$1direction **
Opcionalmente, especifica se as linhas devem ser classificadas em ordem crescente ou decrescente.
Os valores válidos para a direção de classificação são `ASC` para crescente e `DESC` para decrescente.
Se a direção da classificação não for especificada explicitamente, as linhas serão classificadas em ordem crescente por padrão.
Sintaxe: `[ ASC | DESC ]`
+ **nulos\$1sort\$1order **
Opcionalmente, especifica se os valores NULL são retornados antes/depois dos valores não NULL.
Se não `null_sort_order` for especificado, NULLs classifique primeiro se a ordem de classificação for `ASC` e NULLS classificará por último se a ordem de classificação for. `DESC`
1. Se `NULLS FIRST` for especificado, os valores NULL serão retornados primeiro, independentemente da ordem de classificação.
2. Se `NULLS LAST` for especificado, os valores NULL serão retornados por último, independentemente da ordem de classificação.
Sintaxe: `[ NULLS { FIRST | LAST } ] `
**Exemplos**
```
CREATE TABLE person (zip_code INT, name STRING, age INT);
INSERT INTO person VALUES
(94588, 'Shirley Rodriguez', 50),
(94588, 'Juan Li', 18),
(94588, 'Anil K', 27),
(94588, 'John D', NULL),
(94511, 'David K', 42),
(94511, 'Aryan B.', 18),
(94511, 'Lalit B.', NULL);
-- Sort rows by `name` within each partition in ascending manner
SELECT name, age, zip_code FROM person SORT BY name;
+------------------+----+--------+
| name| age|zip_code|
+------------------+----+--------+
| Anil K| 27| 94588|
| Juan Li| 18| 94588|
| John D|null| 94588|
| Shirley Rodriguez| 50| 94588|
| Aryan B.| 18| 94511|
| David K| 42| 94511|
| Lalit B.|null| 94511|
+------------------+----+--------+
-- Sort rows within each partition using column position.
SELECT name, age, zip_code FROM person SORT BY 1;
+----------------+----+----------+
| name| age|zip_code|
+------------------+----+--------+
| Anil K| 27| 94588|
| Juan Li| 18| 94588|
| John D|null| 94588|
| Shirley Rodriguez| 50| 94588|
| Aryan B.| 18| 94511|
| David K| 42| 94511|
| Lalit B.|null| 94511|
+------------------+----+--------+
-- Sort rows within partition in ascending manner keeping null values to be last.
SELECT age, name, zip_code FROM person SORT BY age NULLS LAST;
+----+------------------+--------+
| age| name|zip_code|
+----+------------------+--------+
| 18| Juan Li| 94588|
| 27| Anil K| 94588|
| 50| Shirley Rodriguez| 94588|
|null| John D| 94588|
| 18| Aryan B.| 94511|
| 42| David K| 94511|
|null| Lalit B.| 94511|
+--------------+--------+--------+
-- Sort rows by age within each partition in descending manner, which defaults to NULL LAST.
SELECT age, name, zip_code FROM person SORT BY age DESC;
+----+------------------+--------+
| age| name|zip_code|
+----+------------------+--------+
| 50| Shirley Rodriguez| 94588|
| 27| Anil K| 94588|
| 18| Juan Li| 94588|
|null| John D| 94588|
| 42| David K| 94511|
| 18| Aryan B.| 94511|
|null| Lalit B.| 94511|
+----+------------------+--------+
-- Sort rows by age within each partition in descending manner keeping null values to be first.
SELECT age, name, zip_code FROM person SORT BY age DESC NULLS FIRST;
+----+------------------+--------+
| age| name|zip_code|
+----+------------------+--------+
|null| John D| 94588|
| 50| Shirley Rodriguez| 94588|
| 27| Anil K| 94588|
| 18| Juan Li| 94588|
|null| Lalit B.| 94511|
| 42| David K| 94511|
| 18| Aryan B.| 94511|
+--------------+--------+--------+
-- Sort rows within each partition based on more than one column with each column having
-- different sort direction.
SELECT name, age, zip_code FROM person
SORT BY name ASC, age DESC;
+------------------+----+--------+
| name| age|zip_code|
+------------------+----+--------+
| Anil K| 27| 94588|
| Juan Li| 18| 94588|
| John D|null| 94588|
| Shirley Rodriguez| 50| 94588|
| Aryan B.| 18| 94511|
| David K| 42| 94511|
| Lalit B.|null| 94511|
+------------------+----+--------+
```
#### UNPIVOT
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando SQL, consulte[Comandos e funções OpenSearch SQL compatíveis](#supported-directquery-sql).
A cláusula `UNPIVOT` transforma várias colunas em várias linhas usadas na cláusula `SELECT`. A cláusula `UNPIVOT` pode ser especificada depois do nome da tabela ou da subconsulta.
**Sintaxe**
```
UNPIVOT [ { INCLUDE | EXCLUDE } NULLS ] (
{ single_value_column_unpivot | multi_value_column_unpivot }
) [[AS] alias]
single_value_column_unpivot:
values_column
FOR name_column
IN (unpivot_column [[AS] alias] [, ...])
multi_value_column_unpivot:
(values_column [, ...])
FOR name_column
IN ((unpivot_column [, ...]) [[AS] alias] [, ...])
```
**Parâmetros**
+ **unpivot\$1column **
Contém colunas na cláusula `FROM`, o que especifica as colunas que você deseja despivotar.
+ **name\$1column **
O nome da coluna que contém os nomes das colunas despivotadas.
+ **values\$1column **
O nome da coluna que contém os valores das colunas despivotadas.
**Exemplos**
```
CREATE TABLE sales_quarterly (year INT, q1 INT, q2 INT, q3 INT, q4 INT);
INSERT INTO sales_quarterly VALUES
(2020, null, 1000, 2000, 2500),
(2021, 2250, 3200, 4200, 5900),
(2022, 4200, 3100, null, null);
-- column names are used as unpivot columns
SELECT * FROM sales_quarterly
UNPIVOT (
sales FOR quarter IN (q1, q2, q3, q4)
);
+------+---------+-------+
| year | quarter | sales |
+------+---------+-------+
| 2020 | q2 | 1000 |
| 2020 | q3 | 2000 |
| 2020 | q4 | 2500 |
| 2021 | q1 | 2250 |
| 2021 | q2 | 3200 |
| 2021 | q3 | 4200 |
| 2021 | q4 | 5900 |
| 2022 | q1 | 4200 |
| 2022 | q2 | 3100 |
+------+---------+-------+
-- NULL values are excluded by default, they can be included
-- unpivot columns can be alias
-- unpivot result can be referenced via its alias
SELECT up.* FROM sales_quarterly
UNPIVOT INCLUDE NULLS (
sales FOR quarter IN (q1 AS Q1, q2 AS Q2, q3 AS Q3, q4 AS Q4)
) AS up;
+------+---------+-------+
| year | quarter | sales |
+------+---------+-------+
| 2020 | Q1 | NULL |
| 2020 | Q2 | 1000 |
| 2020 | Q3 | 2000 |
| 2020 | Q4 | 2500 |
| 2021 | Q1 | 2250 |
| 2021 | Q2 | 3200 |
| 2021 | Q3 | 4200 |
| 2021 | Q4 | 5900 |
| 2022 | Q1 | 4200 |
| 2022 | Q2 | 3100 |
| 2022 | Q3 | NULL |
| 2022 | Q4 | NULL |
+------+---------+-------+
-- multiple value columns can be unpivoted per row
SELECT * FROM sales_quarterly
UNPIVOT EXCLUDE NULLS (
(first_quarter, second_quarter)
FOR half_of_the_year IN (
(q1, q2) AS H1,
(q3, q4) AS H2
)
);
+------+------------------+---------------+----------------+
| id | half_of_the_year | first_quarter | second_quarter |
+------+------------------+---------------+----------------+
| 2020 | H1 | NULL | 1000 |
| 2020 | H2 | 2000 | 2500 |
| 2021 | H1 | 2250 | 3200 |
| 2021 | H2 | 4200 | 5900 |
| 2022 | H1 | 4200 | 3100 |
+------+------------------+---------------+----------------+
```