', default: (\)
```
Quando si esportano i dati in formato CSV, questo campo specifica il carattere che deve essere trattato come carattere di escape nel file di dati scritto nel bucket S3. L'escape avviene nei seguenti scenari:
1. Se il valore stesso contiene il carattere di virgoletta («), verrà eliminato utilizzando un carattere di escape. Ad esempio, se il valore è`Time"stream`, dove (\$1) è il carattere di escape configurato, allora verrà escluso come. `Time\"stream`
1. Se il valore contiene il carattere di escape configurato, verrà eliminato. Ad esempio, se il valore è`Time\stream`, allora verrà scappato come. `Time\\stream`
Se l'output esportato contiene tipi di dati complessi come Arrays, Rows o Timeseries, verrà serializzato come stringa JSON. Di seguito è riportato un esempio.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/timestream/latest/developerguide/supported-sql-constructs.UNLOAD.html)
INCLUDE\$1HEADER
```
include_header = 'true' , default: 'false'
```
Quando si esportano i dati in formato CSV, questo campo consente di includere i nomi delle colonne come prima riga dei file di dati CSV esportati.
I valori accettati sono «true» e «false» e il valore predefinito è «false». Le opzioni di trasformazione del testo come `escaped_by` e `field_delimiter` si applicano anche alle intestazioni.
Quando si includono le intestazioni, è importante non selezionare un carattere di ritorno (ASCII 13, hex 0D, testo '\$1 r') o un carattere di interruzione di riga (ASCII 10, hex 0A, text'\$1n') come carattere`FIELD_DELIMITER`, poiché ciò impedirà a molti parser di analizzare correttamente le intestazioni nell'output CSV risultante.
MAX\$1FILE\$1SIZE
```
max_file_size = 'X[MB|GB]' , default: '78GB'
```
Questo campo specifica la dimensione massima dei file che l'`UNLOAD`istruzione crea in Amazon S3. L'`UNLOAD`istruzione può creare più file, ma la dimensione massima di ogni file scritto in Amazon S3 sarà approssimativamente quella specificata in questo campo.
Il valore del campo deve essere compreso tra 16 MB e 78 GB, inclusi. È possibile specificarlo in numeri interi come `12GB` o in decimali come o. `0.5GB` `24.7MB` Il valore predefinito è 78 GB.
La dimensione effettiva del file è approssimativa al momento della scrittura del file, pertanto la dimensione massima effettiva potrebbe non essere esattamente uguale al numero specificato.
# Operatori logici
Timestream for LiveAnalytics supporta i seguenti operatori logici.
| Operatore | Description | Esempio |
| --- | --- | --- |
| AND | Vero se entrambi i valori sono veri | a E b |
| O | Vero se uno dei due valori è vero | a OPPURE b |
| NOT | Vero se il valore è falso | NON un |
+ Il risultato di un `AND` confronto può essere `NULL` se uno o entrambi i lati dell'espressione lo sono`NULL`.
+ Se almeno un lato di un `AND` operatore è, `FALSE` l'espressione restituisce. `FALSE`
+ Il risultato di un `OR` confronto può essere `NULL` se uno o entrambi i lati dell'espressione lo sono`NULL`.
+ Se almeno un lato di un `OR` operatore è, `TRUE` l'espressione restituisce. `TRUE`
+ Il complemento logico di `NULL` is`NULL`.
La seguente tabella di verità mostra la gestione di `NULL` in `AND` e`OR`:
| A | B | A e b | A o b |
| --- | --- | --- | --- |
| null | null | null | 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 seguente tabella di verità mostra la gestione di NULL in NOT:
| A | Non un |
| --- | --- |
| null | null |
| true | false |
| false | true |
# Operatori di confronto
Timestream for LiveAnalytics supporta i seguenti operatori di confronto.
| Operatore | Description |
| --- | --- |
| < | Minore di |
| > | Maggiore di |
| <= | Minore o uguale a |
| >= | Maggiore o uguale a |
| = | Uguale |
| <> | Non uguale |
| \$1= | Non uguale |
**Nota**
L'`BETWEEN`operatore verifica se un valore rientra in un intervallo specificato. La sintassi è esposta di seguito:
```
BETWEEN min AND max
```
La presenza di `NULL` in un'`NOT BETWEEN`istruzione `BETWEEN` or comporterà la valutazione di`NULL`.
`IS NULL `e `IS NOT NULL` gli operatori verificano se un valore è nullo (non definito). L'utilizzo di `NULL` with `IS NULL` restituisce vero.
In SQL, un `NULL` valore indica un valore sconosciuto.
# Funzioni di confronto
Timestream for LiveAnalytics supporta le seguenti funzioni di confronto.
**Topics**
+ [più grande ()](comparison-functions.greatest.md)
+ [almeno ()](comparison-functions.least.md)
+ [ALL (), ANY () e SOME ()](comparison-functions.all-any-some.md)
# più grande ()
La funzione **greatest ()** restituisce il più grande dei valori forniti. Restituisce `NULL` se uno qualsiasi dei valori forniti lo è`NULL`. La sintassi è esposta di seguito.
```
greatest(value1, value2, ..., valueN)
```
# almeno ()
La funzione **least ()** restituisce il più piccolo dei valori forniti. Restituisce `NULL` se uno qualsiasi dei valori forniti lo è`NULL`. La sintassi è esposta di seguito.
```
least(value1, value2, ..., valueN)
```
# ALL (), ANY () e SOME ()
I `SOME` quantificatori`ALL`, `ANY` e possono essere utilizzati insieme agli operatori di confronto nel modo seguente.
| Expression | Significato |
| --- | --- |
| A = TUTTI (...) | Restituisce vero quando A è uguale a tutti i valori. |
| A <> ALL (...) | Restituisce vero quando A non corrisponde a nessun valore. |
| A < TUTTI (...) | Restituisce vero quando A è inferiore al valore più piccolo. |
| A = QUALSIASI (...) | Restituisce vero quando A è uguale a uno qualsiasi dei valori. |
| A <> QUALSIASI (...) | Restituisce vero quando A non corrisponde a uno o più valori. |
| A < QUALSIASI (...) | Restituisce vero quando A è inferiore al valore più grande. |
## Esempi e note di utilizzo
**Nota**
Quando si utilizza `ANY` o `ALL``SOME`, la parola chiave `VALUES` deve essere utilizzata se i valori di confronto sono un elenco di valori letterali.
## Ad esempio: `ANY()`
Di seguito è riportato un esempio di istruzione `ANY()` in una query.
```
SELECT 11.7 = ANY (VALUES 12.0, 13.5, 11.7)
```
Di seguito è riportata una sintassi alternativa per la stessa operazione.
```
SELECT 11.7 = ANY (SELECT 12.0 UNION ALL SELECT 13.5 UNION ALL SELECT 11.7)
```
In questo caso, `ANY()` restituisce. `True`
## Ad esempio: `ALL()`
Di seguito è riportato un esempio di istruzione `ALL()` in una query.
```
SELECT 17 < ALL (VALUES 19, 20, 15);
```
Di seguito è riportata una sintassi alternativa per la stessa operazione.
```
SELECT 17 < ALL (SELECT 19 UNION ALL SELECT 20 UNION ALL SELECT 15);
```
In questo caso, `ALL()` restituisce. `False`
## Ad esempio: `SOME()`
Di seguito è riportato un esempio di istruzione `SOME()` in una query.
```
SELECT 50 >= SOME (VALUES 53, 77, 27);
```
Di seguito è riportata una sintassi alternativa per la stessa operazione.
```
SELECT 50 >= SOME (SELECT 53 UNION ALL SELECT 77 UNION ALL SELECT 27);
```
In questo caso, `SOME()` restituisce. `True`
# Espressioni condizionali
Timestream for LiveAnalytics supporta le seguenti espressioni condizionali.
**Topics**
+ [L'istruzione CASE](conditional-expressions.CASE.md)
+ [L'istruzione IF](conditional-expressions.IF.md)
+ [La dichiarazione COALESCE](conditional-expressions.COALESCE.md)
+ [L'istruzione NULLIF](conditional-expressions.NULLIF.md)
+ [L'istruzione TRY](conditional-expressions.TRY.md)
# L'istruzione CASE
L'istruzione **CASE** cerca ogni espressione di valore da sinistra a destra finché non ne trova una uguale`expression`. Se trova una corrispondenza, viene restituito il risultato per il valore corrispondente. Se non viene trovata alcuna corrispondenza, viene restituito il risultato della `ELSE` clausola se esiste; in caso contrario `null` viene restituito. La sintassi è esposta di seguito:
```
CASE expression
WHEN value THEN result
[ WHEN ... ]
[ ELSE result ]
END
```
**Timestream supporta anche la seguente sintassi per le istruzioni CASE.** In questa sintassi, il modulo «cercato» valuta ogni condizione booleana da sinistra a destra finché non ne è presente una e restituisce il risultato corrispondente. `true` Se non ci sono condizioni`true`, viene restituito il risultato della `ELSE` clausola se esiste; in caso contrario viene restituito. `null` Vedi sotto per la sintassi alternativa:
```
CASE
WHEN condition THEN result
[ WHEN ... ]
[ ELSE result ]
END
```
# L'istruzione IF
L'istruzione **IF** valuta una condizione come vera o falsa e restituisce il valore appropriato. **Timestream supporta le seguenti due rappresentazioni sintattiche per IF:**
```
if(condition, true_value)
```
Questa sintassi valuta e restituisce `true_value` se la condizione è`true`; altrimenti viene restituita e non viene `null` valutata. `true_value`
```
if(condition, true_value, false_value)
```
Questa sintassi valuta e restituisce `true_value` se la condizione è`true`, altrimenti valuta e restituisce. `false_value`
## Esempi
```
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 dichiarazione COALESCE
**COALESCE** restituisce il primo valore non nullo in un elenco di argomenti. La sintassi è esposta di seguito:
```
coalesce(value1, value2[,...])
```
# L'istruzione NULLIF
L'istruzione **IF** valuta una condizione come vera o falsa e restituisce il valore appropriato. **Timestream supporta le seguenti due rappresentazioni sintattiche per IF:**
**NULLIF restituisce null se** è uguale; altrimenti restituisce. `value1` `value2` `value1` La sintassi è esposta di seguito:
```
nullif(value1, value2)
```
# L'istruzione TRY
La funzione **TRY** valuta un'espressione e gestisce determinati tipi di errori `null` restituendoli. La sintassi è esposta di seguito:
```
try(expression)
```
# Funzioni di conversione
Timestream for LiveAnalytics supporta le seguenti funzioni di conversione.
**Topics**
+ [cast()](#conversion-functions.cast)
+ [try\$1cast ()](#conversion-functions.try-cast)
## cast()
La sintassi della funzione cast per trasmettere esplicitamente un valore come tipo è la seguente.
```
cast(value AS type)
```
## try\$1cast ()
Timestream for supporta LiveAnalytics anche la funzione try\$1cast che è simile a cast ma restituisce null se il cast fallisce. La sintassi è esposta di seguito.
```
try_cast(value AS type)
```
# Operatori matematici
Timestream for supporta i seguenti operatori matematici. LiveAnalytics
| Operatore | Description |
| --- | --- |
| \$1 | Addizione |
| - | Sottrazione |
| \$1 | Moltiplicazione |
| / | Divisione (la divisione di numeri interi esegue il troncamento) |
| % | Modulo (resto) |
# Funzioni matematiche
Timestream for LiveAnalytics supporta le seguenti funzioni matematiche.
| Funzione | Tipo di dati di output | Description |
| --- | --- | --- |
| abs (x) | [uguale all'input] | Restituisce il valore assoluto di x. |
| cbrt (x) | virgola mobile a doppia precisione | Restituisce la radice cubica di x. |
| soffitto (x) o soffitto (x) | [uguale all'input] | Restituisce x arrotondato al numero intero più vicino. |
| gradi (x) | virgola mobile a doppia precisione | Converte l'angolo x in radianti in gradi. |
| e () | virgola mobile a doppia precisione | Restituisce il numero costante di Eulero. |
| exp (x) | virgola mobile a doppia precisione | Restituisce il numero di Eulero elevato alla potenza di x. |
| pavimento (x) | [uguale all'input] | Restituisce x arrotondato per difetto al numero intero più vicino. |
| from\$1base (stringa, radice) | bigint | Restituisce il valore di una stringa interpretata come un numero di radice di base. |
| ln (x) | virgola mobile a doppia precisione | Restituisce il logaritmo naturale di x. |
| log2 (x) | virgola mobile a doppia precisione | Restituisce il logaritmo in base 2 di x. |
| log10 (x) | virgola mobile a doppia precisione | Restituisce il logaritmo in base 10 di x. |
| modalità (n, m) | [uguale all'input] | Restituisce il modulo (resto) di n diviso per m. |
| pi () | virgola mobile a doppia precisione | Restituisce la costante Pi. |
| pow (x, p) o power (x, p) | virgola mobile a doppia precisione | Restituisce x elevato alla potenza di p. |
| radianti (x) | virgola mobile a doppia precisione | Converte l'angolo x in gradi in radianti. |
| rand () o random () | virgola mobile a doppia precisione | Restituisce un valore pseudo-casuale nell'intervallo 0,0 1,0. |
| casuale (n) | [uguale all'input] | Restituisce un numero pseudo-casuale compreso tra 0 e n (esclusivo). |
| rotondo (x) | [uguale all'input] | Restituisce x arrotondato al numero intero più vicino. |
| rotondo (x, d) | [uguale all'input] | Restituisce x arrotondato a d cifre decimali. |
| segno (x) | [uguale all'input] | Restituisce la funzione signum di x, ovvero: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/timestream/latest/developerguide/mathematical-functions.html) Per argomenti doppi, la funzione restituisce inoltre: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/timestream/latest/developerguide/mathematical-functions.html) |
| sqrt (x) | virgola mobile a doppia precisione | Restituisce la radice quadrata di x. |
| to\$1base (x, radix) | varchar | Restituisce la rappresentazione della radice di base di x. |
| troncare (x) | virgola mobile a doppia precisione | Restituisce x arrotondato a un numero intero eliminando le cifre dopo il punto decimale. |
| tacos (x) | virgola mobile a doppia precisione | Restituisce l'arcoseno di x. |
| asino (x) | virgola mobile a doppia precisione | Restituisce l'arcoseno di x. |
| atan (x) | virgola mobile a doppia precisione | Restituisce l'arcotangente di x. |
| atan2 (y, x) | virgola mobile a doppia precisione | Restituisce l'arcotangente di y/x. |
| cos (x) | virgola mobile a doppia precisione | Restituisce il coseno di x. |
| cosh (x) | virgola mobile a doppia precisione | Restituisce il coseno iperbolico di x. |
| peccato (x) | virgola mobile a doppia precisione | Restituisce il seno di x. |
| tan (x) | virgola mobile a doppia precisione | Restituisce la tangente di x. |
| tanh (x) | virgola mobile a doppia precisione | Restituisce la tangente iperbolica di x. |
| infinito () | virgola mobile a doppia precisione | Restituisce la costante che rappresenta l'infinito positivo. |
| is\$1finite (x) | booleano | Determina se x è finito. |
| is\$1infinite (x) | booleano | Determina se x è infinito. |
| is\$1nan (x) | booleano | Determina se x è. not-a-number |
| nano () | virgola mobile a doppia precisione | Restituisce la costante che rappresenta not-a-number. |
# Operatori di stringa
Timestream for LiveAnalytics supporta l'`||`operatore per concatenare una o più stringhe.
# Funzioni stringa
**Nota**
Si presume che il tipo di dati di input di queste funzioni sia varchar, se non diversamente specificato.
| Funzione | Tipo di dati di output | Description |
| --- | --- | --- |
| chr (n) | varchar | Restituisce il punto di codice Unicode n come varchar. |
| codepoint (x) | intero | Restituisce il punto di codice Unicode dell'unico carattere di str. |
| concat (x1,..., xN) | varchar | Restituisce la concatenazione di x1, x2,..., xN. |
| hamming\$1distance (x1, x2) | bigint | Restituisce la distanza di Hamming di x1 e x2, ovvero il numero di posizioni in cui i caratteri corrispondenti sono diversi. Nota che i due input varchar devono avere la stessa lunghezza. |
| lunghezza (x) | bigint | Restituisce la lunghezza di x in caratteri. |
| levenshtein\$1distance (x1, x2) | bigint | Restituisce la distanza di modifica di Levenshtein di x1 e x2, ovvero il numero minimo di modifiche a carattere singolo (inserimenti, eliminazioni o sostituzioni) necessarie per cambiare x1 in x2. |
| inferiore (x) | varchar | Converte x in lettere minuscole. |
| carico (x1, grande dimensione, x2) | varchar | Pad sinistro x1 per ridimensionare i caratteri con x2. Se la dimensione è inferiore alla lunghezza di x1, il risultato viene troncato in caratteri di dimensione. la dimensione non deve essere negativa e x2 non deve essere vuota. |
| ltrim (x) | varchar | Rimuove gli spazi bianchi iniziali da x. |
| sostituisci (x1, x2) | varchar | Rimuove tutte le istanze di x2 da x1. |
| sostituisci (x1, x2, x3) | varchar | Sostituisce tutte le istanze di x2 con x3 in x1. |
| Inverso (x) | varchar | Restituisce x con i caratteri in ordine inverso. |
| rpad (x1, grande dimensione, x2) | varchar | Il tasto destro compatta x1 per ridimensionare i caratteri con x2. Se la dimensione è inferiore alla lunghezza di x1, il risultato viene troncato in caratteri di dimensione. la dimensione non deve essere negativa e x2 non deve essere vuota. |
| rtrim (x) | varchar | Rimuove gli spazi bianchi finali da x. |
| dividere (x1, x2) | array(varchar) | Divide x1 sul delimitatore x2 e restituisce un array. |
| split (x1, x2, limite bigint) | array(varchar) | Divide x1 sul delimitatore x2 e restituisce un array. L'ultimo elemento dell'array contiene sempre tutto ciò che rimane nel limite x1. Il limite deve essere un numero positivo. |
| split\$1part (x1, x2, bigint pos) | varchar | Divide x1 sul delimitatore x2 e restituisce il campo varchar in pos. Gli indici dei campi iniziano con 1. Se pos è maggiore del numero di campi, viene restituito null. |
| strpos (x1, x2) | bigint | Restituisce la posizione iniziale della prima istanza di x2 in x1. Le posizioni iniziano con 1. Se non viene trovato, viene restituito 0. |
| strpos (x1, x2, istanza bigint) | bigint | Restituisce la posizione dell'ennesima istanza di x2 in x1. L'istanza deve essere un numero positivo. Le posizioni iniziano con 1. Se non viene trovato, viene restituito 0. |
| strrpos (x1, x2) | bigint | Restituisce la posizione iniziale dell'ultima istanza di x2 in x1. Le posizioni iniziano con 1. Se non viene trovato, viene restituito 0. |
| strrpos (x1, x2, bigint instance) | bigint | Restituisce la posizione dell'ennesima istanza di x2 in x1 a partire dalla fine di x1. l'istanza deve essere un numero positivo. Le posizioni iniziano con 1. Se non viene trovato, viene restituito 0. |
| posizione (x2 IN x1) | bigint | Restituisce la posizione iniziale della prima istanza di x2 in x1. Le posizioni iniziano con 1. Se non viene trovato, viene restituito 0. |
| substr (x, bigint start) | varchar | Restituisce il resto di x dalla posizione iniziale di inizio. Le posizioni iniziano con 1. Una posizione iniziale negativa viene interpretata come relativa alla fine di x. |
| substr (x, bigint start, bigint len) | varchar | Restituisce una sottostringa da x di lunghezza len dalla posizione iniziale start. Le posizioni iniziano con 1. Una posizione iniziale negativa viene interpretata come relativa alla fine di x. |
| tagliare (x) | varchar | Rimuove gli spazi bianchi iniziali e finali da x. |
| superiore (x) | varchar | Converte x in maiuscolo. |
# Operatori di matrice
Timestream for LiveAnalytics supporta i seguenti operatori di array.
| Operatore | Description |
| --- | --- |
| [] | Accedi a un elemento di un array in cui il primo indice inizia da 1. |
| \$1\$1 | Concatena un array con un altro array o elemento dello stesso tipo. |
# Funzioni di array
Timestream for LiveAnalytics supporta le seguenti funzioni di array.
| Funzione | Tipo di dati di output | Description |
| --- | --- | --- |
| array\$1distinct (x) | array | Rimuove i valori duplicati dall'array x. SELECT array_distinct(ARRAY[1,2,2,3])
Risultato di esempio: `[ 1,2,3 ]` |
| array\$1intersect (x, y) | array | Restituisce un array degli elementi nell'intersezione di x e y, senza duplicati. SELECT array_intersect(ARRAY[1,2,3], ARRAY[3,4,5])
Risultato di esempio: `[ 3 ]` |
| array\$1union (x, y) | array | Restituisce un array degli elementi nell'unione di x e y, senza duplicati. SELECT array_union(ARRAY[1,2,3], ARRAY[3,4,5])
Risultato di esempio: `[ 1,2,3,4,5 ]` |
| array\$1except (x, y) | array | Restituisce una matrice di elementi in x ma non in y, senza duplicati. SELECT array_except(ARRAY[1,2,3], ARRAY[3,4,5])
Risultato di esempio: `[ 1,2 ]` |
| array\$1join (x, delimiter, null\$1replacement) | varchar | Concatena gli elementi dell'array specificato utilizzando il delimitatore e una stringa opzionale per sostituire i valori null. SELECT array_join(ARRAY[1,2,3], ';', '')
Risultato di esempio: `1;2;3` |
| array\$1max (x) | come gli elementi dell'array | Restituisce il valore massimo dell'array di input. SELECT array_max(ARRAY[1,2,3])
Risultato di esempio: `3` |
| array\$1min (x) | come gli elementi dell'array | Restituisce il valore minimo dell'array di input. SELECT array_min(ARRAY[1,2,3])
Risultato di esempio: `1` |
| array\$1position (x, element) | bigint | Restituisce la posizione della prima occorrenza dell'elemento nell'array x (o 0 se non viene trovata). SELECT array_position(ARRAY[3,4,5,9], 5)
Risultato di esempio: `3` |
| array\$1remove (x, element) | array | Rimuove tutti gli elementi che sono uguali all'elemento dall'array x. SELECT array_remove(ARRAY[3,4,5,9], 4)
Risultato di esempio: `[ 3,5,9 ]` |
| array\$1sort (x) | array | Ordina e restituisce l'array x. Gli elementi di x devono essere ordinabili. Gli elementi nulli verranno posizionati alla fine dell'array restituito. SELECT array_sort(ARRAY[6,8,2,9,3])
Risultato di esempio: `[ 2,3,6,8,9 ]` |
| arrays\$1overlap (x, y) | booleano | Verifica se gli array x e y hanno elementi non nulli in comune. Restituisce null se non ci sono elementi non nulli in comune ma entrambi gli array contengono null. SELECT arrays_overlap(ARRAY[6,8,2,9,3], ARRAY[6,8])
Risultato di esempio: `true` |
| cardinalità (x) | bigint | Restituisce la dimensione dell'array x. SELECT cardinality(ARRAY[6,8,2,9,3])
Risultato di esempio: `5` |
| concat (matrice1, matrice2,..., matriceN) | array | Concatena gli array array1, array2,..., arrayN. SELECT concat(ARRAY[6,8,2,9,3], ARRAY[11,32], ARRAY[6,8,2,0,14])
Risultato di esempio: `[ 6,8,2,9,3,11,32,6,8,2,0,14 ]` |
| element\$1at (array (E), indice) | E | Restituisce un elemento dell'array in un determinato indice. Se index < 0, element\$1at accede agli elementi dall'ultimo al primo. SELECT element_at(ARRAY[6,8,2,9,3], 1)
Risultato di esempio: `6` |
| repeat (elemento, conteggio) | array | Ripeti l'elemento per contare i tempi. SELECT repeat(1, 3)
Risultato di esempio: `[ 1,1,1 ]` |
| inversa (x) | array | Restituisce un array che ha l'ordine inverso dell'array x. SELECT reverse(ARRAY[6,8,2,9,3])
Risultato di esempio: `[ 3,9,2,8,6 ]` |
| sequenza (inizio, arresto) | matrice (bigint) | Genera una sequenza di numeri interi dall'inizio alla fine, incrementandola di 1 se start è minore o uguale a stop, altrimenti -1. SELECT sequence(3, 8)
Risultato di esempio: `[ 3,4,5,6,7,8 ]` |
| sequenza (inizio, arresto, fase) | matrice (bigint) | Genera una sequenza di numeri interi dall'inizio alla fine, incrementandola passo dopo passo. SELECT sequence(3, 15, 2)
Risultato di esempio: `[ 3,5,7,9,11,13,15 ]` |
| sequenza (inizio, arresto) | array (timestamp) | Genera una sequenza di timestamp dalla data di inizio alla data di fine, con un incremento di 1 giorno. SELECT sequence('2023-04-02 19:26:12.941000000', '2023-04-06 19:26:12.941000000', 1d) Risultato di esempio: `[ 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 ]` |
| sequenza (inizio, arresto, fase) | matrice (timestamp) | Genera una sequenza di timestamp dall'inizio alla fine, incrementandola passo dopo passo. Il tipo di dati del passaggio è intervallo. SELECT sequence('2023-04-02 19:26:12.941000000', '2023-04-10 19:26:12.941000000', 2d) Risultato di esempio: `[ 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 permutazione casuale dell'array dato x. SELECT shuffle(ARRAY[6,8,2,9,3])
Risultato di esempio: `[ 6,3,2,9,8 ]` |
| slice (x, start, length) | array | Array di sottoinsiemi x a partire dall'indice start (o dalla fine se start è negativo) con una lunghezza di lunghezza. SELECT slice(ARRAY[6,8,2,9,3], 1, 3)
Risultato di esempio: `[ 6,8,2 ]` |
| zip (array1, array2 [,...]) | matrice (riga) | Unisce gli array dati, per elemento, in un unico array di righe. Se gli argomenti hanno una lunghezza non uniforme, i valori mancanti vengono riempiti con NULL. SELECT zip(ARRAY[6,8,2,9,3], ARRAY[15,24])
Risultato di esempio: `[ ( 6, 15 ),( 8, 24 ),( 2, - ),( 9, - ),( 3, - ) ]` |
# Funzioni bit per bit
Timestream for LiveAnalytics supporta le seguenti funzioni bit per bit.
| Funzione | Tipo di dati di output | Description |
| --- | --- | --- |
| bit\$1count (bigint, bigint) | bigint (complemento a due) | Restituisce il conteggio dei bit nel primo parametro bigint dove il secondo parametro è un numero intero con segno di bit come 8 o 64. SELECT bit_count(19, 8)
Risultato di esempio: `3` SELECT bit_count(19, 2)
Risultato di esempio: `Number must be representable with the bits specified. 19 can not be represented with 2 bits` |
| bitwise\$1and (bigint, bigint) | bigint (complemento a due) | Restituisce l'AND bit per bit dei parametri bigint. SELECT bitwise_and(12, 7)
Risultato di esempio: `4` |
| bitwise\$1not (bigint) | bigint (complemento a due) | Restituisce il NOT bit per bit del parametro bigint. SELECT bitwise_not(12)
Risultato di esempio: `-13` |
| bitwise\$1or (bigint, bigint) | bigint (complemento a due) | Restituisce l'OR bit per bit dei parametri bigint. SELECT bitwise_or(12, 7)
Risultato di esempio: `15` |
| bitwise\$1xor (bigint, bigint) | bigint (complemento a due) | Restituisce lo XOR bit per bit dei parametri bigint. SELECT bitwise_xor(12, 7)
Risultato di esempio: `11` |
# Funzioni di espressioni regolari
Le funzioni di espressione regolare in Timestream LiveAnalytics supportano la sintassi del [pattern Java.](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html) Timestream for LiveAnalytics supporta le seguenti funzioni di espressione regolare.
| Funzione | Tipo di dati di output | Description |
| --- | --- | --- |
| regexp\$1extract\$1all (stringa, modello) | array(varchar) | Restituisce la o le sottostringhe corrispondenti al modello di espressione regolare in string. SELECT regexp_extract_all('example expect complex', 'ex\w') Risultato di esempio: `[ exa,exp ]` |
| regexp\$1extract\$1all (stringa, pattern, gruppo) | array(varchar) | [Trova tutte le occorrenze del modello di espressione regolare nella stringa e restituisce il gruppo numerico del gruppo di acquisizione.](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html#gnumber) SELECT regexp_extract_all('example expect complex', '(ex)(\w)', 2) Risultato di esempio: `[ a,p ]` |
| regexp\$1extract (stringa, pattern) | varchar | Restituisce la prima sottostringa corrispondente al modello di espressione regolare in string. SELECT regexp_extract('example expect', 'ex\w') Risultato di esempio: `exa` |
| regexp\$1extract (stringa, pattern, group) | varchar | Trova la prima occorrenza del modello di espressione regolare nella stringa e restituisce il gruppo numerico del gruppo di [acquisizione](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html#gnumber). SELECT regexp_extract('example expect', '(ex)(\w)', 2) Risultato di esempio: `a` |
| regexp\$1like (stringa, pattern) | booleano | Valuta il modello di espressione regolare e determina se è contenuto all'interno di una stringa. Questa funzione è simile all'operatore LIKE, tranne per il fatto che il pattern deve essere contenuto solo all'interno di una stringa, anziché dover corrispondere a tutta la stringa. In altre parole, esegue un'operazione di contenimento anziché un'operazione di abbinamento. È possibile abbinare l'intera stringa ancorando il pattern utilizzando ^ e \$1. SELECT regexp_like('example', 'ex') Risultato di esempio: `true` |
| regexp\$1replace (stringa, pattern) | varchar | Rimuove ogni istanza della sottostringa corrispondente al modello di espressione regolare dalla stringa. SELECT regexp_replace('example expect', 'expect') Risultato di esempio: `example` |
| regexp\$1replace (stringa, pattern, sostituzione) | varchar | Sostituisce ogni istanza della sottostringa corrispondente al pattern regex nella stringa con una sostituzione. È possibile fare riferimento ai gruppi di acquisizione in sostituzione utilizzando \$1g per un gruppo numerato o \$1 \$1name\$1 per un gruppo denominato. Un simbolo del dollaro (\$1) può essere incluso nella sostituzione facendone evaporare con una barra rovesciata (\$1 \$1). SELECT regexp_replace('example expect', 'expect', 'surprise') Risultato di esempio: `example surprise` |
| regexp\$1replace (stringa, pattern, funzione) | varchar | Sostituisce ogni istanza della sottostringa corrispondente al modello di espressione regolare nella stringa utilizzando la funzione. La funzione di [espressione lambda](https://prestodb.io/docs/current/functions/lambda.html) viene richiamata per ogni corrispondenza con i gruppi di acquisizione passati come array. L'acquisizione dei numeri di gruppo inizia da uno; non esiste un gruppo per l'intera corrispondenza (se necessario, racchiudi l'intera espressione tra parentesi). SELECT regexp_replace('example', '(\w)', x -> upper(x[1])) Risultato di esempio: `EXAMPLE` |
| regexp\$1split (stringa, pattern) | array(varchar) | Divide la stringa usando il modello di espressione regolare e restituisce un array. Le stringhe vuote finali vengono conservate. SELECT regexp_split('example', 'x') Risultato di esempio: `[ e,ample ]` |
# Operatori data/ora
**Nota**
Timestream for non LiveAnalytics supporta valori temporali negativi. Qualsiasi operazione che genera un tempo negativo genera un errore.
Timestream for LiveAnalytics supporta le seguenti operazioni su `timestamps``dates`, e. `intervals`
| Operatore | Description |
| --- | --- |
| \$1 | Addizione |
| - | Sottrazione |
**Topics**
+ [Operazioni](#date-time-operators-operations)
+ [Addizione](#date-time-operators-addition)
+ [Sottrazione](#date-time-operators-subtraction)
## Operazioni
Il tipo di risultato di un'operazione si basa sugli operandi. È `3s` possibile utilizzare valori letterali a intervalli come `1day` e.
```
SELECT date '2022-05-21' + interval '2' day
```
```
SELECT date '2022-05-21' + 2d
```
```
SELECT date '2022-05-21' + 2day
```
Esempio di risultato per ciascuno: `2022-05-23`
Le unità di intervallo includono`second`,`minute`,`hour`,`day`, `week``month`, e`year`. Ma in alcuni casi non tutte sono applicabili. Ad esempio, secondi, minuti e ore non possono essere aggiunti o sottratti da una data.
```
SELECT interval '4' year + interval '2' month
```
Risultato di esempio: `4-2`
```
SELECT typeof(interval '4' year + interval '2' month)
```
Risultato di esempio: `interval year to month`
Il tipo di risultato delle operazioni a intervalli può essere `'interval year to month'` o `'interval day to second'` dipende dagli operandi. Gli intervalli possono essere aggiunti o sottratti da e. `dates` `timestamps` Ma un `date` o `timestamp` non può essere aggiunto o sottratto da un o. `date` `timestamp` Per trovare intervalli o durate correlati a date o timestamp, vedere e funzioni correlate in. `date_diff` [Intervallo e durata](date-time-functions.md#date-time-functions-interval-duration)
## Addizione
**Example**
```
SELECT date '2022-05-21' + interval '2' day
```
Risultato di esempio: `2022-05-23`
**Example**
```
SELECT typeof(date '2022-05-21' + interval '2' day)
```
Risultato di esempio: `date`
**Example**
```
SELECT interval '2' year + interval '4' month
```
Risultato di esempio: `2-4`
**Example**
```
SELECT typeof(interval '2' year + interval '4' month)
```
Risultato di esempio: `interval year to month`
## Sottrazione
**Example**
```
SELECT timestamp '2022-06-17 01:00' - interval '7' hour
```
Risultato di esempio: `2022-06-16 18:00:00.000000000`
**Example**
```
SELECT typeof(timestamp '2022-06-17 01:00' - interval '7' hour)
```
Risultato di esempio: `timestamp`
**Example**
```
SELECT interval '6' day - interval '4' hour
```
Risultato di esempio: `5 20:00:00.000000000`
**Example**
```
SELECT typeof(interval '6' day - interval '4' hour)
```
Risultato di esempio: `interval day to second`
# Funzioni data/ora
**Nota**
Timestream for non LiveAnalytics supporta valori temporali negativi. Qualsiasi operazione che genera un tempo negativo genera un errore.
Timestream for LiveAnalytics utilizza il fuso orario UTC per data e ora. Timestream supporta le seguenti funzioni per data e ora.
**Topics**
+ [Generale e conversione](#date-time-functions-general)
+ [Intervallo e durata](#date-time-functions-interval-duration)
+ [Formattazione e analisi](#date-time-functions-formatting-parsing)
+ [Estrazione](#date-time-functions-extraction)
## Generale e conversione
Timestream for LiveAnalytics supporta le seguenti funzioni generali e di conversione per data e ora.
| Funzione | Tipo di dati di output | Description |
| --- | --- | --- |
| data\$1corrente | data | Restituisce la data corrente in UTC. Nessuna parentesi utilizzata. SELECT current_date
Risultato di esempio: `2022-07-07` Anche questa è una parola chiave riservata. Per un elenco di parole chiave riservate, vedere[Parole chiave riservate](ts-limits.md#limits.reserved). |
| tempo\$1corrente | time | Restituisce l'ora corrente in UTC. Nessuna parentesi utilizzata. SELECT current_time
Risultato di esempio: `17:41:52.827000000` Anche questa è una parola chiave riservata. Per un elenco di parole chiave riservate, vedere[Parole chiave riservate](ts-limits.md#limits.reserved). |
| current\$1timestamp o now () | timestamp | Restituisce il timestamp corrente in UTC. SELECT current_timestamp
Risultato di esempio: `2022-07-07 17:42:32.939000000` Anche questa è una parola chiave riservata. Per un elenco di parole chiave riservate, vedere[Parole chiave riservate](ts-limits.md#limits.reserved). |
| current\$1timezone () | varchar Il valore sarà 'UTC.' | Timestream utilizza il fuso orario UTC per data e ora. SELECT current_timezone()
Risultato di esempio: `UTC` |
| data (varchar (x)), data (timestamp) | data | SELECT date(TIMESTAMP '2022-07-07 17:44:43.771000000')
Risultato di esempio: `2022-07-07` |
| last\$1day\$1of\$1month (timestamp), last\$1day\$1of\$1month (data) | data | SELECT last_day_of_month(TIMESTAMP '2022-07-07 17:44:43.771000000')
Risultato di esempio: `2022-07-31` |
| from\$1iso8601\$1timestamp (stringa) | timestamp | Analizza il timestamp ISO 8601 nel formato timestamp interno. SELECT from_iso8601_timestamp('2022-06-17T08:04:05.000000000+05:00') Risultato di esempio: `2022-06-17 03:04:05.000000000` |
| from\$1iso8601\$1date (stringa) | data | Analizza la stringa di data ISO 8601 nel formato timestamp interno per l'UTC 00:00:00 della data specificata. SELECT from_iso8601_date('2022-07-17') Risultato di esempio: `2022-07-17` |
| to\$1iso8601 (timestamp), to\$1iso8601 (data) | varchar | Restituisce una stringa in formato ISO 8601 per l'input. SELECT to_iso8601(from_iso8601_date('2022-06-17')) Risultato di esempio: `2022-06-17` |
| from\$1milliseconds (bigint) | timestamp | SELECT from_milliseconds(1)
Risultato di esempio: `1970-01-01 00:00:00.001000000` |
| from\$1nanoseconds (bigint) | timestamp | select from_nanoseconds(300000001)
Risultato di esempio: `1970-01-01 00:00:00.300000001` |
| from\$1unixtime (double) | timestamp | Restituisce un timestamp che corrisponde all'unixtime fornito. SELECT from_unixtime(1)
Risultato di esempio: `1970-01-01 00:00:01.000000000` |
| ora locale | time | Restituisce l'ora corrente in UTC. Nessuna parentesi utilizzata. SELECT localtime
Risultato di esempio: `17:58:22.654000000` Anche questa è una parola chiave riservata. Per un elenco di parole chiave riservate, vedere[Parole chiave riservate](ts-limits.md#limits.reserved). |
| timestamp locale | timestamp | Restituisce il timestamp corrente in UTC. Nessuna parentesi utilizzata. SELECT localtimestamp
Risultato di esempio: `2022-07-07 17:59:04.368000000` Anche questa è una parola chiave riservata. Per un elenco di parole chiave riservate, vedere[Parole chiave riservate](ts-limits.md#limits.reserved). |
| to\$1milliseconds (intervallo da giorno a secondo), to\$1milliseconds (timestamp) | bigint | SELECT to_milliseconds(INTERVAL '2' DAY + INTERVAL '3' HOUR)
Risultato di esempio: `183600000` SELECT to_milliseconds(TIMESTAMP '2022-06-17 17:44:43.771000000')
Risultato di esempio: `1655487883771` |
| to\$1nanoseconds (intervallo da giorno a secondo), to\$1nanoseconds (timestamp) | bigint | SELECT to_nanoseconds(INTERVAL '2' DAY + INTERVAL '3' HOUR)
Risultato di esempio: `183600000000000` SELECT to_nanoseconds(TIMESTAMP '2022-06-17 17:44:43.771000678')
Risultato di esempio: `1655487883771000678` |
| to\$1unixtime (timestamp) | virgola mobile a doppia precisione | Restituisce unixtime per il timestamp fornito. SELECT to_unixtime('2022-06-17 17:44:43.771000000') Risultato di esempio: `1.6554878837710001E9` |
| date\$1trunc (unità, timestamp) | timestamp | Restituisce il timestamp troncato in unità, dove l'unità è uno dei [secondo, minuto, ora, giorno, settimana, mese, trimestre o anno]. SELECT date_trunc('minute', TIMESTAMP '2022-06-17 17:44:43.771000000') Risultato di esempio: `2022-06-17 17:44:00.000000000` |
## Intervallo e durata
Timestream for LiveAnalytics supporta le seguenti funzioni di intervallo e durata per data e ora.
| Funzione | Tipo di dati di output | Description |
| --- | --- | --- |
| date\$1add (unit, bigint, date), date\$1add (unit, bigint, time), date\$1add (varchar (x), bigint, timestamp) | timestamp | Aggiunge un insieme di unità, dove l'unità è una tra [secondo, minuto, ora, giorno, settimana, mese, trimestre o anno]. SELECT date_add('hour', 9, TIMESTAMP '2022-06-17 00:00:00') Risultato di esempio: `2022-06-17 09:00:00.000000000` |
| date\$1diff (unità, data, data), date\$1diff (unità, ora, ora), date\$1diff (unità, timestamp, timestamp) | bigint | Restituisce una differenza, dove l'unità è uno dei [secondo, minuto, ora, giorno, settimana, mese, trimestre o anno]. SELECT date_diff('day', DATE '2020-03-01', DATE '2020-03-02') Risultato di esempio: `1` |
| parse\$1duration (stringa) | intervallo | Analizza la stringa di input per restituire un equivalente. `interval` SELECT parse_duration('42.8ms') Risultato di esempio: `0 00:00:00.042800000` SELECT typeof(parse_duration('42.8ms')) Risultato di esempio: `interval day to second` |
| bin (timestamp, intervallo) | timestamp | Arrotonda il valore intero del `timestamp` parametro al multiplo più vicino del valore intero del `interval` parametro. Il significato di questo valore restituito potrebbe non essere ovvio. Viene calcolato utilizzando l'aritmetica dei numeri interi prima dividendo il numero intero del timestamp per il numero intero dell'intervallo e quindi moltiplicando il risultato per il numero intero dell'intervallo. Tenendo presente che un timestamp specifica un punto UTC come un numero di frazioni di secondo trascorse dall'epoca POSIX (1 gennaio 1970), il valore restituito raramente si allinea alle unità del calendario. Ad esempio, se si specifica un intervallo di 30 giorni, tutti i giorni trascorsi dall'epoca vengono divisi in incrementi di 30 giorni e viene restituito l'inizio dell'incremento di 30 giorni più recente, che non ha alcuna relazione con i mesi del calendario. Ecco alcuni esempi: 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
|
| fa (intervallo) | timestamp | Restituisce il valore corrispondente a `interval` current\$1timestamp. SELECT ago(1d)
Risultato di esempio: `2022-07-06 21:08:53.245000000` |
| valori letterali a intervalli come 1h, 1d e 30m | intervallo | I valori letterali a intervalli sono utili per parse\$1duration (string). Ad esempio, `1d` è equivalente a `parse_duration('1d')`. Ciò consente l'uso dei valori letterali ovunque venga utilizzato un intervallo. Ad esempio `ago(1d)` e `bin(, 1m)`. |
Alcuni valori letterali a intervalli fungono da abbreviazione di parse\$1duration. Ad esempio,,`parse_duration('1day')`, e ogni ritorno in cui `1day` si `parse_duration('1d')` trova il tipo`1d`. `1 00:00:00.000000000` `interval day to second` Lo spazio è consentito nel formato fornito a`parse_duration`. Ad esempio, restituisce `parse_duration('1day')` anche`00:00:00.000000000`. Ma non `1 day` è un intervallo letterale.
Le unità relative a `interval day to second` sono ns, nanosecond, us, microsecond, ms, millisecond, s, second, m, minute, h, hour, d e day.
C'è anche. `interval year to month` Le unità relative all'intervallo da un anno all'altro sono y, anno e mese. Ad esempio, `SELECT 1year` restituisce`1-0`. `SELECT 12month`restituisce anche`1-0`. `SELECT 8month`ritorna`0-8`.
Sebbene l'unità di `quarter` sia disponibile anche per alcune funzioni come `date_trunc` e`date_add`, non `quarter` è disponibile come parte di un intervallo letterale.
## Formattazione e analisi
Timestream for LiveAnalytics supporta le seguenti funzioni di formattazione e analisi per data e ora.
| Funzione | Tipo di dati di output | Description |
| --- | --- | --- |
| date\$1format (timestamp, varchar (x)) | varchar | [Per ulteriori informazioni sugli specificatori di formato usati da questa funzione, vedere \$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')
Risultato di esempio: `2019-10-20 10:20:20` |
| date\$1parse (varchar (x), varchar (y)) | timestamp | [Per ulteriori informazioni sugli specificatori di formato usati da questa funzione, vedere \$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') Risultato di esempio: `2019-10-20 10:20:20.000000000` |
| format\$1datetime (timestamp, varchar (x)) | varchar | [Per ulteriori informazioni sulla stringa di formato utilizzata da questa funzione, vedere 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') Risultato di esempio: `1968-01-13 12` |
| parse\$1datetime (varchar (x), varchar (y)) | timestamp | [Per ulteriori informazioni sulla stringa di formato utilizzata da questa funzione, vedere 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') Risultato di esempio: `2019-12-29 18:10:00.000000000` |
## Estrazione
Timestream for LiveAnalytics supporta le seguenti funzioni di estrazione per data e ora. La funzione di estrazione è la base per le restanti funzioni di praticità.
| Funzione | Tipo di dati di output | Description |
| --- | --- | --- |
| estratto | bigint | Estrae un campo da un timestamp, dove il campo è uno dei [YEAR, QUARTER, MONTH, WEEK, 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')
Risultato di esempio: `2019` |
| giorno (timestamp), giorno (data), giorno (intervallo da giorno a secondo) | bigint | SELECT day('2019-10-12 23:10:34.000000000') Risultato di esempio: `12` |
| day\$1of\$1month (timestamp), day\$1of\$1month (data), day\$1of\$1month (intervallo da giorno a secondo) | bigint | SELECT day_of_month('2019-10-12 23:10:34.000000000') Risultato di esempio: `12` |
| day\$1of\$1week (timestamp), day\$1of\$1week (data) | bigint | SELECT day_of_week('2019-10-12 23:10:34.000000000') Risultato di esempio: `6` |
| day\$1of\$1year (timestamp), day\$1of\$1year (data) | bigint | SELECT day_of_year('2019-10-12 23:10:34.000000000') Risultato di esempio: `285` |
| dow (timestamp), dow (data) | bigint | Alias per day\$1of\$1week |
| doy (timestamp), doy (data) | bigint | Alias per day\$1of\$1year |
| ora (timestamp), ora (ora), ora (intervallo da giorno a secondo) | bigint | SELECT hour('2019-10-12 23:10:34.000000000') Risultato di esempio: `23` |
| millisecondo (timestamp), millisecondo (ora), millisecondo (intervallo da giorno a secondo) | bigint | SELECT millisecond('2019-10-12 23:10:34.000000000') Risultato di esempio: `0` |
| minuto (timestamp), minuto (ora), minuto (intervallo da giorno a secondo) | bigint | SELECT minute('2019-10-12 23:10:34.000000000') Risultato di esempio: `10` |
| mese (timestamp), mese (data), mese (intervallo da anno a mese) | bigint | SELECT month('2019-10-12 23:10:34.000000000') Risultato di esempio: `10` |
| nanosecondo (timestamp), nanosecondo (ora), nanosecondo (intervallo da giorno a secondo) | bigint | SELECT nanosecond(current_timestamp)
Risultato di esempio: `162000000` |
| trimestre (timestamp), trimestre (data) | bigint | SELECT quarter('2019-10-12 23:10:34.000000000') Risultato di esempio: `4` |
| secondo (timestamp), secondo (ora), secondo (intervallo da giorno a secondo) | bigint | SELECT second('2019-10-12 23:10:34.000000000') Risultato di esempio: `34` |
| settimana (timestamp), settimana (data) | bigint | SELECT week('2019-10-12 23:10:34.000000000') Risultato di esempio: `41` |
| settimana\$1del\$1anno (timestamp), settimana\$1del\$1anno (data) | bigint | Alias per settimana |
| anno (timestamp), anno (data), anno (intervallo da anno a mese) | bigint | SELECT year('2019-10-12 23:10:34.000000000') Risultato di esempio: `2019` |
| anno\$1di\$1settimana (timestamp), anno\$1del\$1settimana (data) | bigint | SELECT year_of_week('2019-10-12 23:10:34.000000000') Risultato di esempio: `2019` |
| yow (timestamp), yow (data) | bigint | Alias per year\$1of\$1week |
# Funzioni di aggregazione
Timestream for supporta le seguenti funzioni aggregate. LiveAnalytics
| Funzione | Tipo di dati di output | Description |
| --- | --- | --- |
| arbitrario (x) | [uguale all'input] | Restituisce un valore arbitrario non nullo di x, se ne esiste uno. SELECT arbitrary(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Risultato di esempio: `1` |
| array\$1agg (x) | array< [uguale all'input] | Restituisce un array creato dagli elementi x di input. SELECT array_agg(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Risultato di esempio: `[ 1,2,3,4 ]` |
| avg (x) | virgola mobile a doppia precisione | Restituisce la media (media aritmetica) di tutti i valori di input. SELECT avg(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Risultato di esempio: `2.5` |
| bool\$1and (boolean) ogni (boolean) | booleano | Restituisce TRUE se ogni valore di input è VERO, altrimenti FALSO. SELECT bool_and(t.c) FROM (VALUES true, true, false, true) AS t(c)
Risultato di esempio: `false` |
| bool\$1or (booleano) | booleano | Restituisce TRUE se un valore di input è VERO, altrimenti FALSO. SELECT bool_or(t.c) FROM (VALUES true, true, false, true) AS t(c)
Risultato di esempio: `true` |
| conteggio (\$1) conteggio (x) | bigint | count (\$1) restituisce il numero di righe di input. count (x) restituisce il numero di valori di input non nulli. SELECT count(t.c) FROM (VALUES true, true, false, true) AS t(c)
Risultato di esempio: `4` |
| count\$1if (x) | bigint | Restituisce il numero di valori di input TRUE. SELECT count_if(t.c) FROM (VALUES true, true, false, true) AS t(c)
Risultato di esempio: `3` |
| geometric\$1mean (x) | virgola mobile a doppia precisione | Restituisce la media geometrica di tutti i valori di input. SELECT geometric_mean(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Risultato di esempio: `2.213363839400643` |
| max\$1by (x, y) | [uguale a x] | Restituisce il valore di x associato al valore massimo di y su tutti i valori di input. SELECT max_by(t.c1, t.c2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Risultato di esempio: `d` |
| max\$1by (x, y, n) | matrice< [same as x] > | Restituisce n valori di x associati al valore n più grande di tutti i valori di input di y in ordine decrescente di y. SELECT max_by(t.c1, t.c2, 2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Risultato di esempio: `[ d,c ]` |
| min\$1by (x, y) | [uguale a x] | Restituisce il valore di x associato al valore minimo di y su tutti i valori di input. SELECT min_by(t.c1, t.c2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Risultato di esempio: `a` |
| min\$1by (x, y, n) | matrice< [same as x] > | Restituisce n valori di x associati al valore n più piccolo di tutti i valori di input di y in ordine crescente di y. SELECT min_by(t.c1, t.c2, 2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Risultato di esempio: `[ a,b ]` |
| max (x) | [uguale all'input] | Restituisce il valore massimo di tutti i valori di input. SELECT max(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Risultato di esempio: `4` |
| max (x, n) | matrice< [same as x] > | Restituisce n valori più grandi di tutti i valori di input di x. SELECT max(t.c, 2) FROM (VALUES 1, 2, 3, 4) AS t(c)
Risultato di esempio: `[ 4,3 ]` |
| min (x) | [uguale all'input] | Restituisce il valore minimo di tutti i valori di input. SELECT min(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Risultato di esempio: `1` |
| min (x, n) | matrice< [same as x] > | Restituisce n valori più piccoli di tutti i valori di input di x. SELECT min(t.c, 2) FROM (VALUES 1, 2, 3, 4) AS t(c)
Risultato di esempio: `[ 1,2 ]` |
| somma (x) | [uguale all'input] | Restituisce la somma di tutti i valori di input. SELECT sum(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Risultato di esempio: `10` |
| bitwise\$1and\$1agg (x) | bigint | Restituisce l'AND bit per bit di tutti i valori di input nella rappresentazione del complemento a 2 secondi. SELECT bitwise_and_agg(t.c) FROM (VALUES 1, -3) AS t(c)
Risultato di esempio: `1` |
| bitwise\$1or\$1agg (x) | bigint | Restituisce l'OR bit per bit di tutti i valori di input nella rappresentazione del complemento a 2 secondi. SELECT bitwise_or_agg(t.c) FROM (VALUES 1, -3) AS t(c)
Risultato di esempio: `-3` |
| approx\$1distinct (x) | bigint | Restituisce il numero approssimativo di valori di input distinti. Questa funzione fornisce un'approssimazione del conteggio (DISTINCT x). Viene restituito zero se tutti i valori di input sono nulli. Questa funzione dovrebbe produrre un errore standard del 2,3%, che è la deviazione standard della distribuzione degli errori (approssimativamente normale) su tutti i set possibili. Non garantisce un limite massimo dell'errore per alcun set di input specifico. SELECT approx_distinct(t.c) FROM (VALUES 1, 2, 3, 4, 8) AS t(c)
Risultato di esempio: `5` |
| approx\$1distinct (x, e) | bigint | Restituisce il numero approssimativo di valori di input distinti. Questa funzione fornisce un'approssimazione del conteggio (DISTINCT x). Viene restituito zero se tutti i valori di input sono nulli. Questa funzione dovrebbe produrre un errore standard non superiore a e, che è la deviazione standard della distribuzione degli errori (approssimativamente normale) su tutti i set possibili. Non garantisce un limite massimo dell'errore per alcun set di input specifico. L'attuale implementazione di questa funzione richiede che e sia compreso nell'intervallo [0,0040625, 0,26000]. SELECT approx_distinct(t.c, 0.2) FROM (VALUES 1, 2, 3, 4, 8) AS t(c)
Risultato di esempio: `5` |
| approx\$1percentile (x, percentile) | [uguale a x] | Restituisce il percentile approssimativo per tutti i valori di input di x alla percentuale specificata. Il valore della percentuale deve essere compreso tra zero e uno e deve essere costante per tutte le righe di input. SELECT approx_percentile(t.c, 0.4) FROM (VALUES 1, 2, 3, 4) AS t(c)
Risultato di esempio: `2` |
| approx\$1percentile (x, percentages) | matrice< [same as x] > | Restituisce il percentile approssimativo per tutti i valori di input di x per ciascuna delle percentuali specificate. Ogni elemento dell'array delle percentuali deve essere compreso tra zero e uno e l'array deve essere costante per tutte le righe di input. SELECT approx_percentile(t.c, ARRAY[0.1, 0.8, 0.8]) FROM (VALUES 1, 2, 3, 4) AS t(c)
Risultato di esempio: `[ 1,4,4 ]` |
| approx\$1percentile (x, w, percentage) | [uguale a x] | Restituisce il percentile pesato approssimativo per tutti i valori di input di x utilizzando il peso per articolo w alla percentuale p. Il peso deve essere un valore intero di almeno uno. È effettivamente un conteggio delle repliche per il valore x nel set di percentili. Il valore di p deve essere compreso tra zero e uno e deve essere costante per tutte le righe di input. SELECT approx_percentile(t.c, 1, 0.1) FROM (VALUES 1, 2, 3, 4) AS t(c)
Risultato di esempio: `1` |
| approx\$1percentile (x, w, percentuali) | matrice< [same as x] > | Restituisce il percentile pesato approssimativo per tutti i valori di input di x utilizzando il peso per articolo w in ciascuna delle percentuali specificate nell'array. Il peso deve essere un valore intero di almeno uno. È effettivamente un conteggio delle repliche per il valore x nel set di percentili. Ogni elemento dell'array deve essere compreso tra zero e uno e l'array deve essere costante per tutte le righe di input. SELECT approx_percentile(t.c, 1, ARRAY[0.1, 0.8, 0.8]) FROM (VALUES 1, 2, 3, 4) AS t(c)
Risultato di esempio: `[ 1,4,4 ]` |
| approx\$1percentile (x, w, percentuale, precisione) | [uguale a x] | Restituisce il percentile pesato approssimativo per tutti i valori di input di x utilizzando il peso per articolo w alla percentuale p, con un errore di precisione massimo. Il peso deve essere un valore intero di almeno uno. È effettivamente un conteggio delle repliche per il valore x nel set di percentili. Il valore di p deve essere compreso tra zero e uno e deve essere costante per tutte le righe di input. La precisione deve essere un valore maggiore di zero e minore di uno e deve essere costante per tutte le righe di input. SELECT approx_percentile(t.c, 1, 0.1, 0.5) FROM (VALUES 1, 2, 3, 4) AS t(c)
Risultato di esempio: `1` |
| corr (y, x) | virgola mobile a doppia precisione | Restituisce il coefficiente di correlazione dei valori di input. SELECT corr(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Risultato di esempio: `1.0` |
| covar\$1pop (y, x) | virgola mobile a doppia precisione | Restituisce la covarianza della popolazione dei valori di input. SELECT covar_pop(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Risultato di esempio: `1.25` |
| covar\$1samp (y, x) | virgola mobile a doppia precisione | Restituisce la covarianza campionaria dei valori di input. SELECT covar_samp(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Risultato di esempio: `1.6666666666666667` |
| regr\$1intercept (y, x) | virgola mobile a doppia precisione | Restituisce l'intercetta di regressione lineare dei valori di ingresso. y è il valore dipendente. x è il valore indipendente. SELECT regr_intercept(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Risultato di esempio: `0.0` |
| regr\$1slope (y, x) | virgola mobile a doppia precisione | Restituisce la pendenza di regressione lineare dei valori di ingresso. y è il valore dipendente. x è il valore indipendente. SELECT regr_slope(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Risultato di esempio: `1.0` |
| asimmetria (x) | virgola mobile a doppia precisione | Restituisce l'asimmetria di tutti i valori di input. SELECT skewness(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Risultato di esempio: `0.8978957037987335` |
| stddev\$1pop (x) | virgola mobile a doppia precisione | Restituisce la deviazione standard della popolazione di tutti i valori di input. SELECT stddev_pop(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Risultato di esempio: `2.4166091947189146` |
| stddev\$1samp (x) stddev (x) | virgola mobile a doppia precisione | Restituisce la deviazione standard del campione di tutti i valori di input. SELECT stddev_samp(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Risultato di esempio: `2.701851217221259` |
| var\$1pop (x) | virgola mobile a doppia precisione | Restituisce la varianza della popolazione di tutti i valori di input. SELECT var_pop(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Risultato di esempio: `5.840000000000001` |
| var\$1samp (x) varianza (x) | virgola mobile a doppia precisione | Restituisce la varianza campionaria di tutti i valori di input. SELECT var_samp(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Risultato di esempio: `7.300000000000001` |
# Funzioni finestra
Le funzioni della finestra eseguono calcoli tra le righe del risultato della query. Vengono eseguite dopo la clausola HAVING ma prima della clausola ORDER BY. L'invocazione di una funzione window richiede una sintassi speciale che utilizza la clausola OVER per specificare la finestra. Una finestra ha tre componenti:
+ La specifica della partizione, che separa le righe di input in partizioni diverse. Questo è analogo al modo in cui la clausola GROUP BY separa le righe in diversi gruppi per le funzioni aggregate.
+ La specifica di ordinamento, che determina l'ordine in cui le righe di input verranno elaborate dalla funzione finestra.
+ La cornice della finestra, che specifica una finestra scorrevole di righe che devono essere elaborate dalla funzione per una determinata riga. Se il frame non è specificato, il valore predefinito è RANGE UNBOUNDED PRECEDING, che è lo stesso di RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW. Questo frame contiene tutte le righe dall'inizio della partizione fino all'ultimo peer della riga corrente.
Tutte le funzioni aggregate possono essere utilizzate come funzioni di finestra aggiungendo la clausola OVER. La funzione di aggregazione viene calcolata per ogni riga sulle righe all'interno della cornice della finestra della riga corrente. Oltre alle funzioni aggregate, Timestream for LiveAnalytics supporta le seguenti funzioni di classificazione e valore.
| Funzione | Tipo di dati di output | Description |
| --- | --- | --- |
| cume\$1dist () | bigint | Restituisce la distribuzione cumulativa di un valore in un gruppo di valori. Il risultato è il numero di righe che precedono o coincidono con la riga nella partizione della finestra diviso per il numero totale di righe nella partizione della finestra. Pertanto, tutti i valori di parità presenti nell'ordinamento verranno restituiti allo stesso valore di distribuzione. |
| dense\$1rank () | bigint | Restituisce il rango di un valore in un gruppo di valori. È simile a rank (), tranne per il fatto che i valori di parità non producono spazi vuoti nella sequenza. |
| intile (n) | bigint | Divide le righe per ogni partizione di finestra in n bucket che vanno da 1 a un massimo n. I valori del bucket differiranno al massimo di 1. Se il numero di righe nella partizione non si divide equamente nel numero di bucket, i valori rimanenti vengono distribuiti uno per bucket, a partire dal primo bucket. |
| percent\$1rank () | virgola mobile a doppia precisione | Restituisce la classificazione percentuale di un valore in un gruppo di valori. Il risultato è (r - 1)/(n - 1) dove r è il rango () della riga e n è il numero totale di righe nella partizione della finestra. |
| rango () | bigint | Restituisce il rango di un valore in un gruppo di valori. Il rango è uno più il numero di righe che precedono la riga che non sono uguali alla riga. Pertanto, i valori di parità nell'ordine produrranno lacune nella sequenza. La classificazione viene eseguita per ogni partizione di finestra. |
| numero\$1riga () | bigint | Restituisce un numero sequenziale univoco per ogni riga, a partire da uno, in base all'ordine delle righe all'interno della partizione della finestra. |
| primo\$1valore (x) | [uguale all'input] | Restituisce il primo valore della finestra. Questa funzione è limitata alla cornice della finestra. La funzione accetta un'espressione o un obiettivo come parametro. |
| last\$1value (x) | [uguale all'input] | Restituisce l'ultimo valore della finestra. Questa funzione è limitata alla cornice della finestra. La funzione accetta un'espressione o un obiettivo come parametro. |
| nth\$1value (x, offset) | [uguale all'input] | Restituisce il valore all'offset specificato dall'inizio della finestra. Gli offset partono da 1. L'offset può essere qualsiasi espressione scalare. Se l'offset è nullo o maggiore del numero di valori nella finestra, viene restituito null. È un errore che l'offset sia zero o negativo. La funzione accetta un'espressione o un obiettivo come primo parametro. |
| lead (x [, offset [, default\$1value]]) | [uguale all'input] | Restituisce il valore nelle righe di offset dopo la riga corrente nella finestra. Gli offset iniziano da 0, che è la riga corrente. L'offset può essere qualsiasi espressione scalare. L'offset predefinito è 1. Se l'offset è nullo o maggiore della finestra, viene restituito il valore default\$1value o, se non è specificato, viene restituito null. La funzione accetta un'espressione o un obiettivo come primo parametro. |
| lag (x [, offset [, valore\$1predefinito]]) | [uguale all'input] | Restituisce il valore nelle righe di offset prima della riga corrente nella finestra Offsets start at 0, che è la riga corrente. L'offset può essere qualsiasi espressione scalare. L'offset predefinito è 1. Se l'offset è nullo o maggiore della finestra, viene restituito il valore default\$1value o, se non è specificato, viene restituito null. La funzione accetta un'espressione o un obiettivo come primo parametro. |
# Query di esempio
Questa sezione include esempi di casi d'uso del linguaggio di interrogazione LiveAnalytics di Timestream for.
**Topics**
+ [Interrogazioni semplici](sample-queries.basic-scenarios.md)
+ [Interrogazioni con funzioni di serie temporali](sample-queries.devops-scenarios.md)
+ [Interrogazioni con funzioni aggregate](sample-queries.iot-scenarios.md)
# Interrogazioni semplici
Di seguito vengono ottenuti i 10 punti dati aggiunti più di recente per una tabella.
```
SELECT * FROM .
ORDER BY time DESC
LIMIT 10
```
Di seguito vengono ottenuti i 5 punti dati più vecchi per una misura specifica.
```
SELECT * FROM .
WHERE measure_name = ''
ORDER BY time ASC
LIMIT 5
```
Quanto segue funziona con timestamp di granularità in nanosecondi.
```
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
```
I valori di misura per i record con più misure sono identificati dal nome della colonna. I valori di misura per i record a misura singola sono identificati da`measure_value::`, dove `` è uno di`double`, `bigint``boolean`, o `varchar` come descritto in. [Tipi di dati supportati](supported-data-types.md) Per ulteriori informazioni su come vengono modellati i valori di misura, consulta [Tabella singola e tabelle multiple.](https://docs.aws.amazon.com/timestream/latest/developerguide/data-modeling.html#data-modeling-multiVsinglerecords)
Di seguito vengono recuperati i valori per una misura richiamata `speed` da record con più misure con un di. `measure_name` `IoTMulti-stats`
```
SELECT speed FROM . where measure_name = 'IoTMulti-stats'
```
Quanto segue recupera `double` i valori dai record a misura singola con un di. `measure_name` `load`
```
SELECT measure_value::double FROM . WHERE measure_name = 'load'
```
# Interrogazioni con funzioni di serie temporali
**Topics**
+ [Set di dati e interrogazioni di esempio](#sample-queries.devops-scenarios.example)
## Set di dati e interrogazioni di esempio
È possibile utilizzare Timestream per LiveAnalytics comprendere e migliorare le prestazioni e la disponibilità dei servizi e delle applicazioni. Di seguito è riportato un esempio di tabella e delle query di esempio eseguite su tale tabella.
La tabella `ec2_metrics` memorizza i dati di telemetria, come l'utilizzo della CPU e altre metriche delle istanze EC2. È possibile visualizzare la tabella riportata di seguito.
| Orario | region | az | Hostname (Nome host) | measure\$1name | measure\$1value::double | measure\$1value::bigint |
| --- | --- | --- | --- | --- | --- | --- |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1a | front-end 01 | cpu\$1utilization | 35.1 | null |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1a | front-end 01 | memory\$1utilization | 5.3 | null |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1a | front-end 01 | network\$1bytes\$1in | null | 1.500 |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1a | front-end 01 | network\$1bytes\$1out | null | 6.700 |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1b | front-end 02 | cpu\$1utilization | 38,5 | null |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1b | front-end 02 | memory\$1utilization | 58,4 | null |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1b | front-end 02 | network\$1bytes\$1in | null | 23.000 |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1b | front-end 02 | network\$1bytes\$1out | null | 12.000 |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1c | front-end 03 | cpu\$1utilization | 45.0 | null |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1c | front-end 03 | memory\$1utilization | 65,8 | null |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1c | front-end 03 | network\$1bytes\$1in | null | 15.000 |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1c | front-end 03 | network\$1bytes\$1out | null | 836.000 |
| 2019-12-04 19:00:05.000 000000 | us-east-1 | us-east-1a | front-end 01 | cpu\$1utilization | 55.2 | null |
| 2019-12-04 19:00:05.000 000000 | us-east-1 | us-east-1a | front-end 01 | memory\$1utilization | 75.0 | null |
| 2019-12-04 19:00:05.000 000000 | us-east-1 | us-east-1a | front-end 01 | network\$1bytes\$1in | null | 1.245 |
| 2019-12-04 19:00:05.000 000000 | us-east-1 | us-east-1a | front-end 01 | network\$1bytes\$1out | null | 68.432 |
| 2019-12-04 19:00:08000 000000 | us-east-1 | us-east-1b | front-end 02 | cpu\$1utilization | 65,6 | null |
| 2019-12-04 19:00:08000 000000 | us-east-1 | us-east-1b | front-end 02 | memory\$1utilization | 85,3 | null |
| 2019-12-04 19:00:08000 000000 | us-east-1 | us-east-1b | front-end 02 | network\$1bytes\$1in | null | 1.245 |
| 2019-12-04 19:00:08000 000000 | us-east-1 | us-east-1b | front-end 02 | network\$1bytes\$1out | null | 68.432 |
| 2019-12-04 19:00:20000 000000 | us-east-1 | us-east-1c | front-end 03 | cpu\$1utilization | 12.1 | null |
| 2019-12-04 19:00:20000 000000 | us-east-1 | us-east-1c | front-end 03 | memory\$1utilization | 32,0 | null |
| 2019-12-04 19:00:20000 000000 | us-east-1 | us-east-1c | front-end 03 | network\$1bytes\$1in | null | 1.400 |
| 2019-12-04 19:00:20000 000000 | us-east-1 | us-east-1c | front-end 03 | network\$1bytes\$1out | null | 345 |
| 2019-12-04 19:00:10.000 000000 | us-east-1 | us-east-1a | front-end 01 | cpu\$1utilization | 15.3 | null |
| 2019-12-04 19:00:10.000 000000 | us-east-1 | us-east-1a | front-end 01 | memory\$1utilization | 35,4 | null |
| 2019-12-04 19:00:10.000 000000 | us-east-1 | us-east-1a | front-end 01 | network\$1bytes\$1in | null | 23 |
| 2019-12-04 19:00:10.000 000000 | us-east-1 | us-east-1a | front-end 01 | network\$1bytes\$1out | null | 0 |
| 2019-12-04 19:00:16.000 000000 | us-east-1 | us-east-1b | front-end 02 | cpu\$1utilization | 44.0 | null |
| 2019-12-04 19:00:16.000 000000 | us-east-1 | us-east-1b | front-end 02 | memory\$1utilization | 64.2 | null |
| 2019-12-04 19:00:16000 000000 | us-east-1 | us-east-1b | front-end 02 | network\$1bytes\$1in | null | 1.450 |
| 2019-12-04 19:00:16000 000000 | us-east-1 | us-east-1b | front-end 02 | network\$1bytes\$1out | null | 200 |
| 2019-12-04 19:00:40.000 000000 | us-east-1 | us-east-1c | front-end 03 | cpu\$1utilization | 6.4 | null |
| 2019-12-04 19:00:40,000 000000 | us-east-1 | us-east-1c | front-end 03 | memory\$1utilization | 86,3 | null |
| 2019-12-04 19:00:40,000 000000 | us-east-1 | us-east-1c | front-end 03 | network\$1bytes\$1in | null | 300 |
| 2019-12-04 19:00:40.000 000000 | us-east-1 | us-east-1c | front-end 03 | network\$1bytes\$1out | null | 423 |
Trova l'utilizzo medio della CPU p90, p95 e p99 per uno specifico host EC2 nelle ultime 2 ore:
```
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
```
Identifica gli host EC2 con un utilizzo della CPU superiore del 10% o più rispetto all'utilizzo medio della CPU dell'intera flotta nelle ultime 2 ore:
```
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
```
Trova l'utilizzo medio della CPU suddiviso a intervalli di 30 secondi per uno specifico host EC2 nelle ultime 2 ore:
```
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
```
Trova l'utilizzo medio della CPU eseguito a intervalli di 30 secondi per uno specifico host EC2 nelle ultime 2 ore, inserendo i valori mancanti utilizzando l'interpolazione lineare:
```
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)
```
Trova l'utilizzo medio della CPU eseguito a intervalli di 30 secondi per uno specifico host EC2 nelle ultime 2 ore, inserendo i valori mancanti utilizzando l'interpolazione basata sull'ultima osservazione riportata:
```
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)
```
# Interrogazioni con funzioni aggregate
Di seguito è riportato un esempio di set di dati di esempio di scenario IoT per illustrare le query con funzioni aggregate.
**Topics**
+ [Dati di esempio](#sample-queries.iot-scenarios.example-data)
+ [Query di esempio](#sample-queries.iot-scenarios.example-queries)
## Dati di esempio
Timestream consente di archiviare e analizzare i dati dei sensori IoT come la posizione, il consumo di carburante, la velocità e la capacità di carico di una o più flotte di camion per consentire una gestione efficace della flotta. Di seguito sono riportati lo schema e alcuni dati di una tabella iot\$1trucks che memorizza dati di telemetria come posizione, consumo di carburante, velocità e capacità di carico dei camion.
| Orario | truck\$1id | Make | Modello | Parco istanze | capacità\$1carburante | capacità\$1di carico | measure\$1name | measure\$1value::double | measure\$1value::varchar |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 2019-12-04 19:00:00.000 000000 | 123456781 | GMC | Astro | Alpha (Afa) | 100 | 500 | fuel\$1reading | 65,2 | null |
| 2019-12-04 19:00:00.000 000000 | 123456781 | GMC | Astro | Alpha (Afa) | 100 | 500 | caricare | 400,0 | null |
| 2019-12-04 19:00:00.000 000000 | 123456781 | GMC | Astro | Alpha (Afa) | 100 | 500 | speed | 90,2 | null |
| 2019-12-04 19:00:00.000 000000 | 123456781 | GMC | Astro | Alpha (Afa) | 100 | 500 | location | null | 47,6062 NM, 122.321 W |
| 2019-12-04 19:00:00.000 000000 | 123456782 | Kenworth | W900 | Alpha (Afa) | 150 | 1000 | lettura del carburante | 10.1 | null |
| 2019-12-04 19:00:00.000 000000 | 123456782 | Kenworth | W900 | Alpha (Afa) | 150 | 1000 | caricare | 950,3 | null |
| 2019-12-04 19:00:00.000 000000 | 123456782 | Kenworth | W900 | Alpha (Afa) | 150 | 1000 | speed | 50,8 | null |
| 2019-12-04 19:00:00.000 000000 | 123456782 | Kenworth | W900 | Alpha (Afa) | 150 | 1000 | location | null | 40.7128 gradi N, 74.0060 gradi W |
## Query di esempio
Ottieni un elenco di tutti gli attributi e i valori dei sensori monitorati per ogni camion della flotta.
```
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
```
Ottieni i dati più recenti relativi al carburante di ogni camion della flotta nelle ultime 24 ore.
```
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
```
Identifica i camion che hanno utilizzato poco carburante (meno del 10%) nelle ultime 48 ore:
```
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
)
```
Calcola il carico medio e la velocità massima di ogni camion nell'ultima settimana:
```
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
```
Calcola l'efficienza di carico di ogni camion nell'ultima settimana:
```
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
```