', default: (\)
```
Beim Exportieren der Daten im CSV-Format gibt dieses Feld das Zeichen an, das in der in den S3-Bucket geschriebenen Datendatei als Escape-Zeichen behandelt werden soll. Die Flucht erfolgt in den folgenden Szenarien:
1. Wenn der Wert selbst das Anführungszeichen („) enthält, wird er mit einem Escape-Zeichen maskiert. Wenn der Wert beispielsweise lautet`Time"stream`, wobei (\$1) das konfigurierte Escape-Zeichen ist, dann wird er als maskiert`Time\"stream`.
1. Wenn der Wert das konfigurierte Escape-Zeichen enthält, wird es maskiert. Wenn der Wert beispielsweise ist`Time\stream`, wird er als maskiert`Time\\stream`.
Wenn die exportierte Ausgabe komplexe Datentypen wie Arrays, Zeilen oder Zeitreihen enthält, wird sie als JSON-Zeichenfolge serialisiert. Im Folgenden sehen Sie ein Beispiel.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/timestream/latest/developerguide/supported-sql-constructs.UNLOAD.html)
INCLUDE\$1HEADER
```
include_header = 'true' , default: 'false'
```
Wenn Sie die Daten im CSV-Format exportieren, können Sie in diesem Feld Spaltennamen als erste Zeile der exportierten CSV-Datendateien angeben.
Die akzeptierten Werte sind „wahr“ und „falsch“ und der Standardwert ist „falsch“. Optionen zur Texttransformation, wie z. B. `escaped_by` und, `field_delimiter` gelten auch für Überschriften.
Beim Einbeziehen von Kopfzeilen ist es wichtig, dass Sie kein Wagenrücklaufzeichen (ASCII 13, Hex 0D, Text '\$1 r') oder ein Zeilenumbruchzeichen (ASCII 10, Hex 0A, Text '\$1n') als 'auswählen, da dies viele Parser daran hindert`FIELD_DELIMITER`, die Header in der resultierenden CSV-Ausgabe korrekt zu analysieren.
MAX\$1FILE\$1SIZE
```
max_file_size = 'X[MB|GB]' , default: '78GB'
```
Dieses Feld gibt die maximale Größe der Dateien an, die die `UNLOAD` Anweisung in Amazon S3 erstellt. Die `UNLOAD` Anweisung kann mehrere Dateien erstellen, aber die maximale Größe jeder in Amazon S3 geschriebenen Datei entspricht ungefähr der in diesem Feld angegebenen Größe.
Der Wert des Felds muss zwischen 16 MB und einschließlich 78 GB liegen. Sie können ihn als Ganzzahl wie `12GB` oder in Dezimalzahlen wie `0.5GB` oder angeben. `24.7MB` Der Standardwert ist 78 GB.
Die tatsächliche Dateigröße wird ungefähr angegeben, wenn die Datei geschrieben wird, sodass die tatsächliche Maximalgröße möglicherweise nicht exakt der von Ihnen angegebenen Zahl entspricht.
# Logische Operatoren
Timestream for LiveAnalytics unterstützt die folgenden logischen Operatoren.
| Operator | Beschreibung | Beispiel |
| --- | --- | --- |
| AND | Wahr, wenn beide Werte wahr sind | a UND b |
| ODER | Wahr, wenn einer der Werte wahr ist | a ODER b |
| NOT | Stimmt, wenn der Wert falsch ist | NICHT ein |
+ Das Ergebnis eines `AND` Vergleichs kann sein, `NULL` ob eine oder beide Seiten des Ausdrucks sind`NULL`.
+ Wenn mindestens eine Seite eines `AND` Operators ist, wird `FALSE` der Ausdruck zu `FALSE` ausgewertet.
+ Das Ergebnis eines `OR` Vergleichs kann sein`NULL`, wenn eine oder beide Seiten des `NULL` Ausdrucks
+ Wenn mindestens eine Seite eines `OR` Operators ist, wird `TRUE` der Ausdruck zu `TRUE` ausgewertet.
+ Die logische Ergänzung von `NULL` ist`NULL`.
Die folgende Wahrheitstabelle zeigt den Umgang mit `NULL` in `AND` und`OR`:
| A | B | A und b | A oder 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 |
Die folgende Wahrheitstabelle zeigt den Umgang mit NULL in NOT:
| A | Kein |
| --- | --- |
| Null | Null |
| true | false |
| false | true |
# Vergleichsoperatoren
Timestream for LiveAnalytics unterstützt die folgenden Vergleichsoperatoren.
| Operator | Description |
| --- | --- |
| < | Kleiner als |
| > | Größer als |
| <= | Kleiner als oder gleich |
| >= | Größer als oder gleich |
| = | Gleich |
| <> | Ungleich |
| \$1= | Ungleich |
**Anmerkung**
Der `BETWEEN` Operator testet, ob ein Wert innerhalb eines angegebenen Bereichs liegt. Die Syntax ist wie folgt:
```
BETWEEN min AND max
```
Das Vorhandensein von `NULL` in einer `BETWEEN` `NOT BETWEEN` Oder-Anweisung führt dazu, dass die Anweisung als 0 bewertet wird`NULL`.
`IS NULL `und `IS NOT NULL` Operatoren testen, ob ein Wert Null (undefiniert) ist. Die Verwendung von `NULL` with `IS NULL` ergibt „Wahr“.
In SQL bedeutet ein `NULL` Wert einen unbekannten Wert.
# Vergleichsfunktionen
Timestream for LiveAnalytics unterstützt die folgenden Vergleichsfunktionen.
**Topics**
+ [am größten ()](comparison-functions.greatest.md)
+ [am wenigsten ()](comparison-functions.least.md)
+ [ALL (), ANY () und SOME ()](comparison-functions.all-any-some.md)
# am größten ()
Die Funktion **greatest ()** gibt den größten der angegebenen Werte zurück. Sie gibt zurück`NULL`, ob einer der angegebenen Werte zutrifft`NULL`. Die Syntax ist wie folgt.
```
greatest(value1, value2, ..., valueN)
```
# am wenigsten ()
Die Funktion **least ()** gibt den kleinsten der angegebenen Werte zurück. Sie gibt zurück`NULL`, ob einer der angegebenen Werte zutrifft`NULL`. Die Syntax ist wie folgt.
```
least(value1, value2, ..., valueN)
```
# ALL (), ANY () und SOME ()
Die `SOME` Quantifizierer`ALL`, `ANY` und können zusammen mit Vergleichsoperatoren auf folgende Weise verwendet werden.
| Expression | Bedeutung |
| --- | --- |
| A = ALLE (...) | Wird als wahr ausgewertet, wenn A allen Werten entspricht. |
| A <> ALLE (...) | Wird als wahr ausgewertet, wenn A mit keinem Wert übereinstimmt. |
| A < ALLE (...) | Wird als wahr ausgewertet, wenn A kleiner als der kleinste Wert ist. |
| A = BELIEBIG (...) | Wird als wahr ausgewertet, wenn A einem der Werte entspricht. |
| A <> BELIEBIG (...) | Wird als wahr ausgewertet, wenn A nicht mit einem oder mehreren Werten übereinstimmt. |
| A < BELIEBIG (...) | Wird als wahr ausgewertet, wenn A kleiner als der größte Wert ist. |
## Beispiele und Nutzungshinweise
**Anmerkung**
Bei der Verwendung von `ALL` `ANY` oder `VALUES` sollte das Schlüsselwort verwendet werden`SOME`, wenn es sich bei den Vergleichswerten um eine Liste von Literalen handelt.
## Beispiel: `ANY()`
Ein Beispiel für `ANY()` in einer Abfrageanweisung wie folgt.
```
SELECT 11.7 = ANY (VALUES 12.0, 13.5, 11.7)
```
Eine alternative Syntax für dieselbe Operation lautet wie folgt.
```
SELECT 11.7 = ANY (SELECT 12.0 UNION ALL SELECT 13.5 UNION ALL SELECT 11.7)
```
In diesem Fall `ANY()` ergibt das Ergebnis. `True`
## Beispiel: `ALL()`
Ein Beispiel für `ALL()` in einer Abfrageanweisung wie folgt.
```
SELECT 17 < ALL (VALUES 19, 20, 15);
```
Eine alternative Syntax für dieselbe Operation lautet wie folgt.
```
SELECT 17 < ALL (SELECT 19 UNION ALL SELECT 20 UNION ALL SELECT 15);
```
In diesem Fall `ALL()` ergibt das Ergebnis. `False`
## Beispiel: `SOME()`
Ein Beispiel für `SOME()` in einer Abfrageanweisung wie folgt.
```
SELECT 50 >= SOME (VALUES 53, 77, 27);
```
Eine alternative Syntax für dieselbe Operation lautet wie folgt.
```
SELECT 50 >= SOME (SELECT 53 UNION ALL SELECT 77 UNION ALL SELECT 27);
```
In diesem Fall `SOME()` ergibt das Ergebnis. `True`
# Bedingte Ausdrücke
Timestream for LiveAnalytics unterstützt die folgenden bedingten Ausdrücke.
**Topics**
+ [Die CASE-Anweisung](conditional-expressions.CASE.md)
+ [Die IF-Anweisung](conditional-expressions.IF.md)
+ [Die COALESCE-Erklärung](conditional-expressions.COALESCE.md)
+ [Die NULLIF-Anweisung](conditional-expressions.NULLIF.md)
+ [Die TRY-Anweisung](conditional-expressions.TRY.md)
# Die CASE-Anweisung
Die **CASE-Anweisung** durchsucht jeden Wertausdruck von links nach rechts, bis sie einen findet, der gleich `expression` ist. Wenn eine Übereinstimmung gefunden wird, wird das Ergebnis für den entsprechenden Wert zurückgegeben. Wenn keine Übereinstimmung gefunden wird, wird das Ergebnis der `ELSE` Klausel zurückgegeben, sofern es existiert; andernfalls `null` wird es zurückgegeben. Die Syntax ist wie folgt:
```
CASE expression
WHEN value THEN result
[ WHEN ... ]
[ ELSE result ]
END
```
Timestream unterstützt auch die folgende Syntax für **CASE-Anweisungen**. In dieser Syntax wertet das Formular „Gesucht“ jede boolesche Bedingung von links nach rechts aus, bis eine vorliegt, `true` und gibt das passende Ergebnis zurück. Wenn keine Bedingungen vorliegen`true`, wird das Ergebnis der `ELSE` Klausel zurückgegeben, sofern es existiert; andernfalls `null` wird es zurückgegeben. Im Folgenden finden Sie die alternative Syntax:
```
CASE
WHEN condition THEN result
[ WHEN ... ]
[ ELSE result ]
END
```
# Die IF-Anweisung
Die **IF-Anweisung** bewertet eine Bedingung als wahr oder falsch und gibt den entsprechenden Wert zurück. **Timestream unterstützt die folgenden zwei Syntaxdarstellungen für IF:**
```
if(condition, true_value)
```
Diese Syntax wertet aus und gibt zurück, `true_value` ob die Bedingung erfüllt ist`true`; andernfalls `null` wird sie zurückgegeben und `true_value` nicht ausgewertet.
```
if(condition, true_value, false_value)
```
Diese Syntax wertet aus und gibt zurück, `true_value` ob die Bedingung erfüllt ist`true`, andernfalls wird ausgewertet und zurückgegeben. `false_value`
## Beispiele
```
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 | \$1Spalte 3 |
| --- | --- | --- | --- |
| `example 1` | `-` `null` | `example 3 true` | `example 4 false` |
# Die COALESCE-Erklärung
**COALESCE** gibt den ersten Wert in einer Argumentliste zurück, der nicht Null ist. Die Syntax ist wie folgt:
```
coalesce(value1, value2[,...])
```
# Die NULLIF-Anweisung
Die **IF-Anweisung** bewertet eine Bedingung als wahr oder falsch und gibt den entsprechenden Wert zurück. **Timestream unterstützt die folgenden zwei Syntaxdarstellungen für IF:**
**NULLIF** gibt Null zurück, wenn `value1` gleich; andernfalls wird zurückgegeben. `value2` `value1` Die Syntax ist wie folgt:
```
nullif(value1, value2)
```
# Die TRY-Anweisung
Die **TRY-Funktion** wertet einen Ausdruck aus und behandelt bestimmte Arten von Fehlern, indem sie zurückgibt`null`. Die Syntax ist wie folgt:
```
try(expression)
```
# Konvertierungs-Funktionen
Timestream for LiveAnalytics unterstützt die folgenden Konvertierungsfunktionen.
**Topics**
+ [cast()](#conversion-functions.cast)
+ [try\$1cast ()](#conversion-functions.try-cast)
## cast()
Die Syntax der Cast-Funktion zur expliziten Umwandlung eines Werts in einen Typ lautet wie folgt.
```
cast(value AS type)
```
## try\$1cast ()
Timestream for unterstützt LiveAnalytics auch die Funktion try\$1cast, die Cast ähnelt, aber null zurückgibt, wenn die Übertragung fehlschlägt. Die Syntax ist wie folgt.
```
try_cast(value AS type)
```
# Mathematische Operatoren
Timestream for LiveAnalytics unterstützt die folgenden mathematischen Operatoren.
| Operator | Description |
| --- | --- |
| \$1 | Addition |
| - | Subtraktion |
| \$1 | Multiplikation |
| / | Division (eine Ganzzahldivision führt eine Kürzung durch) |
| % | Modul (Rest) |
# Mathematische Funktionen
Timestream for LiveAnalytics unterstützt die folgenden mathematischen Funktionen.
| Funktion | Ausgabedatentyp | Description |
| --- | --- | --- |
| Bauchmuskeln (x) | [dasselbe wie Eingabe] | Gibt den absoluten Wert von x zurück. |
| cbrt (x) | double | Gibt die Kubikwurzel von x zurück. |
| Decke (x) oder Decke (x) | [wie Eingabe] | Gibt x aufgerundet auf die nächste Ganzzahl zurück. |
| Grad (x) | double | Konvertiert den Winkel x im Bogenmaß in Grad. |
| e () | double | Gibt die Konstante Eulersche Zahl zurück. |
| exp (x) | double | Gibt die Eulersche Zahl potenziert mit x zurück. |
| Stockwerk (x) | [dasselbe wie Eingabe] | Gibt x abgerundet auf die nächste Ganzzahl zurück. |
| from\$1base (Zeichenfolge, Radix) | bigint | Gibt den Wert einer Zeichenfolge zurück, die als Basiszahl interpretiert wird. |
| ln (x) | double | Gibt den natürlichen Logarithmus von x zurück. |
| log2 (x) | double | Gibt den Logarithmus zur Basis 2 von x zurück. |
| log10 (x) | double | Gibt den Logarithmus zur Basis 10 von x zurück. |
| mod (n, m) | [dasselbe wie Eingabe] | Gibt den Modul (Rest) von n geteilt durch m zurück. |
| pi () | double | Gibt die Konstante Pi zurück. |
| pow (x, p) oder Potenz (x, p) | double | Gibt x potenziert mit p zurück. |
| Bogenmaß (x) | double | Konvertiert den Winkel x in Grad in Radiant. |
| rand () oder random () | double | Gibt einen pseudozufälligen Wert im Bereich 0,0 — 1,0 zurück. |
| zufällig (n) | [dasselbe wie Eingabe] | Gibt eine Pseudozufallszahl zwischen 0 und n (ausschließlich) zurück. |
| rund (x) | [dasselbe wie Eingabe] | Gibt x auf die nächste Ganzzahl gerundet zurück. |
| rund (x, d) | [dasselbe wie Eingabe] | Gibt x auf d Dezimalstellen gerundet zurück. |
| Zeichen (x) | [dasselbe wie Eingabe] | Gibt die Signumfunktion von x zurück, das heißt: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/timestream/latest/developerguide/mathematical-functions.html) Bei doppelten Argumenten gibt die Funktion zusätzlich Folgendes zurück: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/timestream/latest/developerguide/mathematical-functions.html) |
| sqrt (x) | double | Gibt die Quadratwurzel von x zurück. |
| to\$1base (x, radix) | varchar | Gibt die Basisradix-Darstellung von x zurück. |
| kürzen (x) | double | Gibt x auf eine Ganzzahl gerundet zurück, indem Ziffern nach dem Dezimalpunkt weggelassen werden. |
| acos (x) | double | Gibt den Arkuskosinus von x zurück. |
| asin (x) | double | Gibt den Arkussinus von x zurück. |
| atan (x) | double | Gibt den Arkustangens von x zurück. |
| atan2 (y, x) | double | Gibt den Bogentangens von y/x zurück. |
| cos (x) | double | Gibt den Kosinus von x zurück. |
| cosh (x) | double | Gibt den hyperbolischen Kosinus von x zurück. |
| sin (x) | double | Gibt den Sinus von x zurück. |
| tan (x) | double | Gibt den Tangens von x zurück. |
| tanh (x) | double | Gibt den hyperbolischen Tangens von x zurück. |
| unendlich () | double | Gibt die Konstante zurück, die eine positive Unendlichkeit darstellt. |
| is\$1endlich (x) | boolesch | Ermitteln Sie, ob x endlich ist. |
| ist\$1unendlich (x) | boolesch | Ermitteln Sie, ob x unendlich ist. |
| is\$1nan (x) | boolesch | Ermitteln Sie, ob x ist. not-a-number |
| Mann () | double | Gibt die Konstante zurück, die repräsentiert not-a-number. |
# Zeichenfolgenoperatoren
Timestream for LiveAnalytics unterstützt den `||` Operator zum Verketten einer oder mehrerer Zeichenketten.
# Zeichenfolgenfunktionen
**Anmerkung**
Es wird davon ausgegangen, dass der Eingabedatentyp dieser Funktionen varchar ist, sofern nicht anders angegeben.
| Funktion | Ausgabedatentyp | Description |
| --- | --- | --- |
| chr (n) | varchar | Gibt den Unicode-Codepunkt n als Varchar zurück. |
| Codepunkt (x) | Ganzzahl | Gibt den Unicode-Codepunkt des einzigen Zeichens von str zurück. |
| concat (x1,..., xN) | varchar | Gibt die Verkettung von x1, x2,..., xN zurück. |
| hamming\$1distance (x1, x2) | bigint | Gibt die Hamming-Distanz von x1 und x2 zurück, d. h. die Anzahl der Positionen, an denen sich die entsprechenden Zeichen unterscheiden. Beachten Sie, dass die beiden Varchar-Eingaben dieselbe Länge haben müssen. |
| Länge (x) | bigint | Gibt die Länge von x in Zeichen zurück. |
| levenshtein\$1distance (x1, x2) | bigint | Gibt die Levenshtein-Bearbeitungsdistanz von x1 und x2 zurück, d. h. die Mindestanzahl von Änderungen einzelner Zeichen (Einfügungen, Löschungen oder Ersetzungen), die erforderlich sind, um x1 in x2 zu ändern. |
| niedriger (x) | varchar | Konvertiert x in Kleinbuchstaben. |
| load (x1, Bigint-Größe, x2) | varchar | Fügt x1 nach links ein, um die Größe von Zeichen mit x2 zu ändern. Wenn die Größe kleiner als die Länge von x1 ist, wird das Ergebnis auf die Größe der Zeichen gekürzt. Größe darf nicht negativ sein und x2 darf nicht leer sein. |
| ltrim (x) | varchar | Entfernt führende Leerzeichen aus x. |
| ersetzt (x1, x2) | varchar | Entfernt alle Instanzen von x2 aus x1. |
| ersetzt (x1, x2, x3) | varchar | Ersetzt alle Instanzen von x2 durch x3 in x1. |
| Rückwärts (x) | varchar | Gibt x mit den Zeichen in umgekehrter Reihenfolge zurück. |
| road (x1, Bigint-Größe, x2) | varchar | Drücken Sie x1 nach rechts, um die Größe von Zeichen mit x2 zu ändern. Wenn die Größe kleiner als die Länge von x1 ist, wird das Ergebnis auf die Größe der Zeichen gekürzt. Größe darf nicht negativ sein und x2 darf nicht leer sein. |
| rtrim (x) | varchar | Entfernt abschließende Leerzeichen aus x. |
| geteilt (x1, x2) | array(varchar) | Teilt x1 am Trennzeichen x2 auf und gibt ein Array zurück. |
| Split (x1, x2, Bigint-Limit) | array(varchar) | Teilt x1 auf das Trennzeichen x2 und gibt ein Array zurück. Das letzte Element im Array enthält immer alles, was im Bereich x1 noch übrig ist. Der Grenzwert muss eine positive Zahl sein. |
| split\$1part (x1, x2, bigint pos) | varchar | Teilt x1 am Trennzeichen x2 auf und gibt das Varchar-Feld an Pos zurück. Feldindizes beginnen mit 1. Wenn pos größer als die Anzahl der Felder ist, wird Null zurückgegeben. |
| strpos (x1, x2) | bigint | Gibt die Startposition der ersten Instanz von x2 in x1 zurück. Positionen beginnen mit 1. Wenn nicht gefunden, wird 0 zurückgegeben. |
| strpos (x1, x2, Bigint-Instanz) | bigint | Gibt die Position der N-ten Instanz von x2 in x1 zurück. Die Instanz muss eine positive Zahl sein. Positionen beginnen mit 1. Wenn nicht gefunden, wird 0 zurückgegeben. |
| strrpos (x1, x2) | bigint | Gibt die Startposition der letzten Instanz von x2 in x1 zurück. Positionen beginnen mit 1. Wenn nicht gefunden, wird 0 zurückgegeben. |
| strrpos (x1, x2, Bigint-Instanz) | bigint | Gibt die Position der N-ten Instanz von x2 in x1 zurück, beginnend am Ende von x1. Instanz muss eine positive Zahl sein. Positionen beginnen mit 1. Wenn nicht gefunden, wird 0 zurückgegeben. |
| Position (x2 IN x1) | bigint | Gibt die Startposition der ersten Instanz von x2 in x1 zurück. Positionen beginnen mit 1. Wenn nicht gefunden, wird 0 zurückgegeben. |
| substr (x, Bigint, Start) | varchar | Gibt den Rest von x von der Startposition start zurück. Positionen beginnen mit 1. Eine negative Startposition wird als relativ zum Ende von x interpretiert. |
| substr (x, bigint start, bigint len) | varchar | Gibt eine Teilzeichenfolge von x mit der Länge len von der Startposition start zurück. Positionen beginnen mit 1. Eine negative Startposition wird als relativ zum Ende von x interpretiert. |
| trimmen (x) | varchar | Entfernt führende und nachfolgende Leerzeichen aus x. |
| oberes (x) | varchar | Konvertiert x in Großbuchstaben. |
# Array-Operatoren
Timestream for LiveAnalytics unterstützt die folgenden Array-Operatoren.
| Operator | Description |
| --- | --- |
| [] | Greifen Sie auf ein Element eines Arrays zu, bei dem der erste Index bei 1 beginnt. |
| \$1\$1 | Verketten Sie ein Array mit einem anderen Array oder Element desselben Typs. |
# Array-Funktionen
Timestream for LiveAnalytics unterstützt die folgenden Array-Funktionen.
| Funktion | Ausgabedatentyp | Description |
| --- | --- | --- |
| array\$1distinct (x) | Array | Entferne doppelte Werte aus dem Array x. SELECT array_distinct(ARRAY[1,2,2,3])
Beispielergebnis: `[ 1,2,3 ]` |
| array\$1intersect (x, y) | Array | Gibt ein Array der Elemente im Schnittpunkt von x und y zurück, ohne Duplikate. SELECT array_intersect(ARRAY[1,2,3], ARRAY[3,4,5])
Beispielergebnis: `[ 3 ]` |
| array\$1union (x, y) | Array | Gibt ein Array der Elemente in der Vereinigung von x und y zurück, ohne Duplikate. SELECT array_union(ARRAY[1,2,3], ARRAY[3,4,5])
Beispielergebnis: `[ 1,2,3,4,5 ]` |
| array\$1except (x, y) | Array | Gibt ein Array von Elementen in x, aber nicht in y, ohne Duplikate zurück. SELECT array_except(ARRAY[1,2,3], ARRAY[3,4,5])
Beispielergebnis: `[ 1,2 ]` |
| array\$1join (x, delimiter, null\$1replacement) | varchar | Verkettet die Elemente des angegebenen Arrays mithilfe des Trennzeichens und einer optionalen Zeichenfolge, um Nullen zu ersetzen. SELECT array_join(ARRAY[1,2,3], ';', '')
Beispielergebnis: `1;2;3` |
| array\$1max (x) | dasselbe wie Array-Elemente | Gibt den Maximalwert des Eingabe-Arrays zurück. SELECT array_max(ARRAY[1,2,3])
Beispielergebnis: `3` |
| array\$1min (x) | dasselbe wie Array-Elemente | Gibt den Minimalwert des Eingabe-Arrays zurück. SELECT array_min(ARRAY[1,2,3])
Beispielergebnis: `1` |
| array\$1position (x, Element) | bigint | Gibt die Position des ersten Vorkommens des Elements in Array x zurück (oder 0, falls es nicht gefunden wurde). SELECT array_position(ARRAY[3,4,5,9], 5)
Beispielergebnis: `3` |
| array\$1remove (x, Element) | Array | Entferne alle Elemente, die dem Element entsprechen, aus dem Array x. SELECT array_remove(ARRAY[3,4,5,9], 4)
Beispielergebnis: `[ 3,5,9 ]` |
| array\$1sort (x) | Array | Sortiert das Array x und gibt es zurück. Die Elemente von x müssen sortierbar sein. Null-Elemente werden am Ende des zurückgegebenen Arrays platziert. SELECT array_sort(ARRAY[6,8,2,9,3])
Beispielergebnis: `[ 2,3,6,8,9 ]` |
| arrays\$1overlap (x, y) | boolesch | Testet, ob die Arrays x und y irgendwelche Elemente gemeinsam haben, die nicht Null sind. Gibt Null zurück, wenn es keine gemeinsamen Elemente gibt, die nicht Null sind, aber eines der Arrays Null enthält. SELECT arrays_overlap(ARRAY[6,8,2,9,3], ARRAY[6,8])
Beispielergebnis: `true` |
| Kardinalität (x) | bigint | Gibt die Größe des Arrays x zurück. SELECT cardinality(ARRAY[6,8,2,9,3])
Beispielergebnis: `5` |
| concat (array1, array2,..., arrayN) | Array | Verkettet die Arrays array1, array2,..., arrayN. SELECT concat(ARRAY[6,8,2,9,3], ARRAY[11,32], ARRAY[6,8,2,0,14])
Beispielergebnis: `[ 6,8,2,9,3,11,32,6,8,2,0,14 ]` |
| element\$1at (Array (E), Index) | E | Gibt das Element eines Arrays am angegebenen Index zurück. Wenn der Index < 0 ist, greift element\$1at auf Elemente vom letzten bis zum ersten zu. SELECT element_at(ARRAY[6,8,2,9,3], 1)
Beispielergebnis: `6` |
| wiederholen (Element, Anzahl) | Array | Wiederhole das Element, um es mal zu zählen. SELECT repeat(1, 3)
Beispielergebnis: `[ 1,1,1 ]` |
| rückwärts (x) | Array | Gibt ein Array zurück, das die umgekehrte Reihenfolge von Array x hat. SELECT reverse(ARRAY[6,8,2,9,3])
Beispielergebnis: `[ 3,9,2,8,6 ]` |
| Reihenfolge (Start, Stopp) | Array (großer Ganzzahl) | Generiert eine Folge von ganzen Zahlen von Anfang bis Ende, wobei sie um 1 erhöht wird, wenn Start kleiner oder gleich Stopp ist, andernfalls -1. SELECT sequence(3, 8)
Beispielergebnis: `[ 3,4,5,6,7,8 ]` |
| Reihenfolge (Start, Stopp, Schritt) | Array (großer Ganzzahl) | Generiert eine Folge von ganzen Zahlen von Anfang bis Ende, die schrittweise inkrementiert wird. SELECT sequence(3, 15, 2)
Beispielergebnis: `[ 3,5,7,9,11,13,15 ]` |
| Reihenfolge (Start, Stopp) | Array (Zeitstempel) | Generiert eine Sequenz von Zeitstempeln vom Startdatum bis zum Enddatum, wobei die Reihenfolge um 1 Tag erhöht wird. SELECT sequence('2023-04-02 19:26:12.941000000', '2023-04-06 19:26:12.941000000', 1d) Beispielergebnis: `[ 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 ]` |
| Reihenfolge (Start, Stopp, Schritt) | Array (Zeitstempel) | Generiert eine Sequenz von Zeitstempeln vom Start bis zum Ende, die schrittweise inkrementiert werden. Der Datentyp des Schritts ist Intervall. SELECT sequence('2023-04-02 19:26:12.941000000', '2023-04-10 19:26:12.941000000', 2d) Beispiel für ein Ergebnis: `[ 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 ]` |
| mischen (x) | Array | Generiert eine zufällige Permutation des angegebenen Arrays x. SELECT shuffle(ARRAY[6,8,2,9,3])
Beispielergebnis: `[ 6,3,2,9,8 ]` |
| Schnitt (x, Start, Länge) | Array | Unterteilt das Array x, beginnend am Indexstart (oder am Ende, falls Start negativ ist) mit einer Länge von length. SELECT slice(ARRAY[6,8,2,9,3], 1, 3)
Beispielergebnis: `[ 6,8,2 ]` |
| zip (Matrix1, Matrix2 [,...]) | array (Zeile) | Fügt die angegebenen Arrays elementweise zu einem einzigen Array von Zeilen zusammen. Wenn die Argumente eine ungleichmäßige Länge haben, werden fehlende Werte mit NULL aufgefüllt. SELECT zip(ARRAY[6,8,2,9,3], ARRAY[15,24])
Beispielergebnis: `[ ( 6, 15 ),( 8, 24 ),( 2, - ),( 9, - ),( 3, - ) ]` |
# Bitweise-Funktionen
Timestream for LiveAnalytics unterstützt die folgenden bitweisen Funktionen.
| Funktion | Ausgabedatentyp | Description |
| --- | --- | --- |
| bit\$1count (Bigint, Bigint) | bigint (Zweierkomplement) | Gibt die Anzahl der Bits im ersten Bigint-Parameter zurück, wobei der zweite Parameter eine Ganzzahl mit Bit-Vorzeichen wie 8 oder 64 ist. SELECT bit_count(19, 8)
Beispielergebnis: `3` SELECT bit_count(19, 2)
Beispielergebnis: `Number must be representable with the bits specified. 19 can not be represented with 2 bits` |
| bitwise\$1and (bigint, bigint) | bigint (Zweierkomplement) | Gibt das bitweise UND der Bigint-Parameter zurück. SELECT bitwise_and(12, 7)
Beispielergebnis: `4` |
| bitwise\$1not (bigint) | bigint (Zweierkomplement) | Gibt das bitweise NOT des Bigint-Parameters zurück. SELECT bitwise_not(12)
Beispielergebnis: `-13` |
| bitwise\$1or (bigint, bigint) | bigint (Zweierkomplement) | Gibt das bitweise ODER der Bigint-Parameter zurück. SELECT bitwise_or(12, 7)
Beispielergebnis: `15` |
| bitwise\$1xor (bigint, bigint) | bigint (Zweierkomplement) | Gibt das bitweise XOR der Bigint-Parameter zurück. SELECT bitwise_xor(12, 7)
Beispielergebnis: `11` |
# Funktionen für reguläre Ausdrücke
Die Funktionen für reguläre Ausdrücke in Timestream for LiveAnalytics unterstützen die [Java-Muster-Syntax](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html). Timestream for LiveAnalytics unterstützt die folgenden Funktionen für reguläre Ausdrücke.
| Funktion | Ausgabedatentyp | Description |
| --- | --- | --- |
| regexp\$1extract\$1all (Zeichenfolge, Muster) | array(varchar) | Gibt die Teilzeichenfolge (n) zurück, denen das reguläre Ausdrucksmuster in der Zeichenfolge entspricht. SELECT regexp_extract_all('example expect complex', 'ex\w') Beispielergebnis: `[ exa,exp ]` |
| regexp\$1extract\$1all (Zeichenfolge, Muster, Gruppe) | array(varchar) | [Findet alle Vorkommen des Musters mit regulären Ausdrücken in einer Zeichenfolge und gibt die Gruppe mit der aufnehmenden Gruppennummer zurück.](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html#gnumber) SELECT regexp_extract_all('example expect complex', '(ex)(\w)', 2) Beispielergebnis: `[ a,p ]` |
| regexp\$1extract (Zeichenfolge, Muster) | varchar | Gibt die erste Teilzeichenfolge zurück, der dem regulären Ausdrucksmuster in der Zeichenfolge entspricht. SELECT regexp_extract('example expect', 'ex\w') Beispielergebnis: `exa` |
| regexp\$1extract (Zeichenfolge, Muster, Gruppe) | varchar | Findet das erste Vorkommen des Musters mit regulären Ausdrücken in einer Zeichenfolge und gibt die Gruppe mit der [aufnehmenden](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html#gnumber) Gruppennummer zurück. SELECT regexp_extract('example expect', '(ex)(\w)', 2) Beispielergebnis: `a` |
| regexp\$1like (Zeichenfolge, Muster) | boolesch | Wertet das Muster eines regulären Ausdrucks aus und bestimmt, ob es in einer Zeichenfolge enthalten ist. Diese Funktion ähnelt dem LIKE-Operator, außer dass das Muster nur in einer Zeichenfolge enthalten sein muss und nicht der gesamten Zeichenfolge entsprechen muss. Mit anderen Worten, sie führt eher eine Contains-Operation als eine Match-Operation aus. Sie können die gesamte Zeichenfolge zuordnen, indem Sie das Muster mit ^ und \$1 verankern. SELECT regexp_like('example', 'ex') Beispielergebnis: `true` |
| regexp\$1replace (Zeichenfolge, Muster) | varchar | Entfernt jede Instanz der Teilzeichenfolge, der dem Muster des regulären Ausdrucks entspricht, aus der Zeichenfolge. SELECT regexp_replace('example expect', 'expect') Beispielergebnis: `example` |
| regexp\$1replace (Zeichenfolge, Muster, Ersatz) | varchar | Ersetzt jede Instanz der Teilzeichenfolge, der dem Regex-Muster in der Zeichenfolge entspricht, durch Ersetzung. Erfassende Gruppen können stattdessen referenziert werden, indem \$1g für eine nummerierte Gruppe oder \$1 \$1name\$1 für eine benannte Gruppe verwendet wird. Ein Dollarzeichen (\$1) kann in die Ersetzung aufgenommen werden, indem es durch einen umgekehrten Schrägstrich (\$1 \$1) ersetzt wird. SELECT regexp_replace('example expect', 'expect', 'surprise') Beispielergebnis: `example surprise` |
| regexp\$1replace (Zeichenfolge, Muster, Funktion) | varchar | Ersetzt mithilfe der Funktion jede Instanz der Teilzeichenfolge, auf die das reguläre Ausdrucksmuster in der Zeichenfolge zutrifft. Die [Lambda-Ausdrucksfunktion](https://prestodb.io/docs/current/functions/lambda.html) wird für jede Übereinstimmung aufgerufen, wobei die Erfassungsgruppen als Array übergeben werden. Die Erfassung von Gruppennummern beginnt bei eins; es gibt keine Gruppe für den gesamten Treffer (falls Sie diese benötigen, setzen Sie den gesamten Ausdruck in Klammern). SELECT regexp_replace('example', '(\w)', x -> upper(x[1])) Beispielergebnis: `EXAMPLE` |
| regexp\$1split (Zeichenfolge, Muster) | array(varchar) | Teilt eine Zeichenfolge anhand des Musters für reguläre Ausdrücke auf und gibt ein Array zurück. Am Ende stehende leere Zeichenketten werden beibehalten. SELECT regexp_split('example', 'x') Beispielergebnis: `[ e,ample ]` |
# Operatoren für Datum und Uhrzeit
**Anmerkung**
Timestream for unterstützt LiveAnalytics keine negativen Zeitwerte. Jede Operation, die zu einer negativen Zeit führt, führt zu einem Fehler.
Timestream for LiveAnalytics unterstützt die folgenden Operationen für `timestamps``dates`, und`intervals`.
| Operator | Description |
| --- | --- |
| \$1 | Addition |
| - | Subtraktion |
**Topics**
+ [Operationen](#date-time-operators-operations)
+ [Addition](#date-time-operators-addition)
+ [Subtraktion](#date-time-operators-subtraction)
## Operationen
Der Ergebnistyp einer Operation basiert auf den Operanden. Intervallliterale wie `1day` und `3s` können verwendet werden.
```
SELECT date '2022-05-21' + interval '2' day
```
```
SELECT date '2022-05-21' + 2d
```
```
SELECT date '2022-05-21' + 2day
```
Beispielergebnis für jedes: `2022-05-23`
Zu den Intervalleinheiten gehören `second` `minute``hour`,`day`,`week`,,`month`, und`year`. In einigen Fällen sind jedoch nicht alle anwendbar. Zum Beispiel können Sekunden, Minuten und Stunden nicht zu einem Datum hinzugefügt oder von diesem subtrahiert werden.
```
SELECT interval '4' year + interval '2' month
```
Beispielergebnis: `4-2`
```
SELECT typeof(interval '4' year + interval '2' month)
```
Beispielergebnis: `interval year to month`
Der Ergebnistyp von Intervalloperationen kann von den Operanden `'interval day to second'` abhängen `'interval year to month'` oder sein. Intervalle können zu und addiert oder von diesen subtrahiert werden. `dates` `timestamps` Ein `date` oder `timestamp` kann jedoch nicht zu einem Oder hinzugefügt oder von diesem subtrahiert werden. `date` `timestamp` Informationen zu Intervallen oder Dauern im Zusammenhang mit Datumsangaben oder Zeitstempeln finden Sie unter `date_diff` und verwandte Funktionen unter. [Intervall und Dauer](date-time-functions.md#date-time-functions-interval-duration)
## Addition
**Example**
```
SELECT date '2022-05-21' + interval '2' day
```
Beispiel für ein Ergebnis: `2022-05-23`
**Example**
```
SELECT typeof(date '2022-05-21' + interval '2' day)
```
Beispielergebnis: `date`
**Example**
```
SELECT interval '2' year + interval '4' month
```
Beispielergebnis: `2-4`
**Example**
```
SELECT typeof(interval '2' year + interval '4' month)
```
Beispielergebnis: `interval year to month`
## Subtraktion
**Example**
```
SELECT timestamp '2022-06-17 01:00' - interval '7' hour
```
Beispielergebnis: `2022-06-16 18:00:00.000000000`
**Example**
```
SELECT typeof(timestamp '2022-06-17 01:00' - interval '7' hour)
```
Beispielergebnis: `timestamp`
**Example**
```
SELECT interval '6' day - interval '4' hour
```
Beispielergebnis: `5 20:00:00.000000000`
**Example**
```
SELECT typeof(interval '6' day - interval '4' hour)
```
Beispielergebnis: `interval day to second`
# Funktionen für Datum und Uhrzeit
**Anmerkung**
Timestream for unterstützt LiveAnalytics keine negativen Zeitwerte. Jede Operation, die zu einer negativen Zeit führt, führt zu einem Fehler.
Timestream für LiveAnalytics verwendet die UTC-Zeitzone für Datum und Uhrzeit. Timestream unterstützt die folgenden Funktionen für Datum und Uhrzeit.
**Topics**
+ [Allgemeines und Konvertierung](#date-time-functions-general)
+ [Intervall und Dauer](#date-time-functions-interval-duration)
+ [Formatieren und Analysieren](#date-time-functions-formatting-parsing)
+ [Extraktion](#date-time-functions-extraction)
## Allgemeines und Konvertierung
Timestream for LiveAnalytics unterstützt die folgenden allgemeinen Funktionen und Konvertierungsfunktionen für Datum und Uhrzeit.
| Funktion | Ausgabedatentyp | Description |
| --- | --- | --- |
| aktuelles\$1Datum | date | Gibt das aktuelle Datum in UTC zurück. Es werden keine Klammern verwendet. SELECT current_date
Beispielergebnis: `2022-07-07` Dies ist auch ein reserviertes Schlüsselwort. Eine Liste der reservierten Schlüsselwörter finden Sie unter[Reservierte Schlüsselwörter](ts-limits.md#limits.reserved). |
| current\$1time | time | Gibt die aktuelle Zeit in UTC zurück. Es wurden keine Klammern verwendet. SELECT current_time
Beispielergebnis: `17:41:52.827000000` Dies ist auch ein reserviertes Schlüsselwort. Eine Liste der reservierten Schlüsselwörter finden Sie unter[Reservierte Schlüsselwörter](ts-limits.md#limits.reserved). |
| current\$1timestamp oder now () | Zeitstempel | Gibt den aktuellen Zeitstempel in UTC zurück. SELECT current_timestamp
Beispielergebnis: `2022-07-07 17:42:32.939000000` Dies ist auch ein reserviertes Schlüsselwort. Eine Liste der reservierten Schlüsselwörter finden Sie unter[Reservierte Schlüsselwörter](ts-limits.md#limits.reserved). |
| current\$1timezone () | varchar Der Wert wird 'UTC' sein. | Timestream verwendet die UTC-Zeitzone für Datum und Uhrzeit. SELECT current_timezone()
Beispielergebnis: `UTC` |
| Datum (varchar (x)), Datum (Zeitstempel) | date | SELECT date(TIMESTAMP '2022-07-07 17:44:43.771000000')
Beispiel für ein Ergebnis: `2022-07-07` |
| last\$1day\$1of\$1month (Zeitstempel), last\$1day\$1of\$1month (Datum) | date | SELECT last_day_of_month(TIMESTAMP '2022-07-07 17:44:43.771000000')
Beispiel für ein Ergebnis: `2022-07-31` |
| from\$1iso8601\$1timestamp (Zeichenfolge) | Zeitstempel | Analysiert den ISO 8601-Zeitstempel in ein internes Zeitstempelformat. SELECT from_iso8601_timestamp('2022-06-17T08:04:05.000000000+05:00') Beispielergebnis: `2022-06-17 03:04:05.000000000` |
| from\$1iso8601\$1date (Zeichenfolge) | date | Analysiert die ISO 8601-Datumszeichenfolge in ein internes Zeitstempelformat für UTC 00:00:00 des angegebenen Datums. SELECT from_iso8601_date('2022-07-17') Beispielergebnis: `2022-07-17` |
| to\$1iso8601 (Zeitstempel), to\$1iso8601 (Datum) | varchar | Gibt eine nach ISO 8601 formatierte Zeichenfolge für die Eingabe zurück. SELECT to_iso8601(from_iso8601_date('2022-06-17')) Beispielergebnis: `2022-06-17` |
| from\$1milliseconds (bigint) | Zeitstempel | SELECT from_milliseconds(1)
Beispiel für ein Ergebnis: `1970-01-01 00:00:00.001000000` |
| from\$1nanoseconds (bigint) | Zeitstempel | select from_nanoseconds(300000001)
Beispielergebnis: `1970-01-01 00:00:00.300000001` |
| from\$1unixtime (doppelt) | Zeitstempel | Gibt einen Zeitstempel zurück, der der angegebenen Unixtime entspricht. SELECT from_unixtime(1)
Beispielergebnis: `1970-01-01 00:00:01.000000000` |
| Ortszeit | time | Gibt die aktuelle Uhrzeit in UTC zurück. Es wurden keine Klammern verwendet. SELECT localtime
Beispielergebnis: `17:58:22.654000000` Dies ist auch ein reserviertes Schlüsselwort. Eine Liste der reservierten Schlüsselwörter finden Sie unter[Reservierte Schlüsselwörter](ts-limits.md#limits.reserved). |
| lokaler Zeitstempel | Zeitstempel | Gibt den aktuellen Zeitstempel in UTC zurück. Es werden keine Klammern verwendet. SELECT localtimestamp
Beispielergebnis: `2022-07-07 17:59:04.368000000` Dies ist auch ein reserviertes Schlüsselwort. Eine Liste der reservierten Schlüsselwörter finden Sie unter[Reservierte Schlüsselwörter](ts-limits.md#limits.reserved). |
| to\$1milliseconds (Intervall von Tag bis Sekunde), to\$1milliseconds (Zeitstempel) | bigint | SELECT to_milliseconds(INTERVAL '2' DAY + INTERVAL '3' HOUR)
Beispielergebnis: `183600000` SELECT to_milliseconds(TIMESTAMP '2022-06-17 17:44:43.771000000')
Beispielergebnis: `1655487883771` |
| to\$1nanoseconds (Intervall von Tag zu Sekunde), to\$1nanoseconds (Zeitstempel) | bigint | SELECT to_nanoseconds(INTERVAL '2' DAY + INTERVAL '3' HOUR)
Beispielergebnis: `183600000000000` SELECT to_nanoseconds(TIMESTAMP '2022-06-17 17:44:43.771000678')
Beispielergebnis: `1655487883771000678` |
| to\$1unixtime (Zeitstempel) | double | Gibt Unixtime für den angegebenen Zeitstempel zurück. SELECT to_unixtime('2022-06-17 17:44:43.771000000') Beispielergebnis: `1.6554878837710001E9` |
| date\$1trunc (Einheit, Zeitstempel) | Zeitstempel | Gibt den auf eine Einheit gekürzten Zeitstempel zurück, wobei Einheit eins von [Sekunde, Minute, Stunde, Tag, Woche, Monat, Quartal oder Jahr] ist. SELECT date_trunc('minute', TIMESTAMP '2022-06-17 17:44:43.771000000') Beispielergebnis: `2022-06-17 17:44:00.000000000` |
## Intervall und Dauer
Timestream for LiveAnalytics unterstützt die folgenden Intervall- und Dauerfunktionen für Datum und Uhrzeit.
| Funktion | Ausgabedatentyp | Description |
| --- | --- | --- |
| date\$1add (Einheit, Bigint, Datum), date\$1add (Einheit, Bigint, Zeit), date\$1add (varchar (x), bigint, timestamp) | Zeitstempel | Fügt einen Bigint von Einheiten hinzu, wobei Einheit eine von [Sekunde, Minute, Stunde, Tag, Woche, Monat, Quartal oder Jahr] ist. SELECT date_add('hour', 9, TIMESTAMP '2022-06-17 00:00:00') Beispielergebnis: `2022-06-17 09:00:00.000000000` |
| date\$1diff (Einheit, Datum, Datum), date\$1diff (Einheit, Zeit, Uhrzeit), date\$1diff (Einheit, Zeitstempel, Zeitstempel) | bigint | Gibt einen Unterschied zurück, wobei die Einheit eins von [Sekunde, Minute, Stunde, Tag, Woche, Monat, Quartal oder Jahr] ist. SELECT date_diff('day', DATE '2020-03-01', DATE '2020-03-02') Beispiel für ein Ergebnis: `1` |
| parse\$1duration (Zeichenfolge) | Intervall | Analysiert die Eingabezeichenfolge, um ein Äquivalent zurückzugeben. `interval` SELECT parse_duration('42.8ms') Beispielergebnis: `0 00:00:00.042800000` SELECT typeof(parse_duration('42.8ms')) Beispielergebnis: `interval day to second` |
| bin (Zeitstempel, Intervall) | Zeitstempel | Rundet den Integer-Wert des `timestamp` Parameters auf das nächste Vielfache des Integer-Werts des `interval` Parameters ab. Die Bedeutung dieses Rückgabewerts ist möglicherweise nicht offensichtlich. Er wird mithilfe der Ganzzahl-Arithmetik berechnet, indem zuerst die Ganzzahl mit dem Zeitstempel durch die Ganzzahl für das Intervall dividiert und dann das Ergebnis mit der Intervallzahl multipliziert wird. Wenn man bedenkt, dass ein Zeitstempel einen UTC-Zeitpunkt als Anzahl von Sekundenbruchteilen angibt, die seit der POSIX-Epoche (1. Januar 1970) vergangen sind, stimmt der Rückgabewert selten mit Kalendereinheiten überein. Wenn Sie beispielsweise ein Intervall von 30 Tagen angeben, werden alle Tage seit der Epoche in 30-Tage-Inkremente unterteilt, und der Beginn des letzten 30-Tage-Inkrements wird zurückgegeben, was keinen Bezug zu Kalendermonaten hat. Hier sind einige Beispiele: 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
|
| vor (Intervall) | Zeitstempel | Gibt den Wert zurück, der current\$1timestamp `interval` entspricht. SELECT ago(1d)
Beispielergebnis: `2022-07-06 21:08:53.245000000` |
| Intervallliterale wie 1h, 1d und 30m | Intervall | Intervallliterale sind praktisch für parse\$1duration (string). Zum Beispiel ist `1d` identisch zu `parse_duration('1d')`. Dies ermöglicht die Verwendung der Literale überall dort, wo ein Intervall verwendet wird. Beispiel: `ago(1d)` und `bin(, 1m)`. |
Einige Intervallliterale dienen als Abkürzung für parse\$1duration. Zum Beispiel,,, und geben `1d` jeweils `parse_duration('1day')` zurück `1day``parse_duration('1d')`, wo sich der Typ befindet. `1 00:00:00.000000000` `interval day to second` Leerzeichen sind in dem Format zulässig, das für bereitgestellt wurde`parse_duration`. Gibt zum Beispiel `parse_duration('1day')` auch zurück`00:00:00.000000000`. `1 day`Ist aber kein Intervall wörtlich.
Die Einheiten, auf die sich beziehen, `interval day to second` sind ns, Nanosekunde, us, Mikrosekunde, ms, Millisekunde, s, Sekunde, m, Minute, h, Stunde, d und Tag.
Es gibt auch. `interval year to month` Die Einheiten, die sich auf das Intervall von Jahr zu Monat beziehen, sind Y, Jahr und Monat. Gibt zum Beispiel `SELECT 1year` zurück`1-0`. `SELECT 12month`kehrt auch zurück`1-0`. `SELECT 8month`kehrt zurück`0-8`.
Obwohl die Einheit von `quarter` auch für einige Funktionen wie `date_trunc` und verfügbar `quarter` ist`date_add`, ist sie nicht als Teil eines Intervallliterals verfügbar.
## Formatieren und Analysieren
Timestream for LiveAnalytics unterstützt die folgenden Formatierungs- und Analysefunktionen für Datum und Uhrzeit.
| Funktion | Ausgabedatentyp | Description |
| --- | --- | --- |
| date\$1format (Zeitstempel, varchar (x)) | varchar | [Weitere Hinweise zu den von dieser Funktion verwendeten Formatbezeichnern finden Sie unter \$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')
Beispielergebnis: `2019-10-20 10:20:20` |
| date\$1parse (varchar (x), varchar (y)) | Zeitstempel | [Weitere Hinweise zu den von dieser Funktion verwendeten Formatbezeichnern finden Sie unter \$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') Beispielergebnis: `2019-10-20 10:20:20.000000000` |
| format\$1datetime (Zeitstempel, varchar (x)) | varchar | [Weitere Informationen zu der von dieser Funktion verwendeten Formatzeichenfolge finden Sie unter http://joda-time.sourceforge. net/apidocs/org/joda/time/format/DateTimeFormat](http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html).html SELECT format_datetime(parse_datetime('1968-01-13 12', 'yyyy-MM-dd HH'), 'yyyy-MM-dd HH') Beispielergebnis: `1968-01-13 12` |
| parse\$1datetime (varchar (x), varchar (y)) | Zeitstempel | [Weitere Informationen zu der von dieser Funktion verwendeten Formatzeichenfolge finden Sie unter http://joda-time.sourceforge. net/apidocs/org/joda/time/format/DateTimeFormat](http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html).html SELECT parse_datetime('2019-12-29 10:10 PST', 'uuuu-LL-dd HH:mm z') Beispielergebnis: `2019-12-29 18:10:00.000000000` |
## Extraktion
Timestream for LiveAnalytics unterstützt die folgenden Extraktionsfunktionen für Datum und Uhrzeit. Die Extraktfunktion ist die Grundlage für die übrigen Komfortfunktionen.
| Funktion | Datentyp der Ausgabe | Description |
| --- | --- | --- |
| extract | bigint | Extrahiert ein Feld aus einem Zeitstempel, wobei das Feld einem der Werte [JAHR, QUARTAL, MONAT, WOCHE, TAG, TAG\$1DES MONATS, DAY\$1OF\$1WEEK, DOW, DAY\$1OF\$1YEAR, DOY, YEAR\$1OF\$1WEEK, YOW, HOUR, MINUTE oder SECOND] entspricht. SELECT extract(YEAR FROM '2019-10-12 23:10:34.000000000')
Beispielergebnis: `2019` |
| Tag (Zeitstempel), Tag (Datum), Tag (Intervall Tag bis Sekunde) | bigint | SELECT day('2019-10-12 23:10:34.000000000') Beispiel für ein Ergebnis: `12` |
| day\$1of\$1month (timestamp), day\$1of\$1month (Datum), day\$1of\$1month (Intervall von Tag bis Sekunde) | bigint | SELECT day_of_month('2019-10-12 23:10:34.000000000') Beispiel für ein Ergebnis: `12` |
| day\$1of\$1week (Zeitstempel), day\$1of\$1week (Datum) | bigint | SELECT day_of_week('2019-10-12 23:10:34.000000000') Beispielergebnis: `6` |
| day\$1of\$1year (Zeitstempel), day\$1of\$1year (Datum) | bigint | SELECT day_of_year('2019-10-12 23:10:34.000000000') Beispielergebnis: `285` |
| dow (Zeitstempel), dow (Datum) | bigint | Alias für day\$1of\$1week |
| doy (Zeitstempel), doy (Datum) | bigint | Alias für day\$1of\$1year |
| Stunde (Zeitstempel), Stunde (Zeit), Stunde (Intervall Tag bis Sekunde) | bigint | SELECT hour('2019-10-12 23:10:34.000000000') Beispiel für ein Ergebnis: `23` |
| Millisekunde (Zeitstempel), Millisekunde (Zeit), Millisekunde (Intervall von Tag zu Sekunde) | bigint | SELECT millisecond('2019-10-12 23:10:34.000000000') Beispielergebnis: `0` |
| Minute (Zeitstempel), Minute (Zeit), Minute (Intervall von Tag zu Sekunde) | bigint | SELECT minute('2019-10-12 23:10:34.000000000') Beispiel für ein Ergebnis: `10` |
| Monat (Zeitstempel), Monat (Datum), Monat (Intervall von Jahr zu Monat) | bigint | SELECT month('2019-10-12 23:10:34.000000000') Beispiel für ein Ergebnis: `10` |
| Nanosekunde (Zeitstempel), Nanosekunde (Zeit), Nanosekunde (Intervall von Tag zu Sekunde) | bigint | SELECT nanosecond(current_timestamp)
Beispielergebnis: `162000000` |
| Quartal (Zeitstempel), Quartal (Datum) | bigint | SELECT quarter('2019-10-12 23:10:34.000000000') Beispiel für ein Ergebnis: `4` |
| Sekunde (Zeitstempel), Sekunde (Zeit), Sekunde (Intervall von Tag zu Sekunde) | bigint | SELECT second('2019-10-12 23:10:34.000000000') Beispiel für ein Ergebnis: `34` |
| Woche (Zeitstempel), Woche (Datum) | bigint | SELECT week('2019-10-12 23:10:34.000000000') Beispielergebnis: `41` |
| week\$1of\$1year (Zeitstempel), week\$1of\$1year (Datum) | bigint | Alias für Woche |
| Jahr (Zeitstempel), Jahr (Datum), Jahr (Intervall von Jahr zu Monat) | bigint | SELECT year('2019-10-12 23:10:34.000000000') Beispiel für ein Ergebnis: `2019` |
| year\$1of\$1week (Zeitstempel), year\$1of\$1week (Datum) | bigint | SELECT year_of_week('2019-10-12 23:10:34.000000000') Beispielergebnis: `2019` |
| yow (Zeitstempel), yow (Datum) | bigint | Alias für year\$1of\$1week |
# Aggregationsfunktionen
Timestream for LiveAnalytics unterstützt die folgenden Aggregatfunktionen.
| Funktion | Ausgabedatentyp | Description |
| --- | --- | --- |
| willkürlich (x) | [dasselbe wie Eingabe] | Gibt einen beliebigen Wert von x zurück, der ungleich Null ist, falls einer existiert. SELECT arbitrary(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Beispielergebnis: `1` |
| array\$1agg (x) | array< [dasselbe wie Eingabe] | Gibt ein Array zurück, das aus den X-Eingabeelementen erstellt wurde. SELECT array_agg(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Beispielergebnis: `[ 1,2,3,4 ]` |
| avg (x) | double | Gibt den Durchschnitt (arithmetisches Mittel) aller Eingabewerte zurück. SELECT avg(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Beispiel für ein Ergebnis: `2.5` |
| bool\$1and (boolean) jeder (boolean) | boolesch | Gibt TRUE zurück, wenn jeder Eingabewert TRUE ist, andernfalls FALSE. SELECT bool_and(t.c) FROM (VALUES true, true, false, true) AS t(c)
Beispielergebnis: `false` |
| bool\$1or (boolean) | boolesch | Gibt TRUE zurück, wenn ein Eingabewert TRUE ist, andernfalls FALSE. SELECT bool_or(t.c) FROM (VALUES true, true, false, true) AS t(c)
Beispielergebnis: `true` |
| zählen (\$1) zählen (x) | bigint | count (\$1) gibt die Anzahl der Eingabezeilen zurück. count (x) gibt die Anzahl der Eingabewerte zurück, die nicht Null sind. SELECT count(t.c) FROM (VALUES true, true, false, true) AS t(c)
Beispiel für ein Ergebnis: `4` |
| count\$1if (x) | bigint | Gibt die Anzahl der TRUE-Eingabewerte zurück. SELECT count_if(t.c) FROM (VALUES true, true, false, true) AS t(c)
Beispielergebnis: `3` |
| geometric\$1mean (x) | double | Gibt den geometrischen Mittelwert aller Eingabewerte zurück. SELECT geometric_mean(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Beispielergebnis: `2.213363839400643` |
| max\$1by (x, y) | [dasselbe wie x] | Gibt den Wert von x zurück, der dem Maximalwert von y für alle Eingabewerte zugeordnet ist. SELECT max_by(t.c1, t.c2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Beispielergebnis: `d` |
| max\$1by (x, y, n) | Reihe< [same as x] > | Gibt n Werte von x zurück, die dem n-größten aller Eingabewerte von y zugeordnet sind, in absteigender Reihenfolge von y. SELECT max_by(t.c1, t.c2, 2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Beispielergebnis: `[ d,c ]` |
| min\$1by (x, y) | [dasselbe wie x] | Gibt den Wert von x zurück, der dem Minimalwert von y für alle Eingabewerte zugeordnet ist. SELECT min_by(t.c1, t.c2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Beispielergebnis: `a` |
| min\$1by (x, y, n) | Reihe< [same as x] > | Gibt n Werte von x zurück, die dem n kleinsten aller Eingabewerte von y zugeordnet sind, in aufsteigender Reihenfolge von y. SELECT min_by(t.c1, t.c2, 2) FROM (VALUES (('a', 1)), (('b', 2)), (('c', 3)), (('d', 4))) AS t(c1, c2) Beispielergebnis: `[ a,b ]` |
| max (x) | [dasselbe wie Eingabe] | Gibt den Maximalwert aller Eingabewerte zurück. SELECT max(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Beispielergebnis: `4` |
| max (x, n) | Reihe< [same as x] > | Gibt n größte Werte aller Eingabewerte von x zurück. SELECT max(t.c, 2) FROM (VALUES 1, 2, 3, 4) AS t(c)
Beispielergebnis: `[ 4,3 ]` |
| min (x) | [dasselbe wie Eingabe] | Gibt den Minimalwert aller Eingabewerte zurück. SELECT min(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Beispielergebnis: `1` |
| min (x, n) | Reihe< [same as x] > | Gibt n kleinste Werte aller Eingabewerte von x zurück. SELECT min(t.c, 2) FROM (VALUES 1, 2, 3, 4) AS t(c)
Beispiel für ein Ergebnis: `[ 1,2 ]` |
| Summe (x) | [dasselbe wie Eingabe] | Gibt die Summe aller Eingabewerte zurück. SELECT sum(t.c) FROM (VALUES 1, 2, 3, 4) AS t(c)
Beispielergebnis: `10` |
| bitwise\$1and\$1agg (x) | bigint | Gibt das bitweise UND aller Eingabewerte in 2s-Komplement-Darstellung zurück. SELECT bitwise_and_agg(t.c) FROM (VALUES 1, -3) AS t(c)
Beispielergebnis: `1` |
| bitwise\$1or\$1agg (x) | bigint | Gibt das bitweise ODER aller Eingabewerte in 2s-Komplement-Darstellung zurück. SELECT bitwise_or_agg(t.c) FROM (VALUES 1, -3) AS t(c)
Beispielergebnis: `-3` |
| approx\$1distinct (x) | bigint | Gibt die ungefähre Anzahl verschiedener Eingabewerte zurück. Diese Funktion liefert eine Näherung der Anzahl (DISTINCT x). Null wird zurückgegeben, wenn alle Eingabewerte Null sind. Diese Funktion sollte einen Standardfehler von 2,3% ergeben, was der Standardabweichung der (ungefähr normalen) Fehlerverteilung über alle möglichen Mengen entspricht. Sie garantiert keine Obergrenze für den Fehler für einen bestimmten Eingabesatz. SELECT approx_distinct(t.c) FROM (VALUES 1, 2, 3, 4, 8) AS t(c)
Beispiel für ein Ergebnis: `5` |
| approx\$1distinct (x, e) | bigint | Gibt die ungefähre Anzahl unterschiedlicher Eingabewerte zurück. Diese Funktion liefert eine Näherung der Anzahl (DISTINCT x). Null wird zurückgegeben, wenn alle Eingabewerte Null sind. Diese Funktion sollte einen Standardfehler von nicht mehr als e erzeugen, was der Standardabweichung der (ungefähr normalen) Fehlerverteilung über alle möglichen Mengen entspricht. Sie garantiert keine Obergrenze für den Fehler für einen bestimmten Eingabesatz. Die aktuelle Implementierung dieser Funktion erfordert, dass e im Bereich von [0,0040625, 0,26000] liegt. SELECT approx_distinct(t.c, 0.2) FROM (VALUES 1, 2, 3, 4, 8) AS t(c)
Beispielergebnis: `5` |
| approx\$1percentile (x, Prozent) | [dasselbe wie x] | Gibt das ungefähre Perzentil für alle Eingabewerte von x zum angegebenen Prozentsatz zurück. Der Prozentwert muss zwischen Null und Eins liegen und für alle Eingabezeilen konstant sein. SELECT approx_percentile(t.c, 0.4) FROM (VALUES 1, 2, 3, 4) AS t(c)
Beispielergebnis: `2` |
| approx\$1percentile (x, Prozentsätze) | Reihe< [same as x] > | Gibt das ungefähre Perzentil für alle Eingabewerte von x bei jedem der angegebenen Prozentsätze zurück. Jedes Element der Prozentsatzmatrix muss zwischen Null und Eins liegen, und die Matrix muss für alle Eingabezeilen konstant sein. SELECT approx_percentile(t.c, ARRAY[0.1, 0.8, 0.8]) FROM (VALUES 1, 2, 3, 4) AS t(c)
Beispielergebnis: `[ 1,4,4 ]` |
| approx\$1percentile (x, w, prozentual) | [dasselbe wie x] | Gibt das ungefähre gewichtete Perzentil für alle Eingabewerte von x zurück, wobei das Gewicht w pro Artikel beim Prozentsatz p verwendet wird. Das Gewicht muss ein ganzzahliger Wert von mindestens eins sein. Es handelt sich praktisch um eine Replikationszahl für den Wert x im Perzentilsatz. Der Wert von p muss zwischen Null und Eins liegen und für alle Eingabezeilen konstant sein. SELECT approx_percentile(t.c, 1, 0.1) FROM (VALUES 1, 2, 3, 4) AS t(c)
Beispielergebnis: `1` |
| approx\$1percentile (x, w, Prozentsätze) | Reihe< [same as x] > | Gibt das ungefähre gewichtete Perzentil für alle Eingabewerte von x zurück, wobei das Gewicht w pro Element bei jedem der im Array angegebenen Prozentsätze verwendet wird. Das Gewicht muss ein ganzzahliger Wert von mindestens eins sein. Es handelt sich praktisch um eine Replikationszahl für den Wert x im Perzentilsatz. Jedes Element des Arrays muss zwischen Null und Eins liegen, und das Array muss für alle Eingabezeilen konstant sein. SELECT approx_percentile(t.c, 1, ARRAY[0.1, 0.8, 0.8]) FROM (VALUES 1, 2, 3, 4) AS t(c)
Beispielergebnis: `[ 1,4,4 ]` |
| approx\$1percentile (x, w, Prozentsatz, Genauigkeit) | [dasselbe wie x] | Gibt das ungefähre gewichtete Perzentil für alle Eingabewerte von x zurück, wobei das Gewicht w pro Artikel als Prozentsatz p verwendet wird, wobei ein maximaler Rangfehler der Genauigkeit verwendet wird. Das Gewicht muss ein ganzzahliger Wert von mindestens eins sein. Es handelt sich praktisch um eine Replikationszahl für den Wert x im Perzentilsatz. Der Wert von p muss zwischen Null und Eins liegen und für alle Eingabezeilen konstant sein. Die Genauigkeit muss ein Wert größer als Null und kleiner als eins sein, und sie muss für alle Eingabezeilen konstant sein. SELECT approx_percentile(t.c, 1, 0.1, 0.5) FROM (VALUES 1, 2, 3, 4) AS t(c)
Beispielergebnis: `1` |
| corr (y, x) | double | Gibt den Korrelationskoeffizienten der Eingabewerte zurück. SELECT corr(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Beispielergebnis: `1.0` |
| covar\$1pop (y, x) | double | Gibt die Populationskovarianz der Eingabewerte zurück. SELECT covar_pop(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Beispielergebnis: `1.25` |
| covar\$1samp (y, x) | double | Gibt die Stichprobenkovarianz der Eingabewerte zurück. SELECT covar_samp(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Beispielergebnis: `1.6666666666666667` |
| regr\$1intercept (y, x) | double | Gibt den linearen Regressionsabschnitt der Eingabewerte zurück. y ist der abhängige Wert. x ist der unabhängige Wert. SELECT regr_intercept(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Beispielergebnis: `0.0` |
| regr\$1slope (y, x) | double | Gibt die lineare Regressionssteigung der Eingabewerte zurück. y ist der abhängige Wert. x ist der unabhängige Wert. SELECT regr_slope(t.c1, t.c2) FROM (VALUES ((1, 1)), ((2, 2)), ((3, 3)), ((4, 4))) AS t(c1, c2)
Beispielergebnis: `1.0` |
| Schiefe (x) | double | Gibt die Schiefe aller Eingabewerte zurück. SELECT skewness(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Beispielergebnis: `0.8978957037987335` |
| stddev\$1pop (x) | double | Gibt die Populationsstandardabweichung aller Eingabewerte zurück. SELECT stddev_pop(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Beispiel für ein Ergebnis: `2.4166091947189146` |
| stddev\$1samp (x) stddev (x) | double | Gibt die Standardabweichung der Stichprobe aller Eingabewerte zurück. SELECT stddev_samp(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Beispielergebnis: `2.701851217221259` |
| var\$1pop (x) | double | Gibt die Populationsvarianz aller Eingabewerte zurück. SELECT var_pop(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Beispiel für ein Ergebnis: `5.840000000000001` |
| var\$1samp (x) Varianz (x) | double | Gibt die Stichprobenvarianz aller Eingabewerte zurück. SELECT var_samp(t.c1) FROM (VALUES 1, 2, 3, 4, 8) AS t(c1)
Beispielergebnis: `7.300000000000001` |
# Fensterfunktionen
Fensterfunktionen führen Berechnungen für mehrere Zeilen des Abfrageergebnisses durch. Sie werden nach der HAVING-Klausel, aber vor der ORDER BY-Klausel ausgeführt. Das Aufrufen einer Fensterfunktion erfordert eine spezielle Syntax, bei der das Fenster mit der OVER-Klausel angegeben wird. Ein Fenster besteht aus drei Komponenten:
+ Die Partitionsspezifikation, die die Eingabezeilen in verschiedene Partitionen unterteilt. Dies entspricht der Art und Weise, wie die GROUP BY-Klausel Zeilen für Aggregatfunktionen in verschiedene Gruppen unterteilt.
+ Die Sortierspezifikation, die die Reihenfolge bestimmt, in der Eingabezeilen von der Fensterfunktion verarbeitet werden.
+ Der Fensterrahmen, der ein verschiebbares Fenster mit Zeilen angibt, die von der Funktion für eine bestimmte Zeile verarbeitet werden sollen. Wenn der Frame nicht angegeben ist, wird standardmäßig RANGE UNBOUNDED PRECEOING verwendet, was dem Wert RANGE BETWEEN UNBOUNDED PRECIOVERING AND CURRENT ROW entspricht. Dieser Frame enthält alle Zeilen vom Anfang der Partition bis zum letzten Peer der aktuellen Zeile.
Alle Aggregatfunktionen können als Fensterfunktionen verwendet werden, indem die OVER-Klausel hinzugefügt wird. Die Aggregatfunktion wird für jede Zeile über die Zeilen innerhalb des Fensterrahmens der aktuellen Zeile berechnet. Zusätzlich zu den Aggregatfunktionen LiveAnalytics unterstützt Timestream for die folgenden Rangfolge- und Wertfunktionen.
| Funktion | Ausgabedatentyp | Description |
| --- | --- | --- |
| cume\$1dist () | bigint | Gibt die kumulative Verteilung eines Werts in einer Gruppe von Werten zurück. Das Ergebnis ist die Anzahl der Zeilen, die der Zeile in der Fensterreihenfolge der Fensterpartition vorausgehen oder ihr gleichrangig sind, geteilt durch die Gesamtzahl der Zeilen in der Fensterpartition. Somit ergeben alle Gleichheitswerte in der Reihenfolge denselben Verteilungswert. |
| dense\$1rank () | bigint | Gibt den Rang eines Wertes in einer Gruppe von Werten zurück. Dies ähnelt rank (), mit dem Unterschied, dass Gleichheitswerte keine Lücken in der Sequenz erzeugen. |
| antil (n) | bigint | Unterteilt die Zeilen für jede Fensterpartition in n Buckets im Bereich von 1 bis höchstens n. Die Bucket-Werte unterscheiden sich höchstens um 1. Wenn sich die Anzahl der Zeilen in der Partition nicht gleichmäßig in die Anzahl der Buckets aufteilt, werden die restlichen Werte einzeln pro Bucket verteilt, beginnend mit dem ersten Bucket. |
| percent\$1rank () | double | Gibt die prozentuale Rangfolge eines Werts in einer Gruppe von Werten zurück. Das Ergebnis ist (r - 1)/(n - 1), wobei r der Rang () der Zeile und n die Gesamtzahl der Zeilen in der Fensterpartition ist. |
| Rang () | bigint | Gibt den Rang eines Werts in einer Gruppe von Werten zurück. Der Rang ist eins plus der Anzahl der Zeilen vor der Zeile, die der Zeile nicht ebenbürtig sind. Somit führen Gleichheitswerte in der Reihenfolge zu Lücken in der Reihenfolge. Die Rangfolge wird für jede Fensterpartition durchgeführt. |
| Zeilennummer () | bigint | Gibt eine eindeutige, sequentielle Zahl für jede Zeile zurück, beginnend mit eins, entsprechend der Reihenfolge der Zeilen innerhalb der Fensterpartition. |
| erster\$1Wert (x) | [dasselbe wie Eingabe] | Gibt den ersten Wert des Fensters zurück. Diese Funktion ist auf den Fensterrahmen beschränkt. Die Funktion verwendet einen Ausdruck oder ein Ziel als Parameter. |
| last\$1value (x) | [dasselbe wie Eingabe] | Gibt den letzten Wert des Fensters zurück. Diese Funktion ist auf den Fensterrahmen beschränkt. Die Funktion verwendet einen Ausdruck oder ein Ziel als Parameter. |
| nth\$1value (x, Offset) | [wie Eingabe] | Gibt den Wert am angegebenen Offset vom Anfang des Fensters zurück. Offsets beginnen bei 1. Der Offset kann ein beliebiger skalarer Ausdruck sein. Wenn der Offset Null oder größer als die Anzahl der Werte im Fenster ist, wird Null zurückgegeben. Es ist ein Fehler, wenn der Offset Null oder negativ ist. Die Funktion verwendet einen Ausdruck oder ein Ziel als ersten Parameter. |
| lead (x [, offset [, default\$1value]]) | [dasselbe wie Eingabe] | Gibt den Wert an den versetzten Zeilen hinter der aktuellen Zeile im Fenster zurück. Offsets beginnen bei 0, der aktuellen Zeile. Der Offset kann ein beliebiger skalarer Ausdruck sein. Der Standard-Offset ist 1. Wenn der Offset Null oder größer als das Fenster ist, wird der Standardwert zurückgegeben, oder wenn er nicht angegeben ist, wird Null zurückgegeben. Die Funktion verwendet einen Ausdruck oder ein Ziel als ersten Parameter. |
| lag (x [, Offset [, Standardwert]]) | [dasselbe wie Eingabe] | Gibt den Wert zurück, der vor der aktuellen Zeile im Fenster liegt. Offsets beginnen bei 0, was der aktuellen Zeile entspricht. Der Offset kann ein beliebiger skalarer Ausdruck sein. Der Standard-Offset ist 1. Wenn der Offset Null oder größer als das Fenster ist, wird der Standardwert zurückgegeben, oder wenn er nicht angegeben ist, wird Null zurückgegeben. Die Funktion verwendet einen Ausdruck oder ein Ziel als ersten Parameter. |
# Beispielabfragen
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
Im Folgenden werden die 10 zuletzt hinzugefügten Datenpunkte für eine Tabelle abgerufen.
```
SELECT * FROM .
ORDER BY time DESC
LIMIT 10
```
Im Folgenden werden die 5 ältesten Datenpunkte für eine bestimmte Kennzahl abgerufen.
```
SELECT * FROM .
WHERE 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::`, wo einer von,, oder `` 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 . 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 . WHERE measure_name = 'load'
```
# Abfragen mit Zeitreihenfunktionen
**Topics**
+ [Beispieldatensatz und Abfragen](#sample-queries.devops-scenarios.example)
## Beispieldatensatz und Abfragen
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
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
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
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
```