', default: (\)
```
Ao exportar os dados no formato CSV, esse campo especifica o caractere que deve ser tratado como um caractere de escape no arquivo de dados gravado no bucket do S3. O escape acontece nos seguintes cenários:
1. Se o valor em si contiver o caractere de aspa (“), ele será escapado usando um caractere de escape. Por exemplo, se o valor for `Time"stream`, onde (\$1) é o caractere de escape configurado, ele será escapado como `Time\"stream`.
1. Se o valor contiver o caractere de escape configurado, ele será escapado. Por exemplo, se o valor for `Time\stream`, ele será escapado como `Time\\stream`.
Se a saída exportada contiver tipos de dados complexos, como matrizes, linhas ou séries temporais, ela será serializada como uma string JSON. Veja um exemplo a seguir.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/timestream/latest/developerguide/supported-sql-constructs.UNLOAD.html)
INCLUDE\$1HEADER
```
include_header = 'true' , default: 'false'
```
Ao exportar os dados no formato CSV, esse campo permite incluir nomes de colunas como a primeira linha dos arquivos de dados CSV exportados.
Os valores aceitos são 'true' e 'false' e o valor padrão é 'false'. Opções de transformação de texto, como `escaped_by` e `field_delimiter`, também se aplicam aos cabeçalhos.
Ao incluir cabeçalhos, é importante que você não selecione um caractere de retorno de carro (ASCII 13, hexadecimal 0D, texto '\$1r') ou um caractere de quebra de linha (ASCII 10, hexadecimal 0A, texto '\$1n') como o `FIELD_DELIMITER`, pois isso impedirá que muitos analisadores consigam analisar os cabeçalhos corretamente na saída CSV resultante.
MAX\$1FILE\$1SIZE
```
max_file_size = 'X[MB|GB]' , default: '78GB'
```
Esse campo especifica o tamanho máximo dos arquivos que a declaração `UNLOAD` cria no Amazon S3. A declaração `UNLOAD` pode criar vários arquivos, mas o tamanho máximo de cada arquivo gravado no Amazon S3 será aproximadamente o especificado nesse campo.
O valor do campo deve ser de 16 MB a 78 GB, inclusive. Isso pode ser especificado em números inteiros como `12GB`, ou em decimais como `0.5GB` ou `24.7MB`. O valor padrão é 78 GB.
O tamanho real do arquivo é aproximado quando o arquivo está sendo gravado, então o tamanho máximo real pode não ser exatamente igual ao número especificado.
# Operadores lógicos
O Timestream for LiveAnalytics suporta os seguintes operadores lógicos.
| Operador | Description | Exemplo |
| --- | --- | --- |
| E | Verdadeiro se ambos os valores forem verdadeiros | a AND b |
| OU | Verdadeiro se um dos valores for verdadeiro | a OR b |
| NOT | Verdadeiro se o valor for falso | NOT a |
+ O resultado de uma comparação `AND` pode ser `NULL` se um ou ambos os lados da expressão forem `NULL`.
+ Se pelo menos um lado de um operador `AND` for `FALSE`, a expressão será avaliada como `FALSE`.
+ O resultado de uma comparação `OR` pode ser `NULL` se um ou ambos os lados da expressão forem `NULL`.
+ Se pelo menos um lado de um operador `OR` for `TRUE`, a expressão será avaliada como `TRUE`.
+ O complemento lógico de `NULL` é `NULL`.
A tabela de verdades a seguir demonstra o tratamento de `NULL` no `AND` e`OR`:
| A | B | A and b | A or b |
| --- | --- | --- | --- |
| nulo | nulo | nulo | nulo |
| false | nulo | false | nulo |
| nulo | false | false | nulo |
| true | nulo | nulo | true |
| nulo | true | nulo | verdadeiro |
| false | false | false | false |
| verdadeiro | false | false | verdadeiro |
| false | verdadeiro | false | true |
| true | true | true | true |
A tabela de verdades a seguir demonstra o tratamento de NULL no NOT:
| A | Not a |
| --- | --- |
| nulo | nulo |
| verdadeiro | false |
| false | verdadeiro |
# Operadores de comparação
O Timestream for LiveAnalytics suporta os seguintes operadores de comparação.
| Operador | Description |
| --- | --- |
| < | Menor que |
| > | Maior que |
| <= | Menor ou igual a |
| >= | Maior ou igual a |
| = | Equal |
| <> | Not equal |
| \$1= | Not equal |
**nota**
O operador `BETWEEN` testa se um valor está dentro de um intervalo especificado. A sintaxe é a seguinte:
```
BETWEEN min AND max
```
A presença do `NULL` em uma declaração `BETWEEN` ou `NOT BETWEEN` resultará na declaração sendo avaliada como `NULL`.
Os opeardores `IS NULL ` e `IS NOT NULL` testam se um valor é nulo (indefinido). Usar `NULL` com `IS NULL` é avaliado como verdadeiro.
Em SQL, um valor `NULL` significa um valor desconhecido.
# Funções de comparação
O Timestream for LiveAnalytics suporta as seguintes funções de comparação.
**Topics**
+ [
# greatest()
](comparison-functions.greatest.md)
+ [
# least()
](comparison-functions.least.md)
+ [
# ALL(), ANY() e SOME()
](comparison-functions.all-any-some.md)
# greatest()
A função **greatest()** retorna o maior dos valores fornecidos. Ele retorna `NULL` se algum dos valores fornecidos for `NULL`. A sintaxe é a seguinte.
```
greatest(value1, value2, ..., valueN)
```
# least()
A função **least()** retorna o menor dos valores fornecidos. Ele retorna `NULL` se algum dos valores fornecidos for `NULL`. A sintaxe é a seguinte.
```
least(value1, value2, ..., valueN)
```
# ALL(), ANY() e SOME()
Os quantificadores `ALL`, `ANY` e `SOME` podem ser usados junto com operadores de comparação da seguinte forma.
| Expressão | Significado |
| --- | --- |
| A = ALL(...) | É avaliado como verdadeiro quando A é igual a todos os valores. |
| A <> ALL(...) | É avaliado como verdadeiro quando A não corresponde a nenhum valor. |
| A < ALL(...) | É avaliado como verdadeiro quando A é menor que o menor valor. |
| A = ANY(...) | É avaliado como verdadeiro quando A é igual a qualquer um dos valores. |
| A <> ANY(...) | É avaliado como verdadeiro quando A não corresponde a um ou mais valores. |
| A < ANY(...) | É avaliado como verdadeiro quando A é menor que o maior valor. |
## Exemplos e observações sobre uso
**nota**
Ao usar `ALL`, `ANY` ou `SOME`, a palavra-chave `VALUES` deve ser usada se os valores de comparação forem uma lista de literais.
## Exemplo: `ANY()`
Um exemplo de `ANY()` em uma declaração de consulta é o seguinte.
```
SELECT 11.7 = ANY (VALUES 12.0, 13.5, 11.7)
```
Uma sintaxe alternativa para a mesma operação é a seguinte.
```
SELECT 11.7 = ANY (SELECT 12.0 UNION ALL SELECT 13.5 UNION ALL SELECT 11.7)
```
Nesse caso, `ANY()` é avaliado como `True`.
## Exemplo: `ALL()`
Um exemplo de `ALL()` em uma declaração de consulta é o seguinte.
```
SELECT 17 < ALL (VALUES 19, 20, 15);
```
Uma sintaxe alternativa para a mesma operação é a seguinte.
```
SELECT 17 < ALL (SELECT 19 UNION ALL SELECT 20 UNION ALL SELECT 15);
```
Nesse caso, `ALL()` é avaliado como `False`.
## Exemplo: `SOME()`
Um exemplo de `SOME()` em uma declaração de consulta é o seguinte.
```
SELECT 50 >= SOME (VALUES 53, 77, 27);
```
Uma sintaxe alternativa para a mesma operação é a seguinte.
```
SELECT 50 >= SOME (SELECT 53 UNION ALL SELECT 77 UNION ALL SELECT 27);
```
Nesse caso, `SOME()` é avaliado como `True`.
# Expressões condicionais
O Timestream for LiveAnalytics suporta as seguintes expressões condicionais.
**Topics**
+ [
# A declaração CASE
](conditional-expressions.CASE.md)
+ [
# A declaração IF
](conditional-expressions.IF.md)
+ [
# A declaração COALESCE
](conditional-expressions.COALESCE.md)
+ [
# A declaração NULLIF
](conditional-expressions.NULLIF.md)
+ [
# A declaração TRY
](conditional-expressions.TRY.md)
# A declaração CASE
A declaração **CASE** pesquisa cada expressão de valor da esquerda para a direita até encontrar uma que seja igual a `expression`. Se encontrar uma correspondência, o resultado do valor correspondente será retornado. Se nenhuma correspondência for encontrada, o resultado da cláusula `ELSE` será retornado se existir. Caso contrário, `null` será retornado. A sintaxe é a seguinte:
```
CASE expression
WHEN value THEN result
[ WHEN ... ]
[ ELSE result ]
END
```
O Timestream também suporta a seguinte sintaxe para declarações **CASE**. Nessa sintaxe, o formulário “pesquisado” avalia cada condição booleana da esquerda para a direita até que uma delas seja `true` e retorna o resultado correspondente. Se não houver condições `true`, o resultado da cláusula `ELSE` será retornado se existir. Caso contrário, `null` será retornado. Veja abaixo a sintaxe alternativa:
```
CASE
WHEN condition THEN result
[ WHEN ... ]
[ ELSE result ]
END
```
# A declaração IF
A declaração **IF** avalia uma condição como verdadeira ou falsa e retorna o valor apropriado. O Timestream suporta as duas representações de sintaxe a seguir para **IF**:
```
if(condition, true_value)
```
Essa sintaxe avalia e retorna `true_value` se a condição for `true`; caso contrário, `null` é retornado e `true_value` não é avaliado.
```
if(condition, true_value, false_value)
```
Essa sintaxe avalia e retorna `true_value` se a condição for `true`, caso contrário, avalia e retorna `false_value`.
## Exemplos
```
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` |
# A declaração COALESCE
**COALESCE** retorna o primeiro valor não nulo em uma lista de argumentos. A sintaxe é a seguinte:
```
coalesce(value1, value2[,...])
```
# A declaração NULLIF
A declaração **IF** avalia uma condição como verdadeira ou falsa e retorna o valor apropriado. O Timestream suporta as duas representações de sintaxe a seguir para **IF**:
**NULLIF** retornará null se `value1` for igual a `value2`; caso contrário, ele retornará `value1`. A sintaxe é a seguinte:
```
nullif(value1, value2)
```
# A declaração TRY
A função **TRY** avalia uma expressão e manipula certos tipos de erros retornando `null`. A sintaxe é a seguinte:
```
try(expression)
```
# Funções de conversão
O Timestream for LiveAnalytics suporta as seguintes funções de conversão.
**Topics**
+ [
## cast()
](#conversion-functions.cast)
+ [
## try\$1cast()
](#conversion-functions.try-cast)
## cast()
A sintaxe da função de conversão para converter explicitamente um valor como um tipo é a seguinte.
```
cast(value AS type)
```
## try\$1cast()
O Timestream for LiveAnalytics também suporta a função try\$1cast, que é semelhante à conversão, mas retorna null se a conversão falhar. A sintaxe é a seguinte.
```
try_cast(value AS type)
```
# Operadores matemáticos
O Timestream for LiveAnalytics suporta os seguintes operadores matemáticos.
| Operador | Description |
| --- | --- |
| \$1 | Adição |
| - | Subtração |
| \$1 | Multiplicação |
| / | Divisão (divisão de inteiros executa o truncamento) |
| % | Módulo (restante) |
# Funções matemáticas
O Timestream for LiveAnalytics suporta as seguintes funções matemáticas.
| Função | Tipo de dados de saída | Description |
| --- | --- | --- |
| abs(x) | [o mesmo que a entrada] | Retorna o valor absoluto de x. |
| cbrt(x) | double | Retorna a raiz cúbica de x. |
| ceiling(x) ou ceil(x) | [o mesmo que a entrada] | Retorna x arredondado para o número inteiro maior mais próximo. |
| degrees(x) | double | Converte o ângulo x em radianos para graus. |
| e() | double | Retorna o número da constante de Euler. |
| exp(x) | double | Retorna o número de Euler elevado à potência de x. |
| floor(x) | [o mesmo que a entrada] | Retorna x arredondado para o número inteiro menor mais próximo. |
| from\$1base(string,radix) | bigint | Retorna o valor da string interpretada como um número de base-radix. |
| ln(x) | double | retorna o logaritmo natural de x. |
| log2(x) | double | Retorna o logaritmo de base 2 de x. |
| log10(x) | double | Retorna o logaritmo de base 10 de x. |
| mod(n,m) | [o mesmo que a entrada] | Retorna o módulo (resto) de n dividido por m. |
| pi() | double | Retorna a constante Pi. |
| pow(x, p) ou power(x, p) | double | Retorna x elevado a uma potência de p. |
| radians(x) | double | Converte o ângulo x em graus para radianos. |
| rand() ou random() | double | Retorna um valor pseudo-aleatório no intervalo de 0.0 a 1.0. |
| random(n) | [o mesmo que a entrada] | Retorna um número pseudo-aleatório entre 0 e n (exclusivo). |
| round(x) | [o mesmo que a entrada] | Retorna x arredondado para o número inteiro mais próximo. |
| round(x,d) | [o mesmo que a entrada] | Retorna x arredondado para d casas decimais. |
| sign(x) | [o mesmo que a entrada] | Retorna a função signum de x, ou seja: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/timestream/latest/developerguide/mathematical-functions.html) Para argumentos duplos, a função também retorna: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/timestream/latest/developerguide/mathematical-functions.html) |
| sqrt(x) | double | Retorna a raiz quadrada de x. |
| to\$1base(x, radix) | varchar | Retorna a representação base-radix de x. |
| truncate(x) | double | Retorna x arredondado para um inteiro eliminando dígitos depois do ponto decimal. |
| acos(x) | double | Retorna o arco do cosseno de x. |
| asin(x) | double | Retorna o arco do seno de x. |
| atan(x) | double | Retorna a tangente de arco de x. |
| atan2(y, x) | double | Retorna a tangente de arco de y/x. |
| cos(x) | double | Retorna o cosseno de x. |
| cosh(x) | double | Retorna o cosseno hiperbólico de x. |
| sin(x) | double | Retorna o seno de x. |
| tan(x) | double | Retorna a tangente de x. |
| tanh(x) | double | Retorna a tangente hiperbólica de x. |
| infinity() | double | Retorna a constante que representa o infinito positivo. |
| is\$1finite(x) | booleano | Determina se x é finito. |
| is\$1infinite(x) | booleano | Determine se x é infinito. |
| is\$1nan(x) | booleano | Determine se x é not-a-number. |
| nan() | double | Retorna a constante que representa not-a-number. |
# Operadores de string
Timestream for LiveAnalytics suporta o `||` operador na concatenação de uma ou mais cadeias de caracteres.
# Funções de string
**nota**
O tipo de dados de entrada dessas funções é considerado varchar, a menos que especificado de outra forma.
| Função | Tipo de dados de saída | Description |
| --- | --- | --- |
| chr(n) | varchar | Retorna o ponto de código Unicode n como um varchar. |
| codepoint(x) | integer | Retorna o ponto de código Unicode do único caractere de str. |
| concat(x1, ..., xN) | varchar | Retorna a concatenação de x1, x2,..., xN. |
| hamming\$1distance(x1,x2) | bigint | Retorna a distância de Hamming de x1 e x2, ou seja, o número de posições nas quais os caracteres correspondentes são diferentes. Observe que as duas entradas varchar devem ter o mesmo comprimento. |
| length(x) | bigint | Retorna o comprimento de x em caracteres. |
| levenshtein\$1distance(x1, x2) | bigint | Retorna a distância de edição de Levenshtein de x1 e x2, ou seja, o número mínimo de edições de um único caractere (inserções, exclusões ou substituições) necessárias para transformar x1 em x2. |
| lower(x) | varchar | Converte x para minúsculas. |
| lpad(x1, bigint size, x2) | varchar | Tecla esquerda x1 para dimensionar caracteres com x2. Se o tamanho for menor que o comprimento de x1, o resultado será truncado para caracteres de tamanho. O tamanho não deve ser negativo e x2 não deve estar vazio. |
| ltrim(x) | varchar | Remove o espaço em branco inicial de x. |
| replace(x1, x2) | varchar | Remove todas as instâncias de x2 de x1. |
| replace(x1, x2, x3) | varchar | Substitui todas as instâncias de x2 com x3 em x1. |
| Reverse(x) | varchar | Retorna x com os caracteres na ordem inversa. |
| rpad(x1, bigint size, x2) | varchar | Tecla direita x1 para dimensionar caracteres com x2. Se o tamanho for menor que o comprimento de x1, o resultado será truncado para caracteres de tamanho. O tamanho não deve ser negativo e x2 não deve estar vazio. |
| rtrim(x) | varchar | Remove o espaço em branco final de x. |
| split(x1, x2) | array(varchar) | Divide x1 no delimitador x2 e retorna uma matriz. |
| split(x1, x2, bigint limit) | array(varchar) | Divide x1 no delimitador x2 e retorna uma matriz. O último elemento na matriz sempre contém tudo o que resta no x1. O limite deve ser um número positivo. |
| split\$1part(x1, x2, bigint pos) | varchar | Divide x1 no delimitador x2 e retorna o campo varchar em pos. Os índices de campo começam com 1. Se pos for maior que o número de campos, será retornado null. |
| strpos(x1, x2) | bigint | Retorna a posição inicial da primeira instância de x2 em x1. As posições começam com 1. Se não for encontrado, 0 será retornado. |
| strpos(x1, x2,bigint instance) | bigint | Retorna a posição da enésima instância de x2 em x1. A instância deve ser um número positivo. As posições começam com 1. Se não for encontrado, 0 será retornado. |
| strrpos(x1, x2) | bigint | Retorna a posição inicial da última instância de x2 em x1. As posições começam com 1. Se não for encontrado, 0 será retornado. |
| strrpos(x1, x2, bigint instance) | bigint | Retorna a posição da enésima instância de x2 em x1 a partir do final de x1. A instância deve ser um número positivo. As posições começam com 1. Se não for encontrado, 0 será retornado. |
| position(x2 IN x1) | bigint | Retorna a posição inicial da primeira instância de x2 em x1. As posições começam com 1. Se não for encontrado, 0 será retornado. |
| substr(x, bigint start) | varchar | Retorna o resto de x do início da posição inicial. As posições começam com 1. Uma posição inicial negativa é interpretada como sendo relativa ao final de x. |
| substr(x, bigint start, bigint len) | varchar | Retorna uma substring de x de comprimento len do início da posição inicial. As posições começam com 1. Uma posição inicial negativa é interpretada como sendo relativa ao final de x. |
| trim(x) | varchar | Remove todos os espaços em branco iniciais e finais de x. |
| upper(x) | varchar | Converte x para maiúsculas. |
# Operadores de matriz
O Timestream for LiveAnalytics suporta os seguintes operadores de matriz.
| Operador | Description |
| --- | --- |
| [] | Acesse um elemento de uma matriz em que o primeiro índice começa em 1. |
| \$1\$1 | Concatene uma matriz com outra matriz ou elemento do mesmo tipo. |
# Funções de array
O Timestream for LiveAnalytics suporta as seguintes funções de matriz.
| Função | Tipo de dados de saída | Description |
| --- | --- | --- |
| array\$1distinct(x) | array | Remove valores duplicados da matriz x. SELECT array_distinct(ARRAY[1,2,2,3])
Exemplo de resultado: `[ 1,2,3 ]` |
| array\$1intersect(x, y) | array | Retorna uma matriz dos elementos na interseção de x e y, sem duplicatas. SELECT array_intersect(ARRAY[1,2,3], ARRAY[3,4,5])
Exemplo de resultado: `[ 3 ]` |
| array\$1union(x, y) | array | Retorna uma matriz dos elementos na união de x e y, sem duplicatas. SELECT array_union(ARRAY[1,2,3], ARRAY[3,4,5])
Exemplo de resultado: `[ 1,2,3,4,5 ]` |
| array\$1except(x, y) | array | Retorna uma matriz de elementos em x, mas não em y, sem duplicatas. SELECT array_except(ARRAY[1,2,3], ARRAY[3,4,5])
Exemplo de resultado: `[ 1,2 ]` |
| array\$1join(x, delimiter, null\$1replacement) | varchar | Concatena os elementos da matriz fornecida usando o delimitador e uma string opcional para substituir os nulos. SELECT array_join(ARRAY[1,2,3], ';', '')
Exemplo de resultado: `1;2;3` |
| array\$1max(x) | o mesmo que elementos da matriz | Retorna o valor máximo da matriz de entrada. SELECT array_max(ARRAY[1,2,3])
Exemplo de resultado: `3` |
| array\$1min(x) | o mesmo que elementos da matriz | Retorna o valor mínimo da matriz de entrada. SELECT array_min(ARRAY[1,2,3])
Exemplo de resultado: `1` |
| array\$1position(x, element) | bigint | Retorna a posição da primeira ocorrência do elemento na matriz x (ou 0 se não for encontrada). SELECT array_position(ARRAY[3,4,5,9], 5)
Exemplo de resultado: `3` |
| array\$1remove(x, element) | array | Remova todos os elementos iguais ao elemento da matriz x. SELECT array_remove(ARRAY[3,4,5,9], 4)
Exemplo de resultado: `[ 3,5,9 ]` |
| array\$1sort(x) | array | Classifica e retorna a matriz x. Os elementos de x devem ser ordenáveis. Elementos nulos serão colocados no final da matriz retornada. SELECT array_sort(ARRAY[6,8,2,9,3])
Exemplo de resultado: `[ 2,3,6,8,9 ]` |
| arrays\$1overlap(x, y) | booleano | Testa se as matrizes x e y têm algum elemento não nulo em comum. Retorna null se não houver elementos não nulos em comum, mas qualquer uma das matrizes contiver null. SELECT arrays_overlap(ARRAY[6,8,2,9,3], ARRAY[6,8])
Exemplo de resultado: `true` |
| cardinality(x) | bigint | Retorna o tamanho da matriz x. SELECT cardinality(ARRAY[6,8,2,9,3])
Exemplo de resultado: `5` |
| concat(array1, array2, ..., arrayN) | array | Concatena as matrizes array1, array2, ..., arrayN. SELECT concat(ARRAY[6,8,2,9,3], ARRAY[11,32], ARRAY[6,8,2,0,14])
Exemplo de resultado: `[ 6,8,2,9,3,11,32,6,8,2,0,14 ]` |
| element\$1at(array(E), index) | E | Retorna o elemento da matriz em um determinado índice. Se o índice for < 0, element\$1at acessa elementos do último ao primeiro. SELECT element_at(ARRAY[6,8,2,9,3], 1)
Exemplo de resultado: `6` |
| repeat(element, count) | array | Repite o elemento para contar os tempos. SELECT repeat(1, 3)
Exemplo de resultado: `[ 1,1,1 ]` |
| reverse(x) | array | Retorna uma matriz que tem a ordem inversa da matriz x. SELECT reverse(ARRAY[6,8,2,9,3])
Exemplo de resultado: `[ 3,9,2,8,6 ]` |
| sequence(start, stop) | array(bigint) | Gere uma sequência de números inteiros do início ao fim, incrementando em 1 se o início for menor ou igual ao término, caso contrário, -1. SELECT sequence(3, 8)
Exemplo de resultado: `[ 3,4,5,6,7,8 ]` |
| sequence(start, stop, step) | array(bigint) | Gere uma sequência de números inteiros do início ao fim, incrementando por etapa. SELECT sequence(3, 15, 2)
Exemplo de resultado: `[ 3,5,7,9,11,13,15 ]` |
| sequence(start, stop) | array(timestamp) | Gere uma sequência de registros de data e hora da data de início até a data de término, incrementando em 1 dia. SELECT sequence('2023-04-02 19:26:12.941000000', '2023-04-06 19:26:12.941000000', 1d) Exemplo 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 ]` |
| sequence(start, stop, step) | array(timestamp) | Gere uma sequência de registros de data e hora do início ao fim, incrementando por etapa. O tipo de dados da etapa é intervalo. SELECT sequence('2023-04-02 19:26:12.941000000', '2023-04-10 19:26:12.941000000', 2d) Exemplo 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 | Gere uma permutação aleatória da matriz x determinada. SELECT shuffle(ARRAY[6,8,2,9,3])
Exemplo de resultado: `[ 6,3,2,9,8 ]` |
| slice(x, start, length) | array | Faz um subconjunto da matriz x começando do início do índice (ou começando do final se o início for negativo) com o comprimento especificado. SELECT slice(ARRAY[6,8,2,9,3], 1, 3)
Exemplo de resultado: `[ 6,8,2 ]` |
| zip(array1, array2[, ...]) | array(row) | Mescla as matrizes determinadas, elemento a elemento, em uma única matriz de linhas. Se os argumentos tiverem um comprimento desigual, os valores ausentes serão preenchidos com NULL. SELECT zip(ARRAY[6,8,2,9,3], ARRAY[15,24])
Exemplo de resultado: `[ ( 6, 15 ),( 8, 24 ),( 2, - ),( 9, - ),( 3, - ) ]` |
# Funções bitwise
O Timestream for LiveAnalytics suporta as seguintes funções bit a bit.
| Função | Tipo de dados de saída | Description |
| --- | --- | --- |
| bit\$1count(bigint, bigint) | bigint (complemento de dois) | Retorna a quantidade de bits no primeiro parâmetro bigint em que o segundo parâmetro é um inteiro com sinal de bits, como 8 ou 64. SELECT bit_count(19, 8)
Exemplo de resultado: `3` SELECT bit_count(19, 2)
Exemplo 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 dois) | Retorna o AND bitwise dos parâmetros bigint. SELECT bitwise_and(12, 7)
Exemplo de resultado: `4` |
| bitwise\$1not(bigint) | bigint (complemento de dois) | Retorna o NOT bitwise do parâmetro bigint. SELECT bitwise_not(12)
Exemplo de resultado: `-13` |
| bitwise\$1or(bigint, bigint) | bigint (complemento de dois) | Retorna o OR bitwise dos parâmetros bigint. SELECT bitwise_or(12, 7)
Exemplo de resultado: `15` |
| bitwise\$1xor(bigint, bigint) | bigint (complemento de dois) | Retorna o XOR bitwise dos parâmetros bigint. SELECT bitwise_xor(12, 7)
Exemplo de resultado: `11` |
# Funções de expressões regulares
A expressão regular funciona no Timestream para LiveAnalytics dar suporte à sintaxe do [padrão Java](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html). O Timestream for LiveAnalytics suporta as seguintes funções de expressão regular.
| Função | Tipo de dados de saída | Description |
| --- | --- | --- |
| regexp\$1extract\$1all(string, pattern) | array(varchar) | Retorna a(s) substring(s) corresponde(m) ao padrão de expressão regular na string. SELECT regexp_extract_all('example expect complex', 'ex\w') Exemplo de resultado: `[ exa,exp ]` |
| regexp\$1extract\$1all(string, pattern, group) | array(varchar) | Encontra todas as ocorrências do padrão de expressão regular na string e retorna o grupo de [número do 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) Exemplo de resultado: `[ a,p ]` |
| regexp\$1extract(string, pattern) | varchar | Retorna a primeira substring correspondente ao padrão de expressão regular na string. SELECT regexp_extract('example expect', 'ex\w') Exemplo de resultado: `exa` |
| regexp\$1extract(string, pattern, group) | varchar | Localiza a primeira ocorrência do padrão de expressão regular na string e retorna o grupo de [número do 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) Exemplo de resultado: `a` |
| regexp\$1like(string, pattern) | booleano | Avalia o padrão de expressão regular e determina se ele está contido na string. Essa função é semelhante ao operador LIKE, exceto que o padrão só precisa estar contido em uma string, em vez de precisar ser correspondente a toda a string. Em outras palavras, isso executa uma operação de contenção em vez de uma operação de correspondência. Você pode combinar a string inteira ancorando o padrão usando ^ e \$1. SELECT regexp_like('example', 'ex') Exemplo de resultado: `true` |
| regexp\$1replace(string, pattern) | varchar | Remove todas as instâncias da substring correspondentes ao padrão de expressão regular da string. SELECT regexp_replace('example expect', 'expect') Exemplo de resultado: `example` |
| regexp\$1replace(string, pattern, replacement) | varchar | Substitui todas as instâncias da substring com correspondência do padrão regex na string por uma substituição. Os grupos de captura podem ser referenciados em substituição usando \$1g para um grupo numerado ou \$1\$1name\$1 para um grupo nomeado. Um cifrão (\$1) pode ser incluído na substituição se for escapado com uma barra invertida (\$1 \$1). SELECT regexp_replace('example expect', 'expect', 'surprise') Exemplo de resultado: `example surprise` |
| regexp\$1replace(string, pattern, function) | varchar | Substitui todas as instâncias da substring com correspondência do padrão de expressão regular na string usando a função. A função da [expressão do lambda](https://prestodb.io/docs/current/functions/lambda.html) é invocada para cada correspondência com os grupos de captura passados como uma matriz. A captura de números de grupos começa em um; não há grupo para a correspondência inteira (se você precisar disso, coloque a expressão inteira entre parênteses). SELECT regexp_replace('example', '(\w)', x -> upper(x[1])) Exemplo de resultado: `EXAMPLE` |
| regexp\$1split(string, pattern) | array(varchar) | Divide a string usando o padrão de expressão regular e retorna uma matriz. As strings vazias à direita são preservadas. SELECT regexp_split('example', 'x') Exemplo de resultado: `[ e,ample ]` |
# Operadores de data e hora
**nota**
O Timestream for LiveAnalytics não suporta valores de tempo negativos. Qualquer operação que resulte em tempo negativo resulta em erro.
O Timestream for LiveAnalytics suporta as seguintes operações em `timestamps``dates`, e. `intervals`
| Operador | Description |
| --- | --- |
| \$1 | Adição |
| - | Subtração |
**Topics**
+ [
## Operações
](#date-time-operators-operations)
+ [
## Adição
](#date-time-operators-addition)
+ [
## Subtração
](#date-time-operators-subtraction)
## Operações
O tipo de resultado de uma operação é baseado nos operandos. Literais de intervalo, como `1day` e `3s`, podem ser usados.
```
SELECT date '2022-05-21' + interval '2' day
```
```
SELECT date '2022-05-21' + 2d
```
```
SELECT date '2022-05-21' + 2day
```
Exemplo de resultado para cada um: `2022-05-23`
As unidades de intervalo incluem `second`, `minute`, `hour`, `day`, `week`, `month` e `year`. Mas, em alguns casos, nem todos são aplicáveis. Por exemplo, segundos, minutos e horas não podem ser adicionados ou subtraídos de uma data.
```
SELECT interval '4' year + interval '2' month
```
Exemplo de resultado: `4-2`
```
SELECT typeof(interval '4' year + interval '2' month)
```
Exemplo de resultado: `interval year to month`
O tipo de resultado das operações de intervalo pode ser `'interval year to month'` ou `'interval day to second'` dependendo dos operandos. Os intervalos podem ser adicionados ou subtraídos de `dates` e `timestamps`. Mas um `date` ou `timestamp` não pode ser adicionado ou subtraído de um `date` ou `timestamp`. Para encontrar intervalos ou durações relacionados a datas ou registros de data e hora, consulte `date_diff` e funções relacionadas em [Intervalo e duração](date-time-functions.md#date-time-functions-interval-duration).
## Adição
**Example**
```
SELECT date '2022-05-21' + interval '2' day
```
Exemplo de resultado: `2022-05-23`
**Example**
```
SELECT typeof(date '2022-05-21' + interval '2' day)
```
Exemplo de resultado: `date`
**Example**
```
SELECT interval '2' year + interval '4' month
```
Exemplo de resultado: `2-4`
**Example**
```
SELECT typeof(interval '2' year + interval '4' month)
```
Exemplo de resultado: `interval year to month`
## Subtração
**Example**
```
SELECT timestamp '2022-06-17 01:00' - interval '7' hour
```
Exemplo de resultado: `2022-06-16 18:00:00.000000000`
**Example**
```
SELECT typeof(timestamp '2022-06-17 01:00' - interval '7' hour)
```
Exemplo de resultado: `timestamp`
**Example**
```
SELECT interval '6' day - interval '4' hour
```
Exemplo de resultado: `5 20:00:00.000000000`
**Example**
```
SELECT typeof(interval '6' day - interval '4' hour)
```
Exemplo de resultado: `interval day to second`
# Funções de data e hora
**nota**
O Timestream for LiveAnalytics não suporta valores de tempo negativos. Qualquer operação que resulte em tempo negativo resulta em erro.
Timestream for LiveAnalytics usa o fuso horário UTC para data e hora. O Timestream suporta as seguintes funções de data e hora.
**Topics**
+ [
## Geral e conversão
](#date-time-functions-general)
+ [
## Intervalo e duração
](#date-time-functions-interval-duration)
+ [
## Formatação e análise
](#date-time-functions-formatting-parsing)
+ [
## Extração
](#date-time-functions-extraction)
## Geral e conversão
O Timestream for LiveAnalytics suporta as seguintes funções gerais e de conversão para data e hora.
| Função | Tipo de dados de saída | Description |
| --- | --- | --- |
| current\$1date | date | Retorna a data atual em UTC. Nenhum parêntese foi usado. SELECT current_date
Exemplo de resultado: `2022-07-07` Essa também é uma palavra-chave reservada. Para obter uma lista de palavras-chave reservadas, consulte [Palavras-chave reservadas](ts-limits.md#limits.reserved). |
| current\$1time | horário | Retorna a hora atual em UTC. Nenhum parêntese foi usado. SELECT current_time
Exemplo de resultado: `17:41:52.827000000` Essa também é uma palavra-chave reservada. Para obter uma lista de palavras-chave reservadas, consulte [Palavras-chave reservadas](ts-limits.md#limits.reserved). |
| current\$1timestamp or now() | timestamp | Retorna o registro de data e hora atual em UTC. SELECT current_timestamp
Exemplo de resultado: `2022-07-07 17:42:32.939000000` Essa também é uma palavra-chave reservada. Para obter uma lista de palavras-chave reservadas, consulte [Palavras-chave reservadas](ts-limits.md#limits.reserved). |
| current\$1timezone() | varchar O valor será 'UTC'. | O Timestream usa o fuso horário UTC para data e hora. SELECT current_timezone()
Exemplo de resultado: `UTC` |
| date(varchar(x)), date(timestamp) | date | SELECT date(TIMESTAMP '2022-07-07 17:44:43.771000000')
Exemplo de resultado: `2022-07-07` |
| last\$1day\$1of\$1month(timestamp), last\$1day\$1of\$1month(date) | date | SELECT last_day_of_month(TIMESTAMP '2022-07-07 17:44:43.771000000')
Exemplo de resultado: `2022-07-31` |
| from\$1iso8601\$1timestamp(string) | timestamp | Analisa o registro de data e hora ISO 8601 em formato de registro de data e hora interno. SELECT from_iso8601_timestamp('2022-06-17T08:04:05.000000000+05:00') Exemplo de resultado: `2022-06-17 03:04:05.000000000` |
| from\$1iso8601\$1date(string) | date | Analisa a string de data ISO 8601 em formato de registro de data e hora interno para UTC 00:00:00 da data especificada. SELECT from_iso8601_date('2022-07-17') Exemplo de resultado: `2022-07-17` |
| to\$1iso8601(timestamp), to\$1iso8601(date) | varchar | Retorna uma string formatada em ISO 8601 para a entrada. SELECT to_iso8601(from_iso8601_date('2022-06-17')) Exemplo de resultado: `2022-06-17` |
| from\$1milliseconds(bigint) | timestamp | SELECT from_milliseconds(1)
Exemplo de resultado: `1970-01-01 00:00:00.001000000` |
| from\$1nanoseconds(bigint) | timestamp | select from_nanoseconds(300000001)
Exemplo de resultado: `1970-01-01 00:00:00.300000001` |
| from\$1unixtime(double) | timestamp | Retorna um registro de data e hora que corresponde ao unixtime fornecido. SELECT from_unixtime(1)
Exemplo de resultado: `1970-01-01 00:00:01.000000000` |
| localtime | horário | Retorna a hora atual em UTC. Nenhum parêntese foi usado. SELECT localtime
Exemplo de resultado: `17:58:22.654000000` Essa também é uma palavra-chave reservada. Para obter uma lista de palavras-chave reservadas, consulte [Palavras-chave reservadas](ts-limits.md#limits.reserved). |
| localtimestamp | timestamp | Retorna o registro de data e hora atual em UTC. Nenhum parêntese foi usado. SELECT localtimestamp
Exemplo de resultado: `2022-07-07 17:59:04.368000000` Essa também é uma palavra-chave reservada. Para obter uma lista de palavras-chave reservadas, consulte [Palavras-chave reservadas](ts-limits.md#limits.reserved). |
| to\$1milliseconds(interval day to second), to\$1milliseconds(timestamp) | bigint | SELECT to_milliseconds(INTERVAL '2' DAY + INTERVAL '3' HOUR)
Exemplo de resultado: `183600000` SELECT to_milliseconds(TIMESTAMP '2022-06-17 17:44:43.771000000')
Exemplo de resultado: `1655487883771` |
| to\$1nanoseconds(interval day to second), to\$1nanoseconds(timestamp) | bigint | SELECT to_nanoseconds(INTERVAL '2' DAY + INTERVAL '3' HOUR)
Exemplo de resultado: `183600000000000` SELECT to_nanoseconds(TIMESTAMP '2022-06-17 17:44:43.771000678')
Exemplo de resultado: `1655487883771000678` |
| to\$1unixtime(timestamp) | double | Retorna unixtime para o registro de data e hora fornecido. SELECT to_unixtime('2022-06-17 17:44:43.771000000') Exemplo de resultado: `1.6554878837710001E9` |
| date\$1trunc(unit, timestamp) | timestamp | Retorna o registro de data e hora truncado para a unidade, onde a unidade é [segundo, minuto, hora, dia, semana, mês, trimestre ou ano]. SELECT date_trunc('minute', TIMESTAMP '2022-06-17 17:44:43.771000000') Exemplo de resultado: `2022-06-17 17:44:00.000000000` |
## Intervalo e duração
O Timestream for LiveAnalytics suporta as seguintes funções de intervalo e duração para data e hora.
| Função | Tipo de dados de saída | Description |
| --- | --- | --- |
| date\$1add(unit, bigint, date), date\$1add(unit, bigint, time), date\$1add(varchar(x), bigint, timestamp) | timestamp | Adiciona uma grande quantidade de unidades, em que a unidade é uma dentre [segundo, minuto, hora, dia, semana, mês, trimestre ou ano]. SELECT date_add('hour', 9, TIMESTAMP '2022-06-17 00:00:00') Exemplo de resultado: `2022-06-17 09:00:00.000000000` |
| date\$1diff(unit, date, date) , date\$1diff(unit, time, time) , date\$1diff(unit, timestamp, timestamp) | bigint | Retorna uma diferença, em que a unidade é uma dentre [segundo, minuto, hora, dia, semana, mês, trimestre ou ano]. SELECT date_diff('day', DATE '2020-03-01', DATE '2020-03-02') Exemplo de resultado: `1` |
| parse\$1duration(string) | intervalo | Analisa a string de entrada para retornar um `interval` equivalente. SELECT parse_duration('42.8ms') Exemplo de resultado: `0 00:00:00.042800000` SELECT typeof(parse_duration('42.8ms')) Exemplo de resultado: `interval day to second` |
| bin(timestamp, interval) | timestamp | Arredonda o valor inteiro do parâmetro `timestamp` para o múltiplo mais próximo do valor inteiro do parâmetro `interval`. O significado desse valor de retorno pode não ser óbvio. Ele é calculado usando aritmética de números inteiros primeiro dividindo o número inteiro do registro de data e hora pelo inteiro do intervalo e depois multiplicando o resultado pelo inteiro do intervalo. Tendo em mente que um registro de data e hora especifica um momento UTC como o número de frações de segundo decorridas desde a época POSIX (1º de janeiro de 1970), o valor de retorno raramente se alinhará ao calendário. Por exemplo, se você especificar um intervalo de 30 dias, todos os dias desde a época serão divididos em incrementos de 30 dias, e o início do incremento mais recente de 30 dias será retornado, o que não tem relação com os meses do calendário. Veja alguns exemplos: 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(interval) | timestamp | Retorna o valor correspondente a current\$1timestamp `interval`. SELECT ago(1d)
Exemplo de resultado: `2022-07-06 21:08:53.245000000` |
| literais de intervalo, como 1h, 1d e 30m | intervalo | Os literais de intervalo são convenientes para parse\$1duration(string). Por exemplo, `1d` é o mesmo que `parse_duration('1d')`. Isso permite o uso dos literais sempre que um intervalo é usado. Por exemplo, `ago(1d)` e `bin(, 1m)`. |
Alguns literais de intervalo funcionam como uma abreviação de parse\$1duration. Por exemplo, `parse_duration('1day')`, `1day`, `parse_duration('1d')` e `1d` retornam `1 00:00:00.000000000` onde o tipo é `interval day to second`. O espaço é permitido no formato fornecido para `parse_duration`. Por exemplo, `parse_duration('1day')` também retorna `00:00:00.000000000`. Mas `1 day` não é um intervalo literal.
As unidades relacionadas a `interval day to second` são ns, nanosegundo, us, microssegundo, ms, milissegundo, s, segundo, m, minuto, h, hora, d e dia.
Também há o `interval year to month`. As unidades relacionadas ao intervalo ano a mês são y, ano e mês. Por exemplo, `SELECT 1year` retorna `1-0`. `SELECT 12month` também retorna `1-0`. `SELECT 8month` retorna `0-8`.
Embora a unidade de `quarter` também esteja disponível para algumas funções, como `date_trunc` e `date_add`, `quarter` não está disponível como parte de um intervalo literal.
## Formatação e análise
O Timestream for LiveAnalytics suporta as seguintes funções de formatação e análise para data e hora.
| Função | Tipo de dados de saída | Description |
| --- | --- | --- |
| date\$1format(timestamp, varchar(x)) | varchar | [Para obter mais informações sobre os especificadores de formato usados por essa função, 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')
Exemplo de resultado: `2019-10-20 10:20:20` |
| date\$1parse(varchar(x), varchar(y)) | timestamp | [Para obter mais informações sobre os especificadores de formato usados por essa função, 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') Exemplo de resultado: `2019-10-20 10:20:20.000000000` |
| format\$1datetime(timestamp, varchar(x)) | varchar | Para obter mais informações sobre a string de formato usada por essa função, 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') Exemplo de resultado: `1968-01-13 12` |
| parse\$1datetime(varchar(x), varchar(y)) | timestamp | Para obter mais informações sobre a string de formato usada por essa função, 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') Exemplo de resultado: `2019-12-29 18:10:00.000000000` |
## Extração
O Timestream for LiveAnalytics suporta as seguintes funções de extração para data e hora. A função de extração é a base para as demais funções de conveniência.
| Função | Tipo de dados de saída | Description |
| --- | --- | --- |
| extract | bigint | Extrai um campo de um registro de data e hora, onde o campo é um dentre [YEAR, QUARTER, MONTH, WEEK, DAY, DAY\$1OF\$1MONTH, DAY\$1OF\$1WEEK, DOW, DAY\$1OF\$1YEAR, DOY, YEAR\$1OF\$1WEEK, YOW, HOUR, MINUTE ou SECOND]. SELECT extract(YEAR FROM '2019-10-12 23:10:34.000000000')
Exemplo de resultado: `2019` |
| day(timestamp), day(date), day(interval day to second) | bigint | SELECT day('2019-10-12 23:10:34.000000000') Exemplo de resultado: `12` |
| day\$1of\$1month(timestamp), day\$1of\$1month(date), day\$1of\$1month(interval day to second) | bigint | SELECT day_of_month('2019-10-12 23:10:34.000000000') Exemplo de resultado: `12` |
| day\$1of\$1week(timestamp), day\$1of\$1week(date) | bigint | SELECT day_of_week('2019-10-12 23:10:34.000000000') Exemplo de resultado: `6` |
| day\$1of\$1year(timestamp), day\$1of\$1year(date) | bigint | SELECT day_of_year('2019-10-12 23:10:34.000000000') Exemplo de resultado: `285` |
| dow(timestamp), dow(date) | bigint | Alias para day\$1of\$1week |
| doy(timestamp), doy(date) | bigint | Alias para day\$1of\$1year |
| hour(timestamp), hour(time), hour(interval day to second) | bigint | SELECT hour('2019-10-12 23:10:34.000000000') Exemplo de resultado: `23` |
| millisecond(timestamp), millisecond(time), millisecond(interval day to second) | bigint | SELECT millisecond('2019-10-12 23:10:34.000000000') Exemplo de resultado: `0` |
| minute(timestamp), minute(time), minute(interval day to second) | bigint | SELECT minute('2019-10-12 23:10:34.000000000') Exemplo de resultado: `10` |
| month(timestamp), month(date), month(interval year to month) | bigint | SELECT month('2019-10-12 23:10:34.000000000') Exemplo de resultado: `10` |
| nanosecond(timestamp), nanosecond(time), nanosecond(interval day to second) | bigint | SELECT nanosecond(current_timestamp)
Exemplo de resultado: `162000000` |
| quarter(timestamp), quarter(date) | bigint | SELECT quarter('2019-10-12 23:10:34.000000000') Exemplo de resultado: `4` |
| second(timestamp), second(time), second(interval day to second) | bigint | SELECT second('2019-10-12 23:10:34.000000000') Exemplo de resultado: `34` |
| week(timestamp), week(date) | bigint | SELECT week('2019-10-12 23:10:34.000000000') Exemplo de resultado: `41` |
| week\$1of\$1year(timestamp), week\$1of\$1year(date) | bigint | Alias para semana |
| year(timestamp), year(date), year(interval year to month) | bigint | SELECT year('2019-10-12 23:10:34.000000000') Exemplo de resultado: `2019` |
| year\$1of\$1week(timestamp), year\$1of\$1week(date) | bigint | SELECT year_of_week('2019-10-12 23:10:34.000000000') Exemplo de resultado: `2019` |
| yow(timestamp), yow(date) | bigint | Alias para year\$1of\$1week |
# Funções agregadas
O Timestream for LiveAnalytics suporta as seguintes funções agregadas.
| Função | Tipo de dados de saída | Description |
| --- | --- | --- |
| arbitrary(x) | [o mesmo que a entrada] | Retorna um valor arbitrário não nulo de x, se existir. SELECT arbitrary(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemplo de resultado: `1` |
| array\$1agg(x) | array<[same as input] | Retorna uma matriz criada a partir dos elementos de entrada x. SELECT array_agg(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemplo de resultado: `[ 1,2,3,4 ]` |
| avg(x) | double | Retorna a média (média aritmética) dos valores de expressão de entrada. SELECT avg(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemplo de resultado: `2.5` |
| bool\$1and(boolean) every(boolean) | booleano | Retorna TRUE se cada valor de entrada for TRUE, caso contrário, retorna FALSE. SELECT bool_and(t.c) FROM (VALUES true, true, false, true) AS t(c)
Exemplo de resultado: `false` |
| bool\$1or(boolean) | booleano | Retorna TRUE se qualquer valor de entrada for TRUE, caso contrário, retorna FALSE. SELECT bool_or(t.c) FROM (VALUES true, true, false, true) AS t(c)
Exemplo de resultado: `true` |
| count(\$1) count(x) | bigint | count(\$1) retorna o número de linhas de entrada. count(x) retorna o número de valores de entrada não nulos. SELECT count(t.c) FROM (VALUES true, true, false, true) AS t(c)
Exemplo de resultado: `4` |
| count\$1if(x) | bigint | Retorna o número de valores de entrada TRUE. SELECT count_if(t.c) FROM (VALUES true, true, false, true) AS t(c)
Exemplo de resultado: `3` |
| geometric\$1mean(x) | double | Retorna a média geométrica de todos os valores de entrada. SELECT geometric_mean(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemplo de resultado: `2.213363839400643` |
| max\$1by(x, y) | [igual a x] | Retorna o valor de x associado ao valor máximo de y em todos os valores de entrada. SELECT max_by(t.c1, t.c2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Exemplo de resultado: `d` |
| max\$1by(x, y, n) | array<[igual a x]> | Retorna n valores de x associados ao n maior de todos os valores de entrada de y em ordem decrescente de y. SELECT max_by(t.c1, t.c2, 2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Exemplo de resultado: `[ d,c ]` |
| min\$1by(x, y) | [igual a x] | Retorna o valor de x associado ao valor mínimo de y em todos os valores de entrada. SELECT min_by(t.c1, t.c2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Exemplo de resultado: `a` |
| min\$1by(x, y, n) | array<[igual a x]> | Retorna n valores de x associados ao menor de todos os valores de entrada de y em ordem crescente de y. SELECT min_by(t.c1, t.c2, 2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Exemplo de resultado: `[ a,b ]` |
| max(x) | [o mesmo que a entrada] | Retorna o valor máximo de todos os valores de entrada. SELECT max(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemplo de resultado: `4` |
| max(x, n) | array<[igual a x]> | Retorna n maiores valores de todos os valores de entrada de x. SELECT max(t.c, 2) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemplo de resultado: `[ 4,3 ]` |
| min(x) | [o mesmo que a entrada] | Retorna o valor mínimo de todos os valores de entrada. SELECT min(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemplo de resultado: `1` |
| min(x, n) | array<[igual a x]> | Retorna n menores valores de todos os valores de entrada de x. SELECT min(t.c, 2) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemplo de resultado: `[ 1,2 ]` |
| sum(x) | [o mesmo que a entrada] | Retorna a soma de todos os valores de entrada. SELECT sum(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemplo de resultado: `10` |
| bitwise\$1and\$1agg(x) | bigint | Retorna o AND bitwise de todos os valores de entrada na representação do complemento 2 s. SELECT bitwise_and_agg(t.c) FROM (VALUES 1, -3) AS t(c)
Exemplo de resultado: `1` |
| bitwise\$1or\$1agg(x) | bigint | Retorna o OR bitwise de todos os valores de entrada na representação do complemento 2 s. SELECT bitwise_or_agg(t.c) FROM (VALUES 1, -3) AS t(c)
Exemplo de resultado: `-3` |
| approx\$1distinct(x) | bigint | Retorna o número aproximado de valores de entrada distintos. Essa função fornece uma aproximação de count(DISTINCT x). O valor retornado será Zero se todos os valores de entrada forem nulos. Essa função deve produzir um erro padrão de 2,3%, que é o desvio padrão da distribuição de erro (aproximadamente normal) em todos os conjuntos possíveis. Isso não garante um limite superior para o erro para nenhum conjunto de entrada específico. SELECT approx_distinct(t.c) FROM (VALUES 1, 2, 3, 4, 8) AS t(c)
Exemplo de resultado: `5` |
| approx\$1distinct(x, e) | bigint | Retorna o número aproximado de valores de entrada distintos. Essa função fornece uma aproximação de count(DISTINCT x). O valor retornado será Zero se todos os valores de entrada forem nulos. Essa função deve produzir um erro padrão de não mais que e, que é o desvio padrão da distribuição de erro (aproximadamente normal) em todos os conjuntos possíveis. Isso não garante um limite superior para o erro para nenhum conjunto de entrada específico. A implementação atual dessa função exige que e esteja na faixa de [0,0040625, 0,26000]. SELECT approx_distinct(t.c, 0.2) FROM (VALUES 1, 2, 3, 4, 8) AS t(c)
Exemplo de resultado: `5` |
| approx\$1percentile(x, percentage) | [igual a x] | Retorna o percentil aproximado para todos os valores de entrada de x na porcentagem dada. O valor da porcentagem deve estar entre zero e um e deve ser constante para todas as linhas de entrada. SELECT approx_percentile(t.c, 0.4) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemplo de resultado: `2` |
| approx\$1percentile(x, percentages) | array<[igual a x]> | Retorna o percentil aproximado para todos os valores de entrada de x em cada uma das porcentagens especificadas. Cada elemento da matriz de porcentagens deve estar entre zero e um, e a matriz deve ser constante para todas as linhas de entrada. SELECT approx_percentile(t.c, ARRAY[0.1, 0.8, 0.8]) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemplo de resultado: `[ 1,4,4 ]` |
| approx\$1percentile(x, w, percentage) | [igual a x] | Retorna o percentil ponderado aproximado para todos os valores de entrada de x usando o peso por item w na porcentagem p. O peso deve ser um valor inteiro de pelo menos um. É efetivamente uma contagem de replicação para o valor x no conjunto de percentis. O valor de p deve estar entre zero e um e deve ser constante para todas as linhas de entrada. SELECT approx_percentile(t.c, 1, 0.1) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemplo de resultado: `1` |
| approx\$1percentile(x, w, percentages) | array<[igual a x]> | Retorna o percentil ponderado aproximado para todos os valores de entrada de x usando o peso por item w em cada uma das porcentagens especificadas na matriz. O peso deve ser um valor inteiro de pelo menos um. É efetivamente uma contagem de replicação para o valor x no conjunto de percentis. Cada elemento da matriz deve estar entre zero e um, e a matriz deve ser constante para todas as linhas de entrada. SELECT approx_percentile(t.c, 1, ARRAY[0.1, 0.8, 0.8]) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemplo de resultado: `[ 1,4,4 ]` |
| approx\$1percentile(x, w, percentage, accuracy) | [igual a x] | Retorna o percentil ponderado aproximado para todos os valores de entrada de x usando o peso por item w na porcentagem p, com um erro máximo de classificação de precisão. O peso deve ser um valor inteiro de pelo menos um. É efetivamente uma contagem de replicação para o valor x no conjunto de percentis. O valor de p deve estar entre zero e um e deve ser constante para todas as linhas de entrada. A precisão deve ser um valor maior que zero e menor que um, e deve ser constante para todas as linhas de entrada. SELECT approx_percentile(t.c, 1, 0.1, 0.5) FROM (VALUES 1, 2, 3, 4) AS t(c)
Exemplo de resultado: `1` |
| corr(y, x) | double | Retorna o coeficiente de correlação dos valores de entrada. SELECT corr(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Exemplo de resultado: `1.0` |
| covar\$1pop(y, x) | double | Retorna a covariância populacional dos valores de entrada. SELECT covar_pop(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Exemplo de resultado: `1.25` |
| covar\$1samp(y, x) | double | Retorna a covariância da amostra dos valores de entrada. SELECT covar_samp(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Exemplo de resultado: `1.6666666666666667` |
| regr\$1intercept(y, x) | double | Retorna a interceptação de regressão linear dos valores de entrada. y é o valor dependente e x é o valor independente. SELECT regr_intercept(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Exemplo de resultado: `0.0` |
| regr\$1slope(y, x) | double | Retorna a inclinação da regressão linear dos valores de entrada. y é o valor dependente e x é o valor independente. SELECT regr_slope(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Exemplo de resultado: `1.0` |
| skewness(x) | double | Retorna a distorção de todos os valores de entrada. SELECT skewness(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Exemplo de resultado: `0.8978957037987335` |
| stddev\$1pop(x) | double | Retorna o desvio padrão da população de todos os valores de entrada. SELECT stddev_pop(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Exemplo de resultado: `2.4166091947189146` |
| stddev\$1samp(x) stddev(x) | double | Retorna o desvio padrão da amostra de todos os valores de entrada. SELECT stddev_samp(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Exemplo de resultado: `2.701851217221259` |
| var\$1pop(x) | double | Retorna a variância populacional de todos os valores de entrada. SELECT var_pop(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Exemplo de resultado: `5.840000000000001` |
| var\$1samp(x) variance(x) | double | Retorna a variância da amostra de todos os valores de entrada. SELECT var_samp(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Exemplo de resultado: `7.300000000000001` |
# Funções de janela
As funções de janela realizam cálculos em todas as linhas do resultado da consulta. Elas são executadas após a cláusula HAVING, mas antes da cláusula ORDER BY. A invocação de uma função de janela requer uma sintaxe especial usando a cláusula OVER para especificar a janela. Uma janela tem três componentes:
+ A especificação da partição, que separa as linhas de entrada em partições diferentes. Isso é análogo à forma como a cláusula GROUP BY separa as linhas em grupos diferentes para funções agregadas.
+ A especificação de ordenação, que determina a ordem na qual as linhas de entrada serão processadas pela função de janela.
+ A estrutura da janela, que especifica uma janela deslizante de linhas a serem processadas pela função para uma determinada linha. Se a estrutura não for especificada, o padrão será RANGE UNBOUNDED PRECEDING, que é o mesmo que RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW. Essa estrutura contém todas as linhas do início da partição até o último par da linha atual.
Todas as funções agregadas podem ser usadas como funções de janela adicionando a cláusula OVER. A função agregada é calculada para cada linha sobre as linhas dentro da moldura da janela da linha atual. Além das funções agregadas, o Timestream for LiveAnalytics suporta as seguintes funções de classificação e valor.
| Função | Tipo de dados de saída | Description |
| --- | --- | --- |
| cume\$1dist() | bigint | Retorna a distribuição cumulativa de um valor em um grupo de valores. O resultado é o número de linhas anteriores ou iguais à linha na ordem da janela da partição da janela dividido pelo número total de linhas na partição da janela. Assim, qualquer valor de empate na ordem será avaliado como o mesmo valor de distribuição. |
| dense\$1rank() | bigint | Retorna a classificação de um valor em um grupo de valores. É semelhante a rank(), exceto que os valores de empate não produzem lacunas na sequência. |
| ntile(n) | bigint | Divide as linhas de cada partição de janela em n compartimentos que variam de 1 a, no máximo, n. Os valores do bucket serão diferentes em, no máximo, 1. Se o número de linhas na partição não se dividir uniformemente no número de buckets, os valores restantes serão distribuídos um por bucket, começando pelo primeiro bucket. |
| percent\$1rank() | double | Retorna a classificação percentual de um valor em um grupo de valores. O resultado é (r - 1)/(n - 1) onde r é o rank() da linha e n é o número total de linhas na partição da janela. |
| rank() | bigint | Retorna a classificação de um valor em um grupo de valores. A classificação é um mais o número de linhas anteriores à linha que não são iguais à linha. Assim, valores de empate na ordenação produzirão lacunas na sequência. A classificação é executada para cada partição da janela. |
| row\$1number() | bigint | Retorna um número sequencial exclusivo para cada linha, começando com um, de acordo com a ordem das linhas na partição da janela. |
| first\$1value(x) | [o mesmo que a entrada] | Retorna o primeiro valor da janela. Essa função tem como escopo a moldura da janela. A função usa uma expressão ou destino como parâmetro. |
| last\$1value(x) | [o mesmo que a entrada] | Retorna o último valor da janela. Essa função tem como escopo a moldura da janela. A função usa uma expressão ou destino como parâmetro. |
| nth\$1value(x, offset) | [o mesmo que a entrada] | Retorna o valor na compensação especificada no início da janela. As compensações começam em 1. A compensação pode ser qualquer expressão escalar. Se a compensação for nula ou maior que o número de valores na janela, será retornado nulo. O deslocamento zero ou negativo é um erro. A função usa uma expressão ou destino como seu primeiro parâmetro. |
| lead(x[, offset[, default\$1value]]) | [o mesmo que a entrada] | Retorna o valor nas linhas de deslocamento após a linha atual na janela. As compensações começam em 0, que é a linha atual. A compensação pode ser qualquer expressão escalar. A compensação padrão é 1.. Se o deslocamento for nulo ou maior que a janela, o valor\$1default\$1value será retornado ou, se não for especificado, null será retornado. A função usa uma expressão ou destino como seu primeiro parâmetro. |
| lag(x[, offset[, default\$1value]]) | [o mesmo que a entrada] | Retorna o valor nas linhas de deslocamento antes da linha atual na janela. As compensações começam em 0, que é a linha atual. A compensação pode ser qualquer expressão escalar. A compensação padrão é 1.. Se o deslocamento for nulo ou maior que a janela, o valor\$1default\$1value será retornado ou, se não for especificado, null será retornado. A função usa uma expressão ou destino como seu primeiro parâmetro. |
# Exemplos de consultas
Esta seção inclui exemplos de casos de uso da linguagem de consulta LiveAnalytics do Timestream for.
**Topics**
+ [
# Consultas simples
](sample-queries.basic-scenarios.md)
+ [
# Consultas com funções de série temporal
](sample-queries.devops-scenarios.md)
+ [
# Consultas com funções agregadas
](sample-queries.iot-scenarios.md)
# Consultas simples
O seguinte retorna os 10 pontos de dados adicionados mais recentemente a uma tabela.
```
SELECT * FROM .
ORDER BY time DESC
LIMIT 10
```
O seguinte retorna os 5 pontos de dados mais antigos de uma medida específica.
```
SELECT * FROM .
WHERE measure_name = ''
ORDER BY time ASC
LIMIT 5
```
O seguinte funciona com registro de data e horas de granularidade de nanossegundos.
```
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
```
Os valores de medida para registros de várias medidas são identificados pelo nome da coluna. Os valores de medida para registros de medida única são identificados por `measure_value::`, onde `` é um dentre `double`, `bigint`, `boolean` ou `varchar` conforme descrito em [Tipos de dados compatíveis](supported-data-types.md). Para obter mais informações sobre como os valores de medida são modelados, consulte [Tabela única versus várias tabelas](https://docs.aws.amazon.com/timestream/latest/developerguide/data-modeling.html#data-modeling-multiVsinglerecords).
O seguinte recupera valores de uma medida chamada `speed` de registros de várias medidas com um `measure_name` de `IoTMulti-stats`.
```
SELECT speed FROM . where measure_name = 'IoTMulti-stats'
```
O seguinte recupera valores `double` de registros de medida única com um `measure_name` de `load`.
```
SELECT measure_value::double FROM . WHERE measure_name = 'load'
```
# Consultas com funções de série temporal
**Topics**
+ [
## Exemplo de conjunto de dados e consultas
](#sample-queries.devops-scenarios.example)
## Exemplo de conjunto de dados e consultas
Você pode usar o Timestream LiveAnalytics para entender e melhorar o desempenho e a disponibilidade de seus serviços e aplicativos. Abaixo está um exemplo de tabela e exemplos de consultas executadas nessa tabela.
A tabela `ec2_metrics` armazena dados de telemetria, como utilização da CPU e outras métricas das instâncias do EC2. Você pode ver a tabela abaixo.
| Hora | 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 | nulo |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1a | frontend01 | memory\$1utilization | 5.3 | nulo |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1a | frontend01 | network\$1bytes\$1in | nulo | 1.500 |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1a | frontend01 | network\$1bytes\$1out | nulo | 6.700 |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1b | frontend02 | cpu\$1utilization | 38,5 | nulo |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1b | frontend02 | memory\$1utilization | 58,4 | nulo |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1b | frontend02 | network\$1bytes\$1in | nulo | 23.000 |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1b | frontend02 | network\$1bytes\$1out | nulo | 12.000 |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1c | frontend03 | cpu\$1utilization | 45.0 | nulo |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1c | frontend03 | memory\$1utilization | 65,8 | nulo |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1c | frontend03 | network\$1bytes\$1in | nulo | 15.000 |
| 2019-12-04 19:00:00.000000000 | us-east-1 | us-east-1c | frontend03 | network\$1bytes\$1out | nulo | 836.000 |
| 2019-12-04 19:00:05.000000000 | us-east-1 | us-east-1a | frontend01 | cpu\$1utilization | 5.2 | nulo |
| 2019-12-04 19:00:05.000000000 | us-east-1 | us-east-1a | frontend01 | memory\$1utilization | 75.0 | nulo |
| 2019-12-04 19:00:05.000000000 | us-east-1 | us-east-1a | frontend01 | network\$1bytes\$1in | nulo | 1.245 |
| 2019-12-04 19:00:05.000000000 | us-east-1 | us-east-1a | frontend01 | network\$1bytes\$1out | nulo | 68.432 |
| 2019-12-04 19:00:08.000000000 | us-east-1 | us-east-1b | frontend02 | cpu\$1utilization | 65,6 | nulo |
| 2019-12-04 19:00:08.000000000 | us-east-1 | us-east-1b | frontend02 | memory\$1utilization | 85,3 | nulo |
| 2019-12-04 19:00:08.000000000 | us-east-1 | us-east-1b | frontend02 | network\$1bytes\$1in | nulo | 1.245 |
| 2019-12-04 19:00:08.000000000 | us-east-1 | us-east-1b | frontend02 | network\$1bytes\$1out | nulo | 68.432 |
| 2019-12-04 19:00:20.000000000 | us-east-1 | us-east-1c | frontend03 | cpu\$1utilization | 12.1 | nulo |
| 2019-12-04 19:00:20.000000000 | us-east-1 | us-east-1c | frontend03 | memory\$1utilization | 32,0 | nulo |
| 2019-12-04 19:00:20.000000000 | us-east-1 | us-east-1c | frontend03 | network\$1bytes\$1in | nulo | 1.400 |
| 2019-12-04 19:00:20.000000000 | us-east-1 | us-east-1c | frontend03 | network\$1bytes\$1out | nulo | 345 |
| 2019-12-04 19:00:10.000000000 | us-east-1 | us-east-1a | frontend01 | cpu\$1utilization | 15.3 | nulo |
| 2019-12-04 19:00:10.000000000 | us-east-1 | us-east-1a | frontend01 | memory\$1utilization | 35,4 | nulo |
| 2019-12-04 19:00:10.000000000 | us-east-1 | us-east-1a | frontend01 | network\$1bytes\$1in | nulo | 23 |
| 2019-12-04 19:00:10.000000000 | us-east-1 | us-east-1a | frontend01 | network\$1bytes\$1out | nulo | 0 |
| 2019-12-04 19:00:16.000000000 | us-east-1 | us-east-1b | frontend02 | cpu\$1utilization | 44.0 | nulo |
| 2019-12-04 19:00:16.000000000 | us-east-1 | us-east-1b | frontend02 | memory\$1utilization | 64.2 | nulo |
| 2019-12-04 19:00:16.000000000 | us-east-1 | us-east-1b | frontend02 | network\$1bytes\$1in | nulo | 1.450 |
| 2019-12-04 19:00:16.000000000 | us-east-1 | us-east-1b | frontend02 | network\$1bytes\$1out | nulo | 200 |
| 2019-12-04 19:00:40.000000000 | us-east-1 | us-east-1c | frontend03 | cpu\$1utilization | 6.4 | nulo |
| 2019-12-04 19:00:40.000000000 | us-east-1 | us-east-1c | frontend03 | memory\$1utilization | 86,3 | nulo |
| 2019-12-04 19:00:40.000000000 | us-east-1 | us-east-1c | frontend03 | network\$1bytes\$1in | nulo | 300 |
| 2019-12-04 19:00:40.000000000 | us-east-1 | us-east-1c | frontend03 | network\$1bytes\$1out | nulo | 423 |
Encontrar a utilização média de CPU p90, p95 e p99 para um host EC2 específico nas ú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 hosts EC2 com utilização de CPU maior em 10% ou mais em comparação com a utilização média de CPU de toda a frota nas ú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
```
Encontrar a utilização média da CPU armazenada em intervalos de 30 segundos para um host EC2 específico nas ú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
```
Encontre a utilização média da CPU armazenada em intervalos de 30 segundos para um host EC2 específico nas últimas 2 horas, preenchendo os valores ausentes usando a interpolação linear:
```
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)
```
Encontre a utilização média da CPU armazenada em intervalos de 30 segundos para um host EC2 específico nas últimas 2 horas, preenchendo os valores ausentes usando a interpolação com base na última observação realizada:
```
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 com funções agregadas
Abaixo está um exemplo de conjunto de dados em cenário IoT para ilustrar consultas com funções agregadas.
**Topics**
+ [
## Exemplo de dados
](#sample-queries.iot-scenarios.example-data)
+ [
## Consultas de exemplo
](#sample-queries.iot-scenarios.example-queries)
## Exemplo de dados
O Timestream permite que você armazene e analise dados de sensores de IoT, como localização, consumo de combustível, velocidade e capacidade de carga de uma ou mais frotas de caminhões para permitir o gerenciamento eficaz da frota. Abaixo está o esquema e alguns dos dados de uma tabela iot\$1trucks que armazena telemetria, como localização, consumo de combustível, velocidade e capacidade de carga dos caminhões.
| Hora | truck\$1id | Make | Modelo | Frota | 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 | nulo |
| 2019-12-04 19:00:00.000000000 | 123456781 | GMC | Astro | Alpha | 100 | 500 | balanceamento | 400,0 | nulo |
| 2019-12-04 19:00:00.000000000 | 123456781 | GMC | Astro | Alpha | 100 | 500 | velocidade | 90,2 | nulo |
| 2019-12-04 19:00:00.000000000 | 123456781 | GMC | Astro | Alpha | 100 | 500 | location | nulo | 47.6062 N, 122.3321 W |
| 2019-12-04 19:00:00.000000000 | 123456782 | Kenworth | W900 | Alpha | 150 | 1000 | fuel\$1reading | 10.1 | nulo |
| 2019-12-04 19:00:00.000000000 | 123456782 | Kenworth | W900 | Alpha | 150 | 1000 | balanceamento | 950,3 | nulo |
| 2019-12-04 19:00:00.000000000 | 123456782 | Kenworth | W900 | Alpha | 150 | 1000 | velocidade | 50,8 | nulo |
| 2019-12-04 19:00:00.000000000 | 123456782 | Kenworth | W900 | Alpha | 150 | 1000 | location | nulo | 40,7128 graus N, 74,0060 graus W |
## Consultas de exemplo
Obtenha uma lista de todos os atributos e valores dos sensores que estão sendo monitorados para cada caminhão da frota.
```
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
```
Obtenha a leitura de combustível mais recente de cada caminhão da frota nas ú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 caminhões que estão com pouco combustível (menos de 10%) nas ú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
)
```
Encontre a carga média e a velocidade máxima de cada caminhão na ú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
```
Obtenha a eficiência de carga de cada caminhão na última semana:
```
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
```