Per funzionalità simili a Amazon Timestream for, prendi in considerazione Amazon Timestream LiveAnalytics per InfluxDB. Offre un'acquisizione semplificata dei dati e tempi di risposta alle query di una sola cifra di millisecondi per analisi in tempo reale. [Scopri](https://docs.aws.amazon.com//timestream/latest/developerguide/timestream-for-influxdb.html) di più qui. Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # 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\_agg (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\_and (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\_or (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 (\*) conteggio (x) | bigint | count (\*) 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\_if (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\_mean (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\_by (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\_by (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\_by (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\_by (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\_and\_agg (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\_or\_agg (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\_distinct (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\_distinct (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\_percentile (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\_percentile (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\_percentile (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\_percentile (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\_percentile (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\_pop (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\_samp (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\_intercept (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\_slope (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\_pop (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\_samp (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\_pop (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\_samp (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` |