`
Si está consultando en Amazon S3 o Security Lake, utilice: `SELECT Body , Operation FROM table_name`
Si está consultando los CloudWatch registros, utilice: `SELECT Body , Operation FROM `LogGroupA``
| Comando | Description (Descripción) | CloudWatch Registros | Amazon S3 | Security Lake | Comando de ejemplo: |
| --- | --- | --- | --- | --- | --- |
| [Cláusula SELECT](#supported-sql-select) | Muestra los valores proyectados. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | SELECT
method,
status
FROM
|
| [Cláusula WHERE](#supported-sql-where) | Filtra los eventos del registro en función de los criterios de campo proporcionados. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | SELECT
*
FROM
WHERE
status = 100
|
| [Cláusula GROUP BY](#supported-sql-group-by) | Los grupos registran los eventos según la categoría y encuentran el promedio en función de las estadísticas. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | SELECT
method,
status,
COUNT(*) AS request_count,
SUM(bytes) AS total_bytes
FROM
GROUP BY
method,
status
|
| [Cláusula HAVING](#supported-sql-having) | Filtra los resultados en función de las condiciones de agrupación. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | 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 los resultados en función de los campos de la cláusula de orden. Puede especificar un orden tanto ascendente como descendente. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | SELECT
*
FROM
ORDER BY
status DESC
|
| [Cláusula JOIN](#supported-sql-join) ( `INNER` \$1 `CROSS` \$1 `LEFT` `OUTER` ) | Une los resultados de dos tablas en función de los campos en común. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible (se deben usar `Inner` y `Left Outer` como palabras clave para unir; solo se admite una operación JOIN en una sentencia SELECT) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible (se deben usar las palabras clave Inner, Left Outer y Cross para unir) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible (se deben usar las palabras clave Inner, Left Outer y 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 los resultados a las N primeras filas. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | SELECT
*
FROM
LIMIT
10
|
| [Cláusula CASE](#supported-sql-case) | Evalúa las condiciones y devuelve un valor cuando se cumple la primera condición. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | 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
|
| [Expresiones de tabla comunes](#supported-sql-cte) | Crea un conjunto de resultados temporal con nombre en una sentencia SELECT, INSERT, UPDATE, DELETE o MERGE. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/negative_icon.svg) no compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | 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) | Muestra el plan de ejecución de una sentencia SQL sin ejecutarla. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/negative_icon.svg) no compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | 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 una subconsulta de la cláusula FROM haga referencia a las columnas de los elementos anteriores de la misma cláusula FROM. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/negative_icon.svg) no compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | SELECT
*
FROM
tableName
LATERAL (
SELECT
*
FROM
t2
WHERE
t1.c1 = t2.c1
)
|
| [Cláusula LATERAL VIEW](#supported-sql-lateral-view) | Genera una tabla virtual mediante la aplicación de una función generadora de tablas a cada fila de una tabla base. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/negative_icon.svg) no compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | 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) | Hace coincidir una cadena con un patrón mediante caracteres comodín. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | SELECT
method,
status,
request,
host
FROM
WHERE
method LIKE 'D%'
|
| [OFFSET](#supported-sql-offset) | Especifica el número de filas que se van a omitir antes de empezar a devolver las filas de la consulta. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible cuando se utiliza junto con una cláusula LIMIT en una consulta. Por ejemplo:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/supported-directquery-sql.html) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | SELECT
method,
status,
bytes,
datetime
FROM
ORDER BY
datetime
OFFSET
10
|
| [Cláusula PIVOT](#supported-sql-pivot) | Transforma las filas en columnas, rotando los datos de un formato basado en filas a un formato basado en columnas. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/negative_icon.svg) no compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | SELECT
*
FROM
(
SELECT
method,
status,
bytes
FROM
) AS SourceTable
PIVOT
(
SUM(bytes)
FOR method IN ('GET', 'POST', 'PATCH', 'PUT', 'DELETE')
) AS PivotTable
|
| [Operadores de establecimiento](#supported-sql-set) | Combina los resultados de dos o más sentencias SELECT (p. ej., UNION, INTERSECT, EXCEPT). | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | 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 el orden en el que se deben devolver los resultados de la consulta. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | SELECT
method,
status,
bytes
FROM
SORT BY
bytes DESC
|
| [UNPIVOT](#supported-sql-unpivot) | Transforma las columnas en filas, rotando los datos de un formato basado en columnas a un formato basado en filas. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/negative_icon.svg) no compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | 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
|
## Funciones
**nota**
En la columna de comandos del ejemplo, reemplace `` según sea necesario en función del origen de datos que esté consultando.
Comando de ejemplo: `SELECT Body , Operation FROM `
Si está consultando en Amazon S3 o Security Lake, utilice: `SELECT Body , Operation FROM table_name`
Si estás consultando CloudWatch registros, usa: `SELECT Body , Operation FROM `LogGroupA``
| Gramática SQL disponible | Description (Descripción) | CloudWatch Registros | Amazon S3 | Security Lake | Comando de ejemplo: |
| --- | --- | --- | --- | --- | --- |
| [Funciones de cadena](#supported-sql-string) | Funciones integradas que pueden manipular y transformar cadenas y datos de texto en consultas SQL. Por ejemplo, convertir mayúsculas y minúsculas, combinar cadenas, extraer partes y limpiar el texto. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | SELECT
UPPER(method) AS upper_method,
LOWER(host) AS lower_host
FROM
|
| [Funciones de fecha y hora](#supported-sql-date-time) | Funciones integradas para administrar y transformar los datos de fecha y hora en las consultas. Por ejemplo, **date\$1add**, **date\$1format**, **datediff** y **current\$1date**. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | 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
|
| [Funciones de agregación](#supported-sql-aggregate) | Funciones integradas que realizan cálculos en varias filas para generar un único valor resumido. Por ejemplo, **suma**, **recuento**, **promedio**, **máximo** y **mínimo**. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | 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
|
| [Funciones condicionales](#supported-sql-conditional) | Funciones integradas que realizan acciones en función de condiciones específicas o que evalúan las expresiones de forma condicional. Por ejemplo, **CASE** e **IF**. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | 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
|
| [Funciones JSON](#supported-sql-json) | Funciones integradas para analizar, extraer, modificar y consultar datos con formato JSON en consultas SQL (por ejemplo, from\$1json, to\$1json, get\$1json\$1object, json\$1tuple) que permiten manipular las estructuras JSON en los conjuntos de datos. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | SELECT
FROM_JSON(
@message,
'STRUCT<
host: STRING,
user-identifier: STRING,
datetime: STRING,
method: STRING,
status: INT,
bytes: INT
>'
) AS parsed_json
FROM
|
| [Funciones de matriz](#supported-sql-array) | Funciones integradas para trabajar con columnas de tipo matriz en consultas SQL, lo que permite realizar operaciones como acceder, modificar y analizar los datos de la matriz (p. ej., size, explode, array\$1contains). | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | SELECT
scores,
size(scores) AS length,
array_contains(scores, 90) AS has_90
FROM
|
| [Funciones de ventana](#supported-sql-window) | Funciones integradas que realizan cálculos en un conjunto específico de filas relacionadas con la fila (ventana) actual, lo que permite realizar operaciones como la clasificación, los totales acumulados y los promedios móviles (por ejemplo, ROW\$1NUMBER, RANK, LAG, LEAD). | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | SELECT
field1,
field2,
RANK() OVER (ORDER BY field2 DESC) AS field2Rank
FROM
|
| [Funciones de conversión](#supported-sql-conversion) | Funciones integradas para convertir datos de un tipo a otro en las consultas SQL, lo que permite la transformación de los tipos de datos y las conversiones de formato (por ejemplo, CAST, TO\$1DATE, TO\$1TIMESTAMP, BINARY) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | SELECT
CAST('123' AS INT) AS converted_number,
CAST(123 AS STRING) AS converted_string
FROM
|
| [Funciones de predicados](#supported-sql-predicate) | Funciones integradas que evalúan las condiciones y devuelven valores booleanos (verdadero/falso) en función de criterios o patrones específicos (por ejemplo, IN, LIKE, BETWEEN, IS NULL, EXISTS) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | SELECT
*
FROM
WHERE
id BETWEEN 50000 AND 75000
|
| [Funciones de mapa](#supported-sql-map) | Aplica una función específica a cada elemento de una colección y transforma los datos a un nuevo conjunto de valores. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/negative_icon.svg) no compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | 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
|
| [Funciones matemáticas](#supported-sql-math) | Realiza operaciones matemáticas con datos numéricos, como calcular promedios, sumas o valores trigonométricos. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | SELECT
bytes,
bytes + 1000 AS added,
bytes - 1000 AS subtracted,
bytes * 2 AS doubled,
bytes / 1024 AS kilobytes,
bytes % 1000 AS remainder
FROM
|
| [Funciones de grupos de registros múltiples](#multi-log-queries) | Permite a los usuarios especificar varios grupos de registros en una sentencia SQL SELECT | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | No aplicable | No aplicable | SELECT
lg1.Column1,
lg1.Column2
FROM
`logGroups(logGroupIdentifier: ['LogGroup1', 'LogGroup2'])` AS lg1
WHERE
lg1.Column3 = "Success"
|
| [Funciones generadoras](#supported-sql-generator) | Crea un objeto iterador que produce una secuencia de valores, lo que permite un uso eficiente de la memoria en conjuntos de datos de gran tamaño. | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/negative_icon.svg) no compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/success_icon.svg) compatible | SELECT
explode(array(10, 20))
|
## Restricciones SQL generales
Se aplican las siguientes restricciones al usar OpenSearch SQL with CloudWatch Logs, Amazon S3 y Security Lake.
1. Solo puede usar una operación JOIN en una sentencia SELECT.
1. Solo se admite un nivel de subconsultas anidadas.
1. No se admiten consultas de varias sentencias separadas por punto y coma.
1. No se admiten consultas que contengan nombres de campo idénticos pero que solo difieran en mayúsculas y minúsculas (como field1 y FIELD1).
Por ejemplo, no se admiten las siguientes consultas:
```
Select AWSAccountId, awsaccountid from LogGroup
```
Sin embargo, la siguiente consulta se debe a que el nombre del campo (@logStream) es idéntico en ambos grupos de registros:
```
Select a.`@logStream`, b.`@logStream` from Table A INNER Join Table B on a.id = b.id
```
1. Las funciones y expresiones deben funcionar con los nombres de los campos y formar parte de una sentencia SELECT con un grupo de registros especificado en la cláusula FROM.
Por ejemplo, no se admite esta consulta:
```
SELECT cos(10) FROM LogGroup
```
Se admite esta consulta:
```
SELECT cos(field1) FROM LogGroup
```
## Información adicional para los usuarios de CloudWatch Logs Insights que utilizan SQL OpenSearch
CloudWatch Logs admite consultas OpenSearch SQL en la consola, la API y la CLI de Logs Insights. Es compatible con la mayoría de los comandos, incluidos SELECT, FROM, WHERE, GROUP BY, HAVING, JOINS y consultas anidadas, además de funciones JSON, matemáticas, de cadena y condicionales. Sin embargo, CloudWatch Logs solo admite operaciones de lectura, por lo que no permite sentencias DDL o DML. Consulte las tablas de las secciones anteriores para obtener una lista completa de los comandos y funciones compatibles.
### Funciones de grupos de registros múltiples
CloudWatch Logs Insights admite la posibilidad de consultar varios grupos de registros. Para abordar este caso de uso en SQL, puede usar el comando `logGroups`. Este comando es específico para consultar datos en CloudWatch Logs Insights que involucran uno o más grupos de registros. Use esta sintaxis para consultar varios grupos de registros especificándolos en el comando, en lugar de escribir una consulta para cada uno de los grupos de registros y combinarlos con un comando `UNION`.
Sintaxis:
```
`logGroups(
logGroupIdentifier: ['LogGroup1','LogGroup2', ...'LogGroupn']
)
```
En esta sintaxis, puede especificar hasta 50 grupos de registros en el parámetro `logGroupIndentifier`. Para hacer referencia a los grupos de registros de una cuenta de supervisión, utilícelo ARNs en lugar de `LogGroup` nombres.
Consulta de ejemplo:
```
SELECT LG1.Column1, LG1.Column2 from `logGroups(
logGroupIdentifier: ['LogGroup1', 'LogGroup2']
)` as LG1
WHERE LG1.Column1 = 'ABC'
```
Al consultar los registros, no se admite la siguiente sintaxis que implica varios grupos de CloudWatch registros después de la `FROM` sentencia:
```
SELECT Column1, Column2 FROM 'LogGroup1', 'LogGroup2', ...'LogGroupn'
WHERE Column1 = 'ABC'
```
### Restricciones
Cuando utilice comandos SQL o PPL, encierre determinados campos entre comillas invertidas para consultarlos. Las comillas invertidas son obligatorias para los campos con caracteres especiales (no alfabéticos ni numéricos). Por ejemplo, encierre `@message`, `Operation.Export,` y `Test::Field` entre comillas invertidas. No es necesario incluir las columnas con nombres exclusivamente alfabéticos entre comillas invertidas.
Ejemplo de consulta con campos sencillos:
```
SELECT SessionToken, Operation, StartTime FROM `LogGroup-A`
LIMIT 1000;
```
La misma consulta con comillas invertidas agregadas:
```
SELECT `SessionToken`, `Operation`, `StartTime` FROM `LogGroup-A`
LIMIT 1000;
```
Para ver otras restricciones generales que no son específicas de los CloudWatch registros, consulte[Restricciones SQL generales](#general-sql-restrictions).
### Consultas y cuotas de ejemplo
**nota**
Lo siguiente se aplica tanto a los usuarios de CloudWatch Logs Insights como a los OpenSearch usuarios que consultan CloudWatch datos.
Para ver ejemplos de consultas SQL que puede usar en CloudWatch Logs, consulte **Consultas guardadas y de ejemplo** en la consola de Amazon CloudWatch Logs Insights para ver ejemplos.
Para obtener información sobre los límites que se aplican al consultar CloudWatch los registros del OpenSearch servicio, consulte [las cuotas de CloudWatch registros](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html) en la Guía del usuario de Amazon CloudWatch Logs. Los límites se refieren al número de grupos de CloudWatch registros que se pueden consultar, el número máximo de consultas simultáneas que se pueden ejecutar, el tiempo máximo de ejecución de las consultas y el número máximo de filas devueltas en los resultados. Los límites son los mismos independientemente del idioma que utilice para consultar los CloudWatch registros (es decir, OpenSearch PPL, SQL y Logs Insights).
### Comandos SQL
**Topics**
+ [Funciones de cadena](#supported-sql-string)
+ [Funciones de fecha y hora](#supported-sql-date-time)
+ [Funciones de agregación](#supported-sql-aggregate)
+ [Funciones condicionales](#supported-sql-conditional)
+ [Funciones JSON](#supported-sql-json)
+ [Funciones de matriz](#supported-sql-array)
+ [Funciones de ventana](#supported-sql-window)
+ [Funciones de conversión](#supported-sql-conversion)
+ [Funciones de predicados](#supported-sql-predicate)
+ [Funciones de mapa](#supported-sql-map)
+ [Funciones matemáticas](#supported-sql-math)
+ [Funciones generadoras](#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)
+ [Expresiones de tabla comunes](#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)
+ [Operadores de establecimiento](#supported-sql-set)
+ [Cláusula SORT BY](#supported-sql-sort-by)
+ [UNPIVOT](#supported-sql-unpivot)
#### Funciones de cadena
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
****
| Función | Description (Descripción) |
| --- | --- |
| ascii(str) | Devuelve el valor numérico del primer carácter de str. |
| base64(bin) | Convierte el argumento de binario bin a una cadena de base 64. |
| bit\$1length(expr) | Devuelve la longitud en bits de los datos de la cadena o el número de bits de los datos binarios. |
| btrim(str) | Elimina los caracteres de espacio inicial y final de str. |
| btrim(str, trimStr) | Elimine los caracteres trimStr iniciales y finales de str. |
| char(expr) | Devuelve el carácter ASCII que tiene el equivalente binario a expr. Si n es mayor que 256, el resultado equivale a chr (n % 256) |
| char\$1length(expr) | Devuelve la longitud en caracteres de la cadena de datos o el número de bytes de los datos binarios. La longitud de los datos de cadena incluye los espacios finales. La longitud de los datos binarios incluye los ceros binarios. |
| character\$1length(expr) | Devuelve la longitud en caracteres de la cadena de datos o el número de bytes de los datos binarios. La longitud de los datos de cadena incluye los espacios finales. La longitud de los datos binarios incluye los ceros binarios. |
| chr(expr) | Devuelve el carácter ASCII que tiene el equivalente binario a expr. Si n es mayor que 256, el resultado equivale a chr (n % 256) |
| concat\$1ws(sep[, str \$1 array(str)]\$1) | Devuelve la concatenación de las cadenas separadas por sep, omitiendo los valores nulos. |
| contains(left, right) | Devuelve un BOOLEANO. El valor es verdadero si right se encuentra dentro de left. Devuelve NULL si alguna de las expresiones de entrada es NULL. De lo contrario, devuelve que el valor es falso. Tanto left como right deben ser de tipo STRING o BINARY. |
| decode(bin, charset) | Decodifica el primer argumento utilizando el juego de caracteres del segundo argumento. |
| decode(expr, search, result [, search, result ] ... [, default]) | Compara expr con cada valor de búsqueda en orden. Si expr es igual a un valor de búsqueda, decode devuelve el resultado correspondiente. Si no se encuentra coincidencia, devuelve el valor predeterminado. Si se omite el valor predeterminado, devuelve un valor nulo. |
| elt(n, input1, input2, ...) | Devuelve la n-ésima entrada, por ejemplo, devuelve input2 cuando n es 2. |
| encode(str, charset) | Codifica el primer argumento utilizando el conjunto de caracteres del segundo argumento. |
| endswith(left, right) | Devuelve un BOOLEANO. El valor es verdadero si left termina con right. Devuelve NULL si alguna de las expresiones de entrada es NULL. De lo contrario, devuelve que el valor es falso. Tanto left como right deben ser de tipo STRING o BINARY. |
| find\$1in\$1set(str, str\$1array) | Devuelve el índice (basado en 1) de la cadena dada (str) en la lista delimitada por comas (str\$1array). Devuelve 0 si no se encontró la cadena o si la cadena dada (str) contiene una coma. |
| format\$1number(expr1, expr2) | Formatea el número expr1 como '\$1, \$1\$1\$1, \$1\$1.\$1\$1', redondeándolo a expr2 decimales. Si expr2 es 0, el resultado no tiene separador decimal ni parte fraccionaria. expr2 también acepta un formato especificado por el usuario. Se supone que funciona como el FORMAT de MySQL. |
| format\$1string(strfmt, obj, ...) | Devuelve una cadena formateada a partir de cadenas de formato de estilo printf. |
| initcap(str) | Devuelve str con la primera letra de cada palabra en mayúscula. Todas las demás letras están en minúscula. Las palabras se delimitan mediante espacios en blanco. |
| instr(str, substr) | Devuelve el índice (basado en 1) de la primera aparición de substr en str. |
| lcase(str) | Devuelve str con todos los caracteres cambiados a minúsculas. |
| left(str, len) | Devuelve los caracteres más a la izquierda len (len pueden ser de tipo cadena) de la cadena str; si len es menor o igual que 0, el resultado es una cadena vacía. |
| len(expr) | Devuelve la longitud en caracteres de la cadena de datos o el número de bytes de los datos binarios. La longitud de los datos de cadena incluye los espacios finales. La longitud de los datos binarios incluye los ceros binarios. |
| length(expr) | Devuelve la longitud en caracteres de la cadena de datos o el número de bytes de los datos binarios. La longitud de los datos de cadena incluye los espacios finales. La longitud de los datos binarios incluye los ceros binarios. |
| levenshtein(str1, str2[, threshold]) | Devuelve la distancia de Levenshtein entre las dos cadenas dadas. Si se establece un umbral y la distancia es superior a este, devuelve -1. |
| locate(substr, str[, pos]) | Devuelve la posición de la primera aparición de substr en str después de la posición de pos. El valor pos dado y el valor devuelto se basan en 1. |
| lower(str) | Devuelve str con todos los caracteres cambiados a minúsculas. |
| lpad(str, len[, pad]) | Devuelve str, rellenado a la izquierda con pad una longitud de len. Si str es más larga que len, el valor devuelto se acorta al len de caracteres de ancho. Si no se especifica pad, str se rellenará a la izquierda con espacios si es una cadena de caracteres y con ceros si es una secuencia de bytes. |
| ltrim(str) | Elimina los caracteres de espacio iniciales de str. |
| luhn\$1check(str ) | Comprueba que una cadena de dígitos es válida según el algoritmo de Luhn. Esta función de suma de verificación se aplica en general a los números de tarjetas de crédito y a los números de identificación gubernamentales para distinguir los números válidos de los números mal escritos o incorrectos. |
| mask(input[, upperChar, lowerChar, digitChar, otherChar]) | Enmascara el valor de cadena determinado. La función reemplaza los caracteres por “X” o “x” y los números por “n”. Esto puede resultar útil para crear copias de tablas que tiene información confidencial que ha sido eliminada. |
| octet\$1length(expr) | Devuelve la longitud en bytes de los datos de cadena o el número de bytes de los datos binarios. |
| overlay(input, replace, pos[, len]) | Reemplaza input por replace que comience en pos y sea len de largo. |
| position(substr, str[, pos]) | Devuelve la posición de la primera aparición de substr en str después de la posición de pos. El valor pos dado y el valor devuelto se basan en 1. |
| printf(strfmt, obj, ...) | Devuelve una cadena formateada a partir de cadenas de formato de estilo printf. |
| regexp\$1count(str, regexp) | Devuelve un recuento del número de veces que el patrón regexp de expresión regular coincide en la cadena str. |
| regexp\$1extract(str, regexp[, idx]) | Extraiga la primera cadena de la str que coincida con la regexp expresión y que corresponda al índice del grupo de expresiones regulares. |
| regexp\$1extract\$1all(str, regexp[, idx]) | Extraiga todas las cadenas que coincidan con la expresión str y que correspondan al índice del grupo de expresiones regulares regexp. |
| regexp\$1instr(str, regexp) | Busca una cadena para un patrón de expresión regular y devuelve un valor entero que indica la posición de inicio o de finalización de la subcadena coincidente. Las posiciones se basan en 1, no en 0. Devuelve 0 si no se encuentran coincidencias. |
| regexp\$1replace(str, regexp, rep[, position]) | Sustituye todas las subcadenas str de esa coincidencia regexp por rep. |
| regexp\$1substr(str, regexp) | Devuelve la subcadena que coincide con la expresión regexp regular de la cadena str. Si no se encuentra la expresión regular, el resultado también será nulo. |
| repeat(str, n) | Devuelve la cadena que repite el valor de cadena dado n veces. |
| replace(str, search[, replace]) | Sustituye todas las apariciones de search por replace. |
| right(str, len) | Devuelve los caracteres más a la derecha len (len pueden ser de tipo cadena) de la cadena str; si len es menor o igual que 0, el resultado es una cadena vacía. |
| rpad(str, len[, pad]) | Devuelve str, rellenado a la derecha con pad una longitud de len. Si str es más larga que len, el valor devuelto se acorta al número de caracteres de len. Si pad no se especifica, str se rellenará a la derecha con espacios si es una cadena de caracteres y con ceros si es una cadena binaria. |
| rtrim(str) | Elimina los caracteres de espacio del final de str. |
| sentences(str[, lang, country]) | str se divide en un conjunto de palabras. |
| soundex(str) | Devuelve el código Soundex de la cadena. |
| space(n) | Devuelve una cadena que consta de n espacios. |
| split(str, regex, limit) | Se divide str en función de las ocurrencias que coinciden regex y devuelve una matriz con una longitud máxima de limit |
| split\$1part(str, delimiter, partNum) | Divide str por delimitador y devuelve la parte solicitada de la división (basada en 1). Si alguna entrada es nula, devuelve null. Si partNum está fuera del rango de partes divididas, devuelve una cadena vacía. Devuelve error si partNum es 0. Si partNum es negativo, las partes se cuentan hacia atrás desde el final de la cadena. Si delimiter es una cadena vacía, str no está dividida. |
| startswith(left, right) | Devuelve un BOOLEANO. El valor es verdadero si left comienza con right. Devuelve NULL si alguna de las expresiones de entrada es NULL. De lo contrario, devuelve que el valor es falso. Tanto left como right deben ser de tipo STRING o BINARY. |
| substr(str, pos[, len]) | Devuelve la subcadena str que comienza en pos y es de longitud len, o el segmento de la matriz de bytes que comienza en pos y es de longitud len. |
| substr(str FROM pos[ FOR len]]) | Devuelve la subcadena str que comienza en pos y es de longitud len, o el segmento de la matriz de bytes que comienza en pos y es de longitud len. |
| substring(str, pos[, len]) | Devuelve la subcadena str que comienza en pos y es de longitud len, o el segmento de la matriz de bytes que comienza en pos y es de longitud len. |
| substring(str FROM pos[ FOR len]]) | Devuelve la subcadena str que comienza en pos y es de longitud len, o el segmento de la matriz de bytes que comienza en pos y es de longitud len. |
| substring\$1index(str, delim, count) | Devuelve la subcadena str antes de la aparición count del delimitador delim. Si count es positivo, devuelve todo lo que esté a la izquierda del delimitador final (contando desde la izquierda). Si count es negativo, devuelve todo lo que esté a la derecha del delimitador final (contando desde la derecha). La función substring\$1index realiza una búsqueda de delim que distingue entre mayúsculas y minúsculas. |
| to\$1binary(str[, fmt]) | Convierte la entrada str en un valor binario en función del fmt proporcionado. fmt puede ser un literal de cadena “hex”, “utf-8”, “utf8” o “base64” que no distinga mayúsculas de minúsculas. De forma predeterminada, el formato binario para la conversión es “hex” si se omite el fmt. La función devuelve NULL si al menos uno de los parámetros de entrada es NULL. |
| to\$1char(numberExpr, formatExpr) | Convierte numberExpr en una cadena basada en formatExpr. Genera una excepción si no se cumple ninguna de las condiciones. El formato puede constar de los siguientes caracteres, sin distinguir entre mayúsculas y minúsculas: “0” o “9”: especifica un dígito esperado entre 0 y 9. Una secuencia de 0 o 9 en la cadena de formato coincide con una secuencia de dígitos del valor de entrada, lo que genera una cadena de resultados de la misma longitud que la secuencia correspondiente de la cadena de formato. La cadena resultante se rellena con ceros a la izquierda si la secuencia 0/9 incluye más dígitos que la parte correspondiente del valor decimal, comienza por 0 y está antes de la coma decimal. De lo contrario, se rellena con espacios. “.” o “D”: especifica la posición de la coma decimal (opcional, solo se permite una vez). “,” o “G”: especifica la posición del separador de agrupamiento (miles) (,). Debe haber un 0 o un 9 a la izquierda y a la derecha de cada separador de agrupamiento. ' |
| tto\$1number(expr, fmt) | Convierte la cadena 'expr' en un número según el formato de cadena 'fmt'. Genera una excepción si no se cumple ninguna de las condiciones. El formato puede constar de los siguientes caracteres, sin distinguir entre mayúsculas y minúsculas: “0” o “9”: especifica un dígito esperado entre 0 y 9. Una secuencia de 0 o 9 en la cadena de formato coincide con una secuencia de dígitos de la cadena de entrada. Si la secuencia 0/9 comienza por 0 y está antes de la coma decimal, solo puede coincidir con una secuencia de dígitos del mismo tamaño. De lo contrario, si la secuencia comienza con 9 o está después de la coma decimal, puede coincidir con una secuencia de dígitos que tenga el mismo tamaño o menor. “.” o “D”: especifica la posición de la coma decimal (opcional, solo se permite una vez). “,” o “G”: especifica la posición del separador de agrupamiento (miles) (,). Debe haber un 0 o un 9 a la izquierda y a la derecha de cada separador de agrupamiento. “expr” debe coincidir con el separador de agrupamiento correspondiente al tamaño del número. ' |
| to\$1varchar(numberExpr, formatExpr) | Convierte numberExpr en una cadena basada en formatExpr. Genera una excepción si no se cumple ninguna de las condiciones. El formato puede constar de los siguientes caracteres, sin distinguir entre mayúsculas y minúsculas: “0” o “9”: especifica un dígito esperado entre 0 y 9. Una secuencia de 0 o 9 en la cadena de formato coincide con una secuencia de dígitos del valor de entrada, lo que genera una cadena de resultados de la misma longitud que la secuencia correspondiente de la cadena de formato. La cadena resultante se rellena con ceros a la izquierda si la secuencia 0/9 incluye más dígitos que la parte correspondiente del valor decimal, comienza por 0 y está antes de la coma decimal. De lo contrario, se rellena con espacios. “.” o “D”: especifica la posición de la coma decimal (opcional, solo se permite una vez). “,” o “G”: especifica la posición del separador de agrupamiento (miles) (,). Debe haber un 0 o un 9 a la izquierda y a la derecha de cada separador de agrupamiento. ' |
| translate(input, from, to) | Traduce la cadena input y los caracteres encontrados en la cadena from reemplazados por los caracteres correspondientes en la cadena to. |
| trim(str) | Elimina los caracteres de espacio inicial y final de str. |
| trim(BOTH FROM str) | Elimina los caracteres de espacio inicial y final de str. |
| trim(LEADING FROM str) | Elimina los caracteres de espacio iniciales de str. |
| trim(TRAILING FROM str) | Elimina los caracteres de espacio del final de str. |
| trim(trimStr FROM str) | Elimine los caracteres trimStr iniciales y finales de str. |
| trim(BOTH trimStr FROM str) | Elimine los caracteres trimStr iniciales y finales de str. |
| trim(LEADING trimStr FROM str) | Elimine los caracteres trimStr iniciales de str. |
| trim(TRAILING trimStr FROM str) | Elimine los caracteres trimStr finales de str. |
| try\$1to\$1binary(str[, fmt]) | Se trata de una versión de to\$1binary especial que realiza la misma operación, pero devuelve un valor NULL en lugar de generar un error si no se puede realizar la conversión. |
| try\$1to\$1number(expr, fmt) | Convierte la cadena 'expr' en un número según el formato de la cadena fmt. Devuelve NULL si la cadena 'expr' no coincide con el formato esperado. El formato sigue la misma semántica que la función to\$1number. |
| ucase(str) | Devuelve str con todos los caracteres cambiados a mayúsculas. |
| unbase64(str) | Convierte el argumento de una cadena str de base 64 en un binario. |
| upper(str) | Devuelve str con todos los caracteres cambiados a mayúsculas. |
**Ejemplos**
```
-- 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|
+---------------+
```
#### Funciones de fecha y hora
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
****
| Función | Description (Descripción) |
| --- | --- |
| add\$1months(start\$1date, num\$1months) | Devuelve la fecha que es num\$1months después de start\$1date. |
| convert\$1timezone([sourceTz, ]targetTz, sourceTs) | Convierte la marca de tiempo sourceTs sin zona horaria sourceTz de a la zona horaria targetTz. |
| curdate() | Devuelve la fecha actual al inicio de la evaluación de la consulta. Todas las llamadas a curdate dentro de la misma consulta devuelven el mismo valor. |
| current\$1date() | Devuelve la fecha actual al inicio de la evaluación de la consulta. Todas las llamadas a current\$1date dentro de la misma consulta devuelven el mismo valor. |
| current\$1date | Devuelve la fecha actual al inicio de la evaluación de la consulta. |
| current\$1timestamp() | Devuelve la marca de tiempo actual al inicio de la evaluación de la consulta. Todas las llamadas a current\$1timestamp dentro de la misma consulta devuelven el mismo valor. |
| current\$1timestamp | Devuelve la marca de tiempo actual al inicio de la evaluación de la consulta. |
| current\$1timezone() | Devuelve la zona horaria local de la sesión actual. |
| date\$1add(start\$1date, num\$1days) | Devuelve la fecha que es num\$1days después de start\$1date. |
| date\$1diff(endDate, startDate) | Devuelve el número de días comprendido entre startDate y endDate. |
| date\$1format(timestamp, fmt) | Se convierte timestamp en un valor de cadena en el formato especificado por el formato de fecha fmt. |
| date\$1from\$1unix\$1date(days) | Crea una fecha a partir del número de días transcurridos desde 1970-01-01. |
| date\$1part(field, source) | Extrae una parte de la fuente date/timestamp o del intervalo. |
| date\$1sub(start\$1date, num\$1days) | Devuelve la fecha que es num\$1days antes de start\$1date. |
| date\$1trunc(fmt, ts) | Devuelve la marca de tiempo ts truncada a la unidad especificada por el modelo de formato fmt. |
| dateadd(start\$1date, num\$1days) | Devuelve la fecha que es num\$1days después de start\$1date. |
| datediff(endDate, startDate) | Devuelve el número de días comprendido entre startDate y endDate. |
| datepart(field, source) | Extrae una parte de la fuente del intervalo date/timestamp o. |
| day(date) | Devuelve el día del mes de la fecha/marca horaria. |
| dayofmonth(date) | Devuelve el día del mes de la fecha/marca horaria. |
| dayofweek(date) | Devuelve el día de la semana de date/timestamp (1 = domingo, 2 = lunes,..., 7 = sábado). |
| dayofyear(date) | Devuelve el día del año de la fecha/marca horaria. |
| extract(field FROM source) | Extrae una parte de la fuente del intervalo date/timestamp o. |
| from\$1unixtime(unix\$1time[, fmt]) | Devuelve el valor unix\$1time especificado en fmt. |
| from\$1utc\$1timestamp(timestamp, timezone) | Dada una marca de tiempo como “2017-07-14 02:40:00.0”, la interpreta como una hora en UTC y representa esa hora como una marca de tiempo en la zona horaria determinada. Por ejemplo, “GMT\$11” daría como resultado “2017-07-14 03:40:00.0”. |
| hour(timestamp) | Devuelve el componente horario de la cadena/marca de tiempo. |
| last\$1day(date) | Devuelve el último día del mes al que pertenece la fecha. |
| localtimestamp() | Devuelve la marca de tiempo actual sin zona horaria al inicio de la evaluación de la consulta. Todas las llamadas a localtimestamp dentro de la misma consulta devuelven el mismo valor. |
| localtimestamp | Devuelve la fecha y hora local actual en la zona horaria de la sesión al inicio de la evaluación de la consulta. |
| make\$1date(year, month, day) | Crea una fecha a partir de los campos de año, mes y día. |
| make\$1dt\$1interval([days[, hours[, mins[, secs]]]]) | Calcula DayTimeIntervalType la duración a partir de días, horas, minutos y segundos. |
| make\$1interval([years[, months[, weeks[, days[, hours[, mins[, secs]]]]]]]) | Hace intervalos entre años, meses, semanas, días, horas, minutos y segundos. |
| make\$1timestamp(year, month, day, hour, min, sec[, timezone]) | Crea una marca de tiempo a partir de los campos de año, mes, día, hora, minuto, segundo y zona horaria. |
| make\$1timestamp\$1ltz(year, month, day, hour, min, sec[, timezone]) | Crea la marca de tiempo actual con la zona horaria local a partir de los campos de año, mes, día, hora, minutos, segundos y zona horaria. |
| make\$1timestamp\$1ntz(year, month, day, hour, min, sec) | Crea una fecha y hora local a partir de los campos de año, mes, día, hora, minutos y segundos. |
| make\$1ym\$1interval([years[, months]]) | Hace un intervalo año-mes a partir de años, meses. |
| minute(timestamp) | Devuelve el componente de minutos de la cadena/marca de tiempo. |
| month(date) | Devuelve el componente mensual de la fecha/marca horaria. |
| months\$1between(timestamp1, timestamp2[, roundOff]) | Si timestamp1 es posterior a timestamp2, entonces el resultado es positivo. Si timestamp1 y timestamp2 son el mismo día del mes, o ambos son el último día del mes, se ignorará la hora del día. De lo contrario, la diferencia se calcula en función de 31 días al mes y se redondea a 8 dígitos, a menos que exista roundOff=false. |
| next\$1day(start\$1date, day\$1of\$1week) | Devuelve la primera fecha posterior a start\$1date y cuyo nombre es el indicado. La función devuelve NULL si al menos uno de los parámetros de entrada es NULL. |
| now() | Devuelve la marca de tiempo actual al inicio de la evaluación de la consulta. |
| quarter(date) | Devuelve el trimestre del año correspondiente a la fecha, en un intervalo de 1 a 4. |
| second(timestamp) | Devuelve el segundo componente de la cadena/marca de tiempo. |
| session\$1window(time\$1column, gap\$1duration) | Genera una ventana de sesión con una marca de tiempo que especifica la duración de la columna y el intervalo. Consulte “Tipos de intervalos” en el documento de la guía de transmisión estructurada para obtener una explicación detallada y ejemplos. |
| timestamp\$1micros(microseconds) | Crea una marca de tiempo a partir del número de microsegundos transcurridos desde la época UTC. |
| timestamp\$1millis(milliseconds) | Crea una marca de tiempo a partir del número de milisegundos transcurridos desde la época UTC. |
| timestamp\$1seconds(seconds) | Crea una marca de tiempo a partir del número de segundos (puede ser fraccionario) desde la época UTC. |
| to\$1date(date\$1str[, fmt]) | Analiza la expresión date\$1str con la expresión fmt hasta una fecha. Devuelve un valor nulo con una entrada no válida. De forma predeterminada, sigue las reglas de selección hasta una fecha si fmt se omite. |
| to\$1timestamp(timestamp\$1str[, fmt]) | Analiza la expresión timestamp\$1str junto con la expresión fmt en una marca de tiempo. Devuelve un valor nulo con una entrada no válida. De forma predeterminada, sigue las reglas de conversión a una marca de tiempo si fmt se omite. |
| to\$1timestamp\$1ltz(timestamp\$1str[, fmt]) | Analiza la expresión timestamp\$1str con la expresión fmt para convertirla en una marca de tiempo con la zona horaria local. Devuelve un valor nulo con una entrada no válida. De forma predeterminada, sigue las reglas de conversión a una marca de tiempo si fmt se omite. |
| to\$1timestamp\$1ntz(timestamp\$1str[, fmt]) | Analiza la expresión timestamp\$1str con la expresión fmt para convertirla en una marca de tiempo sin zona horaria. Devuelve un valor nulo con una entrada no válida. De forma predeterminada, sigue las reglas de conversión a una marca de tiempo si fmt se omite. |
| to\$1unix\$1timestamp(timeExp[, fmt]) | Devuelve la marca de tiempo de UNIX de la hora dada. |
| to\$1utc\$1timestamp(timestamp, timezone) | Dada una marca de tiempo como “2017-07-14 02:40:00.0”, la interpreta como una hora de la zona horaria determinada y representa esa hora como una marca de tiempo en UTC. Por ejemplo, “GMT\$11” daría como resultado “2017-07-14 01:40:00.0”. |
| trunc(date, fmt) | Devuelve date con la parte horaria del día truncada a la unidad especificada por el modelo de formato fmt. |
| try\$1to\$1timestamp(timestamp\$1str[, fmt]) | Analiza la expresión timestamp\$1str junto con la expresión fmt en una marca de tiempo. |
| unix\$1date(date) | Devuelve el número de días transcurridos desde 1970-01-01. |
| unix\$1micros(timestamp) | Devuelve el número de microsegundos transcurridos desde 1970-01-01 00:00:00 UTC. |
| unix\$1millis(timestamp) | Devuelve el número de milisegundos transcurridos desde 1970-01-01 00:00:00 UTC. Trunca los niveles de precisión más altos. |
| unix\$1seconds(timestamp) | Devuelve el número de segundos transcurridos desde 1970-01-01 00:00:00 UTC. Trunca los niveles de precisión más altos. |
| unix\$1timestamp([timeExp[, fmt]]) | Devuelve la marca de tiempo de UNIX de la hora actual o especificada. |
| weekday(date) | Devuelve el día de la semana de date/timestamp (0 = lunes, 1 = martes,..., 6 = domingo). |
| weekofyear(date) | Devuelve la semana del año de la fecha indicada. Se considera que una semana comienza un lunes y la semana 1 es la primera semana con más de 3 días. |
| window(time\$1column, window\$1duration[, slide\$1duration[, start\$1time]]) | Clasifica las filas en una o más ventanas de tiempo con una columna que especifique la marca de tiempo. Los inicios de las ventanas son inclusivos, pero los finales son exclusivos, por ejemplo, las 12:05 estarán en la ventana [12:05,12:10) pero no en [12:00,12:05). Windows admite una precisión de microsegundos. No se admite Windows para el orden de los meses. Consulte “Operaciones de intervalo en tiempos de eventos” en el documento de la guía de transmisión estructurada para obtener una explicación detallada y ejemplos. |
| window\$1time(window\$1column) | Extraiga el valor de tiempo de time/session la columna de la ventana, que se puede usar como valor de tiempo del evento de la ventana. El tiempo extraído es (window.end - 1), lo que refleja el hecho de que los intervalos de agregación tienen un límite superior exclusivo (inicio, final). Consulte “Operaciones de intervalo en tiempos de eventos” en el documento de la guía de transmisión estructurada para obtener una explicación detallada y ejemplos. |
| year(date) | Devuelve el componente anual de la fecha/marca horaria. |
**Ejemplos**
```
-- 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|
+----------------+
```
#### Funciones de agregación
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte[Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql).
Las funciones de agregado funcionan con los valores de las filas para realizar cálculos matemáticos como la suma, el promedio, el recuento, minimum/maximum los valores, la desviación estándar y la estimación, así como algunas operaciones no matemáticas.
**Sintaxis**
```
aggregate_function(input1 [, input2, ...]) FILTER (WHERE boolean_expression)
```
**Parámetros **
+ `boolean_expression`: especifica cualquier expresión que se evalúe como un resultado de tipo booleano. Se pueden combinar dos o más expresiones mediante los operadores lógicos (AND, OR).
**Funciones agregadas de conjuntos ordenados**
Estas funciones de agregación utilizan una sintaxis diferente a la de las demás funciones de agregación para especificar una expresión (normalmente el nombre de una columna) con la que ordenar los valores.
**Sintaxis**
```
{ PERCENTILE_CONT | PERCENTILE_DISC }(percentile) WITHIN GROUP (ORDER BY { order_by_expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] }) FILTER (WHERE boolean_expression)
```
**Parámetros **
+ `percentile`: el percentil del valor que se desea buscar. El percentil debe ser una constante entre 0,0 y 1,0.
+ `order_by_expression`: la expresión (normalmente el nombre de una columna) con la que se ordenan los valores antes de agregarlos.
+ `boolean_expression`: especifica cualquier expresión que se evalúe como un resultado de tipo booleano. Se pueden combinar dos o más expresiones mediante los operadores lógicos (AND, OR).
**Ejemplos**
```
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|
+----------+-------+--------+-------+--------+-----+-----+-----+-----+
```
#### Funciones condicionales
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte[Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql).
****
| Función | Description (Descripción) |
| --- | --- |
| coalesce(expr1, expr2, ...) | Devuelve el primer argumento no nulo si existe. De lo contrario, es nulo. |
| if(expr1, expr2, expr3) | Si se evalúa expr1 como verdadero, devuelve expr2; de lo contrario, devuelve expr3. |
| ifnull(expr1, expr2) | Devuelve expr2 si expr1 es nulo, o expr1. |
| nanvl(expr1, expr2) | Devuelve expr1 si no es NaN, o expr2. |
| nullif(expr1, expr2) | Devuelve null si expr1 es igual a expr2, si no, devuelve expr1. |
| nvl(expr1, expr2) | Devuelve expr2 si expr1 es nulo, o expr1. |
| nvl2(expr1, expr2, expr3) | Devuelve expr2 si expr1 no es nulo, o expr3. |
| CASE WHEN expr1 THEN expr2 [WHEN expr3 THEN expr4]\$1 [ELSE expr5] END | Cuando expr1 es true, devuelve expr2; si no, cuando expr3 es true, devuelve expr4; si no, devuelve expr5. |
**Ejemplos**
```
-- 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|
+--------------------------------------------------+
```
#### Funciones JSON
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
****
| Función | Description (Descripción) |
| --- | --- |
| from\$1json(jsonStr, schema[, options]) | Devuelve un valor de estructura con los valores `jsonStr` y `schema` dados. |
| get\$1json\$1object(json\$1txt, path) | Extrae un objeto json de `path`. |
| json\$1array\$1length(jsonArray) | Devuelve la cantidad de elementos en la matriz exterior de una cadena JSON. |
| json\$1object\$1keys(json\$1object) | Devuelve todas las claves del objeto JSON más externo como una matriz. |
| json\$1tuple(jsonStr, p1, p2, ..., pn) | Devuelve una tupla como la función get\$1json\$1object, pero toma varios nombres. Todos los parámetros de entrada y los tipos de columnas de salida son cadenas. |
| schema\$1of\$1json(json[, options]) | Devuelve el esquema en el formato DDL de la cadena JSON. |
| to\$1json(expr[, options]) | Devuelve una cadena JSON con un valor de estructura determinado |
**Ejemplos**
```
-- 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 qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
****
| Función | Description (Descripción) |
| --- | --- |
| array(expr, ...) | Devuelve una matriz con los elementos dados. |
| array\$1append(array, element) | Agrega el elemento al final de la matriz pasada como primer argumento. El tipo de elemento debe ser similar al tipo de los elementos de la matriz. El elemento nulo también se agrega a la matriz. Pero si la matriz se pasa, es NULL, la salida es NULL |
| array\$1compact(array) | Elimina los valores nulos de la matriz. |
| array\$1contains(array, value) | Devuelve verdadero si la matriz contiene el valor. |
| array\$1distinct(array) | Elimina los valores duplicados de la matriz. |
| array\$1except(array1, array2) | Devuelve una matriz de los elementos de la array1 pero no de la array2, sin duplicados. |
| array\$1insert(x, pos, val) | Coloca val en el punto de índice de la matriz x. Los índices comienzan en 1. El índice negativo máximo es -1 para el que la función inserta un nuevo elemento después del último elemento actual. El índice por encima del tamaño de la matriz se agrega a la matriz, o antepone la matriz si el índice es negativo, con elementos “nulos”. |
| array\$1intersect(array1, array2) | Devuelve una matriz de los elementos en la intersección de array1 y array2, sin duplicados. |
| array\$1join(array, delimiter[, nullReplacement]) | Concatena los elementos de la matriz dada mediante el delimitador y una cadena opcional para reemplazar los valores nulos. Si no se establece ningún valor para nullReplacement, se filtra cualquier valor nulo. |
| array\$1max(array) | Devuelve el valor máximo de la matriz. NaN es mayor que cualquier elemento que no sea NaN por double/float tipo. Se omiten los elementos NULL. |
| array\$1min(array) | Devuelve el valor mínimo de la matriz. NaN es mayor que cualquier elemento que no sea NaN por double/float tipo. Se omiten los elementos NULL. |
| array\$1position(array, element) | Devuelve el índice (basado en 1) del primer elemento coincidente de la matriz siempre que sea largo, o 0 si no se encuentra ninguna coincidencia. |
| array\$1prepend(array, element) | Agrega el elemento al principio de la matriz pasada como primer argumento. El tipo de elemento debe ser el mismo que el tipo de los elementos de la matriz. El elemento nulo también se antepone a la matriz. Pero si la matriz pasada era NULL, la salida va a ser NULL |
| array\$1remove(array, element) | Elimine todos los elementos que sean iguales al elemento de la matriz. |
| array\$1repeat(element, count) | Devuelve la matriz que contiene los tiempos de recuento de elementos. |
| array\$1union(array1, array2) | Devuelve una matriz de los elementos de la unión de array1 y array2, sin duplicados. |
| arrays\$1overlap(a1, a2) | Devuelve verdadero si a1 contiene al menos un elemento no nulo presente también en a2. Si las matrices no tienen ningún elemento común, ninguna está vacía y alguna de ellas contiene un elemento nulo, se devuelve null y falso en caso contrario. |
| arrays\$1zip(a1, a2, ...) | Devuelve una matriz combinada de estructuras en la que la estructura n-ésima contiene todos los valores n-ésimos de las matrices de entrada. |
| aplanar () arrayOfArrays | Transforma una matriz de matrices en una sola matriz. |
| get(array, index) | Devuelve el elemento de la matriz en un índice dado (basado en 0). Si el índice apunta fuera de los límites de la matriz, esta función devuelve NULL. |
| sequence(start, stop, step) | Genera una matriz de elementos desde el principio hasta la parada (ambos incluidos), incrementándose paso a paso. El tipo de valor devuelto es el mismo que el tipo de la expresión. Los tipos compatibles son byte, short, integer, long, date, timestamp. Las expresiones de inicio y parada deben tener el mismo tipo de resolución. Si las expresiones de inicio y finalización se resuelven en el tipo “date” o “timestamp”, la expresión escalonada debe resolverse en el tipo “interval”, “year-month interval” o “day-time interval”; de lo contrario, debe ser del mismo tipo que las expresiones de inicio y finalización. |
| shuffle(array) | Devuelve una permutación aleatoria de la matriz dada. |
| slice(x, start, length) | Subestablece la matriz x a partir del inicio del índice (los índices de la matriz comienzan en 1 o comienzan desde el final si el inicio es negativo) con la longitud especificada. |
| sort\$1array(array[, ascendingOrder]) | Ordena la matriz de entrada en orden ascendente o descendente de acuerdo con el orden natural de los elementos de la matriz. NaN es mayor que cualquier elemento que no sea NaN por double/float tipo. Los elementos nulos se colocarán al principio de la matriz devuelta en orden ascendente o al final de la matriz devuelta en orden descendente. |
**Ejemplos**
```
-- 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]|
+-----------------------------------------+
```
#### Funciones de ventana
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
Las funciones de ventana funcionan en un grupo de filas, denominado ventana y calculan un valor de devolución para cada fila en función del grupo de filas. Las funciones de ventana son útiles para procesar tareas como calcular un promedio móvil, computar una estadística acumulada o acceder al valor de las filas dada la posición relativa de la fila actual.
**Sintaxis**
```
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
Funciones de clasificación
Sintaxis: `RANK | DENSE_RANK | PERCENT_RANK | NTILE | ROW_NUMBER `
Funciones analíticas
Sintaxis: `CUME_DIST | LAG | LEAD | NTH_VALUE | FIRST_VALUE | LAST_VALUE `
Funciones de agregación
Sintaxis: `MAX | MIN | COUNT | SUM | AVG | ... `
+ `nulls_option`: Especifica si se deben omitir o no los valores nulos al evaluar la función de ventana. RESPECT NULLS significa no omitir los valores nulos, mientras que IGNORE NULLS significa omitirlos. Si no se especifica, el valor predeterminado es RESPECT NULLS.
Sintaxis: `{ IGNORE | RESPECT } NULLS `
Nota: `Only LAG` \$1 `LEAD` \$1 `NTH_VALUE` \$1 `FIRST_VALUE` \$1 `LAST_VALUE` se pueden utilizar con `IGNORE NULLS`.
+ `window_frame`: Especifica en qué fila se debe iniciar la ventana y dónde se debe terminar.
Sintaxis: `{ RANGE | ROWS } { frame_start | BETWEEN frame_start AND frame_end }`
frame\$1start y frame\$1end tienen la siguiente sintaxis:
Sintaxis: `UNBOUNDED PRECEDING | offset PRECEDING | CURRENT ROW | offset FOLLOWING | UNBOUNDED FOLLOWING `
offset: especifica el desplazamiento desde la posición de la fila actual.
**Nota:** Si se omite frame\$1end, el valor predeterminado es CURRENT ROW.
**Ejemplos**
```
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|
+--+----+----+----+---------+-----------+----------+
```
#### Funciones de conversión
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
****
| Función | Description (Descripción) |
| --- | --- |
| bigint(expr) | Transfiere el valor `expr` al tipo de datos de destino `bigint`. |
| binary(expr) | Transfiere el valor `expr` al tipo de datos de destino `binario`. |
| boolean(expr) | Transfiere el valor `expr` al tipo de datos de destino `boolean`. |
| cast(expr AS type) | Convierte el valor `expr` al tipo de datos de destino `type`. |
| date(expr) | Transfiere el valor `expr` al tipo de datos de destino `date`. |
| decimal(expr) | Convierte el valor `expr` al tipo de datos de destino `decimal`. |
| double(expr) | Convierte el valor `expr` al tipo de datos de destino `double`. |
| float(expr) | Convierte el valor `expr` al tipo de datos de destino `float`. |
| int(expr) | Transfiere el valor `expr` al tipo de datos de destino `int`. |
| smallint(expr) | Transfiere el valor `expr` al tipo de datos de destino `smallint`. |
| string(expr) | Transfiere el valor `expr` al tipo de datos de destino `string`. |
| timestamp(expr) | Transfiere el valor `expr` al tipo de datos de destino `timestamp`. |
| tinyint(expr) | Transfiere el valor `expr` al tipo de datos de destino `tinyint`. |
**Ejemplos**
```
-- cast
SELECT cast(field as int);
+---------------+
|CAST(field AS INT)|
+---------------+
| 10|
+---------------+
```
#### Funciones de predicados
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
****
| Función | Description (Descripción) |
| --- | --- |
| \$1 expr | No lógico. |
| expr1 < expr2 | Devuelve el valor verdadero si `expr1` es menor que `expr2`. |
| expr1 <= expr2 | Devuelve verdadero si `expr1` es menor o igual que `expr2`. |
| expr1 <=> expr2 | Devuelve el mismo resultado que el operador EQUAL (=) para los operandos no nulos, pero devuelve verdadero si ambos son nulos y falso si uno de ellos es nulo. |
| expr1 = expr2 | Devuelve verdadero si `expr1` es igual a `expr2`, o falso en caso contrario. |
| expr1 == expr2 | Devuelve verdadero si `expr1` es igual a `expr2`, o falso en caso contrario. |
| expr1 > expr2 | Devuelve verdadero si `expr1` es mayor que `expr2`. |
| expr1 >= expr2 | Devuelve verdadero si `expr1` es mayor o igual que `expr2`. |
| expr1 y expr2 | AND lógico. |
| str ilike pattern[ ESCAPE escape] | Devuelve verdadero si str hace coincidir `pattern` con `escape` sin distinguir mayúsculas de minúsculas, null si algún argumento es nulo, falso en caso contrario. |
| expr1 in(expr2, expr3, ...) | Devuelve verdadero si `expr` es igual a cualquier valN. |
| isnan(expr) | Devuelve verdadero si `expr` es NaN, o falso en caso contrario. |
| isnotnull(expr) | Devuelve verdadero si `expr` no es nulo, o falso en caso contrario. |
| isnull(expr) | Devuelve verdadero si `expr` es nulo o falso en caso contrario. |
| str like pattern[ ESCAPE escape] | Devuelve verdadero si str coincide con `pattern` con `escape`, null si algún argumento es nulo, falso en caso contrario. |
| not expr | No lógico. |
| expr1 o expr2 | OR lógico. |
| regexp(str, regexp) | Devuelve verdadero si `str` coincide con `regexp`, o falso en caso contrario. |
| regexp\$1like(str, regexp) | Devuelve verdadero si `str` coincide con `regexp`, o falso en caso contrario. |
| rlike(str, regexp) | Devuelve verdadero si `str` coincide con `regexp`, o falso en caso contrario. |
**Ejemplos**
```
-- !
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|
+---------------+
```
#### Funciones de mapa
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
****
| Función | Description (Descripción) |
| --- | --- |
| element\$1at(array, index) | Devuelve el elemento de la matriz en un índice dado (basado en 1). |
| element\$1at(map, key) | Devuelve el valor de una clave dada. La función devuelve NULL si la clave no se encuentra en el mapa. |
| map(key0, value0, key1, value1, ...) | Crea un mapa con los key/value pares dados. |
| map\$1concat(map, ...) | Devuelve la unión de todos los mapas dados |
| map\$1contains\$1key(map, key) | Devuelve true si el mapa contiene la clave especificada. |
| map\$1entries(map) | Devuelve una matriz desordenada de todas las entradas del mapa dado. |
| map\$1from\$1arrays(keys, values) | Crea un mapa con un par de las key/value matrices dadas. Todos los elementos de las claves no deben ser un valor nulo |
| map\$1from\$1entries () arrayOfEntries | Devuelve un mapa creado a partir de la matriz de entradas dada. |
| map\$1keys(map) | Devuelve una matriz desordenada que contiene las claves del mapa. |
| map\$1values(map) | Devuelve una matriz desordenada que contiene los valores del mapa. |
| str\$1to\$1map (texto [, PairDelim [,]]) keyValueDelim | Crea un mapa después de dividir el texto en pares clave/valor mediante delimitadores. Los delimitadores predeterminados son ',' para `pairDelim` y ':' para ``. keyValueDelim Tanto `PairDelim` como `` se tratan como expresiones regulares. keyValueDelim |
| try\$1element\$1at(array, index) | Devuelve el elemento de la matriz en un índice dado (basado en 1). Si el índice es 0, el sistema generará un error. Si el índice es inferior a 0, accede a los elementos desde el último hasta el primero. La función siempre devuelve NULL si el índice supera la longitud de la matriz. |
| try\$1element\$1at(map, key) | Devuelve el valor de una clave dada. La función siempre devuelve NULL si la clave no está incluida en el mapa. |
**Ejemplos**
```
-- 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|
+----------------------------------+
```
#### Funciones matemáticas
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
****
| Función | Description (Descripción) |
| --- | --- |
| expr1 % expr2 | Devuelve el resto después de `expr1`/`expr2`. |
| expr1 \$1 expr2 | Devuelve `expr1` por `expr2`. |
| expr1 \$1 expr2 | Devuelve `expr1` más `expr2`. |
| expr1 - expr2 | Devuelve `expr1` menos `expr2`. |
| expr1 / expr2 | Devuelve `expr1` dividido `expr2`. Siempre realiza una división de punto flotante. |
| abs(expr) | Devuelve el valor absoluto del valor numérico o del intervalo. |
| acos(expr) | Devuelve el coseno inverso (también conocido como arcoseno) de `expr`, como si se hubiera calculado con `java.lang.math.acos`. |
| acosh(expr) | Devuelve el coseno hiperbólico inverso de `expr`. |
| asin(expr) | Devuelve el seno inverso (también conocido como arco seno), el arco seno de `expr`, como si se hubiera calculado con `java.lang.math.asin`. |
| asinh(expr) | Devuelve el seno hiperbólico inverso de `expr`. |
| atan(expr) | Devuelve la tangente inversa (también conocida como arco tangente) de `expr`, como si la hubiera calculado `java.lang.math.atan` |
| atan2(exprY, exprX) | Devuelve el ángulo en radianes entre el eje x positivo de un plano y el punto dado por las coordenadas (`exprX`, `exprY`), como si se hubiera calculado con `java.lang.Math.atan2`. |
| atanh(expr) | Devuelve la tangente hiperbólica inversa de `expr`. |
| bin(expr) | Devuelve la representación en cadena del valor largo `expr` representado en binario. |
| bround(expr, d) | Devuelve `expr` redondeado a `d` decimales utilizando el modo de redondeo HALF\$1EVEN. |
| cbrt(expr) | Devuelve la raíz cúbica de `expr`. |
| ceil(expr[, scale]) | Devuelve el número más pequeño después de redondear hacia arriba que no sea menor que `expr`. Se puede especificar un parámetro `scale` opcional para controlar el comportamiento de redondeo. |
| ceiling(expr[, scale]) | Devuelve el número más pequeño después de redondear hacia arriba que no sea menor que `expr`. Se puede especificar un parámetro `scale` opcional para controlar el comportamiento de redondeo. |
| conv(num, from\$1base, to\$1base) | Convierte `num` de `from\$1base` a `to\$1base`. |
| cos(expr) | Devuelve el coseno de `expr`, como si lo hubiera calculado `java.lang.Math.cos`. |
| cosh(expr) | Devuelve el coseno hiperbólico de `expr`, como si se hubiera calculado con `java.lang.Math.cosh`. |
| cot(expr) | Devuelve la cotangente de `expr`, como si se hubiera calculado con `1/java.lang.Math.tan`. |
| csc(expr) | Devuelve la cosecante de `expr`, como si se hubiera calculado con `1/java.lang.Math.sin`. |
| degrees(expr) | Convierte radianes en grados. |
| expr1 div expr2 | Divide `expr1` por `expr2`. Devuelve NULL si un operando es NULL o `expr2` es 0. El resultado se convierte en largo. |
| e() | Devuelve el número de Euler, e. |
| expr(expr) | Devuelve e a la potencia de `expr`. |
| expm1(expr) - Devuelve exp(`expr`) | 1 |
| factorial(expr) | Devuelve la factorial de `expr`. `expr` es [0.. 20]. De lo contrario, es nulo. |
| floor(expr[, scale]) | Devuelve el número mayor después de redondear para abajo que no sea mayor que `expr`. Se puede especificar un parámetro `scale` opcional para controlar el comportamiento de redondeo. |
| greatest(expr, ...) | Devuelve el valor máximo de todos los parámetros, omitiendo los valores nulos. |
| hex(expr) | Convierte `expr` en hexadecimal. |
| hypot(expr1, expr2) | Devuelve sqrt(`expr1`\$1\$12 \$1 `expr2`\$1\$12). |
| least(expr, ...) | Devuelve el valor mínimo de todos los parámetros, omitiendo los valores nulos. |
| ln(expr) | Devuelve el logaritmo natural (de base e) de `expr`. |
| log(base, expr) | Devuelve el logaritmo de `expr` con `base`. |
| log10(expr) | Devuelve el logaritmo en base 10 de `expr`. |
| log1p(expr) | Devuelve log(1 \$1 `expr`). |
| log2(expr) | Devuelve el logaritmo de `expr` con base 2. |
| expr1 mod expr2 | Devuelve el resto después de `expr1`/`expr2`. |
| negative(expr) | Devuelve el valor negado de `expr`. |
| pi() | Devuelve pi. |
| pmod(expr1, expr2) | Devuelve el valor positivo del resto de `expr1`/`expr2`. |
| positive(expr) | Devuelve el valor de `expr`. |
| pow(expr1, expr2) | Eleva `expr1` a la potencia de `expr2`. |
| power(expr1, expr2) | Eleva `expr1` a la potencia de `expr2`. |
| radians(expr) | Convierte grados en radianes. |
| rand([seed]) | Devuelve un valor aleatorio con valores independientes e idénticos (i.i.d.) distribuidos uniformemente en [0, 1). |
| randn([seed]) | Devuelve un valor aleatorio con valores independientes y de distribución idéntica (i.i.d.) extraídos de la distribución normal estándar. |
| random([seed]) | Devuelve un valor aleatorio con valores independientes e idénticos (i.i.d.) distribuidos uniformemente en [0, 1). |
| rint(expr) | Devuelve el valor doble que tenga el valor más cercano al argumento y que sea igual a un entero matemático. |
| round(expr, d) | Devuelve `expr` redondeado a `d` decimales utilizando el modo de redondeo HALF\$1UP. |
| sec(expr) | Devuelve la secante de `expr`, como si se hubiera calculado con `1/java.lang.Math.cos`. |
| shiftleft(base, expr) | Cambio bit a bit hacia la izquierda. |
| sign(expr) | Devuelve -1.0, 0.0 o 1.0 si `expr` es negativo, 0 o positivo. |
| signum(expr) | Devuelve -1.0, 0.0 o 1.0 si `expr` es negativo, 0 o positivo. |
| sin(expr) | Devuelve el seno de `expr`, como si lo hubiera calculado `java.lang.Math.sin`. |
| sinh(expr) | Devuelve el seno hiperbólico de `expr`, como si se hubiera calculado mediante `java.lang.Math.sinh`. |
| sqrt(expr) | Devuelve la raíz cuadrada de `expr`. |
| tan(expr) | Devuelve la tangente de `expr`, como si se hubiera calculado con `java.lang.Math.tan`. |
| tanh(expr) | Devuelve la tangente hiperbólica de `expr`, como si se hubiera calculado con `java.lang.Math.tanh`. |
| try\$1add(expr1, expr2) | Devuelve la suma de `expr1`y `expr2` y el resultado es nulo en caso de desbordamiento. Los tipos de entrada aceptables son los mismos que con el operador `\$1`. |
| try\$1divide(dividend, divisor) | Devuelve `dividend`/`divisor`. Siempre realiza una división de punto flotante. Su resultado siempre es nulo si `expr2` es 0. El `dividend` debe ser un número o un intervalo. El `divisor` debe ser numérico. |
| try\$1multiply(expr1, expr2) | Devuelve `expr1`\$1`expr2` y el resultado es nulo en caso de desbordamiento. Los tipos de entrada aceptables son los mismos que con el operador `\$1`. |
| try\$1subtract(expr1, expr2) | Devuelve `expr1`-`expr2` y el resultado es nulo en caso de desbordamiento. Los tipos de entrada aceptables son los mismos para el operador `-`. |
| unhex(expr) | Convierte `expr` hexadecimal en binario. |
| width\$1bucket(value, min\$1value, max\$1value, num\$1bucket) | Devuelve el número de bucket al que se asignaría `value` en un histograma de ancho equivalente con buckets de `num\$1bucket`, en el rango de `min\$1value` a `max\$1value`. |
**Ejemplos**
```
-- %
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|
+-----------------------------------------------------------------------+
```
#### Funciones generadoras
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten estas funciones de SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
****
| Función | Description (Descripción) |
| --- | --- |
| explode(expr) | Separa los elementos de la matriz `expr` en varias filas o los elementos del mapa `expr` en varias filas y columnas. A menos que se especifique lo contrario, utiliza el nombre de columna predeterminado `col` para los elementos de la matriz o `key` y `value` para los elementos del mapa. |
| explode\$1outer(expr) | Separa los elementos de la matriz `expr` en varias filas o los elementos del mapa `expr` en varias filas y columnas. A menos que se especifique lo contrario, utiliza el nombre de columna predeterminado `col` para los elementos de la matriz o `key` y `value` para los elementos del mapa. |
| inline(expr) | Descompone un conjunto de estructuras en una tabla. Utiliza los nombres de columna col1, col2, etc. de forma predeterminada, a menos que se especifique lo contrario. |
| inline\$1outer(expr) | Descompone un conjunto de estructuras en una tabla. Utiliza los nombres de columna col1, col2, etc. de forma predeterminada, a menos que se especifique lo contrario. |
| posexplode(expr) | Separa los elementos de la matriz `expr` en varias filas con posiciones, o los elementos del mapa `expr` en varias filas y columnas con posiciones. A menos que se especifique lo contrario, utiliza el nombre de columna `pos` para la posición, `col` para los elementos de la matriz o `key` y `value` para los elementos del mapa. |
| posexplode\$1outer(expr) | Separa los elementos de la matriz `expr` en varias filas con posiciones, o los elementos del mapa `expr` en varias filas y columnas con posiciones. A menos que se especifique lo contrario, utiliza el nombre de columna `pos` para la posición, `col` para los elementos de la matriz o `key` y `value` para los elementos del mapa. |
| stack(n, expr1, ..., exprk) | Separa `expr1`,..., `expr` en `n` filas. Utiliza los nombres de columna col0, col1, etc. de forma predeterminada a menos que se especifique lo contrario. |
**Ejemplos**
```
-- 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 qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
OpenSearch SQL admite una `SELECT` sentencia que se utiliza para recuperar conjuntos de resultados de una o más tablas. En la siguiente sección se describe la sintaxis general de la consulta y las diferentes estructuras de una consulta.
**Sintaxis**
```
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 } ]
```
Mientras que `select_statement` se define 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**
+ **TODAS**
Selecciona todas las filas coincidentes de la relación y está habilitada de forma predeterminada.
+ **DISTINTO**
Selecciona todas las filas coincidentes de la relación después de eliminar los duplicados de los resultados.
+ **named\$1expression **
Una expresión con un nombre asignado. En general, denota una expresión de columna.
Sintaxis: `expression [[AS] alias]`
+ **from\$1item **
Relación de tabla
Relación de unión
Relación de tablas dinámicas
Relación no dinámica
Funciones con valores de tabla
Tabla en línea
`[ LATERAL ] ( Subquery )`
+ **PIVOTE**
La cláusula `PIVOT` se utiliza desde la perspectiva de los datos. Puede obtener los valores agregados en función de un valor de columna específico.
+ **DESPIVOTAR**
La cláusula `UNPIVOT` transforma las columnas en filas. Es lo contrario a `PIVOT`, excepto en lo que respecta a la agregación de valores.
+ **LATERAL VIEW **
La cláusula `LATERAL VIEW` se usa junto con funciones generadoras, por ejemplo `EXPLODE`, que generarán una tabla virtual que contiene una o más filas.
`LATERAL VIEW` aplicará las filas a cada fila de salida original.
+ **WHERE**
Filtra el resultado de la cláusula `FROM` en función de los predicados proporcionados.
+ **AGRUPAR POR**
Especifica las expresiones que se utilizan para agrupar las filas.
Se utiliza junto con las funciones de agregado (`MIN`, `MAX`, `COUNT`, `SUM`, `AVG`, etc.) para agrupar las filas en función de las expresiones de agrupación y los valores agregados de cada grupo.
Cuando se adjunta una cláusula `FILTER` a una función agregada, solo las filas coincidentes se pasan a esa función.
+ **TENIENDO**
Especifica los predicados mediante los que se filtran las filas producidas por `GROUP BY`.
La cláusula `HAVING` se utiliza para filtrar las filas una vez realizada la agrupación.
Si `HAVING` se especifica sin `GROUP BY`, indica que `GROUP BY` no tiene expresiones de agrupamiento (agregado global).
+ **ORDER BY **
Especifica el orden de las filas del conjunto completo de resultados de la consulta.
Las filas de salida se ordenan en las particiones.
Este parámetro se excluye mutuamente con `SORT BY` y `DISTRIBUTE BY` no se puede especificar de forma conjunta.
+ **SORT BY **
Especifica el orden por el que se ordenan las filas dentro de cada partición.
Este parámetro se excluye mutuamente con `ORDER BY` y no se puede especificar de forma conjunta.
+ **LIMIT**
Especifica el número máximo de filas que puede devolver una sentencia o subconsulta.
Esta cláusula se usa principalmente junto con `ORDER BY` para producir un resultado determinista.
+ **boolean\$1expression **
Especifica cualquier expresión que se evalúe como un valor booleano.
Se pueden combinar dos o más expresiones mediante los operadores lógicos (`AND`, `OR`).
+ **expresión**
Combinación de uno o varios valores, operadores o funciones SQL que dan como resultado un valor.
+ **named\$1window**
Especifica los alias de una o más especificaciones de la ventana de origen.
Se puede hacer referencia a las especificaciones de la ventana de origen en las definiciones de ventana de la consulta.
#### Cláusula WHERE
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte[Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql).
La cláusula `WHERE` se utiliza para limitar los resultados de la cláusula `FROM` de una consulta o subconsulta en función de la condición especificada.
**Sintaxis**
```
WHERE boolean_expression
```
**Parámetros**
+ **boolean\$1expression**
Especifica cualquier expresión que se evalúe como un valor booleano.
Se pueden combinar dos o más expresiones mediante los operadores lógicos (`AND`, `OR`).
**Ejemplos**
```
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 qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
La cláusula `GROUP BY` se utiliza para agrupar las filas en función de un conjunto de expresiones de agrupamiento especificadas y calcular las agregaciones en el grupo de filas en función de una o más funciones de agregación especificadas.
El sistema también realiza múltiples agregaciones para el mismo conjunto de registros de entrada mediante las cláusulas `GROUPING SETS`, `CUBE`, `ROLLUP`. Las expresiones de agrupamiento y las agregaciones avanzadas se pueden mezclar en la cláusula `GROUP BY` y anidar en una cláusula `GROUPING SETS `. Consulte la sección `Mixed/Nested Grouping Analytics ` para obtener más información.
Cuando se adjunta una cláusula `FILTER` a una función agregada, solo las filas coincidentes se pasan a esa función.
**Sintaxis**
```
GROUP BY group_expression [ , group_expression [ , ... ] ] [ WITH { ROLLUP | CUBE } ]
GROUP BY { group_expression | { ROLLUP | CUBE | GROUPING SETS } (grouping_set [ , ...]) } [ , ... ]
```
Mientras que las funciones agregadas se definen de la siguiente manera:
```
aggregate_name ( [ DISTINCT ] expression [ , ... ] ) [ FILTER ( WHERE boolean_expression ) ]
```
**Parámetros**
+ **group\$1expression **
Especifica los criterios en función de los cuales se agrupan las filas. La agrupación de filas se realiza en función de los valores de resultado de las expresiones de agrupación.
Una expresión de agrupamiento puede ser un nombre de columna como `GROUP BY a`, una posición de columna como `GROUP BY 0` o una expresión similar como `GROUP BY a + b`.
+ **grouping\$1set **
Un conjunto de agrupamiento se especifica mediante cero o más expresiones separadas por comas entre paréntesis. Cuando el conjunto de agrupamiento solo tiene un elemento, se pueden omitir los paréntesis.
Por ejemplo, `GROUPING SETS ((a), (b))` es igual que `GROUPING SETS (a, b)`.
Sintaxis: `{ ( [ expression [ , ... ] ] ) | expression }`
+ **GROUPING SETS **
Agrupa las filas de cada conjunto de agrupamiento que se especifique después de `GROUPING SETS`.
Por ejemplo, `GROUP BY GROUPING SETS ((warehouse), (product))` es semánticamente equivalente a la unión de los resultados de `GROUP BY warehouse` y `GROUP BY product`. Esta cláusula es una forma abreviada de UNION ALL, en la que cada parte del operador `UNION ALL` realiza la agregación de cada conjunto de agrupamiento especificado en la cláusula `GROUPING SETS`.
Del mismo modo, `GROUP BY GROUPING SETS ((warehouse, product), (product), ())` es semánticamente equivalente a la unión de los resultados de `GROUP BY warehouse, product, GROUP BY product` y un agregado global.
+ **ROLLUP**
Especifica varios niveles de agregación en una sentencia. Esta cláusula se utiliza para calcular las agregaciones en función de varios conjuntos de agrupamiento. `ROLLUP` es una forma abreviada de `GROUPING SETS`.
Por ejemplo, `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))` es equivalente a `GROUP BY GROUPING SETS((warehouse, product, location), (warehouse, product), (warehouse), ())`.
Los elementos N de una especificación ROLLUP dan como resultado N\$11 GROUPING SETS.
+ **CUBE**
La cláusula CUBE se utiliza para realizar agregaciones basadas en la combinación de columnas de agrupamiento especificadas en la cláusula GROUP BY. CUBE es una forma abreviada de GROUPING SETS.
Por ejemplo, `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))` es equivalente a `GROUP BY GROUPING SETS((warehouse, product, location), (warehouse, product), (warehouse, location), (product, warehouse, location), (warehouse), (product), (warehouse, product), ())`. Los elementos N de una especificación `CUBE` dan como resultado 2^N `GROUPING SETS`.
+ **Análisis de agrupamiento mixto/anidado**
Una cláusula `GROUP BY` puede incluir múltiples group\$1expressions y múltiples `CUBE|ROLLUP|GROUPING SETS`. `GROUPING SETS` también puede tener cláusulas `CUBE|ROLLUP|GROUPING SETS` anidadas, 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` es solo azúcar de sintáctico para `GROUPING SETS`. Consulte las secciones anteriores para saber cómo traducir `CUBE|ROLLUP` a `GROUPING SETS`. `group_expression` se puede tratar como un solo grupo `GROUPING SETS` en este contexto.
En el caso de los múltiplos de `GROUPING SETS` en la cláusula `GROUP BY`, generamos un único `GROUPING SETS` haciendo un producto cruzado del original `GROUPING SETS`. Para anidar `GROUPING SETS` en la cláusula `GROUPING SETS`, simplemente cogemos sus conjuntos de agrupamiento y los eliminamos.
Por ejemplo, `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)))` es equivalente a `GROUP BY GROUPING SETS((warehouse), (warehouse, product))`.
+ **aggregate\$1name **
Especifica el nombre de una función agregada (`MIN`, `MAX`, `COUNT`, `SUM`, `AVG`, etc.).
+ **DISTINTO**
Elimina los duplicados de las filas de entrada antes de pasarlos a las funciones de agregado.
+ **FILTRAR**
Filtra las filas de entrada para las que el valor `boolean_expression` de la cláusula `WHERE` se evalúe como verdadero se pasan a la función de agregado; las demás filas se descartan.
**Ejemplos**
```
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 qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte[Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql).
La cláusula `HAVING` se utiliza para filtrar los resultados generados por `GROUP BY` en función de la condición especificada. Suele utilizarse junto con una cláusula `GROUP BY`.
**Sintaxis**
```
HAVING boolean_expression
```
**Parámetros**
+ **boolean\$1expression **
Especifica cualquier expresión que se evalúe como un valor booleano. Se pueden combinar dos o más expresiones mediante los operadores lógicos (`AND`, `OR`).
**Nota:** Las expresiones especificadas en la cláusula `HAVING` solo pueden hacer referencia a:
1. Constantes
1. Expresiones que aparecen en `GROUP BY`
1. Funciones de agregación
**Ejemplos**
```
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 qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
La cláusula `ORDER BY` se utiliza para devolver las filas de resultados ordenadas en el orden especificado por el usuario. A diferencia de la cláusula SORT BY, esta cláusula garantiza un orden total en la salida.
**Sintaxis**
```
ORDER BY { expression [ sort_direction | nulls_sort_order ] [ , ... ] }
```
**Parámetros**
+ **ORDER BY **
Especifica una lista de expresiones separadas por comas junto con parámetros `sort_direction` y `nulls_sort_order` opcionales que se utilizan para ordenar las filas.
+ **sort\$1direction**
De manera opcional, especifica si se deben ordenar en orden ascendente o descendente.
Los valores válidos para la dirección de ordenación son `ASC` ascendentes y `DESC` descendentes.
Si la dirección de ordenación no se especifica de forma explícita, las filas se ordenan por defecto en orden ascendente.
Sintaxis: `[ ASC | DESC ] `
+ **nulls\$1sort\$1order**
Si lo desea, especifica si `NULL` los valores se devuelven como valores before/after no nulos.
Si no se especifica null\$1sort\$1order, `NULLs` ordena primero si el orden es `ASC` y NULLS ordenará en último lugar si el orden de clasificación es `DESC`.
1. Si `NULLS FIRST` se especifica, los valores NULL se devuelven primero, independientemente del orden de clasificación.
2. Si `NULLS LAST` se especifica, los valores NULL se devuelven en último lugar, independientemente del orden de clasificación.
Sintaxis: `[ NULLS { FIRST | LAST } ]`
**Ejemplos**
```
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 qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
Una unión SQL se utiliza para combinar filas de dos relaciones en función de los criterios de unión. En la siguiente sección se describe la sintaxis general de las uniones y los distintos tipos de uniones, junto con ejemplos.
**Sintaxis**
```
relation INNER JOIN relation [ join_criteria ]
```
**Parámetros**
+ **relation**
Especifica la relación que se va a unir.
+ **join\$1type**
Especifica el tipo de unión.
Sintaxis: `INNER | CROSS | LEFT OUTER`
+ **join\$1criteria**
Especifica cómo se combinarán las filas de una relación con las filas de otra relación.
Sintaxis: `ON boolean_expression | USING ( column_name [ , ... ] ) `
+ **boolean\$1expression **
Especifica una expresión con un tipo de devolución booleano.
**Tipos de unión**
+ **Unión interna**
La combinación interna debe especificarse de forma explícita. Selecciona filas que tienen valores coincidentes en ambas relaciones.
Sintaxis: `relation INNER JOIN relation [ join_criteria ] `
+ **Combinación izquierda**
Una combinación por la izquierda devuelve todos los valores de la relación izquierda y los valores coincidentes de la relación derecha, o agrega NULL si no hay ninguna coincidencia. También se conoce como unión externa izquierda.
Sintaxis: `relation LEFT OUTER JOIN relation [ join_criteria ]`
+ **Unión cruzada**
Una unión cruzada devuelve el producto cartesiano de dos relaciones.
Sintaxis: `relation CROSS JOIN relation [ join_criteria ]`
**Ejemplos**
```
-- 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 qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte[Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql).
La cláusula `LIMIT` se utiliza para restringir el número de filas devueltas por la sentencia `SELECT`. En general, esta cláusula se usa junto con `ORDER BY` para garantizar que los resultados sean deterministas.
**Sintaxis**
```
LIMIT { ALL | integer_expression }
```
**Parámetros**
+ **TODAS**
Si se especifica, la consulta devuelve todas las filas. En otras palabras, no se aplica ningún límite si se especifica esta opción.
+ **integer\$1expression **
Especifica una expresión plegable que devuelve un entero.
**Ejemplos**
```
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 qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte[Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql).
La cláusula `CASE` utiliza una regla para devolver un resultado específico en función de la condición especificada, de forma similar a las sentencias if/else de otros lenguajes de programación.
**Sintaxis**
```
CASE [ expression ] { WHEN boolean_expression THEN then_expression } [ ... ]
[ ELSE else_expression ]
END
```
**Parámetros**
+ **boolean\$1expression **
Especifica cualquier expresión que se evalúe como un valor booleano.
Se pueden combinar dos o más expresiones mediante los operadores lógicos (`AND`, `OR`).
+ **then\$1expression**
Especifica la expresión then en función de la condición boolean\$1expression.
`then_expression` y `else_expression` todas deben ser del mismo tipo o estar sujetas a un tipo común.
+ **else\$1expression **
Especifica la expresión predeterminada.
`then_expression` y ` else_expression` todas deben ser del mismo tipo o estar sujetas a un tipo común.
**Ejemplos**
```
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 |
+------+-----------------------------------------------------------------------------------------------+
```
#### Expresiones de tabla comunes
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
Una expresión de tabla común (CTE) define un conjunto de resultados temporal al que un usuario puede hacer referencia posiblemente varias veces dentro del ámbito de una sentencia SQL. Una CTE se utiliza principalmente en una declaración `SELECT`.
**Sintaxis**
```
WITH common_table_expression [ , ... ]
```
Mientras que `common_table_expression` se define como:
```
Syntexpression_name [ ( column_name [ , ... ] ) ] [ AS ] ( query )
```
**Parámetros**
+ **expression\$1name **
Especifica un nombre para la expresión de tabla común.
+ **consulta**
Una sentencia `SELECT`.
**Ejemplos**
```
-- 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 qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
La sentencia `EXPLAIN` se utiliza para proporcionar planes lógicos/físicos para una sentencia de entrada. De forma predeterminada, esta cláusula proporciona información únicamente sobre un plan físico.
**Sintaxis**
```
EXPLAIN [ EXTENDED | CODEGEN | COST | FORMATTED ] statement
```
**Parámetros**
+ **EXTENDED**
Genera un plan lógico diseccionado, un plan lógico analizado, un plan lógico optimizado y un plan físico.
El plan lógico diseccionado es un plan sin resolver que se extrajo de la consulta.
Los planes lógicos analizados se transforman y traducen `unresolvedAttribute` y `unresolvedRelation` a objetos completamente tipificados.
El plan lógico optimizado se transforma mediante un conjunto de reglas de optimización, lo que da como resultado el plan físico.
+ **CODEGEN**
Genera el código para la declaración, si la hubiera y un plan físico.
+ **COST**
Si las estadísticas de los nodos del plan están disponibles, genera un plan lógico y las estadísticas.
+ **FORMATTED**
Genera dos secciones: un esquema físico del plan y detalles de los nodos.
+ **statement **
Especifica una sentencia SQL que se va a explicar.
**Ejemplos**
```
-- 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 qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
`LATERAL SUBQUERY` es una subconsulta precedida de la palabra clave `LATERAL`. Proporciona una forma de hacer referencia a las columnas de la cláusula `FROM` anterior. Sin la palabra clave `LATERAL`, las subconsultas solo pueden hacer referencia a las columnas de la consulta externa, pero no a las de la cláusula `FROM`. `LATERAL SUBQUERY` simplifica y hace que las consultas complicadas sean más sencillas y eficaces.
**Sintaxis**
```
[ LATERAL ] primary_relation [ join_relation ]
```
**Parámetros**
+ **primary\$1relation **
Especifica la relación principal. Puede ser una de las siguientes opciones:
1. Relación de tabla
1. Consulta con alias
Sintaxis: `( query ) [ [ AS ] alias ] `
1. Relación con alias
`Syntax: ( relation ) [ [ AS ] alias ]`
**Ejemplos**
```
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 qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
La cláusula `LATERAL VIEW` se usa junto con funciones generadoras, por ejemplo `EXPLODE`, que generarán una tabla virtual que contiene una o más filas. `LATERAL VIEW` aplicará las filas a cada fila de salida original.
**Sintaxis**
```
LATERAL VIEW [ OUTER ] generator_function ( expression [ , ... ] ) [ table_alias ] AS column_alias [ , ... ]
```
**Parámetros**
+ **EXTERIOR**
Si `OUTER` se especifica, devuelve nulo si una entrada array/map está vacía o nula.
+ **generator\$1function **
Especifica una función generadora (`EXPLODE`, `INLINE`, etc.).
+ **table\$1alias**
El alias de `generator_function`, que es opcional.
+ **column\$1alias**
Muestra los alias de las columnas de `generator_function`, que se pueden usar en las filas de salida.
Puede tener varios alias si `generator_function` tiene varias columnas de salida.
**Ejemplos**
```
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 qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte[Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql).
Se utiliza un predicado `LIKE` para buscar un patrón específico. Este predicado también admite varios patrones con cuantificadores como `ANY`, `SOME` y `ALL`.
**Sintaxis**
```
[ NOT ] { LIKE search_pattern [ ESCAPE esc_char ] | [ RLIKE | REGEXP ] regex_pattern }
[ NOT ] { LIKE quantifiers ( search_pattern [ , ... ]) }
```
**Parámetros**
+ **search\$1pattern **
Especifica un patrón de cadenas que se va a buscar mediante la cláusula LIKE. Puede contener caracteres especiales que coincidan con el patrón:
+ `%` coincide con 0 o más caracteres.
+ `_` coincide exactamente con un carácter.
+ **esc\$1char**
Especifica el carácter de escape. El carácter de escape predeterminado es `\`.
+ **regex\$1pattern**
Especifica un patrón de búsqueda de expresiones regulares que se va a buscar mediante la cláusula `RLIKE` o `REGEXP`.
+ **quantifiers**
Especifica los cuantificadores de predicados que incluyen `ANY`, `SOME` y `ALL`.
`ANY` o `SOME` significan que si uno de los patrones coincide con la entrada, devuelve verdadero.
`ALL` significa que si todos los patrones coinciden con la entrada, entonces devuelve verdadero.
**Ejemplos**
```
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 qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
La cláusula `OFFSET` se utiliza para especificar el número de filas que se van a omitir antes de empezar a devolver las filas devueltas por la sentencia `SELECT`. En general, esta cláusula se utiliza en conjunto con `ORDER BY` para garantizar que los resultados sean deterministas.
**Sintaxis**
```
OFFSET integer_expression
```
**Parámetros**
+ **integer\$1expression **
Especifica una expresión plegable que devuelve un entero.
**Ejemplos**
```
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 qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
La cláusula `PIVOT` se utiliza desde la perspectiva de los datos. Podemos obtener los valores agregados en función de valores de columna específicos, que se convertirán en varias columnas utilizadas en la cláusula `SELECT`. La cláusula `PIVOT` se puede especificar después del nombre de la tabla o la subconsulta.
**Sintaxis**
```
PIVOT ( { aggregate_expression [ AS aggregate_expression_alias ] } [ , ... ] FOR column_list IN ( expression_list ) )
```
**Parámetros**
+ **expresión\$1de\$1agregación**
Especifica una expresión agregada `(SUM(a)`, `COUNT(DISTINCT b)`, etc.
+ **aggregate\$1expression\$1alias**
Especifica un alias para la expresión agregada.
+ **column\$1list**
Contiene columnas en la cláusula `FROM`, que especifica las columnas que desea reemplazar por columnas nuevas. Puede utilizar corchetes para rodear las columnas, por ejemplo `(c1, c2)`.
+ **expression\$1list**
Especifica las columnas nuevas, que se utilizan para hacer coincidir los valores en `column_list` como la condición de agregación. También puede usar alias para los bots.
**Ejemplos**
```
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 |
+------+-----------+-------+-------+-------+-------+
```
#### Operadores de establecimiento
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
Los operadores de conjuntos se utilizan para combinar dos relaciones de entrada en una sola. OpenSearch SQL admite tres tipos de operadores de conjuntos:
+ `EXCEPT` o `MINUS`
+ `INTERSECT`
+ `UNION`
Las relaciones de entrada deben tener el mismo número de columnas y tipos de datos compatibles para las columnas respectivas.
**EXCEPTO**
`EXCEPT` y `EXCEPT ALL` devuelven las filas que se encuentran en una relación pero no en la otra. `EXCEPT` (alternativamente, `EXCEPT DISTINCT`) solo toma filas distintas, pero `EXCEPT ALL` no elimina los duplicados de las filas de resultados. Tenga en cuenta que `MINUS` es un alias de `EXCEPT`.
**Sintaxis**
```
[ ( ] relation [ ) ] EXCEPT | MINUS [ ALL | DISTINCT ] [ ( ] relation [ ) ]
```
**Ejemplos**
```
-- 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|
+---+
```
**INTERSECTAR**
`INTERSECT` y `INTERSECT ALL` devuelven las filas que se encuentran en ambas relaciones. `INTERSECT` (alternativamente, `INTERSECT DISTINCT`) solo toma filas distintas, pero `INTERSECT ALL` no elimina los duplicados de las filas de resultados.
**Sintaxis**
```
[ ( ] relation [ ) ] INTERSECT [ ALL | DISTINCT ] [ ( ] relation [ ) ]
```
**Ejemplos**
```
(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ÓN**
`UNION` y `UNION ALL` devuelven las filas que se encuentran en cualquiera de las dos relaciones. `UNION` (alternativamente, `UNION DISTINCT`) solo toma filas distintas, pero `UNION ALL` no elimina los duplicados de las filas de resultados.
**Sintaxis**
```
[ ( ] relation [ ) ] UNION [ ALL | DISTINCT ] [ ( ] relation [ ) ]
```
**Ejemplos**
```
(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 qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte[Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql).
La cláusula `SORT BY` se utiliza para devolver las filas de resultados ordenadas dentro de cada partición en el orden especificado por el usuario. Cuando hay más de una partición, `SORT BY` puede devolver un resultado parcialmente ordenado. Esto es diferente a la cláusula `ORDER BY` que garantiza un orden total de la salida.
**Sintaxis**
```
SORT BY { expression [ sort_direction | nulls_sort_order ] [ , ... ] }
```
**Parámetros**
+ **SORT BY **
Especifica una lista de expresiones separadas por comas junto con los parámetros opcionales sort\$1direction y nulls\$1sort\$1order que se utilizan para ordenar las filas de cada partición.
+ **sort\$1direction **
De manera opcional, especifica si se deben ordenar en orden ascendente o descendente.
Los valores válidos para la dirección de ordenación son `ASC` ascendentes y `DESC` descendentes.
Si la dirección de ordenación no se especifica de forma explícita, las filas se ordenan por defecto en orden ascendente.
Sintaxis: `[ ASC | DESC ]`
+ **nulls\$1sort\$1order**
De manera opcional, especifica si los valores NULL se devuelven antes o después de los valores no NULL.
Si no `null_sort_order` se especifica, NULLs ordene primero si el orden de clasificación es `ASC` y NULL ordene en último lugar si el orden de clasificación sí lo es. `DESC`
1. Si `NULLS FIRST` se especifica, los valores NULL se devuelven primero, independientemente del orden de clasificación.
2. Si `NULLS LAST` se especifica, los valores NULL se devuelven en último lugar, independientemente del orden de clasificación.
Sintaxis: `[ NULLS { FIRST | LAST } ] `
**Ejemplos**
```
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 qué integraciones de fuentes de AWS datos admiten este comando SQL, consulte. [Comandos y funciones de OpenSearch SQL compatibles](#supported-directquery-sql)
La cláusula `UNPIVOT` transforma varias columnas en varias filas utilizadas en la cláusula `SELECT`. La cláusula `UNPIVOT` se puede especificar después del nombre de la tabla o la subconsulta.
**Sintaxis**
```
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**
Contiene las columnas de la `FROM` cláusula, que especifican las columnas que queremos dejar de pivotar.
+ **name\$1column **
El nombre de la columna que contiene los nombres de las columnas no pivotantes.
+ **values\$1column **
El nombre de la columna que contiene los valores de las columnas no pivotantes.
**Ejemplos**
```
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 |
+------+------------------+---------------+----------------+
```