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.

# Beispielabfragen
<a name="sample-queries"></a>

Dieser Abschnitt enthält Anwendungsbeispiele für die Abfragesprache von Timestream for LiveAnalytics.

**Topics**
+ [Einfache Abfragen](sample-queries.basic-scenarios.md)
+ [Abfragen mit Zeitreihenfunktionen](sample-queries.devops-scenarios.md)
+ [Abfragen mit Aggregatfunktionen](sample-queries.iot-scenarios.md)

# Einfache Abfragen
<a name="sample-queries.basic-scenarios"></a>

Im Folgenden werden die 10 zuletzt hinzugefügten Datenpunkte für eine Tabelle abgerufen.

```
SELECT * FROM <database_name>.<table_name>
ORDER BY time DESC
LIMIT 10
```

Im Folgenden werden die 5 ältesten Datenpunkte für eine bestimmte Kennzahl abgerufen.

```
SELECT * FROM <database_name>.<table_name>
WHERE measure_name = '<measure_name>'
ORDER BY time ASC
LIMIT 5
```

Das Folgende funktioniert mit Zeitstempeln mit einer Granularität von Nanosekunden.

```
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
```

Messwerte für Datensätze mit mehreren Kennzahlen werden anhand des Spaltennamens identifiziert. Messwerte für Datensätze mit einer Kennzahl werden anhand von`measure_value::<data_type>`, wo einer von,, oder `<data_type>` steht `double``bigint`, oder `varchar` wie unter beschrieben`boolean`, identifiziert. [Unterstützte Datentypen](supported-data-types.md) Weitere Informationen zur Modellierung von Kennzahlwerten finden Sie unter [Einzelne Tabelle im Vergleich zu mehreren](https://docs.aws.amazon.com/timestream/latest/developerguide/data-modeling.html#data-modeling-multiVsinglerecords) Tabellen.

Im Folgenden werden Werte für eine Kennzahl abgerufen, die `speed` aus Datensätzen mit mehreren Kennzahlen mit dem Wert von aufgerufen werden. `measure_name` `IoTMulti-stats`

```
SELECT speed FROM <database_name>.<table_name> where measure_name = 'IoTMulti-stats'
```

Im Folgenden werden `double` Werte aus Datensätzen mit einer Kennzahl von abgerufen. `measure_name` `load`

```
SELECT measure_value::double FROM <database_name>.<table_name> WHERE measure_name = 'load'
```

# Abfragen mit Zeitreihenfunktionen
<a name="sample-queries.devops-scenarios"></a>

**Topics**
+ [Beispieldatensatz und Abfragen](#sample-queries.devops-scenarios.example)

## Beispieldatensatz und Abfragen
<a name="sample-queries.devops-scenarios.example"></a>

Sie können Timestream verwenden LiveAnalytics , um die Leistung und Verfügbarkeit Ihrer Dienste und Anwendungen zu verstehen und zu verbessern. Im Folgenden finden Sie eine Beispieltabelle und Beispielabfragen, die auf dieser Tabelle ausgeführt werden. 

In der Tabelle `ec2_metrics` werden Telemetriedaten wie die CPU-Auslastung und andere Metriken von EC2-Instances gespeichert. Sie können die Tabelle unten einsehen.


| Zeit | Region | az | Hostname | measure\$1name | Messwert::doppelt | Messwert::bigint | 
| --- | --- | --- | --- | --- | --- | --- | 
|  2019-12-04 19:00:00.000 000000  |  us-east-1  |  us-ost-1a  |  Frontend 01  |  CPU-Auslastung  |  35,1  |  Null  | 
|  2019-12-04 19:00:00.000 000000  |  us-east-1  |  us-ost-1a  |  Frontend 01  |  memory\$1utilization  |  55,3  |  Null  | 
|  2019-12-04 19:00:00.000 000000  |  us-east-1  |  us-ost-1a  |  Frontend 01  |  Netzwerk-Bytes-Eingang  |  Null  |  1.500  | 
|  2019-12-04 19:00:00.000 000000  |  us-east-1  |  us-ost-1a  |  Frontend 01  |  netzwerk\$1bytes\$1out  |  Null  |  6.700  | 
|  2019-12-04 19:00:00.000 000000  |  us-east-1  |  us-ost-1b  |  Frontend 02  |  CPU-Auslastung  |  38,5  |  Null  | 
|  2019-12-04 19:00:00.000 000000  |  us-east-1  |  us-ost-1b  |  Frontend 02  |  memory\$1utilization  |  58,4  |  Null  | 
|  2019-12-04 19:00:00.000 000000  |  us-east-1  |  us-ost-1b  |  Frontend 02  |  Netzwerk-Bytes-Eingang  |  Null  |  23.000  | 
|  2019-12-04 19:00:00.000 000000  |  us-east-1  |  us-ost-1b  |  Frontend 02  |  netzwerk\$1bytes\$1out  |  Null  |  12.000  | 
|  2019-12-04 19:00:00.000 000000  |  us-east-1  |  us-ost-1c  |  Frontend 03  |  CPU-Auslastung  |  45.0  |  Null  | 
|  2019-12-04 19:00:00.000 000000  |  us-east-1  |  us-ost-1c  |  Frontend 03  |  memory\$1utilization  |  65,8  |  Null  | 
|  2019-12-04 19:00:00.000 000000  |  us-east-1  |  us-ost-1c  |  Frontend 03  |  Netzwerk-Bytes-Eingang  |  Null  |  15 000  | 
|  2019-12-04 19:00:00.000 000000  |  us-east-1  |  us-ost-1c  |  Frontend 03  |  netzwerk\$1bytes\$1out  |  Null  |  836.000  | 
|  2019-12-04 19:00:05.000 000000  |  us-east-1  |  us-ost-1a  |  Frontend 01  |  CPU-Auslastung  |  55,2  |  Null  | 
|  2019-12-04 19:00:05.000 000000  |  us-east-1  |  us-ost-1a  |  Frontend 01  |  memory\$1utilization  |  75.0  |  Null  | 
|  2019-12-04 19:00:05.000 000000  |  us-east-1  |  us-ost-1a  |  Frontend 01  |  Netzwerk-Bytes-Eingang  |  Null  |  1.245  | 
|  2019-12-04 19:00:05.000 000000  |  us-east-1  |  us-ost-1a  |  Frontend 01  |  netzwerk\$1bytes\$1out  |  Null  |  68.432  | 
|  2019-12-04 19:00:08.000 000000  |  us-east-1  |  us-ost-1b  |  Frontend 02  |  CPU-Auslastung  |  65,6  |  Null  | 
|  2019-12-04 19:00:08.000 000000  |  us-east-1  |  us-ost-1b  |  Frontend 02  |  memory\$1utilization  |  85,3  |  Null  | 
|  2019-12-04 19:00:08.000 000000  |  us-east-1  |  us-ost-1b  |  Frontend 02  |  Netzwerk-Bytes-Eingang  |  Null  |  1.245  | 
|  2019-12-04 19:00:08.000 000000  |  us-east-1  |  us-ost-1b  |  Frontend 02  |  netzwerk\$1bytes\$1out  |  Null  |  68.432  | 
|  2019-12-04 19:00:20.000 000000  |  us-east-1  |  us-ost-1c  |  Frontend 03  |  CPU-Auslastung  |  12.1  |  Null  | 
|  2019-12-04 19:00:20.000 000000  |  us-east-1  |  us-ost-1c  |  Frontend 03  |  memory\$1utilization  |  32,0  |  Null  | 
|  2019-12-04 19:00:20.000 000000  |  us-east-1  |  us-ost-1c  |  Frontend 03  |  Netzwerk-Bytes-Eingang  |  Null  |  1.400  | 
|  2019-12-04 19:00:20.000 000000  |  us-east-1  |  us-ost-1c  |  Frontend 03  |  netzwerk\$1bytes\$1out  |  Null  |  345  | 
|  2019-12-04 19:00:10.000 000000  |  us-east-1  |  us-ost-1a  |  Frontend 01  |  CPU-Auslastung  |  15.3  |  Null  | 
|  2019-12-04 19:00:10.000 000000  |  us-east-1  |  us-ost-1a  |  Frontend 01  |  memory\$1utilization  |  35,4  |  Null  | 
|  2019-12-04 19:00:10.000 000000  |  us-east-1  |  us-ost-1a  |  Frontend 01  |  Netzwerk-Bytes-Eingang  |  Null  |  23  | 
|  2019-12-04 19:00:10.000 000000  |  us-east-1  |  us-ost-1a  |  Frontend 01  |  netzwerk\$1bytes\$1out  |  Null  |  0  | 
|  2019-12-04 19:00:16.000 000000  |  us-east-1  |  us-ost-1b  |  Frontend 02  |  CPU-Auslastung  |  44.0  |  Null  | 
|  2019-12-04 19:00:16.000 000000  |  us-east-1  |  us-ost-1b  |  Frontend 02  |  memory\$1utilization  |  64,2  |  Null  | 
|  2019-12-04 19:00:16.000 000000  |  us-east-1  |  us-ost-1b  |  Frontend 02  |  Netzwerk-Bytes-Eingang  |  Null  |  1.450  | 
|  2019-12-04 19:00:16.000 000000  |  us-east-1  |  us-ost-1b  |  Frontend 02  |  netzwerk\$1bytes\$1out  |  Null  |  200  | 
|  2019-12-04 19:00:40.000 000000  |  us-east-1  |  us-ost-1c  |  Frontend 03  |  CPU-Auslastung  |  66,4  |  Null  | 
|  2019-12-04 19:00:40.000 000000  |  us-east-1  |  us-ost-1c  |  Frontend 03  |  memory\$1utilization  |  86,3  |  Null  | 
|  2019-12-04 19:00:40.000 000000  |  us-east-1  |  us-ost-1c  |  Frontend 03  |  Netzwerk-Bytes-Eingang  |  Null  |  300  | 
|  2019-12-04 19:00:40.000 000000  |  us-east-1  |  us-ost-1c  |  Frontend 03  |  netzwerk\$1bytes\$1out  |  Null  |  423  | 

Ermitteln Sie die durchschnittliche CPU-Auslastung von p90, p95 und p99 für einen bestimmten EC2-Host in den letzten 2 Stunden:

```
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
```

Identifizieren Sie EC2-Hosts mit einer CPU-Auslastung, die um 10% oder mehr höher ist als die durchschnittliche CPU-Auslastung der gesamten Flotte in den letzten 2 Stunden:

```
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
```

Ermitteln Sie die durchschnittliche CPU-Auslastung in Intervallen von 30 Sekunden für einen bestimmten EC2-Host in den letzten 2 Stunden:

```
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
```

Ermitteln Sie die durchschnittliche CPU-Auslastung in Intervallen von 30 Sekunden für einen bestimmten EC2-Host in den letzten 2 Stunden und füllen Sie 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)
```

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)
```

# Abfragen mit Aggregatfunktionen
<a name="sample-queries.iot-scenarios"></a>

Im Folgenden finden Sie einen Beispieldatensatz für ein IoT-Szenario zur Veranschaulichung von Abfragen mit Aggregatfunktionen.

**Topics**
+ [Beispiel für Daten](#sample-queries.iot-scenarios.example-data)
+ [Beispielabfragen](#sample-queries.iot-scenarios.example-queries)

## Beispiel für Daten
<a name="sample-queries.iot-scenarios.example-data"></a>

Mit Timestream können Sie IoT-Sensordaten wie Standort, Kraftstoffverbrauch, Geschwindigkeit und Ladekapazität einer oder mehrerer LKW-Flotten speichern und analysieren, um ein effektives Flottenmanagement zu ermöglichen. Im Folgenden finden Sie das Schema und einige Daten einer Tabelle iot\$1trucks, in der Telemetriedaten wie Standort, Kraftstoffverbrauch, Geschwindigkeit und Ladekapazität von Lkw gespeichert werden.


| Zeit | truck\$1id | Marke | Modell | Flotte | Treibstoffkapazität | Ladekapazität | measure\$1name | Messwert::doppelt | Messwert::varchar | 
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | 
|  2019-12-04 19:00:00.000 000000  |  123456781  |  GMC  |  Astro  |  Alpha (Alpha)  |  100  |  500  |  Treibstoff auslesen  |  65,2  |  Null  | 
|  2019-12-04 19:00:00.000 000000  |  123456781  |  GMC  |  Astro  |  Alpha (Alpha)  |  100  |  500  |  load  |  400,0  |  Null  | 
|  2019-12-04 19:00:00.000 000000  |  123456781  |  GMC  |  Astro  |  Alpha (Alpha)  |  100  |  500  |  speed  |  90,2  |  Null  | 
|  2019-12-04 19:00:00.000 000000  |  123456781  |  GMC  |  Astro  |  Alpha (Alpha)  |  100  |  500  |  location  |  Null  |  47,6062 N, 122,3321 W  | 
|  2019-12-04 19:00:00.000 000000  |  123456782  |  Kenworth  |  W 900  |  Alpha (Alpha)  |  150  |  1000  |  Auslesen von Treibstoff  |  10.1  |  Null  | 
|  2019-12-04 19:00:00.000 000000  |  123456782  |  Kenworth  |  W 900  |  Alpha (Alpha)  |  150  |  1000  |  load  |  950,3  |  Null  | 
|  2019-12-04 19:00:00.000 000000  |  123456782  |  Kenworth  |  W 900  |  Alpha (Alpha)  |  150  |  1000  |  speed  |  50,8  |  Null  | 
|  2019-12-04 19:00:00.000 000000  |  123456782  |  Kenworth  |  W 900  |  Alpha (Alpha)  |  150  |  1000  |  location  |  Null  |  40,7128 Grad N, 74,0060 Grad W  | 

## Beispielabfragen
<a name="sample-queries.iot-scenarios.example-queries"></a>

Rufen Sie eine Liste aller Sensorattribute und -werte ab, die für jeden Lkw in der Flotte überwacht werden.

```
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
```

Rufen Sie die neuesten Kraftstoffwerte für jeden Lkw in der Flotte in den letzten 24 Stunden ab.

```
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
```

Identifizieren Sie Lkw, die in den letzten 48 Stunden mit wenig Kraftstoff (weniger als 10%) gefahren sind:

```
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
)
```

Finden Sie die Durchschnittslast und die Höchstgeschwindigkeit für jeden Lkw in der letzten Woche heraus:

```
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
```

Ermitteln Sie die Ladeeffizienz für jeden Lkw in der letzten Woche:

```
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
```