Für ähnliche Funktionen wie Amazon Timestream für sollten Sie Amazon Timestream for LiveAnalytics InfluxDB in Betracht ziehen. Es bietet eine vereinfachte Datenaufnahme und Antwortzeiten im einstelligen Millisekundenbereich für Analysen in Echtzeit. [Erfahren](https://docs.aws.amazon.com//timestream/latest/developerguide/timestream-for-influxdb.html) Sie hier mehr.
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Integrierte Zeitreihenfunktionalität
Timestream for LiveAnalytics bietet integrierte Zeitreihenfunktionen, die Zeitreihendaten als erstklassiges Konzept behandeln.
Die integrierte Zeitreihenfunktion kann in zwei Kategorien unterteilt werden: Ansichten und Funktionen.
Im Folgenden finden Sie Informationen zu den einzelnen Konstrukten.
**Topics**
+ [Ansichten von Zeitreihen](timeseries-specific-constructs.views.md)
+ [Funktionen für Zeitreihen](timeseries-specific-constructs.functions.md)
# Ansichten von Zeitreihen
Timestream for LiveAnalytics unterstützt die folgenden Funktionen zur Umwandlung Ihrer Daten in den `timeseries` Datentyp:
**Topics**
+ [CREATE\$1TIME\$1SERIES](#timeseries-specific-constructs.views.CREATE_TIME_SERIES)
+ [UNNEST](#timeseries-specific-constructs.views.UNNEST)
## CREATE\$1TIME\$1SERIES
**CREATE\$1TIME\$1SERIES** ist eine Aggregationsfunktion, die alle Rohmessungen einer Zeitreihe (Zeit- und Messwerte) verwendet und einen Zeitreihendatentyp zurückgibt. Die Syntax dieser Funktion lautet wie folgt:
```
CREATE_TIME_SERIES(time, measure_value::)
```
Dabei `` handelt es sich um den Datentyp des Messwerts. Dabei kann es sich um Bigint, Boolean, Double oder Varchar handeln. Der zweite Parameter darf nicht Null sein.
Betrachten Sie die CPU-Auslastung von EC2-Instances, die in einer Tabelle mit dem Namen **Metrics** gespeichert sind, wie unten dargestellt:
| Zeit | Region | az | vpc | instance\$1id | measure\$1name | Messwert::doppelt |
| --- | --- | --- | --- | --- | --- | --- |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-ost-1d | vpc-1a2b3c4d | i-1234567890abcdef0 | CPU-Auslastung | 35,0 |
| 2019-12-04 19:00:01.000 000000 | us-east-1 | us-ost-1d | vpc-1a2b3c4d | i-1234567890abcdef0 | CPU-Auslastung | 38,2 |
| 2019-12-04 19:00:02.000 000000 | us-east-1 | us-ost-1d | vpc-1a2b3c4d | i-1234567890abcdef0 | CPU-Auslastung | 45,3 |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-ost-1d | vpc-1a2b3c4d | i-1234567890abcdef1 | CPU-Auslastung | 54,1 |
| 2019-12-04 19:00:01.000 000000 | us-east-1 | us-ost-1d | vpc-1a2b3c4d | i-1234567890abcdef1 | CPU-Auslastung | 42,5 |
| 2019-12-04 19:00:02.000 000000 | us-east-1 | us-ost-1d | vpc-1a2b3c4d | i-1234567890abcdef1 | CPU-Auslastung | 33,7 |
Die Abfrage ausführen:
```
SELECT region, az, vpc, instance_id, CREATE_TIME_SERIES(time, measure_value::double) as cpu_utilization FROM metrics
WHERE measure_name=’cpu_utilization’
GROUP BY region, az, vpc, instance_id
```
gibt alle Serien zurück, die einen Messwert haben`cpu_utilization`. In diesem Fall haben wir zwei Serien:
| Region | az | vpc | instance\$1id | cpu\$1utilization |
| --- | --- | --- | --- | --- |
| us-east-1 | us-ost-1d | vpc-1a2b3c4d | i-1234567890abcdef0 | [\$1Zeit: 2019-12-04 19:00:00.000 000000, measure\$1value: :double: 35.0\$1, \$1time: 2019-12-04 19:00:01.000 000000, measure\$1value: :double: 38.2\$1, \$1time: 2019-12-04 19:00:02.000 000000, measure\$1value: :double: 45,3\$1] |
| us-east-1 | us-east-1d | vpc-1a2b3c4d | i-1234567890abcdef1 | [\$1Uhrzeit: 2019-12-04 19:00:00.000 000000, measure\$1value: :double: 35.1\$1, \$1time: 2019-12-04 19:00:01.000 000000, measure\$1value: :double: 38,5\$1, \$1time: 2019-12-04 19:00:02.000 000000, measure\$1value: :double: 45.7\$1] |
## UNNEST
`UNNEST`ist eine Tabellenfunktion`timeseries`, mit der Sie Daten in das flache Modell transformieren können. Die Syntax ist wie folgt:
`UNNEST``timeseries`wandelt a in zwei Spalten um, nämlich `time` und`value`. Sie können Aliase auch mit UNNEST verwenden, wie unten gezeigt:
```
UNNEST(timeseries) AS (time_alias, value_alias)
```
wobei `` der Alias für die flache Tabelle, `time_alias` der Alias für die `time` Spalte und der Alias für die `value` Spalte `value_alias` ist.
Stellen Sie sich zum Beispiel das Szenario vor, in dem einige EC2-Instances in Ihrer Flotte so konfiguriert sind, dass sie Metriken in einem Intervall von 5 Sekunden ausgeben, andere Metriken in einem Intervall von 15 Sekunden ausgeben und Sie die durchschnittlichen Metriken für alle Instances mit einer Granularität von 10 Sekunden für die letzten 6 Stunden benötigen. **Um diese Daten zu erhalten, transformieren Sie Ihre Metriken mithilfe von CREATE\$1TIME\$1SERIES in das Zeitreihenmodell.** Anschließend können Sie **INTERPOLATE\$1LINEAR** verwenden, um die fehlenden Werte mit einer Granularität von 10 Sekunden abzurufen. Als Nächstes transformieren Sie die Daten mithilfe von **UNNEST** wieder in das flache Modell und verwenden dann **AVG, um die Durchschnittsmetriken für alle** Instanzen zu ermitteln.
```
WITH interpolated_timeseries AS (
SELECT region, az, vpc, instance_id,
INTERPOLATE_LINEAR(
CREATE_TIME_SERIES(time, measure_value::double),
SEQUENCE(ago(6h), now(), 10s)) AS interpolated_cpu_utilization
FROM timestreamdb.metrics
WHERE measure_name= ‘cpu_utilization’ AND time >= ago(6h)
GROUP BY region, az, vpc, instance_id
)
SELECT region, az, vpc, instance_id, avg(t.cpu_util)
FROM interpolated_timeseries
CROSS JOIN UNNEST(interpolated_cpu_utilization) AS t (time, cpu_util)
GROUP BY region, az, vpc, instance_id
```
Die obige Abfrage demonstriert die Verwendung von **UNNEST** mit einem Alias. Im Folgenden finden Sie ein Beispiel für dieselbe Abfrage ohne Verwendung eines Alias für **UNNEST**:
```
WITH interpolated_timeseries AS (
SELECT region, az, vpc, instance_id,
INTERPOLATE_LINEAR(
CREATE_TIME_SERIES(time, measure_value::double),
SEQUENCE(ago(6h), now(), 10s)) AS interpolated_cpu_utilization
FROM timestreamdb.metrics
WHERE measure_name= ‘cpu_utilization’ AND time >= ago(6h)
GROUP BY region, az, vpc, instance_id
)
SELECT region, az, vpc, instance_id, avg(value)
FROM interpolated_timeseries
CROSS JOIN UNNEST(interpolated_cpu_utilization)
GROUP BY region, az, vpc, instance_id
```
# Funktionen für Zeitreihen
Amazon Timestream for LiveAnalytics unterstützt Zeitreihenfunktionen wie Ableitungen, Integrale und Korrelationen sowie andere, um tiefere Einblicke aus Ihren Zeitreihendaten zu gewinnen. Dieser Abschnitt enthält Nutzungsinformationen für jede dieser Funktionen sowie Beispielabfragen. Wählen Sie unten ein Thema aus, um mehr zu erfahren.
**Topics**
+ [Interpolationsfunktionen](timeseries-specific-constructs.functions.interpolation.md)
+ [Funktionen für Ableitungen](timeseries-specific-constructs.functions.derivatives.md)
+ [Integrale Funktionen](timeseries-specific-constructs.functions.integrals.md)
+ [Korrelationsfunktionen](timeseries-specific-constructs.functions.correlation.md)
+ [Funktionen filtern und reduzieren](timeseries-specific-constructs.functions.filter-reduce.md)
# Interpolationsfunktionen
Wenn in Ihren Zeitreihendaten Werte für Ereignisse zu bestimmten Zeitpunkten fehlen, können Sie die Werte dieser fehlenden Ereignisse mithilfe von Interpolation schätzen. Amazon Timestream unterstützt vier Varianten der Interpolation: lineare Interpolation, kubische Spline-Interpolation, Locf-Interpolation (Last Observation Carried Forward) und konstante Interpolation. Dieser Abschnitt enthält Informationen zur Verwendung von Timestream für Interpolationsfunktionen sowie Beispielabfragen. LiveAnalytics
## Informationen zur Nutzung
| Funktion | Ausgabedatentyp | Description |
| --- | --- | --- |
| `interpolate_linear(timeseries, array[timestamp])` | Zeitreihen | Füllt fehlende Daten mit [linearer Interpolation](https://wikipedia.org/wiki/Linear_interpolation) aus. |
| `interpolate_linear(timeseries, timestamp)` | double | Füllt fehlende Daten mit [linearer](https://wikipedia.org/wiki/Linear_interpolation) Interpolation aus. |
| `interpolate_spline_cubic(timeseries, array[timestamp])` | Zeitreihen | Füllt fehlende Daten mithilfe der [kubischen Spline-Interpolation](https://wikiversity.org/wiki/Cubic_Spline_Interpolation#:~:text=Cubic%20spline%20interpolation%20is%20a,Lagrange%20polynomial%20and%20Newton%20polynomial.) aus. |
| `interpolate_spline_cubic(timeseries, timestamp)` | double | Füllt fehlende Daten mithilfe der [kubischen](https://wikiversity.org/wiki/Cubic_Spline_Interpolation#:~:text=Cubic%20spline%20interpolation%20is%20a,Lagrange%20polynomial%20and%20Newton%20polynomial.) Spline-Interpolation aus. |
| `interpolate_locf(timeseries, array[timestamp])` | Zeitreihen | Füllt fehlende Daten mit dem zuletzt abgetasteten Wert aus. |
| `interpolate_locf(timeseries, timestamp)` | double | Füllt fehlende Daten mit dem zuletzt abgetasteten Wert aus. |
| `interpolate_fill(timeseries, array[timestamp], double)` | Zeitreihen | Füllt fehlende Daten mit einem konstanten Wert aus. |
| `interpolate_fill(timeseries, timestamp, double)` | double | Füllt fehlende Daten mit einem konstanten Wert aus. |
## Abfragebeispiele
**Example**
Ermittelt die durchschnittliche CPU-Auslastung in Intervallen von 30 Sekunden für einen bestimmten EC2-Host in den letzten 2 Stunden und füllt die fehlenden Werte mit linearer Interpolation aus:
```
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)
```
**Example**
Ermitteln Sie die durchschnittliche CPU-Auslastung in 30-Sekunden-Intervallen für einen bestimmten EC2-Host in den letzten 2 Stunden und füllen Sie die fehlenden Werte durch Interpolation auf der Grundlage der letzten übernommenen Beobachtung aus:
```
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)
```
# Funktionen für Ableitungen
Derivate werden verwendet, um die Änderungsrate für eine bestimmte Kennzahl zu berechnen und können verwendet werden, um proaktiv auf ein Ereignis zu reagieren. Nehmen wir beispielsweise an, Sie berechnen die Ableitung der CPU-Auslastung von EC2-Instances in den letzten 5 Minuten und stellen eine signifikante positive Ableitung fest. Dies kann auf eine erhöhte Auslastung Ihrer Arbeitslast hindeuten, sodass Sie möglicherweise entscheiden, mehr EC2-Instances hochzufahren, um Ihre Arbeitslast besser bewältigen zu können.
Amazon Timestream unterstützt zwei Varianten von abgeleiteten Funktionen. Dieser Abschnitt enthält Informationen zur Verwendung von Timestream für LiveAnalytics abgeleitete Funktionen sowie Beispielabfragen.
## Informationen zur Nutzung
| Funktion | Ausgabedatentyp | Description |
| --- | --- | --- |
| `derivative_linear(timeseries, interval)` | Zeitreihen | Berechnet die [Ableitung](https://wikipedia.org/wiki/Derivative) jedes Punktes in der `timeseries` für den angegebenen Wert. `interval` |
| `non_negative_derivative_linear(timeseries, interval)` | Zeitreihen | Wie`derivative_linear(timeseries, interval)`, gibt aber nur positive Werte zurück. |
## Abfragebeispiele
**Example**
Ermitteln Sie die Änderungsrate der CPU-Auslastung alle 5 Minuten in den letzten 1 Stunde:
```
SELECT DERIVATIVE_LINEAR(CREATE_TIME_SERIES(time, measure_value::double), 5m) AS result
FROM “sampleDB”.DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv' and time > ago(1h)
GROUP BY hostname, measure_name
```
**Example**
Berechnen Sie die Rate der Zunahme von Fehlern, die durch einen oder mehrere Microservices verursacht werden:
```
WITH binned_view as (
SELECT bin(time, 5m) as binned_timestamp, ROUND(AVG(measure_value::double), 2) as value
FROM “sampleDB”.DevOps
WHERE micro_service = 'jwt'
AND time > ago(1h)
AND measure_name = 'service_error'
GROUP BY bin(time, 5m)
)
SELECT non_negative_derivative_linear(CREATE_TIME_SERIES(binned_timestamp, value), 1m) as rateOfErrorIncrease
FROM binned_view
```
# Integrale Funktionen
Sie können Integrale verwenden, um die Fläche unter der Kurve pro Zeiteinheit für Ihre Zeitreihenereignisse zu ermitteln. Nehmen wir als Beispiel an, Sie verfolgen das Volumen der Anfragen, die Ihre Anwendung pro Zeiteinheit erhält. In diesem Szenario können Sie die Integralfunktion verwenden, um das Gesamtvolumen der Anfragen zu ermitteln, die in einem bestimmten Intervall über einen bestimmten Zeitraum bearbeitet wurden.
Amazon Timestream unterstützt eine Variante integraler Funktionen. Dieser Abschnitt enthält Informationen zur Verwendung der Funktion Timestream for LiveAnalytics Integral sowie Beispielabfragen.
## Informationen zur Nutzung
| Funktion | Ausgabedatentyp | Description |
| --- | --- | --- |
| `integral_trapezoidal(timeseries(double))` `integral_trapezoidal(timeseries(double), interval day to second)` `integral_trapezoidal(timeseries(bigint))` `integral_trapezoidal(timeseries(bigint), interval day to second)` `integral_trapezoidal(timeseries(integer), interval day to second)` `integral_trapezoidal(timeseries(integer))` | double | Nähert sich dem [Integral](https://wikipedia.org/wiki/Integral) gemäß dem `interval day to second` für den angegebenen Wert angegebenen Wert unter Verwendung der `timeseries` [Trapezregel](https://wikipedia.org/wiki/Trapezoidal_rule) an. Der Parameter Intervall von Tag zu Sekunde ist optional und die Standardeinstellung ist. `1s` Weitere Hinweise zu Intervallen finden Sie unter[Intervall und Dauer](date-time-functions.md#date-time-functions-interval-duration). |
## Abfragebeispiele
**Example**
Berechnen Sie das Gesamtvolumen der Anfragen, die in der letzten Stunde alle fünf Minuten von einem bestimmten Host bearbeitet wurden:
```
SELECT INTEGRAL_TRAPEZOIDAL(CREATE_TIME_SERIES(time, measure_value::double), 5m) AS result FROM sample.DevOps
WHERE measure_name = 'request'
AND hostname = 'host-Hovjv'
AND time > ago (1h)
GROUP BY hostname, measure_name
```
# Korrelationsfunktionen
Bei zwei Zeitreihen ähnlicher Länge liefern Korrelationsfunktionen einen Korrelationskoeffizienten, der erklärt, wie sich die beiden Zeitreihen im Zeitverlauf entwickeln. Der Korrelationskoeffizient reicht von `-1.0` bis`1.0`. `-1.0`gibt an, dass die beiden Zeitreihen mit derselben Geschwindigkeit in entgegengesetzte Richtungen tendieren. `1.0` Bedeutet hingegen, dass die beiden Zeitreihen mit derselben Geschwindigkeit in dieselbe Richtung tendieren. Der Wert von `0` bedeutet, dass keine Korrelation zwischen den beiden Zeitreihen besteht. Wenn beispielsweise der Ölpreis steigt und der Aktienkurs eines Ölunternehmens steigt, weisen der Trend des Ölpreisanstiegs und des Preisanstiegs des Ölunternehmens einen positiven Korrelationskoeffizienten auf. Ein hoher positiver Korrelationskoeffizient würde darauf hindeuten, dass sich die beiden Preise mit ähnlicher Geschwindigkeit entwickeln. In ähnlicher Weise ist der Korrelationskoeffizient zwischen Anleihekursen und Anleiherenditen negativ, was darauf hindeutet, dass diese beiden Werte im Laufe der Zeit in die entgegengesetzte Richtung tendieren.
Amazon Timestream unterstützt zwei Varianten von Korrelationsfunktionen. Dieser Abschnitt enthält Informationen zur Verwendung von Timestream für LiveAnalytics Korrelationsfunktionen sowie Beispielabfragen.
## Informationen zur Nutzung
| Funktion | Ausgabedatentyp | Description |
| --- | --- | --- |
| `correlate_pearson(timeseries, timeseries)` | double | Berechnet den [Korrelationskoeffizienten von Pearson](https://wikipedia.org/wiki/Pearson_correlation_coefficient) für die beiden. `timeseries` Die Zeitreihen müssen dieselben Zeitstempel haben. |
| `correlate_spearman(timeseries, timeseries)` | double | Berechnet den [Spearman-Korrelationskoeffizienten für die beiden](https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient). `timeseries` Die Zeitreihen müssen dieselben Zeitstempel haben. |
## Abfragebeispiele
**Example**
```
WITH cte_1 AS (
SELECT INTERPOLATE_LINEAR(
CREATE_TIME_SERIES(time, measure_value::double),
SEQUENCE(min(time), max(time), 10m)) AS result
FROM sample.DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv' AND time > ago(1h)
GROUP BY hostname, measure_name
),
cte_2 AS (
SELECT INTERPOLATE_LINEAR(
CREATE_TIME_SERIES(time, measure_value::double),
SEQUENCE(min(time), max(time), 10m)) AS result
FROM sample.DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv' AND time > ago(1h)
GROUP BY hostname, measure_name
)
SELECT correlate_pearson(cte_1.result, cte_2.result) AS result
FROM cte_1, cte_2
```
# Funktionen filtern und reduzieren
Amazon Timestream unterstützt Funktionen zur Durchführung von Filter- und Reduktionsvorgängen mit Zeitreihendaten. Dieser Abschnitt enthält Informationen zur Verwendung von Timestream für LiveAnalytics Filter- und Reduktionsfunktionen sowie Beispielabfragen.
## Informationen zur Nutzung
| Funktion | Ausgabedatentyp | Description |
| --- | --- | --- |
| `filter(timeseries(T), function(T, Boolean))` | Zeitreihe (T) | Konstruiert eine Zeitreihe aus einer Eingabezeitreihe und verwendet dabei Werte, für die der übergebene `function` Wert zurückgegeben wird. `true` |
| `reduce(timeseries(T), initialState S, inputFunction(S, T, S), outputFunction(S, R))` | R | Gibt einen einzelnen Wert zurück, reduziert gegenüber der Zeitreihe. Das `inputFunction` wird der Reihe nach für jedes Element in der Zeitreihe aufgerufen. InputFunction verwendet nicht nur das aktuelle Element, sondern auch den aktuellen Status (anfänglich`initialState`) und gibt den neuen Status zurück. Das `outputFunction` wird aufgerufen, um den Endzustand in den Ergebniswert umzuwandeln. Das `outputFunction` kann eine Identitätsfunktion sein. |
## Abfragebeispiele
**Example**
Konstruieren Sie eine Zeitreihe der CPU-Auslastung eines Hosts und filtern Sie Punkte mit einem Messwert von mehr als 70:
```
WITH time_series_view AS (
SELECT INTERPOLATE_LINEAR(
CREATE_TIME_SERIES(time, ROUND(measure_value::double,2)),
SEQUENCE(ago(15m), ago(1m), 10s)) AS cpu_user
FROM sample.DevOps
WHERE hostname = 'host-Hovjv' and measure_name = 'cpu_utilization'
AND time > ago(30m)
GROUP BY hostname
)
SELECT FILTER(cpu_user, x -> x.value > 70.0) AS cpu_above_threshold
from time_series_view
```
**Example**
Konstruieren Sie eine Zeitreihe der CPU-Auslastung eines Hosts und bestimmen Sie die Quadratsumme der Messungen:
```
WITH time_series_view AS (
SELECT INTERPOLATE_LINEAR(
CREATE_TIME_SERIES(time, ROUND(measure_value::double,2)),
SEQUENCE(ago(15m), ago(1m), 10s)) AS cpu_user
FROM sample.DevOps
WHERE hostname = 'host-Hovjv' and measure_name = 'cpu_utilization'
AND time > ago(30m)
GROUP BY hostname
)
SELECT REDUCE(cpu_user,
DOUBLE '0.0',
(s, x) -> x.value * x.value + s,
s -> s)
from time_series_view
```
**Example**
Konstruieren Sie eine Zeitreihe der CPU-Auslastung eines Hosts und bestimmen Sie den Anteil der Stichproben, die über dem CPU-Schwellenwert liegen:
```
WITH time_series_view AS (
SELECT INTERPOLATE_LINEAR(
CREATE_TIME_SERIES(time, ROUND(measure_value::double,2)),
SEQUENCE(ago(15m), ago(1m), 10s)) AS cpu_user
FROM sample.DevOps
WHERE hostname = 'host-Hovjv' and measure_name = 'cpu_utilization'
AND time > ago(30m)
GROUP BY hostname
)
SELECT ROUND(
REDUCE(cpu_user,
-- initial state
CAST(ROW(0, 0) AS ROW(count_high BIGINT, count_total BIGINT)),
-- function to count the total points and points above a certain threshold
(s, x) -> CAST(ROW(s.count_high + IF(x.value > 70.0, 1, 0), s.count_total + 1) AS ROW(count_high BIGINT, count_total BIGINT)),
-- output function converting the counts to fraction above threshold
s -> IF(s.count_total = 0, NULL, CAST(s.count_high AS DOUBLE) / s.count_total)),
4) AS fraction_cpu_above_threshold
from time_series_view
```