', default: (\)
```
Al exportar los datos en formato CSV, este campo especifica el carácter que debe tratarse como un carácter de escape en el archivo de datos escrito en el bucket de S3. Esto ocurre en las siguientes situaciones:
1. Si el valor en sí contiene el carácter entre comillas ("), se escapará mediante un carácter de escape. Por ejemplo, si el valor es `Time"stream`, donde (\$1) es el carácter de escape configurado, se escapa como `Time\"stream`.
1. Si el valor contiene el carácter de escape configurado, se escapará. Por ejemplo, si el valor es `Time\stream`, se escapará como `Time\\stream`.
Si la salida exportada contiene tipos de datos complejos, como matrices, filas o series temporales, se serializará como una cadena JSON. A continuación se muestra un ejemplo.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/timestream/latest/developerguide/supported-sql-constructs.UNLOAD.html)
INCLUDE\$1HEADER
```
include_header = 'true' , default: 'false'
```
Al exportar los datos en formato CSV, este campo le permite incluir los nombres de las columnas como la primera fila de los archivos de datos CSV exportados.
Los valores aceptados son “verdadero” y “falso” y el valor predeterminado es “falso”. Las opciones de transformación de texto, como `escaped_by` y `field_delimiter`, se aplican también a los encabezados.
Al incluir encabezados, es importante no seleccionar un carácter de retorno (ASCII 13, hexadecimal 0D, texto “\$1r”) o un carácter de salto de línea (ASCII 10, hexadecimal 0A, texto “\$1n”) como `FIELD_DELIMITER`, ya que esto impedirá que muchos analizadores puedan analizar correctamente los encabezados en la salida CSV resultante.
MAX\$1FILE\$1SIZE
```
max_file_size = 'X[MB|GB]' , default: '78GB'
```
Este campo especifica el tamaño máximo de los archivos que la instrucción `UNLOAD` crea en Amazon S3. La instrucción `UNLOAD` puede crear varios archivos, pero el tamaño máximo de cada archivo escrito en Amazon S3 será aproximadamente el que se especifique en este campo.
El valor debe estar comprendido entre 16 MB y 78 GB, ambos incluidos. Puede especificarlo en números enteros, como `12GB`, o en decimales, como `0.5GB` o `24.7MB`. El valor predeterminado es 78 GB.
El tamaño real del archivo es aproximado cuando se está escribiendo el archivo, por lo que es posible que el tamaño real máximo no sea exactamente igual al número que especifique.
# Logical operators (Operadores lógicos)
Timestream for LiveAnalytics admite los siguientes operadores lógicos.
| Operador | Description (Descripción) | Ejemplo |
| --- | --- | --- |
| AND | Verdadero si ambos valores son verdaderos | a AND b |
| OR | Verdadero si alguno de los valores es verdadero | a OR b |
| NOT | Verdadero si el valor es falso | NOT a |
+ El resultado de una comparación `AND` puede ser `NULL` si uno o ambos lados de la expresión son `NULL`.
+ Si al menos un lado de un operador `AND` es `FALSE`, el resultado de la expresión es `FALSE`.
+ El resultado de una comparación `OR` puede ser `NULL` si uno o ambos lados de la expresión son `NULL`.
+ Si al menos un lado de un operador `OR` es `TRUE`, el resultado de la expresión es `TRUE`.
+ El complemento lógico de `NULL` es `NULL`.
La siguiente tabla de verdad muestra el manejo de `NULL` en `AND` y `OR`:
| A | B | A and b | A or b |
| --- | --- | --- | --- |
| null | nulo | nulo | null |
| false | null | false | null |
| null | false | false | null |
| true | null | null | true |
| null | true | null | true |
| false | false | false | false |
| true | false | false | true |
| false | true | false | true |
| true | true | true | true |
La siguiente tabla de verdad muestra el manejo de NULL en NOT:
| A | Not a |
| --- | --- |
| null | null |
| true | false |
| false | true |
# Operadores de comparación
Timestream for LiveAnalytics admite los siguientes operadores de comparación.
| Operador | Description (Descripción) |
| --- | --- |
| < | Menor que |
| > | Mayor que |
| <= | Menor o igual que |
| >= | Mayor o igual que |
| = | Igualdad |
| <> | Desigualdad |
| \$1= | Desigualdad |
**nota**
El operador `BETWEEN` comprueba si un valor está dentro de un rango especificado. La sintaxis es la siguiente:
```
BETWEEN min AND max
```
La presencia de `NULL` en una instrucción `BETWEEN` o `NOT BETWEEN` hará que la instrucción se evalúe como `NULL`.
Los operadores `IS NULL ` y `IS NOT NULL` comprueban si un valor es nulo (indefinido). Si se utiliza `NULL` con `IS NULL`, el resultado es verdadero.
En SQL, un valor `NULL` significa un valor desconocido.
# Funciones de comparación
Timestream for LiveAnalytics admite las siguientes funciones de comparación.
**Topics**
+ [
# greatest()
](comparison-functions.greatest.md)
+ [
# least()
](comparison-functions.least.md)
+ [
# ALL(), ANY() y SOME()
](comparison-functions.all-any-some.md)
# greatest()
La función **greatest()** devuelve el mayor de los valores proporcionados. Devuelve `NULL` si alguno de los valores proporcionados es `NULL`. La sintaxis es la siguiente.
```
greatest(value1, value2, ..., valueN)
```
# least()
La función **least()** devuelve el menor de los valores proporcionados. Devuelve `NULL` si alguno de los valores proporcionados es `NULL`. La sintaxis es la siguiente.
```
least(value1, value2, ..., valueN)
```
# ALL(), ANY() y SOME()
Los cuantificadores `ALL`, `ANY` y `SOME` se pueden usar junto con los operadores de comparación de la siguiente manera.
| Expression | Significado |
| --- | --- |
| A = ALL(…) | Se evalúa como verdadero cuando A es igual a todos los valores. |
| A <> ALL(…) | Se evalúa como verdadero cuando A no coincide con ningún valor. |
| A < ALL(…) | Se evalúa como verdadero cuando A es menor que el valor más pequeño. |
| A = ANY(…) | Se evalúa como verdadero cuando A es igual que cualquiera de los valores. |
| A <> ANY(…) | Se evalúa como verdadero cuando A no coincide con uno o más valores. |
| A < ANY(…) | Se evalúa como verdadero cuando A es menor que el valor mayor. |
## Ejemplo y notas de uso
**nota**
Cuando se usa `ALL`, `ANY` o `SOME`, se debe usar la palabra clave `VALUES` si los valores de comparación son una lista de literales.
## Ejemplo: `ANY()`
Un ejemplo de `ANY()` en una instrucción de consulta es el siguiente.
```
SELECT 11.7 = ANY (VALUES 12.0, 13.5, 11.7)
```
Una sintaxis alternativa para la misma operación es la siguiente.
```
SELECT 11.7 = ANY (SELECT 12.0 UNION ALL SELECT 13.5 UNION ALL SELECT 11.7)
```
En este caso, `ANY()` se evalúa como `True`.
## Ejemplo: `ALL()`
Un ejemplo de `ALL()` en una instrucción de consulta es el siguiente.
```
SELECT 17 < ALL (VALUES 19, 20, 15);
```
Una sintaxis alternativa para la misma operación es la siguiente.
```
SELECT 17 < ALL (SELECT 19 UNION ALL SELECT 20 UNION ALL SELECT 15);
```
En este caso, `ALL()` se evalúa como `False`.
## Ejemplo: `SOME()`
Un ejemplo de `SOME()` en una instrucción de consulta es el siguiente.
```
SELECT 50 >= SOME (VALUES 53, 77, 27);
```
Una sintaxis alternativa para la misma operación es la siguiente.
```
SELECT 50 >= SOME (SELECT 53 UNION ALL SELECT 77 UNION ALL SELECT 27);
```
En este caso, `SOME()` se evalúa como `True`.
# Expresiones condicionales
Timestream for LiveAnalytics admite las siguientes expresiones condicionales.
**Topics**
+ [
# La instrucción CASE
](conditional-expressions.CASE.md)
+ [
# La instrucción IF
](conditional-expressions.IF.md)
+ [
# La instrucción COALESCE
](conditional-expressions.COALESCE.md)
+ [
# La instrucción NULLIF
](conditional-expressions.NULLIF.md)
+ [
# La instrucción TRY
](conditional-expressions.TRY.md)
# La instrucción CASE
La instrucción **CASE** busca cada expresión de valor de izquierda a derecha hasta encontrar una que sea igual a `expression`. Si encuentra una coincidencia, se devuelve el resultado del valor coincidente. Si no se encuentra ninguna coincidencia, se devuelve el resultado de la cláusula `ELSE`, si existe; de lo contrario, se devuelve `null`. La sintaxis es la siguiente:
```
CASE expression
WHEN value THEN result
[ WHEN ... ]
[ ELSE result ]
END
```
Timestream también admite la siguiente sintaxis para las instrucciones **CASE**. En esta sintaxis, el formulario “buscado” evalúa cada condición booleana de izquierda a derecha hasta que aparezca una `true` y devuelve el resultado coincidente. Si no hay condiciones `true`, se devuelve el resultado de la cláusula `ELSE` si existe; de lo contrario, se devuelve`null`. Consulte la sintaxis alternativa a continuación:
```
CASE
WHEN condition THEN result
[ WHEN ... ]
[ ELSE result ]
END
```
# La instrucción IF
La instrucción **IF** evalúa una condición como verdadera o falsa y devuelve el valor adecuado. Timestream admite las dos siguientes representaciones sintácticas para **IF**:
```
if(condition, true_value)
```
Esta sintaxis evalúa y devuelve `true_value` si la condición es `true`; de lo contrario, se devuelve `null` y `true_value` no se evalúa.
```
if(condition, true_value, false_value)
```
Esta sintaxis evalúa y devuelve `true_value` si la condición es `true`; de lo contrario, se evalúa y devuelve `false_value`.
## Ejemplos
```
SELECT
if(true, 'example 1'),
if(false, 'example 2'),
if(true, 'example 3 true', 'example 3 false'),
if(false, 'example 4 true', 'example 4 false')
```
| \$1col0 | \$1col1 | \$1col2 | \$1col3 |
| --- | --- | --- | --- |
| `example 1` | `-` `null` | `example 3 true` | `example 4 false` |
# La instrucción COALESCE
**COALESCE** devuelve el primer valor no nulo en una lista de argumentos. La sintaxis es la siguiente:
```
coalesce(value1, value2[,...])
```
# La instrucción NULLIF
La instrucción **IF** evalúa una condición como verdadera o falsa y devuelve el valor adecuado. Timestream admite las dos siguientes representaciones sintácticas para **IF**:
**NULLIF** devuelve nulo si `value1` es igual a `value2`; de lo contrario, devuelve `value1`. La sintaxis es la siguiente:
```
nullif(value1, value2)
```
# La instrucción TRY
La función **TRY** evalúa una expresión y la devuelve `null` para tratar ciertos tipos de errores. La sintaxis es la siguiente:
```
try(expression)
```
# Funciones de conversión
Timestream for LiveAnalytics admite las siguientes funciones de conversión.
**Topics**
+ [
## cast()
](#conversion-functions.cast)
+ [
## try\$1cast()
](#conversion-functions.try-cast)
## cast()
La sintaxis de la función cast para convertir explícitamente un valor como un tipo es la siguiente.
```
cast(value AS type)
```
## try\$1cast()
Timestream for LiveAnalytics también admite la función try\$1cast, que es similar a cast, pero devuelve un valor nulo si la transmisión falla. La sintaxis es la siguiente.
```
try_cast(value AS type)
```
# Operadores matemáticos
Timestream for LiveAnalytics admite los siguientes operadores matemáticos.
| Operador | Description (Descripción) |
| --- | --- |
| \$1 | Suma |
| - | Resta |
| \$1 | Multiplicación |
| / | División (la división de enteros realiza el truncamiento) |
| % | Módulo (resto) |
# Funciones matemáticas
Timestream for LiveAnalytics admite las siguientes funciones matemáticas.
| Función | Tipo de datos de salida | Description (Descripción) |
| --- | --- | --- |
| abs(x) | [igual que la entrada] | Devuelve el valor absoluto de x. |
| cbrt(x) | double | Devuelve la raíz cúbica de x. |
| ceiling(x) o ceil(x) | [igual que la entrada] | Devuelve x que se redondea a la alta al número entero más cercano. |
| degrees(x) | double | Convierte el ángulo x en radianes en grados. |
| e() | double | Devuelve el valor constante del número de Euler. |
| exp(x) | double | Devuelve e (número de Euler) elevado a la potencia de x. |
| floor(x) | [igual que la entrada] | Devuelve x que se redondea a la baja al número entero más cercano. |
| from\$1base(cadena, raíz) | bigint | Devuelve el valor de la cadena interpretada como un número base-radical. |
| ln(x) | double | Devuelve el logaritmo natural de x. |
| log2(x) | double | Devuelve el logaritmo de base 2 de x. |
| log10(x) | double | Devuelve el logaritmo de base 10 de x. |
| mod(n,m) | [igual que la entrada] | Devuelve el módulo (resto) de n dividido entre m. |
| pi() | double | Devuelve la constante pi. |
| pow(x, p) o power(x, p) | double | Devuelve x elevado a la potencia de p. |
| radians(x) | double | Convierte el ángulo x en grados en radianes. |
| rand() o random() | double | Devuelve un valor pseudoaleatorio en el rango de 0,0 a 1,0. |
| random(n) | [igual que la entrada] | Devuelve un número pseudoaleatorio entre 0 y n (exclusivo). |
| round(x) | [igual que la entrada] | Devuelve x redondeado al entero más cercano. |
| round(x,d) | [igual que la entrada] | Devuelve x redondeado a d decimales. |
| sign(x) | [igual que la entrada] | Devuelve la función signum de x, es decir: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/timestream/latest/developerguide/mathematical-functions.html) Para argumentos dobles, la función devuelve además: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/timestream/latest/developerguide/mathematical-functions.html) |
| sqrt(x) | double | Devuelve la raíz cuadrada de x. |
| to\$1base(x, radix) | varchar | Devuelve la representación base-radical de x. |
| truncate(x) | double | Devuelve x redondeada a un número entero y quita los dígitos después de la coma decimal. |
| acos(x) | double | Devuelve el arco coseno de x. |
| asin(x) | double | Devuelve el arco seno de x. |
| atan(x) | double | Devuelve el arco tangente de x. |
| atan2(y,x) | double | Devuelve el arco tangente de y/x. |
| cos(x) | double | Devuelve el coseno de x. |
| cosh(x) | double | Devuelve el coseno hiperbólico de x. |
| sin(x) | double | Devuelve el seno de x. |
| tan(x) | double | Devuelve la tangente de x. |
| tanh(x) | double | Devuelve la tangente hiperbólica de x. |
| infinity() | double | Devuelve la constante que representa el infinito positivo. |
| is\$1finite(x) | booleano | Determina si x es finito. |
| is\$1infinite(x) | booleano | Determina si x es infinito. |
| is\$1nan(x) | booleano | Determine si x es. not-a-number |
| nan() | double | Devuelve la constante que representa not-a-number. |
# Operadores de cadena
Timestream for LiveAnalytics admite el `||` operador para concatenar una o más cadenas.
# Funciones de cadena
**nota**
Se supone que el tipo de datos de entrada de estas funciones es varchar, a menos que se especifique lo contrario.
| Función | Tipo de datos de salida | Description (Descripción) |
| --- | --- | --- |
| chr(n) | varchar | Devuelve el punto de código Unicode n como un varchar. |
| codepoint(x) | entero | Devuelve el punto de código Unicode del único carácter de str. |
| concat(x1, …, xN) | varchar | Devuelve la concatenación de x1, x2, …, xN. |
| hamming\$1distance(x1,x2) | bigint | Devuelve la distancia de Hamming de x1 y x2, es decir, el número de posiciones en las que los caracteres correspondientes son diferentes. Tenga en cuenta que las dos entradas de varchar deben tener la misma longitud. |
| length(x) | bigint | Devuelve la longitud de x en caracteres. |
| levenshtein\$1distance(x1, x2) | bigint | Devuelve la distancia de edición de Levenshtein de x1 y x2, es decir, el número mínimo de ediciones de un solo carácter (inserciones, eliminaciones o sustituciones) necesarias para cambiar x1 a x2. |
| lower(x) | varchar | Cambia x a minúsculas. |
| lpad(x1, tamaño de bigint, x2) | varchar | Rellena x1 por la izquierda con x2 hasta llegar al tamaño que especifique. Si el tamaño es inferior a x1, el resultado se trunca para ajustar el tamaño de los caracteres. El tamaño no debe ser negativo y x2 no debe estar vacío. |
| ltrim(x) | varchar | Elimina los espacios en blanco iniciales de x. |
| replace(x1, x2) | varchar | Elimina todas las instancias de x2 de x1. |
| replace(x1, x2, x3) | varchar | Sustituye todas las instancias de x2 en x1 por x3. |
| Reverse(x) | varchar | Devuelve x con los caracteres en orden inverso. |
| rpad(x1, tamaño de bigint, x2) | varchar | Rellena x1 por la derecha con x2 hasta llegar al tamaño que especifique. Si el tamaño es inferior a x1, el resultado se trunca para ajustar el tamaño de los caracteres. El tamaño no debe ser negativo y x2 no debe estar vacío. |
| rtrim(x) | varchar | Elimina los espacios en blanco finales de x. |
| split(x1, x2) | array(varchar) | Divide x1 en el delimitador x2 y devuelve una matriz. |
| split(x1, x2, límite de bigint) | array(varchar) | Divide x1 en el delimitador x2 y devuelve una matriz. El último elemento de la matriz siempre contiene todo lo que queda en la x1. El límite debe ser un número positivo. |
| split\$1part(x1, x2, bigint pos) | varchar | Divide x1 en el delimitador x2 y devuelve el campo varchar en pos. Los índices de campo comienzan por 1. Si pos es mayor que el número de campos, se devuelve el valor nulo. |
| strpos(x1, x2) | bigint | Devuelve la posición inicial de la primera instancia de x2 en x1. Las posiciones comienzan con 1. Si no se encuentra, se devuelve 0. |
| strpos(x1, x2, instancia de bigint) | bigint | Devuelve la posición de la enésima instancia de x2 en x1. La instancia debe ser un número positivo. Las posiciones comienzan con 1. Si no se encuentra, se devuelve 0. |
| strrpos(x1, x2) | bigint | Devuelve la posición inicial de la última instancia de x2 en x1. Las posiciones comienzan con 1. Si no se encuentra, se devuelve 0. |
| strrpos(x1, x2, instancia de bigint) | bigint | Devuelve la posición de la enésima instancia de x2 en x1 empezando por el final de x1. La instancia debe ser un número positivo. Las posiciones comienzan con 1. Si no se encuentra, se devuelve 0. |
| position(x2 EN x1) | bigint | Devuelve la posición inicial de la primera instancia de x2 en x1. Las posiciones comienzan con 1. Si no se encuentra, se devuelve 0. |
| substr(x, bigint start) | varchar | Devuelve el resto de x desde la posición inicial start. Las posiciones comienzan con 1. Una posición inicial negativa se interpreta como relativa al final de x. |
| substr(x, bigint start, bigint len) | varchar | Devuelve una subcadena de x de longitud len desde la posición inicial start. Las posiciones comienzan con 1. Una posición inicial negativa se interpreta como relativa al final de x. |
| trim(x) | varchar | Elimina todos los espacios en blanco del principio y del final de x. |
| upper(x) | varchar | Cambia x a mayúsculas. |
# Operadores de matrices
Timestream for admite los siguientes operadores de matriz. LiveAnalytics
| Operador | Description (Descripción) |
| --- | --- |
| [] | Acceda a un elemento de una matriz donde el primer índice comience en 1. |
| \$1\$1 | Concatena una matriz con otra matriz o elemento del mismo tipo. |
# Funciones de matriz
Timestream for LiveAnalytics admite las siguientes funciones de matriz.
| Función | Tipo de datos de salida | Description (Descripción) |
| --- | --- | --- |
| array\$1distinct(x) | array | Elimina los valores duplicados de la matriz x. SELECT array_distinct(ARRAY[1,2,2,3])
Ejemplo de resultado: `[ 1,2,3 ]` |
| array\$1intersect(x, y) | array | Devuelve una matriz de los elementos en la intersección de x e y, sin duplicados. SELECT array_intersect(ARRAY[1,2,3], ARRAY[3,4,5])
Ejemplo de resultado: `[ 3 ]` |
| array\$1union(x, y) | array | Devuelve una matriz de los elementos en la unión de x e y, sin duplicados. SELECT array_union(ARRAY[1,2,3], ARRAY[3,4,5])
Ejemplo de resultado: `[ 1,2,3,4,5 ]` |
| array\$1except(x, y) | array | Devuelve una matriz de elementos en x, pero no en y, sin duplicados. SELECT array_except(ARRAY[1,2,3], ARRAY[3,4,5])
Ejemplo de resultado: `[ 1,2 ]` |
| array\$1join(x, delimiter, null\$1replacement) | varchar | Concatena los elementos de la matriz dada mediante el delimitador y una cadena opcional para reemplazar los valores nulos. SELECT array_join(ARRAY[1,2,3], ';', '')
Ejemplo de resultado: `1;2;3` |
| array\$1max(x) | igual que los elementos de la matriz | Devuelve el valor máximo de la matriz de entrada. SELECT array_max(ARRAY[1,2,3])
Ejemplo de resultado: `3` |
| array\$1min(x) | igual que los elementos de la matriz | Devuelve el valor mínimo de la matriz de entrada. SELECT array_min(ARRAY[1,2,3])
Ejemplo de resultado: `1` |
| array\$1position(x, elemento) | bigint | Devuelve la posición de la primera aparición del elemento en la matriz x (o 0 si no se encuentra). SELECT array_position(ARRAY[3,4,5,9], 5)
Ejemplo de resultado: `3` |
| array\$1remove(x, elemento) | array | Elimina todos los elementos que sean iguales al elemento de la matriz x. SELECT array_remove(ARRAY[3,4,5,9], 4)
Ejemplo de resultado: `[ 3,5,9 ]` |
| array\$1sort(x) | array | Ordena y devuelve la matriz x. Los elementos de x deben poder ordenarse. Los elementos nulos se colocarán al final de la matriz devuelta. SELECT array_sort(ARRAY[6,8,2,9,3])
Ejemplo de resultado: `[ 2,3,6,8,9 ]` |
| arrays\$1overlap(x, y) | booleano | Comprueba si las matrices x e y tienen en común algún elemento que no sea nulo. Devuelve nulo si no hay elementos que no sean nulos en común, pero alguna de las matrices contiene valores nulos. SELECT arrays_overlap(ARRAY[6,8,2,9,3], ARRAY[6,8])
Ejemplo de resultado: `true` |
| cardinality(x) | bigint | Devuelve el tamaño de la matriz x. SELECT cardinality(ARRAY[6,8,2,9,3])
Ejemplo de resultado: `5` |
| concat(matriz1, matriz2, …, matrizN) | array | Concatena las matrices matriz1, matriz2, …, matrizN. SELECT concat(ARRAY[6,8,2,9,3], ARRAY[11,32], ARRAY[6,8,2,0,14])
Ejemplo de resultado: `[ 6,8,2,9,3,11,32,6,8,2,0,14 ]` |
| element\$1at(matriz(E), índice) | E | Devuelve el elemento de la matriz en un índice dado. Si el índice es inferior a 0, element\$1at accede a los elementos desde el último hasta el primero. SELECT element_at(ARRAY[6,8,2,9,3], 1)
Ejemplo de resultado: `6` |
| repeat(elemento, recuento) | array | Repita el elemento el número de veces según el recuento. SELECT repeat(1, 3)
Ejemplo de resultado: `[ 1,1,1 ]` |
| reverse(x) | array | Devuelve una matriz que tiene el orden inverso al de la matriz x. SELECT reverse(ARRAY[6,8,2,9,3])
Ejemplo de resultado: `[ 3,9,2,8,6 ]` |
| sequence(inicio, parada) | array(bigint) | Genera una secuencia de números enteros desde el principio hasta la parada y la incrementa a razón de 1 si el inicio es menor o igual que la parada; de lo contrario, disminuye a razón de -1. SELECT sequence(3, 8)
Ejemplo de resultado: `[ 3,4,5,6,7,8 ]` |
| secuencia(inicio, parada, paso) | array(bigint) | Genera una secuencia de números enteros desde el inicio hasta la parada y la incrementa paso a paso. SELECT sequence(3, 15, 2)
Ejemplo de resultado: `[ 3,5,7,9,11,13,15 ]` |
| sequence(inicio, parada) | array(marca de tiempo) | Genera una secuencia de marcas de tiempo desde la fecha de inicio hasta la fecha de parada, y las incrementa en 1 día. SELECT sequence('2023-04-02 19:26:12.941000000', '2023-04-06 19:26:12.941000000', 1d) Ejemplo de resultado: `[ 2023-04-02 19:26:12.941000000,2023-04-03 19:26:12.941000000,2023-04-04 19:26:12.941000000,2023-04-05 19:26:12.941000000,2023-04-06 19:26:12.941000000 ]` |
| secuencia(inicio, parada, paso) | array(marca de tiempo) | Genera una secuencia de marcas de tiempo desde el principio hasta la parada y las incrementa paso a paso. El tipo de datos del paso es el intervalo. SELECT sequence('2023-04-02 19:26:12.941000000', '2023-04-10 19:26:12.941000000', 2d) Ejemplo de resultado: `[ 2023-04-02 19:26:12.941000000,2023-04-04 19:26:12.941000000,2023-04-06 19:26:12.941000000,2023-04-08 19:26:12.941000000,2023-04-10 19:26:12.941000000 ]` |
| shuffle(x) | array | Genera una permutación aleatoria de la matriz x dada. SELECT shuffle(ARRAY[6,8,2,9,3])
Ejemplo de resultado: `[ 6,3,2,9,8 ]` |
| slice(x, inicio, longitud) | array | Subestablece la matriz x desde el inicio del índice (o desde el final si el inicio es negativo) con la longitud que especifique. SELECT slice(ARRAY[6,8,2,9,3], 1, 3)
Ejemplo de resultado: `[ 6,8,2 ]` |
| zip(matriz1, matriz2 [, …]) | array(fila) | Fusiona las matrices dadas, por elementos, en una sola matriz de filas. Si los argumentos tienen una longitud irregular, los valores faltantes se rellenan con NULL. SELECT zip(ARRAY[6,8,2,9,3], ARRAY[15,24])
Ejemplo de resultado: `[ ( 6, 15 ),( 8, 24 ),( 2, - ),( 9, - ),( 3, - ) ]` |
# Bitwise functions (Funciones Bitwise)
Timestream for LiveAnalytics admite las siguientes funciones bit a bit.
| Función | Tipo de datos de salida | Description (Descripción) |
| --- | --- | --- |
| bit\$1count(bigint, bigint) | bigint (complemento de dos) | Devuelve el recuento de bits del primer parámetro de bigint, donde el segundo parámetro es un entero con signo de bits, como 8 o 64. SELECT bit_count(19, 8)
Ejemplo de resultado: `3` SELECT bit_count(19, 2)
Ejemplo de resultado: `Number must be representable with the bits specified. 19 can not be represented with 2 bits` |
| bitwise\$1and(bigint, bigint) | bigint (complemento de dos) | Devuelve el AND bit a bit de los parámetros de bigint. SELECT bitwise_and(12, 7)
Ejemplo de resultado: `4` |
| bitwise\$1not(bigint) | bigint (complemento de dos) | Devuelve el NOT bit a bit del parámetro de bigint. SELECT bitwise_not(12)
Ejemplo de resultado: `-13` |
| bitwise\$1or(bigint, bigint) | bigint (complemento de dos) | Devuelve el OR bit a bit de los parámetros de bigint. SELECT bitwise_or(12, 7)
Ejemplo de resultado: `15` |
| bitwise\$1xor(bigint, bigint) | bigint (complemento de dos) | Devuelve el XOR bit a bit de los parámetros de bigint. SELECT bitwise_xor(12, 7)
Ejemplo de resultado: `11` |
# Regular expression functions (Funciones de expresión regular)
La expresión regular funciona en Timestream para LiveAnalytics admitir la sintaxis de [patrones de Java](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html). Timestream for LiveAnalytics admite las siguientes funciones de expresiones regulares.
| Función | Tipo de datos de salida | Description (Descripción) |
| --- | --- | --- |
| regexp\$1extract\$1all(cadena, patrón) | array(varchar) | Devuelve las subcadenas que coinciden con el patrón de expresión regular de la cadena. SELECT regexp_extract_all('example expect complex', 'ex\w') Ejemplo de resultado: `[ exa,exp ]` |
| regexp\$1extract\$1all(cadena, patrón, grupo) | array(varchar) | Busca todas las apariciones del patrón de expresión regular en una cadena y devuelve el grupo [numérico del grupo de captura](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html#gnumber). SELECT regexp_extract_all('example expect complex', '(ex)(\w)', 2) Ejemplo de resultado: `[ a,p ]` |
| regexp\$1extract(cadena, patrón) | varchar | Devuelve la primera subcadena que coincide con el patrón de expresión regular de la cadena. SELECT regexp_extract('example expect', 'ex\w') Ejemplo de resultado: `exa` |
| regexp\$1extract(cadena, patrón, grupo) | varchar | Busca la primera aparición del patrón de expresión regular en la cadena y devuelve el grupo [numérico del grupo de captura](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html#gnumber). SELECT regexp_extract('example expect', '(ex)(\w)', 2) Ejemplo de resultado: `a` |
| regexp\$1like(cadena, patrón) | booleano | Evalúa el patrón de expresión regular y determina si se encuentra contenido dentro de una cadena. Esta función es similar al operador LIKE, excepto en que el patrón solo debe encontrarse contenido en la cadena, en lugar de tener que coincidir con toda la cadena. En otras palabras, realiza una operación de contención en lugar de una operación de coincidencia. Puede anclar el patrón con ^ y \$1 para hacer coincidir toda la cadena. SELECT regexp_like('example', 'ex') Ejemplo de resultado: `true` |
| regexp\$1replace(cadena, patrón) | varchar | Elimina de la cadena todas las instancias de la subcadena que coincidan con el patrón de expresión regular. SELECT regexp_replace('example expect', 'expect') Ejemplo de resultado: `example` |
| regexp\$1replace(cadena, patrón, reemplazo) | varchar | Sustituye todas las instancias de la subcadena que coincidan con el patrón de expresión regular de la cadena por una de reemplazo. Se puede hacer referencia a los grupos de captura en lugar de usar \$1g para un grupo numerado o \$1 \$1name\$1 para un grupo con nombre. Se puede incluir un signo de dólar (\$1) en el reemplazo si lo escapa con una barra invertida (\$1\$1). SELECT regexp_replace('example expect', 'expect', 'surprise') Ejemplo de resultado: `example surprise` |
| regexp\$1replace(cadena, patrón, función) | varchar | Reemplaza todas las instancias de la subcadena que coincidan con el patrón de expresión regular en la cadena mediante la función. La función de [expresión lambda](https://prestodb.io/docs/current/functions/lambda.html) se invoca para cada coincidencia y los grupos de captura se pasan como una matriz. Los números de los grupos de captura comienzan por el número uno; no hay ningún grupo para toda la coincidencia (si lo necesita, ponga toda la expresión entre paréntesis). SELECT regexp_replace('example', '(\w)', x -> upper(x[1])) Ejemplo de resultado: `EXAMPLE` |
| regexp\$1split(cadena, patrón) | array(varchar) | Divide la cadena mediante el patrón de expresión regular y devuelve una matriz. Se conservan las cadenas vacías finales. SELECT regexp_split('example', 'x') Ejemplo de resultado: `[ e,ample ]` |
# Operadores de fecha y hora
**nota**
Timestream for no LiveAnalytics admite valores de tiempo negativos. Cualquier operación que dé como resultado un tiempo negativo genera un error.
Timestream for LiveAnalytics admite las siguientes operaciones en`timestamps`, y. `dates` `intervals`
| Operador | Description (Descripción) |
| --- | --- |
| \$1 | Suma |
| - | Resta |
**Topics**
+ [
## Operaciones
](#date-time-operators-operations)
+ [
## Suma
](#date-time-operators-addition)
+ [
## Resta
](#date-time-operators-subtraction)
## Operaciones
El tipo de resultado de una operación se basa en los operandos. Se pueden usar literales de intervalo como `1day` y `3s`.
```
SELECT date '2022-05-21' + interval '2' day
```
```
SELECT date '2022-05-21' + 2d
```
```
SELECT date '2022-05-21' + 2day
```
Ejemplo de resultado para cada uno: `2022-05-23`
Las unidades de intervalo incluyen `second`, `minute`, `hour`, `day`, `week`, `month` y `year`. Sin embargo, en algunos casos no todas aplican. Por ejemplo, los segundos, los minutos y las horas no se pueden sumar ni restar de una fecha.
```
SELECT interval '4' year + interval '2' month
```
Ejemplo de resultado: `4-2`
```
SELECT typeof(interval '4' year + interval '2' month)
```
Ejemplo de resultado: `interval year to month`
El tipo de resultado de las operaciones de intervalo puede ser `'interval year to month'` o `'interval day to second'` según los operandos. Los intervalos se pueden sumar a `dates` y `timestamps` o restarse de estos valores. Pero `date` o `timestamp` no se pueden sumar a `date` o `timestamp` ni restarse de estos valores. Para buscar intervalos o duraciones relacionados con fechas o marcas de tiempo, consulte `date_diff` y funciones relacionadas en [Intervalo y duración](date-time-functions.md#date-time-functions-interval-duration).
## Suma
**Example**
```
SELECT date '2022-05-21' + interval '2' day
```
Ejemplo de resultado: `2022-05-23`
**Example**
```
SELECT typeof(date '2022-05-21' + interval '2' day)
```
Ejemplo de resultado: `date`
**Example**
```
SELECT interval '2' year + interval '4' month
```
Ejemplo de resultado: `2-4`
**Example**
```
SELECT typeof(interval '2' year + interval '4' month)
```
Ejemplo de resultado: `interval year to month`
## Resta
**Example**
```
SELECT timestamp '2022-06-17 01:00' - interval '7' hour
```
Ejemplo de resultado: `2022-06-16 18:00:00.000000000`
**Example**
```
SELECT typeof(timestamp '2022-06-17 01:00' - interval '7' hour)
```
Ejemplo de resultado: `timestamp`
**Example**
```
SELECT interval '6' day - interval '4' hour
```
Ejemplo de resultado: `5 20:00:00.000000000`
**Example**
```
SELECT typeof(interval '6' day - interval '4' hour)
```
Ejemplo de resultado: `interval day to second`
# Funciones de fecha y hora
**nota**
Timestream for no LiveAnalytics admite valores de tiempo negativos. Cualquier operación que dé como resultado un tiempo negativo genera un error.
Timestream for LiveAnalytics utiliza la zona horaria UTC para la fecha y la hora. Timestream admite las siguientes funciones de fecha y hora:
**Topics**
+ [
## Funciones generales y de conversión
](#date-time-functions-general)
+ [
## Intervalo y duración
](#date-time-functions-interval-duration)
+ [
## Formato y análisis
](#date-time-functions-formatting-parsing)
+ [
## Extracción
](#date-time-functions-extraction)
## Funciones generales y de conversión
Timestream for LiveAnalytics admite las siguientes funciones generales y de conversión de fecha y hora.
| Función | Tipo de datos de salida | Description (Descripción) |
| --- | --- | --- |
| current\$1date | date | Devuelve la fecha actual en UTC. No se usan paréntesis. SELECT current_date
Ejemplo de resultado: `2022-07-07` También es una palabra clave reservada. Para obtener una lista de palabras clave reservadas, consulte [Palabras clave reservadas](ts-limits.md#limits.reserved). |
| current\$1time | hora | Devuelve la hora actual en UTC. No se usan paréntesis. SELECT current_time
Ejemplo de resultado: `17:41:52.827000000` También es una palabra clave reservada. Para obtener una lista de palabras clave reservadas, consulte [Palabras clave reservadas](ts-limits.md#limits.reserved). |
| current\$1timestamp o now() | timestamp | Devuelve la marca de tiempo actual en UTC. SELECT current_timestamp
Ejemplo de resultado: `2022-07-07 17:42:32.939000000` También es una palabra clave reservada. Para obtener una lista de palabras clave reservadas, consulte [Palabras clave reservadas](ts-limits.md#limits.reserved). |
| current\$1timezone() | varchar El valor será “UTC”. | Timestream usa la zona horaria UTC para la fecha y la hora. SELECT current_timezone()
Ejemplo de resultado: `UTC` |
| date(varchar(x)), date(marca de tiempo) | date | SELECT date(TIMESTAMP '2022-07-07 17:44:43.771000000')
Ejemplo de resultado: `2022-07-07` |
| last\$1day\$1of\$1month(marca de tiempo), last\$1day\$1of\$1month(fecha) | date | SELECT last_day_of_month(TIMESTAMP '2022-07-07 17:44:43.771000000')
Ejemplo de resultado: `2022-07-31` |
| from\$1iso8601\$1timestamp(cadena) | timestamp | Analiza la marca de tiempo ISO 8601 en un formato de marca de tiempo interno. SELECT from_iso8601_timestamp('2022-06-17T08:04:05.000000000+05:00') Ejemplo de resultado: `2022-06-17 03:04:05.000000000` |
| from\$1iso8601\$1date(cadena) | date | Analiza la cadena de fecha ISO 8601 para convertirla en un formato de marca de tiempo interno para las 00:00:00 UTC de la fecha especificada. SELECT from_iso8601_date('2022-07-17') Ejemplo de resultado: `2022-07-17` |
| to\$1iso8601(marca de tiempo), to\$1iso8601(fecha) | varchar | Devuelve una cadena con formato ISO 8601 para la entrada. SELECT to_iso8601(from_iso8601_date('2022-06-17')) Ejemplo de resultado: `2022-06-17` |
| from\$1milliseconds(bigint) | timestamp | SELECT from_milliseconds(1)
Ejemplo de resultado: `1970-01-01 00:00:00.001000000` |
| from\$1nanoseconds(bigint) | timestamp | select from_nanoseconds(300000001)
Ejemplo de resultado: `1970-01-01 00:00:00.300000001` |
| from\$1unixtime (doble) | timestamp | Devuelve una marca de tiempo que corresponde al unixtime proporcionado. SELECT from_unixtime(1)
Ejemplo de resultado: `1970-01-01 00:00:01.000000000` |
| localtime | hora | Devuelve la hora actual en UTC. No se usan paréntesis. SELECT localtime
Ejemplo de resultado: `17:58:22.654000000` También es una palabra clave reservada. Para obtener una lista de palabras clave reservadas, consulte [Palabras clave reservadas](ts-limits.md#limits.reserved). |
| localtimestamp | timestamp | Devuelve la marca de tiempo actual en UTC. No se usan paréntesis. SELECT localtimestamp
Ejemplo de resultado: `2022-07-07 17:59:04.368000000` También es una palabra clave reservada. Para obtener una lista de palabras clave reservadas, consulte [Palabras clave reservadas](ts-limits.md#limits.reserved). |
| to\$1milliseconds(intervalo de un día a un segundo), to\$1milliseconds(marca de tiempo) | bigint | SELECT to_milliseconds(INTERVAL '2' DAY + INTERVAL '3' HOUR)
Ejemplo de resultado: `183600000` SELECT to_milliseconds(TIMESTAMP '2022-06-17 17:44:43.771000000')
Ejemplo de resultado: `1655487883771` |
| to\$1nanoseconds(intervalo de un día a un segundo), to\$1nanoseconds(marca de tiempo) | bigint | SELECT to_nanoseconds(INTERVAL '2' DAY + INTERVAL '3' HOUR)
Ejemplo de resultado: `183600000000000` SELECT to_nanoseconds(TIMESTAMP '2022-06-17 17:44:43.771000678')
Ejemplo de resultado: `1655487883771000678` |
| to\$1unixtime(marca de tiempo) | double | Devuelve unixtime para la marca de tiempo proporcionada. SELECT to_unixtime('2022-06-17 17:44:43.771000000') Ejemplo de resultado: `1.6554878837710001E9` |
| date\$1trunc(unidad, marca de tiempo) | timestamp | Devuelve la marca de tiempo truncada a la unidad, donde la unidad puede ser una de las siguientes: [segundo, minuto, hora, día, semana, mes, trimestre o año]. SELECT date_trunc('minute', TIMESTAMP '2022-06-17 17:44:43.771000000') Ejemplo de resultado: `2022-06-17 17:44:00.000000000` |
## Intervalo y duración
Timestream for LiveAnalytics admite las siguientes funciones de intervalo y duración para la fecha y la hora.
| Función | Tipo de datos de salida | Description (Descripción) |
| --- | --- | --- |
| date\$1add(unidad, bigint, fecha), date\$1add(unidad, bigint, hora), date\$1add(varchar (x), bigint, marca de tiempo) | timestamp | Añade un bigint de unidades, donde la unidad es una de las siguientes: [segundo, minuto, hora, día, semana, mes, trimestre o año]. SELECT date_add('hour', 9, TIMESTAMP '2022-06-17 00:00:00') Ejemplo de resultado: `2022-06-17 09:00:00.000000000` |
| date\$1diff(unidad, fecha, fecha), date\$1diff(unidad, hora, hora), date\$1diff(unidad, marca de tiempo, marca de tiempo) | bigint | Devuelve una diferencia, donde la unidad es una de las siguientes: [segundo, minuto, hora, día, semana, mes, trimestre o año]. SELECT date_diff('day', DATE '2020-03-01', DATE '2020-03-02') Ejemplo de resultado: `1` |
| parse\$1duration(cadena) | intervalo | Analiza la cadena de entrada para devolver un `interval` equivalente. SELECT parse_duration('42.8ms') Ejemplo de resultado: `0 00:00:00.042800000` SELECT typeof(parse_duration('42.8ms')) Ejemplo de resultado: `interval day to second` |
| bin(marca de tiempo, intervalo) | timestamp | Redondea el valor entero del parámetro `timestamp` al múltiplo más cercano del valor entero del parámetro `interval`. El significado de este valor devuelto puede no ser obvio. Se calcula mediante aritmética de enteros, donde se divide primero el entero de la marca de tiempo por el entero del intervalo y, a continuación, se multiplica el resultado por el entero del intervalo. Si se tiene en cuenta que una marca de tiempo especifica un punto UTC en el tiempo como el número de fracciones de segundo que han transcurrido desde la época POSIX (1 de enero de 1970), el valor devuelto rara vez se alineará con las unidades del calendario. Por ejemplo, si especifica un intervalo de 30 días, todos los días transcurridos desde la época se dividen en incrementos de 30 días y se devuelve el inicio del incremento de 30 días más reciente, que no tiene relación con los meses naturales. Estos son algunos ejemplos: bin(TIMESTAMP '2022-06-17 10:15:20', 5m) ==> 2022-06-17 10:15:00.000000000
bin(TIMESTAMP '2022-06-17 10:15:20', 1d) ==> 2022-06-17 00:00:00.000000000
bin(TIMESTAMP '2022-06-17 10:15:20', 10day) ==> 2022-06-17 00:00:00.000000000
bin(TIMESTAMP '2022-06-17 10:15:20', 30day) ==> 2022-05-28 00:00:00.000000000
|
| ago(intervalo) | timestamp | Devuelve el valor correspondiente al `interval` current\$1timestamp. SELECT ago(1d)
Ejemplo de resultado: `2022-07-06 21:08:53.245000000` |
| Literales de intervalo como 1h, 1d y 30m | intervalo | Los literales de intervalo son útiles para parse\$1duration(cadena). Por ejemplo, `1d` es igual que `parse_duration('1d')`. Esto permite el uso de los literales siempre que se utilice un intervalo. Por ejemplo, `ago(1d)` y `bin(, 1m)`. |
Algunos literales de intervalo actúan como forma abreviada de parse\$1duration. Por ejemplo, `parse_duration('1day')`, `1day`, `parse_duration('1d')` y `1d` devuelven individualmente `1 00:00:00.000000000` de tipo `interval day to second`. Se permite el espacio en el formato que se proporciona a `parse_duration`. Por ejemplo, `parse_duration('1day')` también devuelve `00:00:00.000000000`. Pero `1 day` no es un intervalo literal.
Las unidades correspondientes a `interval day to second` son ns, nanosegundo, us, microsegundo, ms, milisegundo, s, segundo, m, minuto, h, hora, d y día.
También hay `interval year to month`. Las unidades relacionadas con el intervalo de año a mes son y, año, y mes. Por ejemplo, `SELECT 1year` devuelve `1-0`. `SELECT 12month` también devuelve `1-0`. `SELECT 8month`devuelve `0-8`.
Aunque la unidad de `quarter` también está disponible para algunas funciones, como `date_trunc` y `date_add`, `quarter` no está disponible como parte de un intervalo literal.
## Formato y análisis
Timestream for LiveAnalytics admite las siguientes funciones de formato y análisis de fecha y hora.
| Función | Tipo de datos de salida | Description (Descripción) |
| --- | --- | --- |
| date\$1format(timestamp, varchar (x)) | varchar | [Para obtener más información sobre los especificadores de formato utilizados por esta función, consulte \$1 https://trino.io/docs/current/functions/datetime.html mysql-date-functions](https://trino.io/docs/current/functions/datetime.html#mysql-date-functions) SELECT date_format(TIMESTAMP '2019-10-20 10:20:20', '%Y-%m-%d %H:%i:%s')
Ejemplo de resultado: `2019-10-20 10:20:20` |
| date\$1parse(varchar (x), varchar (y)) | timestamp | [Para obtener más información sobre los especificadores de formato utilizados por esta función, consulte \$1 https://trino.io/docs/current/functions/datetime.html mysql-date-functions](https://trino.io/docs/current/functions/datetime.html#mysql-date-functions) SELECT date_parse('2019-10-20 10:20:20', '%Y-%m-%d %H:%i:%s') Ejemplo de resultado: `2019-10-20 10:20:20.000000000` |
| format\$1datetime(timestamp, varchar (x)) | varchar | Para obtener más información sobre la cadena de formato utilizada por esta función, consulte [http://joda-time.sourceforge. net/apidocs/org/joda/time/format/DateTimeFormat.html](http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html) SELECT format_datetime(parse_datetime('1968-01-13 12', 'yyyy-MM-dd HH'), 'yyyy-MM-dd HH') Ejemplo de resultado: `1968-01-13 12` |
| parse\$1datetime(varchar(x), varchar(y)) | timestamp | Para obtener más información sobre la cadena de formato utilizada por esta función, consulte [http://joda-time.sourceforge. net/apidocs/org/joda/time/format/DateTimeFormat.html](http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html) SELECT parse_datetime('2019-12-29 10:10 PST', 'uuuu-LL-dd HH:mm z') Ejemplo de resultado: `2019-12-29 18:10:00.000000000` |
## Extracción
Timestream for LiveAnalytics admite las siguientes funciones de extracción de fecha y hora. La función de extracción es la base de las demás funciones prácticas.
| Función | Tipo de datos de salida | Description (Descripción) |
| --- | --- | --- |
| extract | bigint | Extrae un campo de una marca de tiempo, donde el campo es uno de los siguientes: [YEAR, QUARTER, MONTH, WEEK, DAY, DAY\$1OF\$1MONTH, DAY\$1OF\$1WEEK, DOW, DAY\$1OF\$1YEAR, DOY, YEAR\$1OF\$1WEEK, YOW, HOUR, MINUTE o SECOND]. SELECT extract(YEAR FROM '2019-10-12 23:10:34.000000000')
Ejemplo de resultado: `2019` |
| day(marca de tiempo), day(fecha), day(intervalo de un día a otro) | bigint | SELECT day('2019-10-12 23:10:34.000000000') Ejemplo de resultado: `12` |
| day\$1of\$1month(marca de tiempo), day\$1of\$1month(fecha), day\$1of\$1month(intervalo de día a segundo) | bigint | SELECT day_of_month('2019-10-12 23:10:34.000000000') Ejemplo de resultado: `12` |
| day\$1of\$1week(marca de tiempo), day\$1of\$1week(fecha) | bigint | SELECT day_of_week('2019-10-12 23:10:34.000000000') Ejemplo de resultado: `6` |
| day\$1of\$1year(marca de tiempo), day\$1of\$1year(fecha) | bigint | SELECT day_of_year('2019-10-12 23:10:34.000000000') Ejemplo de resultado: `285` |
| dow(marca de tiempo), dow(fecha) | bigint | Alias de day\$1of\$1week |
| doy(marca de tiempo), doy(fecha) | bigint | Alias de day\$1of\$1year |
| hour(marca de tiempo), hour(hora), hour(intervalo de día a segundo) | bigint | SELECT hour('2019-10-12 23:10:34.000000000') Ejemplo de resultado: `23` |
| millisecond(marca de tiempo), millisecond(hora), millisecond(intervalo de día a segundo) | bigint | SELECT millisecond('2019-10-12 23:10:34.000000000') Ejemplo de resultado: `0` |
| minute(marca de tiempo), minute(hora), minute(intervalo de día a segundo) | bigint | SELECT minute('2019-10-12 23:10:34.000000000') Ejemplo de resultado: `10` |
| month(marca de tiempo), month(fecha), month(intervalo de año a mes) | bigint | SELECT month('2019-10-12 23:10:34.000000000') Ejemplo de resultado: `10` |
| nanosecond(marca de tiempo), nanosecond(hora), nanosecond(intervalo de día a segundo) | bigint | SELECT nanosecond(current_timestamp)
Ejemplo de resultado: `162000000` |
| quarter(marca de tiempo), quarter(fecha) | bigint | SELECT quarter('2019-10-12 23:10:34.000000000') Ejemplo de resultado: `4` |
| second(marca de tiempo), second(hora), second(intervalo de día a segundo) | bigint | SELECT second('2019-10-12 23:10:34.000000000') Ejemplo de resultado: `34` |
| week(marca de tiempo), week(fecha) | bigint | SELECT week('2019-10-12 23:10:34.000000000') Ejemplo de resultado: `41` |
| week\$1of\$1year(marca de tiempo), week\$1of\$1year(fecha) | bigint | Alias de semana |
| year(marca de tiempo), year(fecha), year(intervalo de año a mes) | bigint | SELECT year('2019-10-12 23:10:34.000000000') Ejemplo de resultado: `2019` |
| year\$1of\$1week(marca de tiempo), year\$1of\$1week(fecha) | bigint | SELECT year_of_week('2019-10-12 23:10:34.000000000') Ejemplo de resultado: `2019` |
| yow(marca de tiempo), yow(fecha) | bigint | Alias de year\$1of\$1week |
# Funciones de agregación
Timestream for LiveAnalytics admite las siguientes funciones de agregación.
| Función | Tipo de datos de salida | Description (Descripción) |
| --- | --- | --- |
| arbitrary(x) | [igual que la entrada] | Devuelve un valor arbitrario no nulo de x, si existe. SELECT arbitrary(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Ejemplo de resultado: `1` |
| array\$1agg(x) | array<[igual que la entrada] | Devuelve una matriz creada a partir de los elementos de x de entrada. SELECT array_agg(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Ejemplo de resultado: `[ 1,2,3,4 ]` |
| avg(x) | double | Devuelve el promedio (media aritmética) de todos los valores de entrada. SELECT avg(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Ejemplo de resultado: `2.5` |
| bool\$1and(booleano) every(booleano) | booleano | Devuelve VERDADERO si todos los valores de entrada son VERDADEROS; de lo contrario, devuelve FALSO. SELECT bool_and(t.c) FROM (VALUES true, true, false, true) AS t(c)
Ejemplo de resultado: `false` |
| bool\$1or(booleano) | booleano | Devuelve VERDADERO si algún valor de entrada es VERDADERO; de lo contrario, devuelve FALSO. SELECT bool_or(t.c) FROM (VALUES true, true, false, true) AS t(c)
Ejemplo de resultado: `true` |
| count(\$1) count(x) | bigint | count(\$1) devuelve el número de filas de entrada. count(x) devuelve el número de valores de entrada no nulos. SELECT count(t.c) FROM (VALUES true, true, false, true) AS t(c)
Ejemplo de resultado: `4` |
| count\$1if(x) | bigint | Devuelve el número de valores de entrada TRUE. SELECT count_if(t.c) FROM (VALUES true, true, false, true) AS t(c)
Ejemplo de resultado: `3` |
| geometric\$1mean(x) | double | Devuelve la media geométrica de todos los valores de entrada. SELECT geometric_mean(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Ejemplo de resultado: `2.213363839400643` |
| max\$1by(x, y) | [igual que x] | Devuelve el valor de x asociado al valor máximo de y sobre todos los valores de entrada. SELECT max_by(t.c1, t.c2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Ejemplo de resultado: `d` |
| max\$1by(x, y, n) | matriz<[igual que x]> | Devuelve n valores de x asociados al n mayor de todos los valores de entrada de y en orden descendente de y. SELECT max_by(t.c1, t.c2, 2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Ejemplo de resultado: `[ d,c ]` |
| min\$1by(x, y) | [igual que x] | Devuelve el valor de x asociado al valor mínimo de y sobre todos los valores de entrada. SELECT min_by(t.c1, t.c2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Ejemplo de resultado: `a` |
| min\$1by(x, y, n) | matriz<[igual que x]> | Devuelve n valores de x asociados al n menor de todos los valores de entrada de y en orden ascendente de y. SELECT min_by(t.c1, t.c2, 2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Ejemplo de resultado: `[ a,b ]` |
| max(x) | [igual que la entrada] | Devuelve el valor máximo de todos los valores de entrada. SELECT max(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Ejemplo de resultado: `4` |
| max(x, n) | matriz<[igual que x]> | Devuelve los n valores más altos de todos los valores de entrada de x. SELECT max(t.c, 2) FROM (VALUES 1, 2, 3, 4) AS t(c)
Ejemplo de resultado: `[ 4,3 ]` |
| min(x) | [igual que la entrada] | Devuelve el valor mínimo de todos los valores de entrada. SELECT min(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Ejemplo de resultado: `1` |
| min(x, n) | matriz<[igual que x]> | Devuelve los n valores más bajos de todos los valores de entrada de x. SELECT min(t.c, 2) FROM (VALUES 1, 2, 3, 4) AS t(c)
Ejemplo de resultado: `[ 1,2 ]` |
| sum(x) | [igual que la entrada] | Devuelve la suma de todos los valores de entrada. SELECT sum(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Ejemplo de resultado: `10` |
| bitwise\$1and\$1agg(x) | bigint | Devuelve el AND bit a bit de todos los valores de entrada en una representación de complemento de 2. SELECT bitwise_and_agg(t.c) FROM (VALUES 1, -3) AS t(c)
Ejemplo de resultado: `1` |
| bitwise\$1or\$1agg(x) | bigint | Devuelve el OR bit a bit de todos los valores de entrada en una representación de complemento de 2. SELECT bitwise_or_agg(t.c) FROM (VALUES 1, -3) AS t(c)
Ejemplo de resultado: `-3` |
| approx\$1distinct(x) | bigint | Devuelve el número aproximado de elementos distintos de una columna. Esta función proporciona una aproximación del recuento (DISTINCT x). Si todos los valores de entrada son nulos, se devuelve cero. Esta función debería producir un error estándar del 2,3 %, que es la desviación estándar de la distribución del error (aproximadamente normal) en todos los conjuntos posibles. No garantiza un límite superior del error para ningún conjunto de entradas específico. SELECT approx_distinct(t.c) FROM (VALUES 1, 2, 3, 4, 8) AS t(c)
Ejemplo de resultado: `5` |
| approx\$1distinct(x, e) | bigint | Devuelve el número aproximado de elementos distintos de una columna. Esta función proporciona una aproximación del recuento (DISTINCT x). Si todos los valores de entrada son nulos, se devuelve cero. Esta función debería producir un error estándar inferior a e, que es la desviación estándar de la distribución del error (aproximadamente normal) en todos los conjuntos posibles. No garantiza un límite superior del error para ningún conjunto de entradas específico. La implementación actual de esta función requiere que e esté en el rango de [0,0040625; 0,26000]. SELECT approx_distinct(t.c, 0.2) FROM (VALUES 1, 2, 3, 4, 8) AS t(c)
Ejemplo de resultado: `5` |
| approx\$1percentile(x, porcentaje) | [igual que x] | Devuelve el percentil aproximado de todos los valores de entrada de x en el porcentaje indicado. El valor del porcentaje debe estar entre cero y uno y debe ser constante en todas las filas de entrada. SELECT approx_percentile(t.c, 0.4) FROM (VALUES 1, 2, 3, 4) AS t(c)
Ejemplo de resultado: `2` |
| approx\$1percentile(x, porcentajes) | matriz<[igual que x]> | Devuelve el percentil aproximado de todos los valores de entrada de x en cada uno de los porcentajes indicados. Cada elemento de la matriz de porcentajes debe estar entre cero y uno, y la matriz debe ser constante en todas las filas de entrada. SELECT approx_percentile(t.c, ARRAY[0.1, 0.8, 0.8]) FROM (VALUES 1, 2, 3, 4) AS t(c)
Ejemplo de resultado: `[ 1,4,4 ]` |
| approx\$1percentile(x, w, porcentaje) | [igual que x] | Devuelve el percentil ponderado aproximado de todos los valores de entrada de x mediante el uso del peso w por elemento al porcentaje p. El peso debe ser un valor entero de al menos uno. En efecto, es un recuento de réplicas para el valor x del conjunto de percentiles. El valor de p debe estar entre cero y uno y debe ser constante en todas las filas de entrada. SELECT approx_percentile(t.c, 1, 0.1) FROM (VALUES 1, 2, 3, 4) AS t(c)
Ejemplo de resultado: `1` |
| approx\$1percentile(x, w, porcentajes) | matriz<[igual que x]> | Devuelve el percentil ponderado aproximado de todos los valores de entrada de x mediante el uso del peso w por elemento en cada uno de los porcentajes que se especifica en la matriz. El peso debe ser un valor entero de al menos uno. En efecto, es un recuento de réplicas para el valor x del conjunto de percentiles. Cada elemento de la matriz debe estar entre cero y uno, y la matriz debe ser constante en todas las filas de entrada. SELECT approx_percentile(t.c, 1, ARRAY[0.1, 0.8, 0.8]) FROM (VALUES 1, 2, 3, 4) AS t(c)
Ejemplo de resultado: `[ 1,4,4 ]` |
| approx\$1percentile(x, w, porcentaje, precisión) | [igual que x] | Devuelve el percentil ponderado aproximado de todos los valores de entrada de x mediante el uso del peso w por elemento en el porcentaje p, con un error de precisión máximo. El peso debe ser un valor entero de al menos uno. En efecto, es un recuento de réplicas para el valor x del conjunto de percentiles. El valor de p debe estar entre cero y uno y debe ser constante en todas las filas de entrada. La precisión debe ser un valor superior a cero e inferior a uno, y debe ser constante en todas las filas de entrada. SELECT approx_percentile(t.c, 1, 0.1, 0.5) FROM (VALUES 1, 2, 3, 4) AS t(c)
Ejemplo de resultado: `1` |
| corr(y, x) | double | Devuelve el coeficiente de correlación de los valores de entrada. SELECT corr(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Ejemplo de resultado: `1.0` |
| covar\$1pop(y, x) | double | Devuelve la covarianza poblacional de los valores de entrada. SELECT covar_pop(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Ejemplo de resultado: `1.25` |
| covar\$1samp(y, x) | double | Devuelve la covarianza muestral de los valores de entrada. SELECT covar_samp(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Ejemplo de resultado: `1.6666666666666667` |
| regr\$1intercept(y, x) | double | Devuelve la intersección de regresión lineal de los valores de entrada. y es el valor dependiente. x es el valor independiente. SELECT regr_intercept(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Ejemplo de resultado: `0.0` |
| regr\$1slope(y, x) | double | Devuelve la pendiente de regresión lineal de los valores de entrada. y es el valor dependiente. x es el valor independiente. SELECT regr_slope(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Ejemplo de resultado: `1.0` |
| skewness(x) | double | Devuelve la asimetría de todos los valores de entrada. SELECT skewness(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Ejemplo de resultado: `0.8978957037987335` |
| stddev\$1pop(x) | double | Devuelve la desviación estándar poblacional de todos los valores de entrada. SELECT stddev_pop(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Ejemplo de resultado: `2.4166091947189146` |
| stddev\$1samp(x) stddev(x) | double | Devuelve la desviación estándar muestral de todos los valores de entrada. SELECT stddev_samp(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Ejemplo de resultado: `2.701851217221259` |
| var\$1pop(x) | double | Devuelve la varianza poblacional de todos los valores de entrada. SELECT var_pop(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Ejemplo de resultado: `5.840000000000001` |
| var\$1samp(x) variance(x) | double | Devuelve la varianza muestral de todos los valores de entrada. SELECT var_samp(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Ejemplo de resultado: `7.300000000000001` |
# Funciones de ventana
Las funciones de ventana realizan cálculos en todas las filas del resultado de la consulta. Se ejecutan después de la cláusula HAVING, pero antes de la cláusula ORDER BY. La invocación de una función de ventana requiere una sintaxis especial mediante la cláusula OVER para especificar la ventana. Una ventana consta de tres componentes:
+ La especificación de la partición, que separa las filas de entrada en diferentes particiones. Esto es análogo a la forma en que la cláusula GROUP BY separa las filas en diferentes grupos para las funciones de agregación.
+ La especificación de ordenación, que determina el orden en el que la función de ventana procesará las filas de entrada.
+ El marco de la ventana, que especifica una ventana deslizante de filas que la función procesará para una fila determinada. Si no se especifica el marco, el valor predeterminado es RANGE UNBOUNDED PRECEDING, que es lo mismo que RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW. Este marco contiene todas las filas desde el inicio de la partición hasta el último par de la fila actual.
Todas las funciones de agregación se pueden usar como funciones de ventana si añade la cláusula OVER. La función de agregación se calcula para cada fila sobre las filas del marco de ventana de la fila actual. Además de las funciones de agregado, Timestream for LiveAnalytics admite las siguientes funciones de clasificación y valor.
| Función | Tipo de datos de salida | Description (Descripción) |
| --- | --- | --- |
| cume\$1dist() | bigint | Devuelve la distribución acumulada de un valor en un grupo de valores. El resultado es el número de filas que preceden o coinciden con la fila en el orden de la partición de la ventana dividido por el número total de filas de la partición de la ventana. Por lo tanto, cualquier valor de empate en el orden se evaluará con el mismo valor de distribución. |
| dense\$1rank() | bigint | Devuelve el rango de un valor en un grupo de valores. Es similar a rank(), excepto en que los valores de empate no producen huecos en la secuencia. |
| ntile(n) | bigint | Divide las filas de cada partición de ventana en n buckets que van desde 1 hasta n como máximo. Los valores del bucket diferirán como máximo en 1. Si el número de filas de la partición no se divide uniformemente entre el número de buckets, los valores restantes se distribuyen a razón de uno por bucket, a partir del primer bucket. |
| percent\$1rank() | double | Devuelve el rango de porcentaje de un valor en un grupo de valores. El resultado es (r - 1)/(n - 1) donde r es el rank() de la fila y n es el número total de filas de la partición de la ventana. |
| rank() | bigint | Devuelve el rango de un valor en un grupo de valores. El rango es uno más el número de filas que preceden a la fila y que no coinciden con la fila. Por lo tanto, los valores de empate en el orden producirán huecos en la secuencia. La clasificación se realiza para cada partición de ventana. |
| row\$1number() | bigint | Devuelve un número secuencial único para cada fila, a partir de uno, según el orden de las filas dentro de la partición de la ventana. |
| first\$1value(x) | [igual que la entrada] | Devuelve el primer valor de la ventana. Esta función se limita al marco de la ventana. La función toma una expresión o un objetivo como parámetro. |
| last\$1value(x) | [igual que la entrada] | Devuelve el valor medio de la ventana. Esta función se limita al marco de la ventana. La función toma una expresión o un objetivo como parámetro. |
| nth\$1value(x, desplazamiento) | [igual que la entrada] | Devuelve el valor con el desplazamiento que se especifica desde el inicio de la ventana. Los desplazamientos comienzan en 1. El desplazamiento puede ser cualquier expresión escalar. Si el desplazamiento es nulo o superior al número de valores de la ventana, se devuelve un valor nulo. Es un error que el desplazamiento sea cero o negativo. La función toma una expresión o un objetivo como primer parámetro. |
| lead (x [, desplazamiento [, default\$1value]]) | [igual que la entrada] | Devuelve el valor de las filas desplazadas después de la fila actual de la ventana. Los desplazamientos comienzan en 0, que es la fila actual. El desplazamiento puede ser cualquier expresión escalar. El valor predeterminado es 1. Si el desplazamiento es nulo o mayor que la ventana, se devuelve el valor predeterminado o, si no se especifica, se devuelve nulo. La función toma una expresión o un objetivo como primer parámetro. |
| lag (x [, desplazamiento [, default\$1value]]) | [igual que la entrada] | Devuelve el valor de las filas desplazadas antes de la fila actual de la ventana. Las compensaciones comienzan en 0, que es la fila actual. El desplazamiento puede ser cualquier expresión escalar. El valor predeterminado es 1. Si el desplazamiento es nulo o mayor que la ventana, se devuelve el valor predeterminado o, si no se especifica, se devuelve nulo. La función toma una expresión o un objetivo como primer parámetro. |
# Consultas de ejemplo
Esta sección incluye ejemplos de casos de uso del lenguaje de consulta de Timestream for LiveAnalytics.
**Topics**
+ [
# Consultas sencillas
](sample-queries.basic-scenarios.md)
+ [
# Consultas con funciones de serie temporal
](sample-queries.devops-scenarios.md)
+ [
# Consultas con funciones de agregación
](sample-queries.iot-scenarios.md)
# Consultas sencillas
A continuación, se obtienen los últimos 10 puntos de datos que se agregaron a una tabla.
```
SELECT * FROM .
ORDER BY time DESC
LIMIT 10
```
A continuación, se obtienen los 5 puntos de datos más antiguos de una medida específica.
```
SELECT * FROM .
WHERE measure_name = ''
ORDER BY time ASC
LIMIT 5
```
Lo siguiente funciona con marcas de tiempo de granularidad de nanosegundos.
```
SELECT now() AS time_now
, now() - (INTERVAL '12' HOUR) AS twelve_hour_earlier -- Compatibility with ANSI SQL
, now() - 12h AS also_twelve_hour_earlier -- Convenient time interval literals
, ago(12h) AS twelve_hours_ago -- More convenience with time functionality
, bin(now(), 10m) AS time_binned -- Convenient time binning support
, ago(50ns) AS fifty_ns_ago -- Nanosecond support
, now() + (1h + 50ns) AS hour_fifty_ns_future
```
Los valores de medida de los registros de medidas múltiples se identifican por el nombre de la columna. Los valores de medida de los registros de medida única se identifican con `measure_value::`, donde `` puede ser `double`, `bigint`, `boolean`, o `varchar`, tal como se describe en [Tipos de datos compatibles](supported-data-types.md). Para obtener más información sobre cómo se modelan los valores de medida, consulte [Tabla única frente a tablas múltiples.](https://docs.aws.amazon.com/timestream/latest/developerguide/data-modeling.html#data-modeling-multiVsinglerecords)
A continuación, se recuperan los valores de una medida llamada `speed` partir de registros de varias medidas con un valor `measure_name` de `IoTMulti-stats`.
```
SELECT speed FROM . where measure_name = 'IoTMulti-stats'
```
A continuación, se recuperan los valores `double` de registros de medida única con un `measure_name` de `load`.
```
SELECT measure_value::double FROM . WHERE measure_name = 'load'
```
# Consultas con funciones de serie temporal
**Topics**
+ [
## Conjunto de datos y consultas de ejemplo
](#sample-queries.devops-scenarios.example)
## Conjunto de datos y consultas de ejemplo
Puede usar Timestream para LiveAnalytics comprender y mejorar el rendimiento y la disponibilidad de sus servicios y aplicaciones. A continuación, se muestra una tabla de ejemplo y ejemplos de consultas que se ejecutan en esa tabla.
La tabla `ec2_metrics` almacena datos de telemetría, como el uso de la CPU y otras métricas de las instancias de EC2. Puede ver la tabla que aparece a continuación.
| Time | region | az | Hostname | measure\$1name | measure\$1value::double | measure\$1value::bigint |
| --- | --- | --- | --- | --- | --- | --- |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1a | frontend01 | cpu\$1utilization | 35.1 | null |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1a | frontend01 | memory\$1utilization | 55.3 | null |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1a | frontend01 | network\$1bytes\$1in | null | 1500 |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1a | frontend01 | network\$1bytes\$1out | null | 6700 |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1b | frontend02 | cpu\$1utilization | 38,5 | null |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1b | frontend02 | memory\$1utilization | 58,4 | null |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1b | frontend02 | network\$1bytes\$1in | null | 23.000 |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1b | frontend02 | network\$1bytes\$1out | null | 12 000 |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1c | frontend03 | cpu\$1utilization | 45.0 | null |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1c | frontend03 | memory\$1utilization | 65,8 | null |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1c | frontend03 | network\$1bytes\$1in | null | 15.000 |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1c | frontend03 | network\$1bytes\$1out | null | 836.000 |
| 2019-12-04 19:00:05.000000000 | us-east-1 | us-east-1a | frontend01 | cpu\$1utilization | 55,2 | null |
| 2019-12-04 19:00:05.000000000 | us-east-1 | us-east-1a | frontend01 | memory\$1utilization | 75.0 | null |
| 2019-12-04 19:00:05.000000000 | us-east-1 | us-east-1a | frontend01 | network\$1bytes\$1in | null | 1.245 |
| 2019-12-04 19:00:05.000000000 | us-east-1 | us-east-1a | frontend01 | network\$1bytes\$1out | null | 68.432 |
| 2019-12-04 19:00:08.000000000 | us-east-1 | us-east-1b | frontend02 | cpu\$1utilization | 65,6 | null |
| 2019-12-04 19:00:08.000000000 | us-east-1 | us-east-1b | frontend02 | memory\$1utilization | 85,3 | null |
| 2019-12-04 19:00:08.000000000 | us-east-1 | us-east-1b | frontend02 | network\$1bytes\$1in | null | 1.245 |
| 2019-12-04 19:00:08.000000000 | us-east-1 | us-east-1b | frontend02 | network\$1bytes\$1out | null | 68.432 |
| 2019-12-04 19:00:20.000000000 | us-east-1 | us-east-1c | frontend03 | cpu\$1utilization | 12.1 | null |
| 2019-12-04 19:00:20.000000000 | us-east-1 | us-east-1c | frontend03 | memory\$1utilization | 32,0 | null |
| 2019-12-04 19:00:20.000000000 | us-east-1 | us-east-1c | frontend03 | network\$1bytes\$1in | null | 1.400 |
| 2019-12-04 19:00:20.000000000 | us-east-1 | us-east-1c | frontend03 | network\$1bytes\$1out | null | 345 |
| 2019-12-04 19:00:10.000000000 | us-east-1 | us-east-1a | frontend01 | cpu\$1utilization | 15.3 | null |
| 2019-12-04 19:00:10.000000000 | us-east-1 | us-east-1a | frontend01 | memory\$1utilization | 35,4 | null |
| 2019-12-04 19:00:10.000000000 | us-east-1 | us-east-1a | frontend01 | network\$1bytes\$1in | null | 23 |
| 2019-12-04 19:00:10.000000000 | us-east-1 | us-east-1a | frontend01 | network\$1bytes\$1out | null | 0 |
| 2019-12-04 19:00:16.000000000 | us-east-1 | us-east-1b | frontend02 | cpu\$1utilization | 44.0 | null |
| 2019-12-04 19:00:16.000000000 | us-east-1 | us-east-1b | frontend02 | memory\$1utilization | 64,2 | null |
| 2019-12-04 19:00:16.000000000 | us-east-1 | us-east-1b | frontend02 | network\$1bytes\$1in | null | 1.450 |
| 2019-12-04 19:00:16.000000000 | us-east-1 | us-east-1b | frontend02 | network\$1bytes\$1out | null | 200 |
| 2019-12-04 19:00:40.000000000 | us-east-1 | us-east-1c | frontend03 | cpu\$1utilization | 66,4 | null |
| 2019-12-04 19:00:40.000000000 | us-east-1 | us-east-1c | frontend03 | memory\$1utilization | 86,3 | null |
| 2019-12-04 19:00:40.000000000 | us-east-1 | us-east-1c | frontend03 | network\$1bytes\$1in | null | 300 |
| 2019-12-04 19:00:40.000000000 | us-east-1 | us-east-1c | frontend03 | network\$1bytes\$1out | null | 423 |
Calcular la media de uso de la CPU en los valores p90, p95 y p99 de un host EC2 específico durante las últimas 2 horas:
```
SELECT region, az, hostname, BIN(time, 15s) AS binned_timestamp,
ROUND(AVG(measure_value::double), 2) AS avg_cpu_utilization,
ROUND(APPROX_PERCENTILE(measure_value::double, 0.9), 2) AS p90_cpu_utilization,
ROUND(APPROX_PERCENTILE(measure_value::double, 0.95), 2) AS p95_cpu_utilization,
ROUND(APPROX_PERCENTILE(measure_value::double, 0.99), 2) AS p99_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv'
AND time > ago(2h)
GROUP BY region, hostname, az, BIN(time, 15s)
ORDER BY binned_timestamp ASC
```
Identificar los hosts EC2 cuyo uso de la CPU sea superior en un 10 %, o más, a la media de uso de la CPU de toda la flota durante las últimas 2 horas:
```
WITH avg_fleet_utilization AS (
SELECT COUNT(DISTINCT hostname) AS total_host_count, AVG(measure_value::double) AS fleet_avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND time > ago(2h)
), avg_per_host_cpu AS (
SELECT region, az, hostname, AVG(measure_value::double) AS avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND time > ago(2h)
GROUP BY region, az, hostname
)
SELECT region, az, hostname, avg_cpu_utilization, fleet_avg_cpu_utilization
FROM avg_fleet_utilization, avg_per_host_cpu
WHERE avg_cpu_utilization > 1.1 * fleet_avg_cpu_utilization
ORDER BY avg_cpu_utilization DESC
```
Calcular la media de uso de la CPU agrupada en intervalos de 30 segundos para un host EC2 específico durante las últimas 2 horas:
```
SELECT BIN(time, 30s) AS binned_timestamp, ROUND(AVG(measure_value::double), 2) AS avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv'
AND time > ago(2h)
GROUP BY hostname, BIN(time, 30s)
ORDER BY binned_timestamp ASC
```
Calcular la media de uso de la CPU agrupada en intervalos de 30 segundos para un host EC2 específico durante las últimas 2 horas, y rellenar los valores faltantes mediante la interpolación lineal:
```
WITH binned_timeseries AS (
SELECT hostname, BIN(time, 30s) AS binned_timestamp, ROUND(AVG(measure_value::double), 2) AS avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv'
AND time > ago(2h)
GROUP BY hostname, BIN(time, 30s)
), interpolated_timeseries AS (
SELECT hostname,
INTERPOLATE_LINEAR(
CREATE_TIME_SERIES(binned_timestamp, avg_cpu_utilization),
SEQUENCE(min(binned_timestamp), max(binned_timestamp), 15s)) AS interpolated_avg_cpu_utilization
FROM binned_timeseries
GROUP BY hostname
)
SELECT time, ROUND(value, 2) AS interpolated_cpu
FROM interpolated_timeseries
CROSS JOIN UNNEST(interpolated_avg_cpu_utilization)
```
Calcular la media de uso de la CPU agrupada en intervalos de 30 segundos para un host EC2 específico durante las últimas 2 horas, y rellenar los valores faltantes mediante la interpolación lineal en función de la última observación disponible:
```
WITH binned_timeseries AS (
SELECT hostname, BIN(time, 30s) AS binned_timestamp, ROUND(AVG(measure_value::double), 2) AS avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv'
AND time > ago(2h)
GROUP BY hostname, BIN(time, 30s)
), interpolated_timeseries AS (
SELECT hostname,
INTERPOLATE_LOCF(
CREATE_TIME_SERIES(binned_timestamp, avg_cpu_utilization),
SEQUENCE(min(binned_timestamp), max(binned_timestamp), 15s)) AS interpolated_avg_cpu_utilization
FROM binned_timeseries
GROUP BY hostname
)
SELECT time, ROUND(value, 2) AS interpolated_cpu
FROM interpolated_timeseries
CROSS JOIN UNNEST(interpolated_avg_cpu_utilization)
```
# Consultas con funciones de agregación
A continuación, se muestra un ejemplo de conjunto de datos de un escenario de IoT para ilustrar las consultas con funciones agregadas.
**Topics**
+ [
## Datos de ejemplo
](#sample-queries.iot-scenarios.example-data)
+ [
## Consultas de ejemplo
](#sample-queries.iot-scenarios.example-queries)
## Datos de ejemplo
Timestream le permite almacenar y analizar los datos de los sensores de IoT, como la ubicación, el consumo de combustible, la velocidad y la capacidad de carga de una o más flotas de camiones, para permitir una gestión eficaz de la flota. A continuación, se muestra el esquema y algunos de los datos de una tabla iot\$1trucks que almacena la telemetría, como la ubicación, el consumo de combustible, la velocidad y la capacidad de carga de los camiones.
| Time | truck\$1id | Make | Modelo | Fleet | fuel\$1capacity | load\$1capacity | measure\$1name | measure\$1value::double | measure\$1value::varchar |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 2019-12-04 19:00:00.000000000 | 123456781 | GMC | Astro | Alpha | 100 | 500 | fuel\$1reading | 65,2 | null |
| 2019-12-04 19:00:00.000000000 | 123456781 | GMC | Astro | Alpha | 100 | 500 | carga | 400,0 | null |
| 2019-12-04 19:00:00.000000000 | 123456781 | GMC | Astro | Alpha | 100 | 500 | speed | 90,2 | null |
| 2019-12-04 19:00:00.000000000 | 123456781 | GMC | Astro | Alpha | 100 | 500 | ubicación | null | 47,6062 N, 122,3321 W |
| 2019-12-04 19:00:00.000000000 | 123456782 | Kenworth | W900 | Alpha | 150 | 1 000 | fuel\$1reading | 10.1 | null |
| 2019-12-04 19:00:00.000000000 | 123456782 | Kenworth | W900 | Alpha | 150 | 1 000 | carga | 950,3 | null |
| 2019-12-04 19:00:00.000000000 | 123456782 | Kenworth | W900 | Alpha | 150 | 1 000 | speed | 50,8 | null |
| 2019-12-04 19:00:00.000000000 | 123456782 | Kenworth | W900 | Alpha | 150 | 1 000 | ubicación | null | 40,7128 grados N, 74,0060 grados W |
## Consultas de ejemplo
Obtener una lista de todos los atributos y valores de los sensores que se monitorean para cada camión de la flota.
```
SELECT
truck_id,
fleet,
fuel_capacity,
model,
load_capacity,
make,
measure_name
FROM "sampleDB".IoT
GROUP BY truck_id, fleet, fuel_capacity, model, load_capacity, make, measure_name
```
Obtener la lectura de combustible más reciente de cada camión de la flota en las últimas 24 horas.
```
WITH latest_recorded_time AS (
SELECT
truck_id,
max(time) as latest_time
FROM "sampleDB".IoT
WHERE measure_name = 'fuel-reading'
AND time >= ago(24h)
GROUP BY truck_id
)
SELECT
b.truck_id,
b.fleet,
b.make,
b.model,
b.time,
b.measure_value::double as last_reported_fuel_reading
FROM
latest_recorded_time a INNER JOIN "sampleDB".IoT b
ON a.truck_id = b.truck_id AND b.time = a.latest_time
WHERE b.measure_name = 'fuel-reading'
AND b.time > ago(24h)
ORDER BY b.truck_id
```
Identificar los camiones que han estado funcionando con poco combustible (menos del 10 %) en las últimas 48 horas:
```
WITH low_fuel_trucks AS (
SELECT time, truck_id, fleet, make, model, (measure_value::double/cast(fuel_capacity as double)*100) AS fuel_pct
FROM "sampleDB".IoT
WHERE time >= ago(48h)
AND (measure_value::double/cast(fuel_capacity as double)*100) < 10
AND measure_name = 'fuel-reading'
),
other_trucks AS (
SELECT time, truck_id, (measure_value::double/cast(fuel_capacity as double)*100) as remaining_fuel
FROM "sampleDB".IoT
WHERE time >= ago(48h)
AND truck_id IN (SELECT truck_id FROM low_fuel_trucks)
AND (measure_value::double/cast(fuel_capacity as double)*100) >= 10
AND measure_name = 'fuel-reading'
),
trucks_that_refuelled AS (
SELECT a.truck_id
FROM low_fuel_trucks a JOIN other_trucks b
ON a.truck_id = b.truck_id AND b.time >= a.time
)
SELECT DISTINCT truck_id, fleet, make, model, fuel_pct
FROM low_fuel_trucks
WHERE truck_id NOT IN (
SELECT truck_id FROM trucks_that_refuelled
)
```
Calcular la carga media y la velocidad máxima de cada camión durante la última semana:
```
SELECT
bin(time, 1d) as binned_time,
fleet,
truck_id,
make,
model,
AVG(
CASE WHEN measure_name = 'load' THEN measure_value::double ELSE NULL END
) AS avg_load_tons,
MAX(
CASE WHEN measure_name = 'speed' THEN measure_value::double ELSE NULL END
) AS max_speed_mph
FROM "sampleDB".IoT
WHERE time >= ago(7d)
AND measure_name IN ('load', 'speed')
GROUP BY fleet, truck_id, make, model, bin(time, 1d)
ORDER BY truck_id
```
Obtener la eficiencia de carga de cada camión durante la semana pasada:
```
WITH average_load_per_truck AS (
SELECT
truck_id,
avg(measure_value::double) AS avg_load
FROM "sampleDB".IoT
WHERE measure_name = 'load'
AND time >= ago(7d)
GROUP BY truck_id, fleet, load_capacity, make, model
),
truck_load_efficiency AS (
SELECT
a.truck_id,
fleet,
load_capacity,
make,
model,
avg_load,
measure_value::double,
time,
(measure_value::double*100)/avg_load as load_efficiency -- , approx_percentile(avg_load_pct, DOUBLE '0.9')
FROM "sampleDB".IoT a JOIN average_load_per_truck b
ON a.truck_id = b.truck_id
WHERE a.measure_name = 'load'
)
SELECT
truck_id,
time,
load_efficiency
FROM truck_load_efficiency
ORDER BY truck_id, time
```