`
Wenn Sie Amazon S3 oder Security Lake abfragen, verwenden Sie: `SELECT Body , Operation FROM table_name`
Wenn Sie CloudWatch Logs abfragen, verwenden Sie: `SELECT Body , Operation FROM `LogGroupA``
| Befehl | Description | CloudWatch Logs | Amazon S3 | Sicherheit, Lake | Beispielbefehl |
| --- | --- | --- | --- | --- | --- |
| [SELECT-Klausel](#supported-sql-select) | Zeigt projizierte Werte an. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
method,
status
FROM
|
| [WHERE-Klausel](#supported-sql-where) | Filtert Protokollereignisse auf der Grundlage der angegebenen Feldkriterien. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
*
FROM
WHERE
status = 100
|
| [GROUP BY-Klausel](#supported-sql-group-by) | Gruppen protokollieren Ereignisse nach Kategorien und ermitteln anhand von Statistiken den Durchschnitt. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
method,
status,
COUNT(*) AS request_count,
SUM(bytes) AS total_bytes
FROM
GROUP BY
method,
status
|
| [HAVING-Klausel](#supported-sql-having) | Filtert die Ergebnisse auf der Grundlage von Gruppierungsbedingungen. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
method,
status,
COUNT(*) AS request_count,
SUM(bytes) AS total_bytes
FROM
GROUP BY
method,
status
HAVING
COUNT(*) > 5
|
| [ORDER BY-Klausel](#supported-sql-order-by) | Sortiert die Ergebnisse auf der Grundlage der Felder in der Order-Klausel. Sie können entweder in absteigender oder aufsteigender Reihenfolge sortieren. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
*
FROM
ORDER BY
status DESC
|
| [JOIN-Klausel](#supported-sql-join) ( `INNER` \$1 `CROSS` \$1 `LEFT` `OUTER` ) | Verbindet die Ergebnisse für zwei Tabellen auf der Grundlage gemeinsamer Felder. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt (für den Join müssen `Left Outer` Schlüsselwörter `Inner` und -Schlüsselwörter verwendet werden; in einer SELECT-Anweisung wird nur ein JOIN-Vorgang unterstützt) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt (für die Verknüpfung müssen die Schlüsselwörter Inner, Left Outer und Cross verwendet werden) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt (für die Verknüpfung müssen die Schlüsselwörter Inner, Left Outer und Cross verwendet werden) | SELECT
A.Body,
B.Timestamp
FROM
AS A
INNER JOIN
AS B
ON A.`requestId` = B.`requestId`
|
| [LIMIT-Klausel](#supported-sql-limit) | Beschränkt die Ergebnisse auf die ersten N Zeilen. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
*
FROM
LIMIT
10
|
| [CASE-Klausel](#supported-sql-case) | Wertet Bedingungen aus und gibt einen Wert zurück, wenn die erste Bedingung erfüllt ist. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
method,
status,
CASE
WHEN status BETWEEN 100 AND 199 THEN 'Informational'
WHEN status BETWEEN 200 AND 299 THEN 'Success'
WHEN status BETWEEN 300 AND 399 THEN 'Redirection'
WHEN status BETWEEN 400 AND 499 THEN 'Client Error'
WHEN status BETWEEN 500 AND 599 THEN 'Server Error'
ELSE 'Unknown Status'
END AS status_category,
CASE method
WHEN 'GET' THEN 'Read Operation'
WHEN 'POST' THEN 'Create Operation'
WHEN 'PUT' THEN 'Update Operation'
WHEN 'PATCH' THEN 'Partial Update Operation'
WHEN 'DELETE' THEN 'Delete Operation'
ELSE 'Other Operation'
END AS operation_type,
bytes,
datetime
FROM
|
| [Gemeinsamer Tabellenausdruck](#supported-sql-cte) | Erstellt eine benannte temporäre Ergebnismenge innerhalb einer SELECT-, INSERT-, UPDATE-, DELETE- oder MERGE-Anweisung. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/negative_icon.svg)Wird nicht unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | WITH RequestStats AS (
SELECT
method,
status,
bytes,
COUNT(*) AS request_count
FROM
tableName
GROUP BY
method,
status,
bytes
)
SELECT
method,
status,
bytes,
request_count
FROM
RequestStats
WHERE
bytes > 1000
|
| [EXPLAIN](#supported-sql-explain) | Zeigt den Ausführungsplan einer SQL-Anweisung an, ohne sie tatsächlich auszuführen. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/negative_icon.svg)Wird nicht unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | EXPLAIN
SELECT
k,
SUM(v)
FROM
VALUES
(1, 2),
(1, 3) AS t(k, v)
GROUP BY
k
|
| [LATERALE SUBQUERY-Klausel](#supported-sql-lateral-subquery) | Ermöglicht einer Unterabfrage in der FROM-Klausel, auf Spalten aus vorherigen Elementen in derselben FROM-Klausel zu verweisen. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/negative_icon.svg)Wird nicht unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
*
FROM
tableName
LATERAL (
SELECT
*
FROM
t2
WHERE
t1.c1 = t2.c1
)
|
| [Klausel LATERAL VIEW](#supported-sql-lateral-view) | Generiert eine virtuelle Tabelle, indem eine Funktion zum Generieren von Tabellen auf jede Zeile einer Basistabelle angewendet wird. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/negative_icon.svg)Wird nicht unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
*
FROM
tableName
LATERAL VIEW
EXPLODE(ARRAY(30, 60)) tableName AS c_age
LATERAL VIEW
EXPLODE(ARRAY(40, 80)) AS d_age
|
| [LIKE-Prädikat](#supported-sql-like-predicate) | Ordnet eine Zeichenfolge einem Muster unter Verwendung von Platzhalterzeichen zu. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
method,
status,
request,
host
FROM
WHERE
method LIKE 'D%'
|
| [OFFSET](#supported-sql-offset) | Gibt die Anzahl der Zeilen an, die übersprungen werden sollen, bevor mit der Rückgabe von Zeilen aus der Abfrage begonnen wird. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Wird unterstützt, wenn es in Verbindung mit einer LIMIT Klausel in einer Abfrage verwendet wird. Beispiel:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/supported-directquery-sql.html) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
method,
status,
bytes,
datetime
FROM
ORDER BY
datetime
OFFSET
10
|
| [PIVOT-Klausel](#supported-sql-pivot) | Transformiert Zeilen in Spalten und rotiert Daten von einem zeilenbasierten Format in ein spaltenbasiertes Format. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/negative_icon.svg)Wird nicht unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
*
FROM
(
SELECT
method,
status,
bytes
FROM
) AS SourceTable
PIVOT
(
SUM(bytes)
FOR method IN ('GET', 'POST', 'PATCH', 'PUT', 'DELETE')
) AS PivotTable
|
| [Satzoperatoren](#supported-sql-set) | Kombiniert die Ergebnisse von zwei oder mehr SELECT-Anweisungen (z. B. UNION, INTERSECT, EXCEPT). | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
method,
status,
bytes
FROM
WHERE
status = '416'
UNION
SELECT
method,
status,
bytes
FROM
WHERE
bytes > 20000
|
| [SORT BY-Klausel](#supported-sql-sort-by) | Gibt die Reihenfolge an, in der die Abfrageergebnisse zurückgegeben werden sollen. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
method,
status,
bytes
FROM
SORT BY
bytes DESC
|
| [UNPIVOT](#supported-sql-unpivot) | Wandelt Spalten in Zeilen um und rotiert Daten von einem spaltenbasierten Format in ein zeilenbasiertes Format. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/negative_icon.svg)Wird nicht unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
status,
REPLACE(method, '_bytes', '') AS request_method,
bytes,
datetime
FROM
PivotedData
UNPIVOT
(
bytes
FOR method IN
(
GET_bytes,
POST_bytes,
PATCH_bytes,
PUT_bytes,
DELETE_bytes
)
) AS UnpivotedData
|
## Funktionen
**Anmerkung**
Ersetzen Sie in der Spalte mit den Beispielbefehlen nach `` Bedarf, je nachdem, welche Datenquelle Sie abfragen.
Beispielbefehl: `SELECT Body , Operation FROM `
Wenn Sie Amazon S3 oder Security Lake abfragen, verwenden Sie: `SELECT Body , Operation FROM table_name`
Wenn Sie CloudWatch Logs abfragen, verwenden Sie: `SELECT Body , Operation FROM `LogGroupA``
| Verfügbare SQL-Grammatik | Description | CloudWatch Logs | Amazon S3 | Sicherheit, Lake | Beispielbefehl |
| --- | --- | --- | --- | --- | --- |
| [Zeichenfolgenfunktionen](#supported-sql-string) | Integrierte Funktionen, mit denen Zeichenketten- und Textdaten in SQL-Abfragen bearbeitet und transformiert werden können. Zum Beispiel das Konvertieren von Groß- und Kleinschreibung, das Kombinieren von Zeichenketten, das Extrahieren von Teilen und das Bereinigen von Text. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
UPPER(method) AS upper_method,
LOWER(host) AS lower_host
FROM
|
| [Datums- und Zeitfunktionen](#supported-sql-date-time) | Integrierte Funktionen für die Verarbeitung und Transformation von Datums- und Zeitstempeldaten in Abfragen. ****Zum Beispiel **date\$1add, date\$1format****, datediff** und current\$1date.**** | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
TO_TIMESTAMP(datetime) AS timestamp,
TIMESTAMP_SECONDS(UNIX_TIMESTAMP(datetime)) AS from_seconds,
UNIX_TIMESTAMP(datetime) AS to_unix,
FROM_UTC_TIMESTAMP(datetime, 'PST') AS to_pst,
TO_UTC_TIMESTAMP(datetime, 'EST') AS from_est
FROM
|
| [Aggregationsfunktionen](#supported-sql-aggregate) | Integrierte Funktionen, die Berechnungen für mehrere Zeilen durchführen, um einen einzigen zusammengefassten Wert zu erzeugen. Zum Beispiel **Summe**, **Anzahl**, **Durchschnitt**, **Maximum** und **Min**. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
COUNT(*) AS total_records,
COUNT(DISTINCT method) AS unique_methods,
SUM(bytes) AS total_bytes,
AVG(bytes) AS avg_bytes,
MIN(bytes) AS min_bytes,
MAX(bytes) AS max_bytes
FROM
|
| [Konditionale Funktionen](#supported-sql-conditional) | Integrierte Funktionen, die Aktionen auf der Grundlage bestimmter Bedingungen ausführen oder Ausdrücke bedingt auswerten. Zum Beispiel **CASE** und **IF**. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
CASE
WHEN method = 'GET' AND bytes < 1000 THEN 'Small Read'
WHEN method = 'POST' AND bytes > 10000 THEN 'Large Write'
WHEN status >= 400 OR bytes = 0 THEN 'Problem'
ELSE 'Normal'
END AS request_type
FROM
|
| [JSON-Funktionen](#supported-sql-json) | Integrierte Funktionen zum Parsen, Extrahieren, Ändern und Abfragen von Daten im JSON-Format innerhalb von SQL-Abfragen (z. B. from\$1json, to\$1json, get\$1json\$1object, json\$1tuple), die die Manipulation von JSON-Strukturen in Datensätzen ermöglichen. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Wird unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
FROM_JSON(
@message,
'STRUCT<
host: STRING,
user-identifier: STRING,
datetime: STRING,
method: STRING,
status: INT,
bytes: INT
>'
) AS parsed_json
FROM
|
| [Array-Funktionen](#supported-sql-array) | Integrierte Funktionen für die Arbeit mit Spalten vom Typ Array in SQL-Abfragen, die Operationen wie das Zugreifen auf, Ändern und Analysieren von Array-Daten (z. B. size, explode, array\$1contains) ermöglichen. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
scores,
size(scores) AS length,
array_contains(scores, 90) AS has_90
FROM
|
| [Fensterfunktionen](#supported-sql-window) | Integrierte Funktionen, die Berechnungen für einen bestimmten Satz von Zeilen durchführen, die sich auf die aktuelle Zeile (Fenster) beziehen, wodurch Operationen wie Rangfolge, Gesamtwerte und gleitende Durchschnitte (z. B. ROW\$1NUMBER, RANK, LAG, LEAD) ermöglicht werden | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Wird unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
field1,
field2,
RANK() OVER (ORDER BY field2 DESC) AS field2Rank
FROM
|
| [Konvertierungs-Funktionen](#supported-sql-conversion) | Integrierte Funktionen zum Konvertieren von Daten von einem Typ in einen anderen innerhalb von SQL-Abfragen, die Datentyptransformationen und Formatkonvertierungen ermöglichen (z. B. CAST, TO\$1DATE, TO\$1TIMESTAMP, BINARY) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Wird unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
CAST('123' AS INT) AS converted_number,
CAST(123 AS STRING) AS converted_string
FROM
|
| [Prädikatsfunktionen](#supported-sql-predicate) | Integrierte Funktionen, die Bedingungen auswerten und boolesche Werte (true/false) basierend auf bestimmten Kriterien oder Mustern zurückgeben (z. B. IN, LIKE, BETWEEN, IS NULL, EXISTS) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Wird unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
*
FROM
WHERE
id BETWEEN 50000 AND 75000
|
| [Funktionen zuordnen](#supported-sql-map) | Wendet eine angegebene Funktion auf jedes Element in einer Sammlung an und wandelt die Daten in einen neuen Satz von Werten um. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/negative_icon.svg)Wird nicht unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
MAP_FILTER(
MAP(
'method', method,
'status', CAST(status AS STRING),
'bytes', CAST(bytes AS STRING)
),
(k, v) -> k IN ('method', 'status') AND v != 'null'
) AS filtered_map
FROM
WHERE
status = 100
|
| [Mathematische Funktionen](#supported-sql-math) | Führt mathematische Operationen mit numerischen Daten aus, z. B. die Berechnung von Durchschnittswerten, Summen oder trigonometrischen Werten. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
bytes,
bytes + 1000 AS added,
bytes - 1000 AS subtracted,
bytes * 2 AS doubled,
bytes / 1024 AS kilobytes,
bytes % 1000 AS remainder
FROM
|
| [Gruppenfunktionen mit mehreren Protokollen](#multi-log-queries) | Ermöglicht Benutzern, mehrere Protokollgruppen in einer SQL SELECT-Anweisung anzugeben | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | Nicht zutreffend | Nicht zutreffend | SELECT
lg1.Column1,
lg1.Column2
FROM
`logGroups(logGroupIdentifier: ['LogGroup1', 'LogGroup2'])` AS lg1
WHERE
lg1.Column3 = "Success"
|
| [Generatorfunktionen](#supported-sql-generator) | Erzeugt ein Iterator-Objekt, das eine Folge von Werten liefert und so eine effiziente Speichernutzung in großen Datensätzen ermöglicht. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/negative_icon.svg)Wird nicht unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | SELECT
explode(array(10, 20))
|
## Allgemeine SQL-Einschränkungen
Die folgenden Einschränkungen gelten bei der Verwendung von OpenSearch SQL with CloudWatch Logs, Amazon S3 und Security Lake.
1. Sie können in einer SELECT-Anweisung nur eine JOIN-Operation verwenden.
1. Es wird nur eine Ebene verschachtelter Unterabfragen unterstützt.
1. Abfragen mit mehreren Anweisungen, die durch Semikolons getrennt sind, werden nicht unterstützt.
1. Abfragen mit Feldnamen, die identisch sind, sich aber nur in der Groß- und Kleinschreibung unterscheiden (wie Feld1 und FIELD1), werden nicht unterstützt.
Beispielsweise werden die folgenden Abfragen nicht unterstützt:
```
Select AWSAccountId, awsaccountid from LogGroup
```
Die folgende Abfrage ist jedoch darauf zurückzuführen, dass der Feldname (@logStream) in beiden Protokollgruppen identisch ist:
```
Select a.`@logStream`, b.`@logStream` from Table A INNER Join Table B on a.id = b.id
```
1. Funktionen und Ausdrücke müssen mit Feldnamen arbeiten und Teil einer SELECT-Anweisung mit einer in der FROM-Klausel angegebenen Protokollgruppe sein.
Diese Abfrage wird beispielsweise nicht unterstützt:
```
SELECT cos(10) FROM LogGroup
```
Diese Abfrage wird unterstützt:
```
SELECT cos(field1) FROM LogGroup
```
## Zusätzliche Informationen für CloudWatch Logs Insights-Benutzer, die OpenSearch SQL verwenden
CloudWatch Logs unterstützt OpenSearch SQL-Abfragen in der Logs Insights-Konsole, API und CLI. Es unterstützt die meisten Befehle, darunter SELECT, FROM, WHERE, GROUP BY, HAVING, JOINS und verschachtelte Abfragen sowie JSON-, Math-, Zeichenketten- und Bedingungsfunktionen. CloudWatch Logs unterstützt jedoch nur Lesevorgänge, sodass DDL- oder DML-Anweisungen nicht zulässig sind. Eine vollständige Liste der unterstützten Befehle und Funktionen finden Sie in den Tabellen in den vorherigen Abschnitten.
### Gruppenfunktionen mit mehreren Protokollen
CloudWatch Logs Insights unterstützt die Möglichkeit, mehrere Protokollgruppen abzufragen. Um diesen Anwendungsfall in SQL zu behandeln, können Sie den `logGroups` Befehl verwenden. Dieser Befehl ist spezifisch für das Abfragen von Daten in CloudWatch Logs Insights, an denen eine oder mehrere Protokollgruppen beteiligt sind. Verwenden Sie diese Syntax, um mehrere Protokollgruppen abzufragen, indem Sie sie im Befehl angeben, anstatt eine Abfrage für jede der Protokollgruppen zu schreiben und sie mit einem `UNION` Befehl zu kombinieren.
Syntax:
```
`logGroups(
logGroupIdentifier: ['LogGroup1','LogGroup2', ...'LogGroupn']
)
```
In dieser Syntax können Sie bis zu 50 Protokollgruppen im `logGroupIndentifier` Parameter angeben. Wenn Sie in einem Monitoring-Konto auf Protokollgruppen verweisen möchten, verwenden Sie ARNs anstelle von `LogGroup` Namen.
Beispielabfrage:
```
SELECT LG1.Column1, LG1.Column2 from `logGroups(
logGroupIdentifier: ['LogGroup1', 'LogGroup2']
)` as LG1
WHERE LG1.Column1 = 'ABC'
```
Die folgende Syntax mit mehreren Protokollgruppen nach der `FROM` Anweisung wird bei der Abfrage von CloudWatch Logs nicht unterstützt:
```
SELECT Column1, Column2 FROM 'LogGroup1', 'LogGroup2', ...'LogGroupn'
WHERE Column1 = 'ABC'
```
### Einschränkungen
Wenn Sie SQL- oder PPL-Befehle verwenden, schließen Sie bestimmte Felder in Backticks ein, um sie abzufragen. Backticks sind für Felder mit Sonderzeichen (nicht alphabetisch und nicht numerisch) erforderlich. Zum Beispiel „einschließen`@message`“ und „in Backticks“. `Operation.Export,` `Test::Field` Sie müssen Spalten mit rein alphabetischen Namen nicht in Backticks einschließen.
Beispielabfrage mit einfachen Feldern:
```
SELECT SessionToken, Operation, StartTime FROM `LogGroup-A`
LIMIT 1000;
```
Dieselbe Abfrage mit angehängten Backticks:
```
SELECT `SessionToken`, `Operation`, `StartTime` FROM `LogGroup-A`
LIMIT 1000;
```
Weitere allgemeine Einschränkungen, die nicht spezifisch für CloudWatch Protokolle sind, finden Sie unter. [Allgemeine SQL-Einschränkungen](#general-sql-restrictions)
### Beispielabfragen und Kontingente
**Anmerkung**
Das Folgende gilt sowohl für CloudWatch Logs Insights-Benutzer als auch für OpenSearch Benutzer, die CloudWatch Daten abfragen.
Beispiele für SQL-Abfragen, die Sie in CloudWatch Logs verwenden können, finden Sie unter **Gespeicherte Abfragen und Beispielabfragen** in der Amazon CloudWatch Logs Insights-Konsole.
Informationen zu den Beschränkungen, die bei der Abfrage von CloudWatch Logs from OpenSearch Service gelten, finden Sie unter [CloudWatch Log-Kontingente](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html) im Amazon CloudWatch Logs-Benutzerhandbuch. Die Beschränkungen betreffen die Anzahl der CloudWatch Protokollgruppen, die Sie abfragen können, die maximale Anzahl gleichzeitiger Abfragen, die Sie ausführen können, die maximale Ausführungszeit von Abfragen und die maximale Anzahl von Zeilen, die in Ergebnissen zurückgegeben werden. Die Grenzwerte sind dieselben, unabhängig davon, welche Sprache Sie für die Abfrage von CloudWatch Logs verwenden (nämlich OpenSearch PPL, SQL und Logs Insights).
### SQL-Befehle
**Topics**
+ [Zeichenfolgenfunktionen](#supported-sql-string)
+ [Datums- und Zeitfunktionen](#supported-sql-date-time)
+ [Aggregationsfunktionen](#supported-sql-aggregate)
+ [Konditionale Funktionen](#supported-sql-conditional)
+ [JSON-Funktionen](#supported-sql-json)
+ [Array-Funktionen](#supported-sql-array)
+ [Fensterfunktionen](#supported-sql-window)
+ [Konvertierungs-Funktionen](#supported-sql-conversion)
+ [Prädikatsfunktionen](#supported-sql-predicate)
+ [Funktionen zuordnen](#supported-sql-map)
+ [Mathematische Funktionen](#supported-sql-math)
+ [Generatorfunktionen](#supported-sql-generator)
+ [SELECT-Klausel](#supported-sql-select)
+ [WHERE-Klausel](#supported-sql-where)
+ [GROUP BY-Klausel](#supported-sql-group-by)
+ [HAVING-Klausel](#supported-sql-having)
+ [ORDER BY-Klausel](#supported-sql-order-by)
+ [JOIN-Klausel](#supported-sql-join)
+ [LIMIT-Klausel](#supported-sql-limit)
+ [CASE-Klausel](#supported-sql-case)
+ [Gemeinsamer Tabellenausdruck](#supported-sql-cte)
+ [EXPLAIN](#supported-sql-explain)
+ [LATERALE SUBQUERY-Klausel](#supported-sql-lateral-subquery)
+ [Klausel LATERAL VIEW](#supported-sql-lateral-view)
+ [LIKE-Prädikat](#supported-sql-like-predicate)
+ [OFFSET](#supported-sql-offset)
+ [PIVOT-Klausel](#supported-sql-pivot)
+ [Satzoperatoren](#supported-sql-set)
+ [SORT BY-Klausel](#supported-sql-sort-by)
+ [UNPIVOT](#supported-sql-unpivot)
#### Zeichenfolgenfunktionen
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter. [Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql)
****
| Funktion | Description |
| --- | --- |
| ascii (str) | Gibt den numerischen Wert des ersten Zeichens von zurück. str |
| base64 (bin) | Konvertiert das Argument von einer Binärdatei bin in eine Base-64-Zeichenfolge. |
| bit\$1length (expr) | Gibt die Bitlänge von Zeichenkettendaten oder die Anzahl der Bits von Binärdaten zurück. |
| btrim (str) | Entfernt die führenden und nachfolgenden Leerzeichen von. str |
| btrim (str, trimStr) | Entferne die führenden und nachfolgenden trimStr Zeichen von. str |
| char (Ausdruck) | Gibt das ASCII-Zeichen zurück, dessen binäre Entsprechung zu ist. expr Wenn n größer als 256 ist, entspricht das Ergebnis chr (n% 256) |
| Zeichenlänge (Ausdruck) | Gibt die Zeichenlänge von Zeichenkettendaten oder die Anzahl der Byte von Binärdaten zurück. Die Länge von Zeichenkettendaten schließt die abschließenden Leerzeichen ein. Die Länge von Binärdaten beinhaltet binäre Nullen. |
| Zeichenlänge (expr) | Gibt die Zeichenlänge von Zeichenkettendaten oder die Anzahl der Byte von Binärdaten zurück. Die Länge von Zeichenkettendaten schließt die abschließenden Leerzeichen ein. Die Länge von Binärdaten beinhaltet binäre Nullen. |
| chr (expr) | Gibt das ASCII-Zeichen zurück, dessen binäre Entsprechung zu ist. expr Wenn n größer als 256 ist, entspricht das Ergebnis chr (n% 256) |
| concat\$1ws (sep [, str \$1 array (str)] \$1) | Gibt die Verkettung der Zeichenketten zurück, getrennt durch, wobei Nullwerte übersprungen werden. sep |
| enthält (links, rechts) | Gibt einen booleschen Wert zurück. Der Wert ist True, wenn rechts innerhalb von links gefunden wird. Gibt NULL zurück, wenn einer der Eingabeausdrücke NULL ist. Andernfalls wird False zurückgegeben. Sowohl links als auch rechts müssen vom Typ STRING oder BINARY sein. |
| dekodieren (bin, Zeichensatz) | Dekodiert das erste Argument mit dem Zeichensatz des zweiten Arguments. |
| dekodieren (expr, search, result [, search, result]... [, default]) | Vergleicht expr der Reihe nach mit jedem Suchwert. Wenn expr einem Suchwert entspricht, gibt decode das entsprechende Ergebnis zurück. Wenn keine Übereinstimmung gefunden wird, wird der Standardwert zurückgegeben. Wenn Standard weggelassen wird, wird Null zurückgegeben. |
| elt (n, Eingabe1, Eingabe2,...) | Gibt n die -te Eingabe zurück, gibt z. B. zurück, input2 wenn n 2 ist. |
| kodieren (str, Zeichensatz) | Kodiert das erste Argument mit dem Zeichensatz des zweiten Arguments. |
| endet mit (links, rechts) | Gibt einen booleschen Wert zurück. Der Wert ist True, wenn links mit rechts endet. Gibt NULL zurück, wenn einer der Eingabeausdrücke NULL ist. Andernfalls wird False zurückgegeben. Sowohl links als auch rechts müssen vom Typ STRING oder BINARY sein. |
| find\$1in\$1set (str, str\$1array) | Gibt den Index (1-basiert) der angegebenen Zeichenfolge () in der kommagetrennten Liste (str) zurück. str\$1array Gibt 0 zurück, wenn die Zeichenfolge nicht gefunden wurde oder wenn die angegebene Zeichenfolge () str ein Komma enthält. |
| format\$1number (expr1, expr2) | Formatiert die Zahl expr1 wie '\$1, \$1\$1\$1, \$1\$1\$1.\$1\$1', auf Dezimalstellen gerundet. expr2 Wenn 0 expr2 ist, hat das Ergebnis weder einen Dezimalpunkt noch einen Bruchteil. expr2akzeptiert auch ein benutzerdefiniertes Format. Das soll wie FORMAT von MySQL funktionieren. |
| format\$1string (strfmt, obj,...) | Gibt eine formatierte Zeichenfolge aus Formatzeichenketten im Printf-Stil zurück. |
| initcap (str) | Gibt zurück, str wobei der erste Buchstabe jedes Worts in Großbuchstaben geschrieben wird. Alle anderen Buchstaben werden in Kleinbuchstaben geschrieben. Wörter werden durch Leerraum getrennt. |
| instr (str, substr) | Gibt den (1-basierten) Index des ersten Vorkommens von in zurück. substr str |
| lcase (str) | Gibt zurück, str bei der alle Zeichen in Kleinbuchstaben geändert wurden. |
| links (str, len) | Gibt die am weitesten links stehenden Zeichen len (lenkann vom Typ Zeichenfolge sein) aus der Zeichenfolge zurück. Wenn sie kleiner oder gleich 0 len iststr, ist das Ergebnis eine leere Zeichenfolge. |
| len (expr) | Gibt die Zeichenlänge von Zeichenkettendaten oder die Anzahl der Byte von Binärdaten zurück. Die Länge von Zeichenkettendaten schließt die abschließenden Leerzeichen ein. Die Länge von Binärdaten beinhaltet binäre Nullen. |
| Länge (expr) | Gibt die Zeichenlänge von Zeichenkettendaten oder die Anzahl der Byte von Binärdaten zurück. Die Länge von Zeichenkettendaten schließt die abschließenden Leerzeichen ein. Die Länge von Binärdaten beinhaltet binäre Nullen. |
| levenshtein (str1, str2 [, Schwellenwert]) | Gibt den Levenshtein-Abstand zwischen den beiden angegebenen Zeichenketten zurück. Wenn der Schwellenwert gesetzt ist und die Entfernung größer ist, wird -1 zurückgegeben. |
| lokalisieren (substr, str [, pos]) | Gibt die Position des ersten Vorkommens von substr in str nach der Position pos zurück. Der angegebene Wert pos und der Rückgabewert basieren auf 1. |
| niedriger (str) | Gibt zurück, str bei der alle Zeichen in Kleinbuchstaben geändert wurden. |
| lpad (str, len [, pad]) | Gibt zurückstr, links aufgefüllt mit pad bis zu einer Länge von. len Wenn str ist länger alslen, wird der Rückgabewert auf len Zeichen oder Byte gekürzt. Wenn pad nicht angegeben, str wird es nach links mit Leerzeichen aufgefüllt, wenn es sich um eine Zeichenfolge handelt, und mit Nullen, wenn es sich um eine Bytefolge handelt. |
| ltrim (str) | Entfernt die führenden Leerzeichen vonstr. |
| luhn\$1check (str) | Überprüft, ob eine Ziffernfolge gemäß dem Luhn-Algorithmus gültig ist. Diese Prüfsummenfunktion wird häufig bei Kreditkartennummern und behördlichen Identifikationsnummern angewendet, um gültige Zahlen von falsch eingegebenen Zahlen zu unterscheiden. |
| Maske (Eingabe [, UpperChar, LowerChar, DigitChar, OtherChar]) | maskiert den angegebenen Zeichenkettenwert. Die Funktion ersetzt Zeichen durch 'X' oder 'x' und Zahlen durch 'n'. Dies kann nützlich sein, um Kopien von Tabellen zu erstellen, bei denen vertrauliche Informationen entfernt wurden. |
| octet\$1length (expr) | Gibt die Bytelänge von Zeichenkettendaten oder die Anzahl der Byte von Binärdaten zurück. |
| Überlagerung (Eingabe, Ersetzen, Pos [, Len]) | Ersetze durch input replace das, was bei der Länge beginnt pos und eine Länge len hat. |
| position (substr, str [, pos]) | Gibt die Position des ersten Vorkommens von substr in str nach Position pos zurück. Der angegebene Wert pos und der Rückgabewert basieren auf 1. |
| printf (strfmt, obj,...) | Gibt eine formatierte Zeichenfolge aus Formatzeichenketten im Printf-Stil zurück. |
| regexp\$1count (str, regexp) | Gibt zurück, wie oft das Muster regexp eines regulären Ausdrucks in der Zeichenfolge übereinstimmt. str |
| regexp\$1extract (str, regexp [, idx]) | Extrahieren Sie die erste Zeichenfolge in derstr, die dem regexp Ausdruck entspricht und dem Regex-Gruppenindex entspricht. |
| regexp\$1extract\$1all (str, regexp [, idx]) | Extrahiert alle Zeichenketten in derstr, die dem Ausdruck entsprechen und dem Regex-Gruppenindex entsprechen. regexp |
| regexp\$1instr (str, regexp) | Durchsucht eine Zeichenfolge nach einem regulären Ausdruck und gibt eine Ganzzahl zurück, die die Anfangsposition der übereinstimmenden Teilzeichenfolge angibt. Positionen basieren auf 1, nicht auf 0. Wenn keine Übereinstimmung gefunden wird, wird 0 zurückgegeben. |
| regexp\$1replace (str, regexp, rep [, position]) | Ersetzt alle Teilstrings dieses Matches durch. str regexp rep |
| regexp\$1substr (str, regexp) | Gibt die Teilzeichenfolge zurück, die dem regulären Ausdruck innerhalb der Zeichenfolge entspricht. regexp str Wenn der reguläre Ausdruck nicht gefunden wird, ist das Ergebnis Null. |
| wiederhole (str, n) | Gibt die Zeichenfolge zurück, die den angegebenen Zeichenkettenwert n-mal wiederholt. |
| ersetzen (str, suche [, ersetzen]) | Ersetzt alle Vorkommen von search mitreplace. |
| rechts (str, len) | Gibt die am weitesten rechts stehenden Zeichen len (lenkann vom Typ Zeichenfolge sein) aus der Zeichenfolge zurück. Wenn sie kleiner oder gleich 0 len iststr, ist das Ergebnis eine leere Zeichenfolge. |
| rpad (str, len [, pad]) | Gibt zurückstr, nach rechts aufgefüllt mit pad bis zu einer Länge von. len Wenn str ist länger alslen, wird der Rückgabewert auf len Zeichen gekürzt. Wenn pad nicht angegeben, str wird es nach rechts mit Leerzeichen aufgefüllt, wenn es sich um eine Zeichenfolge handelt, und mit Nullen, wenn es sich um eine binäre Zeichenfolge handelt. |
| rtrim (str) | Entfernt die abschließenden Leerzeichen von. str |
| Sätze (str [, lang, country]) | Teilt sich str in eine Reihe von Wörtern auf. |
| Soundex (str) | Gibt den Soundex-Code der Zeichenfolge zurück. |
| Leerzeichen (n) | Gibt eine Zeichenfolge zurück, die aus n Leerzeichen besteht. |
| split (str, regex, limit) | Teilt str nach übereinstimmenden Vorkommen auf regex und gibt ein Array mit einer Länge von höchstens limit |
| split\$1part (str, delimiter, partNum) | Teilt str nach Trennzeichen auf und gibt den angeforderten Teil der Aufteilung zurück (1-basiert). Wenn eine Eingabe Null ist, wird Null zurückgegeben. Liegt eine Eingabe außerhalb des Bereichs der geteilten Teile, partNum wird eine leere Zeichenfolge zurückgegeben. Wenn 0 partNum ist, wird ein Fehler ausgegeben. Wenn negativ partNum ist, werden die Teile vom Ende der Zeichenfolge rückwärts gezählt. Wenn delimiter es sich um eine leere Zeichenfolge handelt, str wird die nicht aufgeteilt. |
| beginnt mit (links, rechts) | Gibt einen booleschen Wert zurück. Der Wert ist True, wenn links mit rechts beginnt. Gibt NULL zurück, wenn einer der Eingabeausdrücke NULL ist. Andernfalls wird False zurückgegeben. Sowohl links als auch rechts müssen vom Typ STRING oder BINARY sein. |
| substr (str, pos [, len]) | Gibt den Teilstring zurückstr, der bei der Länge beginnt pos und die Länge hatlen, oder den Teil des Byte-Arrays, der bei beginnt pos und die Länge hat. len |
| substr (str VON pos [FÜR len]]) | Gibt den Teilstring zurückstr, der bei der Länge beginnt pos und die Länge hatlen, oder den Teil eines Byte-Arrays, der mit der Länge beginnt pos und diese hat. len |
| Teilzeichenfolge (str, pos [, len]) | Gibt die Teilzeichenfolge zurückstr, die bei der Länge beginnt pos und die Länge hatlen, oder den Teil eines Byte-Arrays, der bei beginnt pos und die Länge hat. len |
| Teilzeichenfolge (str FROM pos [FÜR LEN]]) | Gibt die Teilzeichenfolge zurückstr, die bei der Länge beginnt pos und die Länge hatlen, oder den Teil eines Byte-Arrays, der mit der Länge beginnt pos und diese hat. len |
| substring\$1index (str, delim, count) | Gibt die Teilzeichenfolge zurück, die str vor count dem Auftreten des Trennzeichens entstanden ist. delim Falls positiv, count wird alles zurückgegeben, was sich links vom letzten Trennzeichen befindet (von links gezählt). Wenn negativ count ist, wird alles zurückgegeben, was sich rechts vom letzten Trennzeichen befindet (von rechts gezählt). Die Funktion substring\$1index führt bei der Suche nach einen Treffer unter Berücksichtigung der Groß- und Kleinschreibung durch. delim |
| to\$1binary (str [, fmt]) | Konvertiert die Eingabe in einen Binärwertstr, der auf dem angegebenen Wert basiert. fmt fmtkann ein Zeichenkettenliteral von „hex“, „utf-8", „utf8" oder „base64" sein, das Groß- und Kleinschreibung nicht berücksichtigt. Standardmäßig ist das Binärformat für die Konvertierung „hex“, wenn es weggelassen wird. fmt Die Funktion gibt NULL zurück, wenn mindestens einer der Eingabeparameter NULL ist. |
| to\$1char (NumberExpr, FormatExpr) | Konvertiert in eine Zeichenfolge, numberExpr die auf dem basiert. formatExpr Löst eine Ausnahme aus, wenn die Konvertierung fehlschlägt. Das Format kann ohne Berücksichtigung der Groß- und Kleinschreibung aus den folgenden Zeichen bestehen: '0' oder '9': Gibt eine erwartete Ziffer zwischen 0 und 9 an. Eine Folge von 0 oder 9 in der Formatzeichenfolge entspricht einer Ziffernfolge im Eingabewert, wodurch eine Ergebniszeichenfolge mit derselben Länge wie die entsprechende Sequenz in der Formatzeichenfolge generiert wird. Die Ergebniszeichenfolge wird links mit Nullen aufgefüllt, wenn die 0/9-Sequenz mehr Ziffern umfasst als der entsprechende Teil des Dezimalwerts, mit 0 beginnt und vor dem Dezimalpunkt liegt. Andernfalls wird sie mit Leerzeichen aufgefüllt. '.' oder 'D': Gibt die Position des Dezimaltrennzeichens an (optional, nur einmal zulässig). ',' oder 'G': Gibt die Position des Gruppierungstrennzeichens (Tausende) an (,). Links und rechts von jedem Gruppierungstrennzeichen muss eine 0 oder 9 stehen. ' |
| to\$1number (expr, fmt) | Konvertiert die Zeichenfolge 'expr' in eine Zahl, die auf dem Zeichenkettenformat 'fmt' basiert. Löst eine Ausnahme aus, wenn die Konvertierung fehlschlägt. Das Format kann ohne Berücksichtigung der Groß- und Kleinschreibung aus den folgenden Zeichen bestehen: '0' oder '9': Gibt eine erwartete Ziffer zwischen 0 und 9 an. Eine Folge von 0 oder 9 in der Formatzeichenfolge entspricht einer Ziffernfolge in der Eingabezeichenfolge. Wenn die 0/9-Sequenz mit 0 beginnt und vor dem Dezimaltrennzeichen liegt, kann sie nur einer Ziffernfolge derselben Größe entsprechen. Andernfalls, wenn die Sequenz mit 9 beginnt oder nach dem Dezimalpunkt liegt, kann sie einer Ziffernfolge entsprechen, die dieselbe oder eine kleinere Größe hat. '.' oder 'D': Gibt die Position des Dezimaltrennzeichens an (optional, nur einmal zulässig). ',' oder 'G': Gibt die Position des Gruppierungstrennzeichens (Tausend) an (,). Links und rechts von jedem Gruppierungstrennzeichen muss eine 0 oder 9 stehen. 'expr' muss mit dem Gruppierungstrennzeichen übereinstimmen, das für die Größe der Zahl relevant ist. ' |
| to\$1varchar (NumberExpr, FormatExpr) | Konvertiert in numberExpr eine Zeichenfolge, die auf dem basiert. formatExpr Löst eine Ausnahme aus, wenn die Konvertierung fehlschlägt. Das Format kann ohne Berücksichtigung der Groß- und Kleinschreibung aus den folgenden Zeichen bestehen: '0' oder '9': Gibt eine erwartete Ziffer zwischen 0 und 9 an. Eine Folge von 0 oder 9 in der Formatzeichenfolge entspricht einer Ziffernfolge im Eingabewert, wodurch eine Ergebniszeichenfolge mit derselben Länge wie die entsprechende Sequenz in der Formatzeichenfolge generiert wird. Die Ergebniszeichenfolge wird links mit Nullen aufgefüllt, wenn die 0/9-Sequenz mehr Ziffern umfasst als der entsprechende Teil des Dezimalwerts, mit 0 beginnt und vor dem Dezimalpunkt liegt. Andernfalls wird sie mit Leerzeichen aufgefüllt. '.' oder 'D': Gibt die Position des Dezimaltrennzeichens an (optional, nur einmal zulässig). ',' oder 'G': Gibt die Position des Gruppierungstrennzeichens (Tausende) an (,). Links und rechts von jedem Gruppierungstrennzeichen muss eine 0 oder 9 stehen. ' |
| übersetzen (Eingabe, von, nach) | Übersetzt die input Zeichenfolge, indem die in der from Zeichenfolge vorhandenen Zeichen durch die entsprechenden Zeichen in der to Zeichenfolge ersetzt werden. |
| trim (str) | Entfernt die führenden und abschließenden Leerzeichen vonstr. |
| trim (BEIDE VON str) | Entfernt die führenden und nachfolgenden Leerzeichen vonstr. |
| trim (FÜHREND VON str) | Entfernt die führenden Leerzeichen vonstr. |
| trim (NACHFOLGEND VON str) | Entfernt die abschließenden Leerzeichen von. str |
| trim (trimStr VON str) | Entferne die führenden und nachfolgenden Zeichen von. trimStr str |
| trim (BEIDE trimStr VON str) | Entferne die führenden und nachfolgenden Zeichen von. trimStr str |
| trim (FÜHRENDES TrimStr VON str) | Entferne die führenden trimStr Zeichen von. str |
| trim (ABSCHLIESSENDES TrimStr VON str) | Entferne die nachfolgenden trimStr Zeichen von. str |
| try\$1to\$1binary (str [, fmt]) | Dies ist eine spezielle Version vonto\$1binary, die dieselbe Operation ausführt, aber einen NULL-Wert zurückgibt, anstatt einen Fehler auszulösen, wenn die Konvertierung nicht durchgeführt werden kann. |
| try\$1to\$1number (expr, fmt) | Konvertiert die Zeichenfolge 'expr' in eine Zahl, die auf dem Zeichenkettenformat basiert. fmt Gibt NULL zurück, wenn die Zeichenfolge 'expr' nicht dem erwarteten Format entspricht. Das Format folgt derselben Semantik wie die Funktion to\$1number. |
| ucase (str) | Gibt zurück, str bei der alle Zeichen in Großbuchstaben geändert wurden. |
| unbase64 (str) | Konvertiert das Argument von einer Base-64-Zeichenfolge in eine str Binärdatei. |
| oberer (str) | Gibt zurück, str bei der alle Zeichen in Großbuchstaben geändert wurden. |
**Beispiele**
```
-- ascii
SELECT ascii('222');
+----------+
|ascii(222)|
+----------+
| 50|
+----------+
SELECT ascii(2);
+--------+
|ascii(2)|
+--------+
| 50|
+--------+
-- base64
SELECT base64('Feathers');
+-----------------+
|base64(Feathers)|
+-----------------+
| RmVhdGhlcnM=|
+-----------------+
SELECT base64(x'537061726b2053514c');
+-----------------------------+
|base64(X'537061726B2053514C')|
+-----------------------------+
| U3BhcmsgU1FM|
+-----------------------------+
-- bit_length
SELECT bit_length('Feathers');
+---------------------+
|bit_length(Feathers)|
+---------------------+
| 64|
+---------------------+
SELECT bit_length(x'537061726b2053514c');
+---------------------------------+
|bit_length(X'537061726B2053514C')|
+---------------------------------+
| 72|
+---------------------------------+
-- btrim
SELECT btrim(' Feathers ');
+----------------------+
|btrim( Feathers )|
+----------------------+
| Feathers|
+----------------------+
SELECT btrim(encode(' Feathers ', 'utf-8'));
+-------------------------------------+
|btrim(encode( Feathers , utf-8))|
+-------------------------------------+
| Feathers|
+-------------------------------------+
SELECT btrim('Feathers', 'Fe');
+---------------------+
|btrim(Alphabet, Al)|
+---------------------+
| athers|
+---------------------+
SELECT btrim(encode('Feathers', 'utf-8'), encode('Al', 'utf-8'));
+---------------------------------------------------+
|btrim(encode(Feathers, utf-8), encode(Al, utf-8))|
+---------------------------------------------------+
| athers|
+---------------------------------------------------+
-- char
SELECT char(65);
+--------+
|char(65)|
+--------+
| A|
+--------+
-- char_length
SELECT char_length('Feathers ');
+-----------------------+
|char_length(Feathers )|
+-----------------------+
| 9 |
+-----------------------+
SELECT char_length(x'537061726b2053514c');
+----------------------------------+
|char_length(X'537061726B2053514C')|
+----------------------------------+
| 9|
+----------------------------------+
SELECT CHAR_LENGTH('Feathers ');
+-----------------------+
|char_length(Feathers )|
+-----------------------+
| 9|
+-----------------------+
SELECT CHARACTER_LENGTH('Feathers ');
+----------------------------+
|character_length(Feathers )|
+----------------------------+
| 9|
+----------------------------+
-- character_length
SELECT character_length('Feathers ');
+----------------------------+
|character_length(Feathers )|
+----------------------------+
| 9|
+----------------------------+
SELECT character_length(x'537061726b2053514c');
+---------------------------------------+
|character_length(X'537061726B2053514C')|
+---------------------------------------+
| 9|
+---------------------------------------+
SELECT CHAR_LENGTH('Feathers ');
+-----------------------+
|char_length(Feathers )|
+-----------------------+
| 9|
+-----------------------+
SELECT CHARACTER_LENGTH('Feathers ');
+----------------------------+
|character_length(Feathers )|
+----------------------------+
| 9|
+----------------------------+
-- chr
SELECT chr(65);
+-------+
|chr(65)|
+-------+
| A|
+-------+
-- concat_ws
SELECT concat_ws(' ', 'Fea', 'thers');
+------------------------+
|concat_ws( , Fea, thers)|
+------------------------+
| Feathers|
+------------------------+
SELECT concat_ws('s');
+------------+
|concat_ws(s)|
+------------+
| |
+------------+
SELECT concat_ws('/', 'foo', null, 'bar');
+----------------------------+
|concat_ws(/, foo, NULL, bar)|
+----------------------------+
| foo/bar|
+----------------------------+
SELECT concat_ws(null, 'Fea', 'thers');
+---------------------------+
|concat_ws(NULL, Fea, thers)|
+---------------------------+
| NULL|
+---------------------------+
-- contains
SELECT contains('Feathers', 'Fea');
+--------------------------+
|contains(Feathers, Fea)|
+--------------------------+
| true|
+--------------------------+
SELECT contains('Feathers', 'SQL');
+--------------------------+
|contains(Feathers, SQL)|
+--------------------------+
| false|
+--------------------------+
SELECT contains('Feathers', null);
+-------------------------+
|contains(Feathers, NULL)|
+-------------------------+
| NULL|
+-------------------------+
SELECT contains(x'537061726b2053514c', x'537061726b');
+----------------------------------------------+
|contains(X'537061726B2053514C', X'537061726B')|
+----------------------------------------------+
| true|
+----------------------------------------------+
-- decode
SELECT decode(encode('abc', 'utf-8'), 'utf-8');
+---------------------------------+
|decode(encode(abc, utf-8), utf-8)|
+---------------------------------+
| abc|
+---------------------------------+
SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic');
+----------------------------------------------------------------------------------+
|decode(2, 1, Southlake, 2, San Francisco, 3, New Jersey, 4, Seattle, Non domestic)|
+----------------------------------------------------------------------------------+
| San Francisco|
+----------------------------------------------------------------------------------+
SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic');
+----------------------------------------------------------------------------------+
|decode(6, 1, Southlake, 2, San Francisco, 3, New Jersey, 4, Seattle, Non domestic)|
+----------------------------------------------------------------------------------+
| Non domestic|
+----------------------------------------------------------------------------------+
SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle');
+--------------------------------------------------------------------+
|decode(6, 1, Southlake, 2, San Francisco, 3, New Jersey, 4, Seattle)|
+--------------------------------------------------------------------+
| NULL|
+--------------------------------------------------------------------+
SELECT decode(null, 6, 'Fea', NULL, 'thers', 4, 'rock');
+-------------------------------------------+
|decode(NULL, 6, Fea, NULL, thers, 4, rock)|
+-------------------------------------------+
| thers|
+-------------------------------------------+
-- elt
SELECT elt(1, 'scala', 'java');
+-------------------+
|elt(1, scala, java)|
+-------------------+
| scala|
+-------------------+
SELECT elt(2, 'a', 1);
+------------+
|elt(2, a, 1)|
+------------+
| 1|
+------------+
-- encode
SELECT encode('abc', 'utf-8');
+------------------+
|encode(abc, utf-8)|
+------------------+
| [61 62 63]|
+------------------+
-- endswith
SELECT endswith('Feathers', 'ers');
+------------------------+
|endswith(Feathers, ers)|
+------------------------+
| true|
+------------------------+
SELECT endswith('Feathers', 'SQL');
+--------------------------+
|endswith(Feathers, SQL)|
+--------------------------+
| false|
+--------------------------+
SELECT endswith('Feathers', null);
+-------------------------+
|endswith(Feathers, NULL)|
+-------------------------+
| NULL|
+-------------------------+
SELECT endswith(x'537061726b2053514c', x'537061726b');
+----------------------------------------------+
|endswith(X'537061726B2053514C', X'537061726B')|
+----------------------------------------------+
| false|
+----------------------------------------------+
SELECT endswith(x'537061726b2053514c', x'53514c');
+------------------------------------------+
|endswith(X'537061726B2053514C', X'53514C')|
+------------------------------------------+
| true|
+------------------------------------------+
-- find_in_set
SELECT find_in_set('ab','abc,b,ab,c,def');
+-------------------------------+
|find_in_set(ab, abc,b,ab,c,def)|
+-------------------------------+
| 3|
+-------------------------------+
-- format_number
SELECT format_number(12332.123456, 4);
+------------------------------+
|format_number(12332.123456, 4)|
+------------------------------+
| 12,332.1235|
+------------------------------+
SELECT format_number(12332.123456, '##################.###');
+---------------------------------------------------+
|format_number(12332.123456, ##################.###)|
+---------------------------------------------------+
| 12332.123|
+---------------------------------------------------+
-- format_string
SELECT format_string("Hello World %d %s", 100, "days");
+-------------------------------------------+
|format_string(Hello World %d %s, 100, days)|
+-------------------------------------------+
| Hello World 100 days|
+-------------------------------------------+
-- initcap
SELECT initcap('Feathers');
+------------------+
|initcap(Feathers)|
+------------------+
| Feathers|
+------------------+
-- instr
SELECT instr('Feathers', 'ers');
+--------------------+
|instr(Feathers, ers)|
+--------------------+
| 6|
+--------------------+
-- lcase
SELECT lcase('Feathers');
+---------------+
|lcase(Feathers)|
+---------------+
| feathers|
+---------------+
-- left
SELECT left('Feathers', 3);
+------------------+
|left(Feathers, 3)|
+------------------+
| Fea|
+------------------+
SELECT left(encode('Feathers', 'utf-8'), 3);
+---------------------------------+
|left(encode(Feathers, utf-8), 3)|
+---------------------------------+
| [RmVh]|
+---------------------------------+
-- len
SELECT len('Feathers ');
+---------------+
|len(Feathers )|
+---------------+
| 9|
+---------------+
SELECT len(x'537061726b2053514c');
+--------------------------+
|len(X'537061726B2053514C')|
+--------------------------+
| 9|
+--------------------------+
SELECT CHAR_LENGTH('Feathers ');
+-----------------------+
|char_length(Feathers )|
+-----------------------+
| 9|
+-----------------------+
SELECT CHARACTER_LENGTH('Feathers ');
+----------------------------+
|character_length(Feathers )|
+----------------------------+
| 9|
+----------------------------+
-- length
SELECT length('Feathers ');
+------------------+
|length(Feathers )|
+------------------+
| 9|
+------------------+
SELECT length(x'537061726b2053514c');
+-----------------------------+
|length(X'537061726B2053514C')|
+-----------------------------+
| 9|
+-----------------------------+
SELECT CHAR_LENGTH('Feathers ');
+-----------------------+
|char_length(Feathers )|
+-----------------------+
| 9|
+-----------------------+
SELECT CHARACTER_LENGTH('Feathers ');
+----------------------------+
|character_length(Feathers )|
+----------------------------+
| 9|
+----------------------------+
-- levenshtein
SELECT levenshtein('kitten', 'sitting');
+----------------------------+
|levenshtein(kitten, sitting)|
+----------------------------+
| 3|
+----------------------------+
SELECT levenshtein('kitten', 'sitting', 2);
+-------------------------------+
|levenshtein(kitten, sitting, 2)|
+-------------------------------+
| -1|
+-------------------------------+
-- locate
SELECT locate('bar', 'foobarbar');
+-------------------------+
|locate(bar, foobarbar, 1)|
+-------------------------+
| 4|
+-------------------------+
SELECT locate('bar', 'foobarbar', 5);
+-------------------------+
|locate(bar, foobarbar, 5)|
+-------------------------+
| 7|
+-------------------------+
SELECT POSITION('bar' IN 'foobarbar');
+-------------------------+
|locate(bar, foobarbar, 1)|
+-------------------------+
| 4|
+-------------------------+
-- lower
SELECT lower('Feathers');
+---------------+
|lower(Feathers)|
+---------------+
| feathers|
+---------------+
-- lpad
SELECT lpad('hi', 5, '??');
+---------------+
|lpad(hi, 5, ??)|
+---------------+
| ???hi|
+---------------+
SELECT lpad('hi', 1, '??');
+---------------+
|lpad(hi, 1, ??)|
+---------------+
| h|
+---------------+
SELECT lpad('hi', 5);
+--------------+
|lpad(hi, 5, )|
+--------------+
| hi|
+--------------+
SELECT hex(lpad(unhex('aabb'), 5));
+--------------------------------+
|hex(lpad(unhex(aabb), 5, X'00'))|
+--------------------------------+
| 000000AABB|
+--------------------------------+
SELECT hex(lpad(unhex('aabb'), 5, unhex('1122')));
+--------------------------------------+
|hex(lpad(unhex(aabb), 5, unhex(1122)))|
+--------------------------------------+
| 112211AABB|
+--------------------------------------+
-- ltrim
SELECT ltrim(' Feathers ');
+----------------------+
|ltrim( Feathers )|
+----------------------+
| Feathers |
+----------------------+
-- luhn_check
SELECT luhn_check('8112189876');
+----------------------+
|luhn_check(8112189876)|
+----------------------+
| true|
+----------------------+
SELECT luhn_check('79927398713');
+-----------------------+
|luhn_check(79927398713)|
+-----------------------+
| true|
+-----------------------+
SELECT luhn_check('79927398714');
+-----------------------+
|luhn_check(79927398714)|
+-----------------------+
| false|
+-----------------------+
-- mask
SELECT mask('abcd-EFGH-8765-4321');
+----------------------------------------+
|mask(abcd-EFGH-8765-4321, X, x, n, NULL)|
+----------------------------------------+
| xxxx-XXXX-nnnn-nnnn|
+----------------------------------------+
SELECT mask('abcd-EFGH-8765-4321', 'Q');
+----------------------------------------+
|mask(abcd-EFGH-8765-4321, Q, x, n, NULL)|
+----------------------------------------+
| xxxx-QQQQ-nnnn-nnnn|
+----------------------------------------+
SELECT mask('AbCD123-@$#', 'Q', 'q');
+--------------------------------+
|mask(AbCD123-@$#, Q, q, n, NULL)|
+--------------------------------+
| QqQQnnn-@$#|
+--------------------------------+
SELECT mask('AbCD123-@$#');
+--------------------------------+
|mask(AbCD123-@$#, X, x, n, NULL)|
+--------------------------------+
| XxXXnnn-@$#|
+--------------------------------+
SELECT mask('AbCD123-@$#', 'Q');
+--------------------------------+
|mask(AbCD123-@$#, Q, x, n, NULL)|
+--------------------------------+
| QxQQnnn-@$#|
+--------------------------------+
SELECT mask('AbCD123-@$#', 'Q', 'q');
+--------------------------------+
|mask(AbCD123-@$#, Q, q, n, NULL)|
+--------------------------------+
| QqQQnnn-@$#|
+--------------------------------+
SELECT mask('AbCD123-@$#', 'Q', 'q', 'd');
+--------------------------------+
|mask(AbCD123-@$#, Q, q, d, NULL)|
+--------------------------------+
| QqQQddd-@$#|
+--------------------------------+
SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', 'o');
+-----------------------------+
|mask(AbCD123-@$#, Q, q, d, o)|
+-----------------------------+
| QqQQdddoooo|
+-----------------------------+
SELECT mask('AbCD123-@$#', NULL, 'q', 'd', 'o');
+--------------------------------+
|mask(AbCD123-@$#, NULL, q, d, o)|
+--------------------------------+
| AqCDdddoooo|
+--------------------------------+
SELECT mask('AbCD123-@$#', NULL, NULL, 'd', 'o');
+-----------------------------------+
|mask(AbCD123-@$#, NULL, NULL, d, o)|
+-----------------------------------+
| AbCDdddoooo|
+-----------------------------------+
SELECT mask('AbCD123-@$#', NULL, NULL, NULL, 'o');
+--------------------------------------+
|mask(AbCD123-@$#, NULL, NULL, NULL, o)|
+--------------------------------------+
| AbCD123oooo|
+--------------------------------------+
SELECT mask(NULL, NULL, NULL, NULL, 'o');
+-------------------------------+
|mask(NULL, NULL, NULL, NULL, o)|
+-------------------------------+
| NULL|
+-------------------------------+
SELECT mask(NULL);
+-------------------------+
|mask(NULL, X, x, n, NULL)|
+-------------------------+
| NULL|
+-------------------------+
SELECT mask('AbCD123-@$#', NULL, NULL, NULL, NULL);
+-----------------------------------------+
|mask(AbCD123-@$#, NULL, NULL, NULL, NULL)|
+-----------------------------------------+
| AbCD123-@$#|
+-----------------------------------------+
-- octet_length
SELECT octet_length('Feathers');
+-----------------------+
|octet_length(Feathers)|
+-----------------------+
| 8|
+-----------------------+
SELECT octet_length(x'537061726b2053514c');
+-----------------------------------+
|octet_length(X'537061726B2053514C')|
+-----------------------------------+
| 9|
+-----------------------------------+
-- overlay
SELECT overlay('Feathers' PLACING '_' FROM 6);
+----------------------------+
|overlay(Feathers, _, 6, -1)|
+----------------------------+
| Feathe_ers|
+----------------------------+
SELECT overlay('Feathers' PLACING 'ures' FROM 5);
+-------------------------------+
|overlay(Feathers, ures, 5, -1)|
+-------------------------------+
| Features |
+-------------------------------+
-- position
SELECT position('bar', 'foobarbar');
+---------------------------+
|position(bar, foobarbar, 1)|
+---------------------------+
| 4|
+---------------------------+
SELECT position('bar', 'foobarbar', 5);
+---------------------------+
|position(bar, foobarbar, 5)|
+---------------------------+
| 7|
+---------------------------+
SELECT POSITION('bar' IN 'foobarbar');
+-------------------------+
|locate(bar, foobarbar, 1)|
+-------------------------+
| 4|
+-------------------------+
-- printf
SELECT printf("Hello World %d %s", 100, "days");
+------------------------------------+
|printf(Hello World %d %s, 100, days)|
+------------------------------------+
| Hello World 100 days|
+------------------------------------+
-- regexp_count
SELECT regexp_count('Steven Jones and Stephen Smith are the best players', 'Ste(v|ph)en');
+------------------------------------------------------------------------------+
|regexp_count(Steven Jones and Stephen Smith are the best players, Ste(v|ph)en)|
+------------------------------------------------------------------------------+
| 2|
+------------------------------------------------------------------------------+
SELECT regexp_count('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
+--------------------------------------------------+
|regexp_count(abcdefghijklmnopqrstuvwxyz, [a-z]{3})|
+--------------------------------------------------+
| 8|
+--------------------------------------------------+
-- regexp_extract
SELECT regexp_extract('100-200', '(\\d+)-(\\d+)', 1);
+---------------------------------------+
|regexp_extract(100-200, (\d+)-(\d+), 1)|
+---------------------------------------+
| 100|
+---------------------------------------+
-- regexp_extract_all
SELECT regexp_extract_all('100-200, 300-400', '(\\d+)-(\\d+)', 1);
+----------------------------------------------------+
|regexp_extract_all(100-200, 300-400, (\d+)-(\d+), 1)|
+----------------------------------------------------+
| [100, 300]|
+----------------------------------------------------+
-- regexp_instr
SELECT regexp_instr('user@opensearch.org', '@[^.]*');
+----------------------------------------------+
|regexp_instr(user@opensearch.org, @[^.]*, 0)|
+----------------------------------------------+
| 5|
+----------------------------------------------+
-- regexp_replace
SELECT regexp_replace('100-200', '(\\d+)', 'num');
+--------------------------------------+
|regexp_replace(100-200, (\d+), num, 1)|
+--------------------------------------+
| num-num|
+--------------------------------------+
-- regexp_substr
SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', 'Ste(v|ph)en');
+-------------------------------------------------------------------------------+
|regexp_substr(Steven Jones and Stephen Smith are the best players, Ste(v|ph)en)|
+-------------------------------------------------------------------------------+
| Steven|
+-------------------------------------------------------------------------------+
SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', 'Jeck');
+------------------------------------------------------------------------+
|regexp_substr(Steven Jones and Stephen Smith are the best players, Jeck)|
+------------------------------------------------------------------------+
| NULL|
+------------------------------------------------------------------------+
-- repeat
SELECT repeat('123', 2);
+--------------+
|repeat(123, 2)|
+--------------+
| 123123|
+--------------+
-- replace
SELECT replace('ABCabc', 'abc', 'DEF');
+-------------------------+
|replace(ABCabc, abc, DEF)|
+-------------------------+
| ABCDEF|
+-------------------------+
-- right
SELECT right('Feathers', 3);
+-------------------+
|right(Feathers, 3)|
+-------------------+
| ers|
+-------------------+
-- rpad
SELECT rpad('hi', 5, '??');
+---------------+
|rpad(hi, 5, ??)|
+---------------+
| hi???|
+---------------+
SELECT rpad('hi', 1, '??');
+---------------+
|rpad(hi, 1, ??)|
+---------------+
| h|
+---------------+
SELECT rpad('hi', 5);
+--------------+
|rpad(hi, 5, )|
+--------------+
| hi |
+--------------+
SELECT hex(rpad(unhex('aabb'), 5));
+--------------------------------+
|hex(rpad(unhex(aabb), 5, X'00'))|
+--------------------------------+
| AABB000000|
+--------------------------------+
SELECT hex(rpad(unhex('aabb'), 5, unhex('1122')));
+--------------------------------------+
|hex(rpad(unhex(aabb), 5, unhex(1122)))|
+--------------------------------------+
| AABB112211|
+--------------------------------------+
-- rtrim
SELECT rtrim(' Feathers ');
+----------------------+
|rtrim( Feathers )|
+----------------------+
| Feathers|
+----------------------+
-- sentences
SELECT sentences('Hi there! Good morning.');
+--------------------------------------+
|sentences(Hi there! Good morning., , )|
+--------------------------------------+
| [[Hi, there], [Go...|
+--------------------------------------+
-- soundex
SELECT soundex('Miller');
+---------------+
|soundex(Miller)|
+---------------+
| M460|
+---------------+
-- space
SELECT concat(space(2), '1');
+-------------------+
|concat(space(2), 1)|
+-------------------+
| 1|
+-------------------+
-- split
SELECT split('oneAtwoBthreeC', '[ABC]');
+--------------------------------+
|split(oneAtwoBthreeC, [ABC], -1)|
+--------------------------------+
| [one, two, three, ]|
+--------------------------------+
SELECT split('oneAtwoBthreeC', '[ABC]', -1);
+--------------------------------+
|split(oneAtwoBthreeC, [ABC], -1)|
+--------------------------------+
| [one, two, three, ]|
+--------------------------------+
SELECT split('oneAtwoBthreeC', '[ABC]', 2);
+-------------------------------+
|split(oneAtwoBthreeC, [ABC], 2)|
+-------------------------------+
| [one, twoBthreeC]|
+-------------------------------+
-- split_part
SELECT split_part('11.12.13', '.', 3);
+--------------------------+
|split_part(11.12.13, ., 3)|
+--------------------------+
| 13|
+--------------------------+
-- startswith
SELECT startswith('Feathers', 'Fea');
+----------------------------+
|startswith(Feathers, Fea)|
+----------------------------+
| true|
+----------------------------+
SELECT startswith('Feathers', 'SQL');
+--------------------------+
|startswith(Feathers, SQL)|
+--------------------------+
| false|
+--------------------------+
SELECT startswith('Feathers', null);
+---------------------------+
|startswith(Feathers, NULL)|
+---------------------------+
| NULL|
+---------------------------+
SELECT startswith(x'537061726b2053514c', x'537061726b');
+------------------------------------------------+
|startswith(X'537061726B2053514C', X'537061726B')|
+------------------------------------------------+
| true|
+------------------------------------------------+
SELECT startswith(x'537061726b2053514c', x'53514c');
+--------------------------------------------+
|startswith(X'537061726B2053514C', X'53514C')|
+--------------------------------------------+
| false|
+--------------------------------------------+
-- substr
SELECT substr('Feathers', 5);
+--------------------------------+
|substr(Feathers, 5, 2147483647)|
+--------------------------------+
| hers |
+--------------------------------+
SELECT substr('Feathers', -3);
+---------------------------------+
|substr(Feathers, -3, 2147483647)|
+---------------------------------+
| ers|
+---------------------------------+
SELECT substr('Feathers', 5, 1);
+-----------------------+
|substr(Feathers, 5, 1)|
+-----------------------+
| h|
+-----------------------+
SELECT substr('Feathers' FROM 5);
+-----------------------------------+
|substring(Feathers, 5, 2147483647)|
+-----------------------------------+
| hers |
+-----------------------------------+
SELECT substr('Feathers' FROM -3);
+------------------------------------+
|substring(Feathers, -3, 2147483647)|
+------------------------------------+
| ers|
+------------------------------------+
SELECT substr('Feathers' FROM 5 FOR 1);
+--------------------------+
|substring(Feathers, 5, 1)|
+--------------------------+
| h|
+--------------------------+
-- substring
SELECT substring('Feathers', 5);
+-----------------------------------+
|substring(Feathers, 5, 2147483647)|
+-----------------------------------+
| hers |
+-----------------------------------+
SELECT substring('Feathers', -3);
+------------------------------------+
|substring(Feathers, -3, 2147483647)|
+------------------------------------+
| ers|
+------------------------------------+
SELECT substring('Feathers', 5, 1);
+--------------------------+
|substring(Feathers, 5, 1)|
+--------------------------+
| h|
+--------------------------+
SELECT substring('Feathers' FROM 5);
+-----------------------------------+
|substring(Feathers, 5, 2147483647)|
+-----------------------------------+
| hers |
+-----------------------------------+
SELECT substring('Feathers' FROM -3);
+------------------------------------+
|substring(Feathers, -3, 2147483647)|
+------------------------------------+
| ers|
+------------------------------------+
SELECT substring('Feathers' FROM 5 FOR 1);
+--------------------------+
|substring(Feathers, 5, 1)|
+--------------------------+
| h|
+--------------------------+
-- substring_index
SELECT substring_index('www.apache.org', '.', 2);
+-------------------------------------+
|substring_index(www.apache.org, ., 2)|
+-------------------------------------+
| www.apache|
+-------------------------------------+
-- to_binary
SELECT to_binary('abc', 'utf-8');
+---------------------+
|to_binary(abc, utf-8)|
+---------------------+
| [61 62 63]|
+---------------------+
-- to_char
SELECT to_char(454, '999');
+-----------------+
|to_char(454, 999)|
+-----------------+
| 454|
+-----------------+
SELECT to_char(454.00, '000D00');
+-----------------------+
|to_char(454.00, 000D00)|
+-----------------------+
| 454.00|
+-----------------------+
SELECT to_char(12454, '99G999');
+----------------------+
|to_char(12454, 99G999)|
+----------------------+
| 12,454|
+----------------------+
SELECT to_char(78.12, '$99.99');
+----------------------+
|to_char(78.12, $99.99)|
+----------------------+
| $78.12|
+----------------------+
SELECT to_char(-12454.8, '99G999D9S');
+----------------------------+
|to_char(-12454.8, 99G999D9S)|
+----------------------------+
| 12,454.8-|
+----------------------------+
-- to_number
SELECT to_number('454', '999');
+-------------------+
|to_number(454, 999)|
+-------------------+
| 454|
+-------------------+
SELECT to_number('454.00', '000.00');
+-------------------------+
|to_number(454.00, 000.00)|
+-------------------------+
| 454.00|
+-------------------------+
SELECT to_number('12,454', '99,999');
+-------------------------+
|to_number(12,454, 99,999)|
+-------------------------+
| 12454|
+-------------------------+
SELECT to_number('$78.12', '$99.99');
+-------------------------+
|to_number($78.12, $99.99)|
+-------------------------+
| 78.12|
+-------------------------+
SELECT to_number('12,454.8-', '99,999.9S');
+-------------------------------+
|to_number(12,454.8-, 99,999.9S)|
+-------------------------------+
| -12454.8|
+-------------------------------+
-- to_varchar
SELECT to_varchar(454, '999');
+-----------------+
|to_char(454, 999)|
+-----------------+
| 454|
+-----------------+
SELECT to_varchar(454.00, '000D00');
+-----------------------+
|to_char(454.00, 000D00)|
+-----------------------+
| 454.00|
+-----------------------+
SELECT to_varchar(12454, '99G999');
+----------------------+
|to_char(12454, 99G999)|
+----------------------+
| 12,454|
+----------------------+
SELECT to_varchar(78.12, '$99.99');
+----------------------+
|to_char(78.12, $99.99)|
+----------------------+
| $78.12|
+----------------------+
SELECT to_varchar(-12454.8, '99G999D9S');
+----------------------------+
|to_char(-12454.8, 99G999D9S)|
+----------------------------+
| 12,454.8-|
+----------------------------+
-- translate
SELECT translate('AaBbCc', 'abc', '123');
+---------------------------+
|translate(AaBbCc, abc, 123)|
+---------------------------+
| A1B2C3|
+---------------------------+
-- try_to_binary
SELECT try_to_binary('abc', 'utf-8');
+-------------------------+
|try_to_binary(abc, utf-8)|
+-------------------------+
| [61 62 63]|
+-------------------------+
select try_to_binary('a!', 'base64');
+-------------------------+
|try_to_binary(a!, base64)|
+-------------------------+
| NULL|
+-------------------------+
select try_to_binary('abc', 'invalidFormat');
+---------------------------------+
|try_to_binary(abc, invalidFormat)|
+---------------------------------+
| NULL|
+---------------------------------+
-- try_to_number
SELECT try_to_number('454', '999');
+-----------------------+
|try_to_number(454, 999)|
+-----------------------+
| 454|
+-----------------------+
SELECT try_to_number('454.00', '000.00');
+-----------------------------+
|try_to_number(454.00, 000.00)|
+-----------------------------+
| 454.00|
+-----------------------------+
SELECT try_to_number('12,454', '99,999');
+-----------------------------+
|try_to_number(12,454, 99,999)|
+-----------------------------+
| 12454|
+-----------------------------+
SELECT try_to_number('$78.12', '$99.99');
+-----------------------------+
|try_to_number($78.12, $99.99)|
+-----------------------------+
| 78.12|
+-----------------------------+
SELECT try_to_number('12,454.8-', '99,999.9S');
+-----------------------------------+
|try_to_number(12,454.8-, 99,999.9S)|
+-----------------------------------+
| -12454.8|
+-----------------------------------+
-- ucase
SELECT ucase('Feathers');
+---------------+
|ucase(Feathers)|
+---------------+
| FEATHERS|
+---------------+
-- unbase64
SELECT unbase64('U3BhcmsgU1FM');
+----------------------+
|unbase64(U3BhcmsgU1FM)|
+----------------------+
| [53 70 61 72 6B 2...|
+----------------------+
-- upper
SELECT upper('Feathers');
+---------------+
|upper(Feathers)|
+---------------+
| FEATHERS|
+---------------+
```
#### Datums- und Zeitfunktionen
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter. [Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql)
****
| Funktion | Description |
| --- | --- |
| add\$1months (Startdatum, Anzahl\$1Monate) | Gibt das Datum zurück, das danach liegt. num\$1months start\$1date |
| convert\$1timezone ([QuellTZ,] ZielTZ, QuellTS) | Konvertiert den Zeitstempel ohne Zeitzone von der Zeitzone in. sourceTs sourceTz targetTz |
| kurieren () | Gibt das aktuelle Datum zu Beginn der Abfrageauswertung zurück. Alle Aufrufe von curdate innerhalb derselben Abfrage geben denselben Wert zurück. |
| aktuelles\$1Datum () | Gibt das aktuelle Datum zu Beginn der Abfrageauswertung zurück. Alle Aufrufe von current\$1date innerhalb derselben Abfrage geben denselben Wert zurück. |
| current\$1date | Gibt das aktuelle Datum zu Beginn der Abfrageauswertung zurück. |
| current\$1timestamp () | Gibt den aktuellen Zeitstempel zu Beginn der Abfrageauswertung zurück. Alle Aufrufe von current\$1timestamp innerhalb derselben Abfrage geben denselben Wert zurück. |
| current\$1timestamp | Gibt den aktuellen Zeitstempel zu Beginn der Abfrageauswertung zurück. |
| current\$1timezone () | Gibt die lokale Zeitzone der aktuellen Sitzung zurück. |
| date\$1add (Startdatum, Anzahl\$1Tage) | Gibt das Datum zurück, das danach liegt. num\$1days start\$1date |
| date\$1diff (Enddatum, Startdatum) | Gibt die Anzahl der Tage von bis zurück. startDate endDate |
| date\$1format (Zeitstempel, fmt) | Konvertiert timestamp in einen Zeichenkettenwert in dem durch das Datumsformat angegebenen Format. fmt |
| date\$1from\$1unix\$1date (Tage) | Erzeugt ein Datum aus der Anzahl der Tage seit dem 01.01.1970. |
| date\$1part (Feld, Quelle) | Extrahiert einen Teil der Quelle date/timestamp oder des Intervalls. |
| date\$1sub (Startdatum, Anzahl\$1Tage) | Gibt das Datum zurück, das davor liegt. num\$1days start\$1date |
| date\$1trunc (fmt, ts) | Gibt den Zeitstempel zurück, der auf die im Formatmodell angegebene Einheit ts gekürzt wurde. fmt |
| dateadd (Startdatum, Anzahl\$1Tage) | Gibt das Datum zurück, das danach liegt. num\$1days start\$1date |
| datediff (EndDate, StartDate) | Gibt die Anzahl der Tage von bis zurück. startDate endDate |
| Datepart (Feld, Quelle) | Extrahiert einen Teil der Quelle date/timestamp oder des Intervalls. |
| Tag (Datum) | Gibt den Tag des Monats zurück, an dem das Datum/der Zeitstempel angegeben wurde. |
| Tag des Monats (Datum) | Gibt den Tag des Monats zurück, an dem das Datum/der Zeitstempel angegeben wurde. |
| Wochentag (Datum) | Gibt den Wochentag für date/timestamp (1 = Sonntag, 2 = Montag,..., 7 = Samstag) zurück. |
| TagOfYear (Datum) | Gibt den Tag des Jahres des Datums/Zeitstempels zurück. |
| extrahieren (Feld AUS der Quelle) | Extrahiert einen Teil der Quelle date/timestamp oder des Intervalls. |
| from\$1unixtime (unix\$1time [, fmt]) | Gibt im unix\$1time angegebenen Wert fmt zurück. |
| from\$1utc\$1timestamp (Zeitstempel, Zeitzone) | Ein gegebener Zeitstempel wie '2017-07-14 02:40:00.0 'interpretiert ihn als eine Zeit in UTC und rendert diese Zeit als Zeitstempel in der angegebenen Zeitzone. Zum Beispiel würde 'GMT\$11' den Wert '2017-07-14 03:40:00.0 'ergeben. |
| Stunde (Zeitstempel) | Gibt die Stundenkomponente der Zeichenkette/des Zeitstempels zurück. |
| last\$1day (Datum) | Gibt den letzten Tag des Monats zurück, zu dem das Datum gehört. |
| localtimestamp () | Gibt den aktuellen Zeitstempel ohne Zeitzone zu Beginn der Abfrageauswertung zurück. Alle Aufrufe von localtimestamp innerhalb derselben Abfrage geben denselben Wert zurück. |
| lokaler Zeitstempel | Gibt das aktuelle lokale Datum und die Uhrzeit in der Zeitzone der Sitzung zu Beginn der Abfrageauswertung zurück. |
| make\$1date (Jahr, Monat, Tag) | Erstellen Sie ein Datum aus den Feldern Jahr, Monat und Tag. |
| make\$1dt\$1interval ([Tage [, Stunden [, Minuten [, Sekunden]]]]) | Stellen Sie die DayTimeIntervalType Dauer aus Tagen, Stunden, Minuten und Sekunden zusammen. |
| make\$1interval ([Jahre [, Monate [, Wochen [, Tage [, Stunden [, Minuten [, Sekunden]]]]]]]]]]) | Erstelle ein Intervall aus Jahren, Monaten, Wochen, Tagen, Stunden, Minuten und Sekunden. |
| make\$1timestamp (Jahr, Monat, Tag, Stunde, Minute, Sekunde [, Zeitzone]) | Erstellen Sie einen Zeitstempel aus den Feldern Jahr, Monat, Tag, Stunde, Minute, Sekunde und Zeitzone. |
| make\$1timestamp\$1ltz (Jahr, Monat, Tag, Stunde, Minute, Sekunde [, Zeitzone]) | Erstellt den aktuellen Zeitstempel mit der lokalen Zeitzone aus den Feldern Jahr, Monat, Tag, Stunde, Minute, Sekunde und Zeitzone. |
| make\$1timestamp\$1ntz (Jahr, Monat, Tag, Stunde, Minute, Sekunde) | Erstellen Sie lokale Datums-/Uhrzeitangaben aus den Feldern Jahr, Monat, Tag, Stunde, Minute und Sekunde. |
| make\$1ym\$1interval ([Jahre [, Monate]]) | Erstelle das Jahres-Monats-Intervall aus Jahren, Monaten. |
| Minute (Zeitstempel) | Gibt die Minutenkomponente der Zeichenkette/des Zeitstempels zurück. |
| Monat (Datum) | Gibt die Monatskomponente des Datums-/Zeitstempels zurück. |
| months\$1between (timestamp1, timestamp2 [, RoundOff]) | Wenn es später ist als, dann ist das Ergebnis positiv. timestamp1 timestamp2 Wenn timestamp1 und timestamp2 am selben Tag des Monats liegen oder beide der letzte Tag des Monats sind, wird die Uhrzeit ignoriert. Andernfalls wird die Differenz auf der Grundlage von 31 Tagen pro Monat berechnet und auf 8 Ziffern gerundet, es sei denn, RoundOff=False. |
| nächster Tag (Startdatum, Wochentag) | Gibt das erste Datum zurück, das nach dem angegebenen Datum liegt und wie angegeben benannt ist. start\$1date Die Funktion gibt NULL zurück, wenn mindestens einer der Eingabeparameter NULL ist. |
| jetzt () | Gibt den aktuellen Zeitstempel zu Beginn der Abfrageauswertung zurück. |
| Quartal (Datum) | Gibt das Quartal des Jahres für das Datum im Bereich 1 bis 4 zurück. |
| Sekunde (Zeitstempel) | Gibt die zweite Komponente der Zeichenkette/des Zeitstempels zurück. |
| session\$1window (Zeitspalte, Gap\$1Duration) | Generiert ein Sitzungsfenster anhand eines Zeitstempels, der die Spalten- und Lückendauer angibt. Ausführliche Erläuterungen und Beispiele finden Sie im Dokument „Arten von Zeitfenstern“ im Dokument „Strukturiertes Streaming“. |
| timestamp\$1micros (Mikrosekunden) | Erzeugt einen Zeitstempel aus der Anzahl der Mikrosekunden seit der UTC-Epoche. |
| timestamp\$1millis (Millisekunden) | Erzeugt einen Zeitstempel aus der Anzahl der Millisekunden seit der UTC-Epoche. |
| timestamp\$1seconds (Sekunden) | Erzeugt einen Zeitstempel aus der Anzahl der Sekunden (kann Bruchteile sein) seit der UTC-Epoche. |
| to\$1date (date\$1str [, fmt]) | Analysiert den date\$1str Ausdruck mit dem Ausdruck bis zu einem Datum. fmt Gibt bei ungültiger Eingabe Null zurück. Standardmäßig folgt es den Umwandlungsregeln für ein Datum, wenn das weggelassen fmt wird. |
| to\$1timestamp (timestamp\$1str [, fmt]) | Analysiert den Ausdruck mit dem Ausdruck bis zu einem Zeitstempel. timestamp\$1str fmt Gibt bei ungültiger Eingabe Null zurück. Standardmäßig folgt es den Umwandlungsregeln in einen Zeitstempel, wenn der weggelassen fmt wird. |
| to\$1timestamp\$1ltz (timestamp\$1str [, fmt]) | Analysiert den Ausdruck mit dem Ausdruck bis zu einem Zeitstempel mit lokaler Zeitzone. timestamp\$1str fmt Gibt bei ungültiger Eingabe Null zurück. Standardmäßig folgt es den Umwandlungsregeln in einen Zeitstempel, wenn der weggelassen fmt wird. |
| to\$1timestamp\$1ntz (timestamp\$1str [, fmt]) | Analysiert den Ausdruck mit dem Ausdruck bis zu einem Zeitstempel ohne Zeitzone. timestamp\$1str fmt Gibt bei ungültiger Eingabe Null zurück. Standardmäßig folgt es den Umwandlungsregeln in einen Zeitstempel, wenn der weggelassen fmt wird. |
| to\$1unix\$1timestamp (TimeExp [, fmt]) | Gibt den UNIX-Zeitstempel der angegebenen Zeit zurück. |
| to\$1utc\$1timestamp (Zeitstempel, Zeitzone) | Ein gegebener Zeitstempel wie '2017-07-14 02:40:00.0 'interpretiert ihn als eine Zeit in der angegebenen Zeitzone und rendert diese Zeit als Zeitstempel in UTC. Zum Beispiel würde 'GMT\$11' den Wert '2017-07-14 01:40:00.0 'ergeben. |
| trunc (Datum, FMT) | Gibt zurück, date wobei der Zeitteil des Tages auf die im Formatmodell angegebene Einheit gekürzt wird. fmt |
| try\$1to\$1timestamp (timestamp\$1str [, fmt]) | Analysiert den Ausdruck mit dem Ausdruck bis zu einem Zeitstempel. timestamp\$1str fmt |
| unix\$1date (Datum) | Gibt die Anzahl der Tage seit dem 01.01.1970 zurück. |
| unix\$1micros (Zeitstempel) | Gibt die Anzahl der Mikrosekunden seit 1970-01-01 00:00:00 UTC zurück. |
| unix\$1millis (Zeitstempel) | Gibt die Anzahl der Millisekunden seit 1970-01-01 00:00:00 UTC zurück. Kürzt höhere Genauigkeitsstufen. |
| unix\$1seconds (Zeitstempel) | Gibt die Anzahl der Sekunden seit 1970-01-01 00:00:00 UTC zurück. Kürzt höhere Genauigkeitsstufen. |
| unix\$1timestamp ([TimeExp [, fmt]]) | Gibt den UNIX-Zeitstempel der aktuellen oder angegebenen Zeit zurück. |
| Wochentag (Datum) | Gibt den Wochentag für date/timestamp (0 = Montag, 1 = Dienstag,..., 6 = Sonntag) zurück. |
| Woche des Jahres (Datum) | Gibt die Woche des Jahres des angegebenen Datums zurück. Es wird davon ausgegangen, dass eine Woche an einem Montag beginnt und Woche 1 ist die erste Woche mit >3 Tagen. |
| window (time\$1column, window\$1duration [, slide\$1duration [, start\$1time]]) | Ordnet Zeilen anhand eines Zeitstempels, der die Spalte angibt, in ein oder mehrere Zeitfenster. Fensteranfänge sind inklusiv, aber die Fensterenden sind exklusiv, z. B. 12:05 Uhr wird im Fenster [12:05,12:10) sein, aber nicht in [12:00,12:05). Windows kann eine Genauigkeit im Mikrosekundenbereich unterstützen. Windows in der Reihenfolge der Monate wird nicht unterstützt. Ausführliche Erläuterungen und Beispiele finden Sie im Dokument „Fensteroperationen bei Event Time“ im Dokument „Structured Streaming Guide“. |
| Fensterzeit (Fensterspalte) | Extrahieren Sie den Zeitwert aus der time/session Fensterspalte, der als Ereigniszeitwert des Fensters verwendet werden kann. Die extrahierte Zeit ist (window.end — 1), was die Tatsache widerspiegelt, dass die aggregierten Fenster eine exklusive Obergrenze haben — [Start, Ende). Ausführliche Erläuterungen und Beispiele finden Sie unter „Fensteroperationen bei Event Time“ im Dokument Structured Streaming Guide. |
| Jahr (Datum) | Gibt die Jahreskomponente des Datums-/Zeitstempels zurück. |
**Beispiele**
```
-- add_months
SELECT add_months('2016-08-31', 1);
+-------------------------+
|add_months(2016-08-31, 1)|
+-------------------------+
| 2016-09-30|
+-------------------------+
-- convert_timezone
SELECT convert_timezone('Europe/Brussels', 'America/Los_Angeles', timestamp_ntz'2021-12-06 00:00:00');
+-------------------------------------------------------------------------------------------+
|convert_timezone(Europe/Brussels, America/Los_Angeles, TIMESTAMP_NTZ '2021-12-06 00:00:00')|
+-------------------------------------------------------------------------------------------+
| 2021-12-05 15:00:00|
+-------------------------------------------------------------------------------------------+
SELECT convert_timezone('Europe/Brussels', timestamp_ntz'2021-12-05 15:00:00');
+------------------------------------------------------------------------------------------+
|convert_timezone(current_timezone(), Europe/Brussels, TIMESTAMP_NTZ '2021-12-05 15:00:00')|
+------------------------------------------------------------------------------------------+
| 2021-12-05 07:00:00|
+------------------------------------------------------------------------------------------+
-- curdate
SELECT curdate();
+--------------+
|current_date()|
+--------------+
| 2024-02-24|
+--------------+
-- current_date
SELECT current_date();
+--------------+
|current_date()|
+--------------+
| 2024-02-24|
+--------------+
SELECT current_date;
+--------------+
|current_date()|
+--------------+
| 2024-02-24|
+--------------+
-- current_timestamp
SELECT current_timestamp();
+--------------------+
| current_timestamp()|
+--------------------+
|2024-02-24 16:36:...|
+--------------------+
SELECT current_timestamp;
+--------------------+
| current_timestamp()|
+--------------------+
|2024-02-24 16:36:...|
+--------------------+
-- current_timezone
SELECT current_timezone();
+------------------+
|current_timezone()|
+------------------+
| Asia/Seoul|
+------------------+
-- date_add
SELECT date_add('2016-07-30', 1);
+-----------------------+
|date_add(2016-07-30, 1)|
+-----------------------+
| 2016-07-31|
+-----------------------+
-- date_diff
SELECT date_diff('2009-07-31', '2009-07-30');
+---------------------------------+
|date_diff(2009-07-31, 2009-07-30)|
+---------------------------------+
| 1|
+---------------------------------+
SELECT date_diff('2009-07-30', '2009-07-31');
+---------------------------------+
|date_diff(2009-07-30, 2009-07-31)|
+---------------------------------+
| -1|
+---------------------------------+
-- date_format
SELECT date_format('2016-04-08', 'y');
+--------------------------+
|date_format(2016-04-08, y)|
+--------------------------+
| 2016|
+--------------------------+
-- date_from_unix_date
SELECT date_from_unix_date(1);
+----------------------+
|date_from_unix_date(1)|
+----------------------+
| 1970-01-02|
+----------------------+
-- date_part
SELECT date_part('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456');
+-------------------------------------------------------+
|date_part(YEAR, TIMESTAMP '2019-08-12 01:00:00.123456')|
+-------------------------------------------------------+
| 2019|
+-------------------------------------------------------+
SELECT date_part('week', timestamp'2019-08-12 01:00:00.123456');
+-------------------------------------------------------+
|date_part(week, TIMESTAMP '2019-08-12 01:00:00.123456')|
+-------------------------------------------------------+
| 33|
+-------------------------------------------------------+
SELECT date_part('doy', DATE'2019-08-12');
+---------------------------------+
|date_part(doy, DATE '2019-08-12')|
+---------------------------------+
| 224|
+---------------------------------+
SELECT date_part('SECONDS', timestamp'2019-10-01 00:00:01.000001');
+----------------------------------------------------------+
|date_part(SECONDS, TIMESTAMP '2019-10-01 00:00:01.000001')|
+----------------------------------------------------------+
| 1.000001|
+----------------------------------------------------------+
SELECT date_part('days', interval 5 days 3 hours 7 minutes);
+-------------------------------------------------+
|date_part(days, INTERVAL '5 03:07' DAY TO MINUTE)|
+-------------------------------------------------+
| 5|
+-------------------------------------------------+
SELECT date_part('seconds', interval 5 hours 30 seconds 1 milliseconds 1 microseconds);
+-------------------------------------------------------------+
|date_part(seconds, INTERVAL '05:00:30.001001' HOUR TO SECOND)|
+-------------------------------------------------------------+
| 30.001001|
+-------------------------------------------------------------+
SELECT date_part('MONTH', INTERVAL '2021-11' YEAR TO MONTH);
+--------------------------------------------------+
|date_part(MONTH, INTERVAL '2021-11' YEAR TO MONTH)|
+--------------------------------------------------+
| 11|
+--------------------------------------------------+
SELECT date_part('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND);
+---------------------------------------------------------------+
|date_part(MINUTE, INTERVAL '123 23:55:59.002001' DAY TO SECOND)|
+---------------------------------------------------------------+
| 55|
+---------------------------------------------------------------+
-- date_sub
SELECT date_sub('2016-07-30', 1);
+-----------------------+
|date_sub(2016-07-30, 1)|
+-----------------------+
| 2016-07-29|
+-----------------------+
-- date_trunc
SELECT date_trunc('YEAR', '2015-03-05T09:32:05.359');
+-----------------------------------------+
|date_trunc(YEAR, 2015-03-05T09:32:05.359)|
+-----------------------------------------+
| 2015-01-01 00:00:00|
+-----------------------------------------+
SELECT date_trunc('MM', '2015-03-05T09:32:05.359');
+---------------------------------------+
|date_trunc(MM, 2015-03-05T09:32:05.359)|
+---------------------------------------+
| 2015-03-01 00:00:00|
+---------------------------------------+
SELECT date_trunc('DD', '2015-03-05T09:32:05.359');
+---------------------------------------+
|date_trunc(DD, 2015-03-05T09:32:05.359)|
+---------------------------------------+
| 2015-03-05 00:00:00|
+---------------------------------------+
SELECT date_trunc('HOUR', '2015-03-05T09:32:05.359');
+-----------------------------------------+
|date_trunc(HOUR, 2015-03-05T09:32:05.359)|
+-----------------------------------------+
| 2015-03-05 09:00:00|
+-----------------------------------------+
SELECT date_trunc('MILLISECOND', '2015-03-05T09:32:05.123456');
+---------------------------------------------------+
|date_trunc(MILLISECOND, 2015-03-05T09:32:05.123456)|
+---------------------------------------------------+
| 2015-03-05 09:32:...|
+---------------------------------------------------+
-- dateadd
SELECT dateadd('2016-07-30', 1);
+-----------------------+
|date_add(2016-07-30, 1)|
+-----------------------+
| 2016-07-31|
+-----------------------+
-- datediff
SELECT datediff('2009-07-31', '2009-07-30');
+--------------------------------+
|datediff(2009-07-31, 2009-07-30)|
+--------------------------------+
| 1|
+--------------------------------+
SELECT datediff('2009-07-30', '2009-07-31');
+--------------------------------+
|datediff(2009-07-30, 2009-07-31)|
+--------------------------------+
| -1|
+--------------------------------+
-- datepart
SELECT datepart('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456');
+----------------------------------------------------------+
|datepart(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456')|
+----------------------------------------------------------+
| 2019|
+----------------------------------------------------------+
SELECT datepart('week', timestamp'2019-08-12 01:00:00.123456');
+----------------------------------------------------------+
|datepart(week FROM TIMESTAMP '2019-08-12 01:00:00.123456')|
+----------------------------------------------------------+
| 33|
+----------------------------------------------------------+
SELECT datepart('doy', DATE'2019-08-12');
+------------------------------------+
|datepart(doy FROM DATE '2019-08-12')|
+------------------------------------+
| 224|
+------------------------------------+
SELECT datepart('SECONDS', timestamp'2019-10-01 00:00:01.000001');
+-------------------------------------------------------------+
|datepart(SECONDS FROM TIMESTAMP '2019-10-01 00:00:01.000001')|
+-------------------------------------------------------------+
| 1.000001|
+-------------------------------------------------------------+
SELECT datepart('days', interval 5 days 3 hours 7 minutes);
+----------------------------------------------------+
|datepart(days FROM INTERVAL '5 03:07' DAY TO MINUTE)|
+----------------------------------------------------+
| 5|
+----------------------------------------------------+
SELECT datepart('seconds', interval 5 hours 30 seconds 1 milliseconds 1 microseconds);
+----------------------------------------------------------------+
|datepart(seconds FROM INTERVAL '05:00:30.001001' HOUR TO SECOND)|
+----------------------------------------------------------------+
| 30.001001|
+----------------------------------------------------------------+
SELECT datepart('MONTH', INTERVAL '2021-11' YEAR TO MONTH);
+-----------------------------------------------------+
|datepart(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH)|
+-----------------------------------------------------+
| 11|
+-----------------------------------------------------+
SELECT datepart('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND);
+------------------------------------------------------------------+
|datepart(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND)|
+------------------------------------------------------------------+
| 55|
+------------------------------------------------------------------+
-- day
SELECT day('2009-07-30');
+---------------+
|day(2009-07-30)|
+---------------+
| 30|
+---------------+
-- dayofmonth
SELECT dayofmonth('2009-07-30');
+----------------------+
|dayofmonth(2009-07-30)|
+----------------------+
| 30|
+----------------------+
-- dayofweek
SELECT dayofweek('2009-07-30');
+---------------------+
|dayofweek(2009-07-30)|
+---------------------+
| 5|
+---------------------+
-- dayofyear
SELECT dayofyear('2016-04-09');
+---------------------+
|dayofyear(2016-04-09)|
+---------------------+
| 100|
+---------------------+
-- extract
SELECT extract(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456');
+---------------------------------------------------------+
|extract(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456')|
+---------------------------------------------------------+
| 2019|
+---------------------------------------------------------+
SELECT extract(week FROM timestamp'2019-08-12 01:00:00.123456');
+---------------------------------------------------------+
|extract(week FROM TIMESTAMP '2019-08-12 01:00:00.123456')|
+---------------------------------------------------------+
| 33|
+---------------------------------------------------------+
SELECT extract(doy FROM DATE'2019-08-12');
+-----------------------------------+
|extract(doy FROM DATE '2019-08-12')|
+-----------------------------------+
| 224|
+-----------------------------------+
SELECT extract(SECONDS FROM timestamp'2019-10-01 00:00:01.000001');
+------------------------------------------------------------+
|extract(SECONDS FROM TIMESTAMP '2019-10-01 00:00:01.000001')|
+------------------------------------------------------------+
| 1.000001|
+------------------------------------------------------------+
SELECT extract(days FROM interval 5 days 3 hours 7 minutes);
+---------------------------------------------------+
|extract(days FROM INTERVAL '5 03:07' DAY TO MINUTE)|
+---------------------------------------------------+
| 5|
+---------------------------------------------------+
SELECT extract(seconds FROM interval 5 hours 30 seconds 1 milliseconds 1 microseconds);
+---------------------------------------------------------------+
|extract(seconds FROM INTERVAL '05:00:30.001001' HOUR TO SECOND)|
+---------------------------------------------------------------+
| 30.001001|
+---------------------------------------------------------------+
SELECT extract(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH);
+----------------------------------------------------+
|extract(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH)|
+----------------------------------------------------+
| 11|
+----------------------------------------------------+
SELECT extract(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND);
+-----------------------------------------------------------------+
|extract(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND)|
+-----------------------------------------------------------------+
| 55|
+-----------------------------------------------------------------+
-- from_unixtime
SELECT from_unixtime(0, 'yyyy-MM-dd HH:mm:ss');
+-------------------------------------+
|from_unixtime(0, yyyy-MM-dd HH:mm:ss)|
+-------------------------------------+
| 1970-01-01 09:00:00|
+-------------------------------------+
SELECT from_unixtime(0);
+-------------------------------------+
|from_unixtime(0, yyyy-MM-dd HH:mm:ss)|
+-------------------------------------+
| 1970-01-01 09:00:00|
+-------------------------------------+
-- from_utc_timestamp
SELECT from_utc_timestamp('2016-08-31', 'Asia/Seoul');
+------------------------------------------+
|from_utc_timestamp(2016-08-31, Asia/Seoul)|
+------------------------------------------+
| 2016-08-31 09:00:00|
+------------------------------------------+
-- hour
SELECT hour('2009-07-30 12:58:59');
+-------------------------+
|hour(2009-07-30 12:58:59)|
+-------------------------+
| 12|
+-------------------------+
-- last_day
SELECT last_day('2009-01-12');
+--------------------+
|last_day(2009-01-12)|
+--------------------+
| 2009-01-31|
+--------------------+
-- localtimestamp
SELECT localtimestamp();
+--------------------+
| localtimestamp()|
+--------------------+
|2024-02-24 16:36:...|
+--------------------+
-- make_date
SELECT make_date(2013, 7, 15);
+----------------------+
|make_date(2013, 7, 15)|
+----------------------+
| 2013-07-15|
+----------------------+
SELECT make_date(2019, 7, NULL);
+------------------------+
|make_date(2019, 7, NULL)|
+------------------------+
| NULL|
+------------------------+
-- make_dt_interval
SELECT make_dt_interval(1, 12, 30, 01.001001);
+-------------------------------------+
|make_dt_interval(1, 12, 30, 1.001001)|
+-------------------------------------+
| INTERVAL '1 12:30...|
+-------------------------------------+
SELECT make_dt_interval(2);
+-----------------------------------+
|make_dt_interval(2, 0, 0, 0.000000)|
+-----------------------------------+
| INTERVAL '2 00:00...|
+-----------------------------------+
SELECT make_dt_interval(100, null, 3);
+----------------------------------------+
|make_dt_interval(100, NULL, 3, 0.000000)|
+----------------------------------------+
| NULL|
+----------------------------------------+
-- make_interval
SELECT make_interval(100, 11, 1, 1, 12, 30, 01.001001);
+----------------------------------------------+
|make_interval(100, 11, 1, 1, 12, 30, 1.001001)|
+----------------------------------------------+
| 100 years 11 mont...|
+----------------------------------------------+
SELECT make_interval(100, null, 3);
+----------------------------------------------+
|make_interval(100, NULL, 3, 0, 0, 0, 0.000000)|
+----------------------------------------------+
| NULL|
+----------------------------------------------+
SELECT make_interval(0, 1, 0, 1, 0, 0, 100.000001);
+-------------------------------------------+
|make_interval(0, 1, 0, 1, 0, 0, 100.000001)|
+-------------------------------------------+
| 1 months 1 days 1...|
+-------------------------------------------+
-- make_timestamp
SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887);
+-------------------------------------------+
|make_timestamp(2014, 12, 28, 6, 30, 45.887)|
+-------------------------------------------+
| 2014-12-28 06:30:...|
+-------------------------------------------+
SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887, 'CET');
+------------------------------------------------+
|make_timestamp(2014, 12, 28, 6, 30, 45.887, CET)|
+------------------------------------------------+
| 2014-12-28 14:30:...|
+------------------------------------------------+
SELECT make_timestamp(2019, 6, 30, 23, 59, 60);
+---------------------------------------+
|make_timestamp(2019, 6, 30, 23, 59, 60)|
+---------------------------------------+
| 2019-07-01 00:00:00|
+---------------------------------------+
SELECT make_timestamp(2019, 6, 30, 23, 59, 1);
+--------------------------------------+
|make_timestamp(2019, 6, 30, 23, 59, 1)|
+--------------------------------------+
| 2019-06-30 23:59:01|
+--------------------------------------+
SELECT make_timestamp(null, 7, 22, 15, 30, 0);
+--------------------------------------+
|make_timestamp(NULL, 7, 22, 15, 30, 0)|
+--------------------------------------+
| NULL|
+--------------------------------------+
-- make_timestamp_ltz
SELECT make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887);
+-----------------------------------------------+
|make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887)|
+-----------------------------------------------+
| 2014-12-28 06:30:...|
+-----------------------------------------------+
SELECT make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887, 'CET');
+----------------------------------------------------+
|make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887, CET)|
+----------------------------------------------------+
| 2014-12-28 14:30:...|
+----------------------------------------------------+
SELECT make_timestamp_ltz(2019, 6, 30, 23, 59, 60);
+-------------------------------------------+
|make_timestamp_ltz(2019, 6, 30, 23, 59, 60)|
+-------------------------------------------+
| 2019-07-01 00:00:00|
+-------------------------------------------+
SELECT make_timestamp_ltz(null, 7, 22, 15, 30, 0);
+------------------------------------------+
|make_timestamp_ltz(NULL, 7, 22, 15, 30, 0)|
+------------------------------------------+
| NULL|
+------------------------------------------+
-- make_timestamp_ntz
SELECT make_timestamp_ntz(2014, 12, 28, 6, 30, 45.887);
+-----------------------------------------------+
|make_timestamp_ntz(2014, 12, 28, 6, 30, 45.887)|
+-----------------------------------------------+
| 2014-12-28 06:30:...|
+-----------------------------------------------+
SELECT make_timestamp_ntz(2019, 6, 30, 23, 59, 60);
+-------------------------------------------+
|make_timestamp_ntz(2019, 6, 30, 23, 59, 60)|
+-------------------------------------------+
| 2019-07-01 00:00:00|
+-------------------------------------------+
SELECT make_timestamp_ntz(null, 7, 22, 15, 30, 0);
+------------------------------------------+
|make_timestamp_ntz(NULL, 7, 22, 15, 30, 0)|
+------------------------------------------+
| NULL|
+------------------------------------------+
-- make_ym_interval
SELECT make_ym_interval(1, 2);
+----------------------+
|make_ym_interval(1, 2)|
+----------------------+
| INTERVAL '1-2' YE...|
+----------------------+
SELECT make_ym_interval(1, 0);
+----------------------+
|make_ym_interval(1, 0)|
+----------------------+
| INTERVAL '1-0' YE...|
+----------------------+
SELECT make_ym_interval(-1, 1);
+-----------------------+
|make_ym_interval(-1, 1)|
+-----------------------+
| INTERVAL '-0-11' ...|
+-----------------------+
SELECT make_ym_interval(2);
+----------------------+
|make_ym_interval(2, 0)|
+----------------------+
| INTERVAL '2-0' YE...|
+----------------------+
-- minute
SELECT minute('2009-07-30 12:58:59');
+---------------------------+
|minute(2009-07-30 12:58:59)|
+---------------------------+
| 58|
+---------------------------+
-- month
SELECT month('2016-07-30');
+-----------------+
|month(2016-07-30)|
+-----------------+
| 7|
+-----------------+
-- months_between
SELECT months_between('1997-02-28 10:30:00', '1996-10-30');
+-----------------------------------------------------+
|months_between(1997-02-28 10:30:00, 1996-10-30, true)|
+-----------------------------------------------------+
| 3.94959677|
+-----------------------------------------------------+
SELECT months_between('1997-02-28 10:30:00', '1996-10-30', false);
+------------------------------------------------------+
|months_between(1997-02-28 10:30:00, 1996-10-30, false)|
+------------------------------------------------------+
| 3.9495967741935485|
+------------------------------------------------------+
-- next_day
SELECT next_day('2015-01-14', 'TU');
+------------------------+
|next_day(2015-01-14, TU)|
+------------------------+
| 2015-01-20|
+------------------------+
-- now
SELECT now();
+--------------------+
| now()|
+--------------------+
|2024-02-24 16:36:...|
+--------------------+
-- quarter
SELECT quarter('2016-08-31');
+-------------------+
|quarter(2016-08-31)|
+-------------------+
| 3|
+-------------------+
-- second
SELECT second('2009-07-30 12:58:59');
+---------------------------+
|second(2009-07-30 12:58:59)|
+---------------------------+
| 59|
+---------------------------+
-- session_window
SELECT a, session_window.start, session_window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:10:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, session_window(b, '5 minutes') ORDER BY a, start;
+---+-------------------+-------------------+---+
| a| start| end|cnt|
+---+-------------------+-------------------+---+
| A1|2021-01-01 00:00:00|2021-01-01 00:09:30| 2|
| A1|2021-01-01 00:10:00|2021-01-01 00:15:00| 1|
| A2|2021-01-01 00:01:00|2021-01-01 00:06:00| 1|
+---+-------------------+-------------------+---+
SELECT a, session_window.start, session_window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:10:00'), ('A2', '2021-01-01 00:01:00'), ('A2', '2021-01-01 00:04:30') AS tab(a, b) GROUP by a, session_window(b, CASE WHEN a = 'A1' THEN '5 minutes' WHEN a = 'A2' THEN '1 minute' ELSE '10 minutes' END) ORDER BY a, start;
+---+-------------------+-------------------+---+
| a| start| end|cnt|
+---+-------------------+-------------------+---+
| A1|2021-01-01 00:00:00|2021-01-01 00:09:30| 2|
| A1|2021-01-01 00:10:00|2021-01-01 00:15:00| 1|
| A2|2021-01-01 00:01:00|2021-01-01 00:02:00| 1|
| A2|2021-01-01 00:04:30|2021-01-01 00:05:30| 1|
+---+-------------------+-------------------+---+
-- timestamp_micros
SELECT timestamp_micros(1230219000123123);
+----------------------------------+
|timestamp_micros(1230219000123123)|
+----------------------------------+
| 2008-12-26 00:30:...|
+----------------------------------+
-- timestamp_millis
SELECT timestamp_millis(1230219000123);
+-------------------------------+
|timestamp_millis(1230219000123)|
+-------------------------------+
| 2008-12-26 00:30:...|
+-------------------------------+
-- timestamp_seconds
SELECT timestamp_seconds(1230219000);
+-----------------------------+
|timestamp_seconds(1230219000)|
+-----------------------------+
| 2008-12-26 00:30:00|
+-----------------------------+
SELECT timestamp_seconds(1230219000.123);
+---------------------------------+
|timestamp_seconds(1230219000.123)|
+---------------------------------+
| 2008-12-26 00:30:...|
+---------------------------------+
-- to_date
SELECT to_date('2009-07-30 04:17:52');
+----------------------------+
|to_date(2009-07-30 04:17:52)|
+----------------------------+
| 2009-07-30|
+----------------------------+
SELECT to_date('2016-12-31', 'yyyy-MM-dd');
+-------------------------------+
|to_date(2016-12-31, yyyy-MM-dd)|
+-------------------------------+
| 2016-12-31|
+-------------------------------+
-- to_timestamp
SELECT to_timestamp('2016-12-31 00:12:00');
+---------------------------------+
|to_timestamp(2016-12-31 00:12:00)|
+---------------------------------+
| 2016-12-31 00:12:00|
+---------------------------------+
SELECT to_timestamp('2016-12-31', 'yyyy-MM-dd');
+------------------------------------+
|to_timestamp(2016-12-31, yyyy-MM-dd)|
+------------------------------------+
| 2016-12-31 00:00:00|
+------------------------------------+
-- to_timestamp_ltz
SELECT to_timestamp_ltz('2016-12-31 00:12:00');
+-------------------------------------+
|to_timestamp_ltz(2016-12-31 00:12:00)|
+-------------------------------------+
| 2016-12-31 00:12:00|
+-------------------------------------+
SELECT to_timestamp_ltz('2016-12-31', 'yyyy-MM-dd');
+----------------------------------------+
|to_timestamp_ltz(2016-12-31, yyyy-MM-dd)|
+----------------------------------------+
| 2016-12-31 00:00:00|
+----------------------------------------+
-- to_timestamp_ntz
SELECT to_timestamp_ntz('2016-12-31 00:12:00');
+-------------------------------------+
|to_timestamp_ntz(2016-12-31 00:12:00)|
+-------------------------------------+
| 2016-12-31 00:12:00|
+-------------------------------------+
SELECT to_timestamp_ntz('2016-12-31', 'yyyy-MM-dd');
+----------------------------------------+
|to_timestamp_ntz(2016-12-31, yyyy-MM-dd)|
+----------------------------------------+
| 2016-12-31 00:00:00|
+----------------------------------------+
-- to_unix_timestamp
SELECT to_unix_timestamp('2016-04-08', 'yyyy-MM-dd');
+-----------------------------------------+
|to_unix_timestamp(2016-04-08, yyyy-MM-dd)|
+-----------------------------------------+
| 1460041200|
+-----------------------------------------+
-- to_utc_timestamp
SELECT to_utc_timestamp('2016-08-31', 'Asia/Seoul');
+----------------------------------------+
|to_utc_timestamp(2016-08-31, Asia/Seoul)|
+----------------------------------------+
| 2016-08-30 15:00:00|
+----------------------------------------+
-- trunc
SELECT trunc('2019-08-04', 'week');
+-----------------------+
|trunc(2019-08-04, week)|
+-----------------------+
| 2019-07-29|
+-----------------------+
SELECT trunc('2019-08-04', 'quarter');
+--------------------------+
|trunc(2019-08-04, quarter)|
+--------------------------+
| 2019-07-01|
+--------------------------+
SELECT trunc('2009-02-12', 'MM');
+---------------------+
|trunc(2009-02-12, MM)|
+---------------------+
| 2009-02-01|
+---------------------+
SELECT trunc('2015-10-27', 'YEAR');
+-----------------------+
|trunc(2015-10-27, YEAR)|
+-----------------------+
| 2015-01-01|
+-----------------------+
-- try_to_timestamp
SELECT try_to_timestamp('2016-12-31 00:12:00');
+-------------------------------------+
|try_to_timestamp(2016-12-31 00:12:00)|
+-------------------------------------+
| 2016-12-31 00:12:00|
+-------------------------------------+
SELECT try_to_timestamp('2016-12-31', 'yyyy-MM-dd');
+----------------------------------------+
|try_to_timestamp(2016-12-31, yyyy-MM-dd)|
+----------------------------------------+
| 2016-12-31 00:00:00|
+----------------------------------------+
SELECT try_to_timestamp('foo', 'yyyy-MM-dd');
+---------------------------------+
|try_to_timestamp(foo, yyyy-MM-dd)|
+---------------------------------+
| NULL|
+---------------------------------+
-- unix_date
SELECT unix_date(DATE("1970-01-02"));
+---------------------+
|unix_date(1970-01-02)|
+---------------------+
| 1|
+---------------------+
-- unix_micros
SELECT unix_micros(TIMESTAMP('1970-01-01 00:00:01Z'));
+---------------------------------+
|unix_micros(1970-01-01 00:00:01Z)|
+---------------------------------+
| 1000000|
+---------------------------------+
-- unix_millis
SELECT unix_millis(TIMESTAMP('1970-01-01 00:00:01Z'));
+---------------------------------+
|unix_millis(1970-01-01 00:00:01Z)|
+---------------------------------+
| 1000|
+---------------------------------+
-- unix_seconds
SELECT unix_seconds(TIMESTAMP('1970-01-01 00:00:01Z'));
+----------------------------------+
|unix_seconds(1970-01-01 00:00:01Z)|
+----------------------------------+
| 1|
+----------------------------------+
-- unix_timestamp
SELECT unix_timestamp();
+--------------------------------------------------------+
|unix_timestamp(current_timestamp(), yyyy-MM-dd HH:mm:ss)|
+--------------------------------------------------------+
| 1708760216|
+--------------------------------------------------------+
SELECT unix_timestamp('2016-04-08', 'yyyy-MM-dd');
+--------------------------------------+
|unix_timestamp(2016-04-08, yyyy-MM-dd)|
+--------------------------------------+
| 1460041200|
+--------------------------------------+
-- weekday
SELECT weekday('2009-07-30');
+-------------------+
|weekday(2009-07-30)|
+-------------------+
| 3|
+-------------------+
-- weekofyear
SELECT weekofyear('2008-02-20');
+----------------------+
|weekofyear(2008-02-20)|
+----------------------+
| 8|
+----------------------+
-- window
SELECT a, window.start, window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '5 minutes') ORDER BY a, start;
+---+-------------------+-------------------+---+
| a| start| end|cnt|
+---+-------------------+-------------------+---+
| A1|2021-01-01 00:00:00|2021-01-01 00:05:00| 2|
| A1|2021-01-01 00:05:00|2021-01-01 00:10:00| 1|
| A2|2021-01-01 00:00:00|2021-01-01 00:05:00| 1|
+---+-------------------+-------------------+---+
SELECT a, window.start, window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '10 minutes', '5 minutes') ORDER BY a, start;
+---+-------------------+-------------------+---+
| a| start| end|cnt|
+---+-------------------+-------------------+---+
| A1|2020-12-31 23:55:00|2021-01-01 00:05:00| 2|
| A1|2021-01-01 00:00:00|2021-01-01 00:10:00| 3|
| A1|2021-01-01 00:05:00|2021-01-01 00:15:00| 1|
| A2|2020-12-31 23:55:00|2021-01-01 00:05:00| 1|
| A2|2021-01-01 00:00:00|2021-01-01 00:10:00| 1|
+---+-------------------+-------------------+---+
-- window_time
SELECT a, window.start as start, window.end as end, window_time(window), cnt FROM (SELECT a, window, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '5 minutes') ORDER BY a, window.start);
+---+-------------------+-------------------+--------------------+---+
| a| start| end| window_time(window)|cnt|
+---+-------------------+-------------------+--------------------+---+
| A1|2021-01-01 00:00:00|2021-01-01 00:05:00|2021-01-01 00:04:...| 2|
| A1|2021-01-01 00:05:00|2021-01-01 00:10:00|2021-01-01 00:09:...| 1|
| A2|2021-01-01 00:00:00|2021-01-01 00:05:00|2021-01-01 00:04:...| 1|
+---+-------------------+-------------------+--------------------+---+
-- year
SELECT year('2016-07-30');
+----------------+
|year(2016-07-30)|
+----------------+
| 2016|
+----------------+
```
#### Aggregationsfunktionen
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter. [Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql)
Aggregatfunktionen verarbeiten Werte in mehreren Zeilen, um mathematische Berechnungen wie Summe, Durchschnitt, Zählung, minimum/maximum Werte, Standardabweichung und Schätzung sowie einige nichtmathematische Operationen durchzuführen.
**Syntax**
```
aggregate_function(input1 [, input2, ...]) FILTER (WHERE boolean_expression)
```
**Parameter**
+ `boolean_expression`- Gibt einen beliebigen Ausdruck an, der zu einem booleschen Ergebnistyp ausgewertet wird. Zwei oder mehr Ausdrücke können mithilfe der logischen Operatoren (AND, OR) miteinander kombiniert werden.
**Aggregatfunktionen mit geordneten Mengen**
Diese Aggregatfunktionen verwenden eine andere Syntax als die anderen Aggregatfunktionen, um einen Ausdruck (normalerweise einen Spaltennamen) anzugeben, nach dem die Werte sortiert werden sollen.
**Syntax**
```
{ PERCENTILE_CONT | PERCENTILE_DISC }(percentile) WITHIN GROUP (ORDER BY { order_by_expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] }) FILTER (WHERE boolean_expression)
```
**Parameter**
+ `percentile`- Das Perzentil des Werts, den Sie finden möchten. Das Perzentil muss eine Konstante zwischen 0,0 und 1,0 sein.
+ `order_by_expression`- Der Ausdruck (normalerweise ein Spaltenname), nach dem die Werte sortiert werden sollen, bevor sie aggregiert werden.
+ `boolean_expression`- Gibt einen beliebigen Ausdruck an, der zu einem booleschen Ergebnistyp ausgewertet wird. Zwei oder mehr Ausdrücke können mithilfe der logischen Operatoren (AND, OR) miteinander kombiniert werden.
**Beispiele**
```
CREATE OR REPLACE TEMPORARY VIEW basic_pays AS SELECT * FROM VALUES
('Jane Doe','Accounting',8435),
('Akua Mansa','Accounting',9998),
('John Doe','Accounting',8992),
('Juan Li','Accounting',8870),
('Carlos Salazar','Accounting',11472),
('Arnav Desai','Accounting',6627),
('Saanvi Sarkar','IT',8113),
('Shirley Rodriguez','IT',5186),
('Nikki Wolf','Sales',9181),
('Alejandro Rosalez','Sales',9441),
('Nikhil Jayashankar','Sales',6660),
('Richard Roe','Sales',10563),
('Pat Candella','SCM',10449),
('Gerard Hernandez','SCM',6949),
('Pamela Castillo','SCM',11303),
('Paulo Santos','SCM',11798),
('Jorge Souza','SCM',10586)
AS basic_pays(employee_name, department, salary);
SELECT * FROM basic_pays;
+-------------------+----------+------+
| employee_name |department|salary|
+-------------------+----------+------+
| Arnav Desai |Accounting| 6627|
| Jorge Souza | SCM| 10586|
| Jane Doe |Accounting| 8435|
| Nikhil Jayashankar| Sales| 6660|
| Diego Vanauf | Sales| 10563|
| Carlos Salazar |Accounting| 11472|
| Gerard Hernandez | SCM| 6949|
| John Doe |Accounting| 8992|
| Nikki Wolf | Sales| 9181|
| Paulo Santos | SCM| 11798|
| Saanvi Sarkar | IT| 8113|
| Shirley Rodriguez | IT| 5186|
| Pat Candella | SCM| 10449|
| Akua Mansa |Accounting| 9998|
| Pamela Castillo | SCM| 11303|
| Alejandro Rosalez | Sales| 9441|
| Juan Li |Accounting| 8870|
+-------------------+----------+------+
SELECT
department,
percentile_cont(0.25) WITHIN GROUP (ORDER BY salary) AS pc1,
percentile_cont(0.25) WITHIN GROUP (ORDER BY salary) FILTER (WHERE employee_name LIKE '%Bo%') AS pc2,
percentile_cont(0.25) WITHIN GROUP (ORDER BY salary DESC) AS pc3,
percentile_cont(0.25) WITHIN GROUP (ORDER BY salary DESC) FILTER (WHERE employee_name LIKE '%Bo%') AS pc4,
percentile_disc(0.25) WITHIN GROUP (ORDER BY salary) AS pd1,
percentile_disc(0.25) WITHIN GROUP (ORDER BY salary) FILTER (WHERE employee_name LIKE '%Bo%') AS pd2,
percentile_disc(0.25) WITHIN GROUP (ORDER BY salary DESC) AS pd3,
percentile_disc(0.25) WITHIN GROUP (ORDER BY salary DESC) FILTER (WHERE employee_name LIKE '%Bo%') AS pd4
FROM basic_pays
GROUP BY department
ORDER BY department;
+----------+-------+--------+-------+--------+-----+-----+-----+-----+
|department| pc1| pc2| pc3| pc4| pd1| pd2| pd3| pd4|
+----------+-------+--------+-------+--------+-----+-----+-----+-----+
|Accounting|8543.75| 7838.25| 9746.5|10260.75| 8435| 6627| 9998|11472|
| IT|5917.75| NULL|7381.25| NULL| 5186| NULL| 8113| NULL|
| Sales|8550.75| NULL| 9721.5| NULL| 6660| NULL|10563| NULL|
| SCM|10449.0|10786.25|11303.0|11460.75|10449|10449|11303|11798|
+----------+-------+--------+-------+--------+-----+-----+-----+-----+
```
#### Konditionale Funktionen
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter[Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql).
****
| Funktion | Description |
| --- | --- |
| verschmelzen (Ausdruck1, Ausdruck2,...) | Gibt das erste Argument zurück, das nicht Null ist, falls vorhanden. Andernfalls NULL. |
| wenn (Ausdruck1, Ausdruck2, Ausdruck3) | Wenn das Ergebnis wahr istexpr1, wird zurückgegeben; andernfalls wird zurückgegeben. expr2 expr3 |
| wenn null (Ausdruck1, Ausdruck2) | Gibt zurück, expr2 ob Null expr1 ist oder nicht. expr1 |
| nanvl (Ausdruck1, Ausdruck2) | Gibt zurückexpr1, ob es nicht NaN oder expr2 anders ist. |
| null (Ausdruck1, Ausdruck2) | Gibt null zurück, wenn gleich oder anders. expr1 expr2 expr1 |
| nvl (Ausdruck1, Ausdruck2) | Gibt zurück, expr2 ob Null expr1 ist oder nicht. expr1 |
| nvl2 (Ausdruck1, Ausdruck2, Ausdruck3) | Gibt zurückexpr2, ob nicht Null ist oder nicht. expr1 expr3 |
| FALL WENN Ausdruck1 DANN Ausdruck2 [WENN Ausdruck3 DANN Ausdruck4] \$1 [SONST Ausdruck5] ENDE | Wenn expr1 = wahr, kehrt zurück; andernfalls wenn = wahr, kehrt zurückexpr2; sonst kehrt zurück. expr3 expr4 expr5 |
**Beispiele**
```
-- coalesce
SELECT coalesce(NULL, 1, NULL);
+-----------------------+
|coalesce(NULL, 1, NULL)|
+-----------------------+
| 1|
+-----------------------+
-- if
SELECT if(1 < 2, 'a', 'b');
+-------------------+
|(IF((1 < 2), a, b))|
+-------------------+
| a|
+-------------------+
-- ifnull
SELECT ifnull(NULL, array('2'));
+----------------------+
|ifnull(NULL, array(2))|
+----------------------+
| [2]|
+----------------------+
-- nanvl
SELECT nanvl(cast('NaN' as double), 123);
+-------------------------------+
|nanvl(CAST(NaN AS DOUBLE), 123)|
+-------------------------------+
| 123.0|
+-------------------------------+
-- nullif
SELECT nullif(2, 2);
+------------+
|nullif(2, 2)|
+------------+
| NULL|
+------------+
-- nvl
SELECT nvl(NULL, array('2'));
+-------------------+
|nvl(NULL, array(2))|
+-------------------+
| [2]|
+-------------------+
-- nvl2
SELECT nvl2(NULL, 2, 1);
+----------------+
|nvl2(NULL, 2, 1)|
+----------------+
| 1|
+----------------+
-- when
SELECT CASE WHEN 1 > 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END;
+-----------------------------------------------------------+
|CASE WHEN (1 > 0) THEN 1 WHEN (2 > 0) THEN 2.0 ELSE 1.2 END|
+-----------------------------------------------------------+
| 1.0|
+-----------------------------------------------------------+
SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END;
+-----------------------------------------------------------+
|CASE WHEN (1 < 0) THEN 1 WHEN (2 > 0) THEN 2.0 ELSE 1.2 END|
+-----------------------------------------------------------+
| 2.0|
+-----------------------------------------------------------+
SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 < 0 THEN 2.0 END;
+--------------------------------------------------+
|CASE WHEN (1 < 0) THEN 1 WHEN (2 < 0) THEN 2.0 END|
+--------------------------------------------------+
| NULL|
+--------------------------------------------------+
```
#### JSON-Funktionen
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter[Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql).
****
| Funktion | Description |
| --- | --- |
| from\$1json (JsonStr, Schema [, Optionen]) | Gibt einen Strukturwert mit den angegebenen Werten `JsonStr` und `schema` zurück. |
| get\$1json\$1object (json\$1txt, Pfad) | Extrahiert ein JSON-Objekt aus `path`. |
| json\$1array\$1length (JsonArray) | Gibt die Anzahl der Elemente im äußersten JSON-Array zurück. |
| json\$1object\$1keys (json\$1object) | Gibt alle Schlüssel des äußersten JSON-Objekts als Array zurück. |
| json\$1tuple (JsonStr, p1, p2,..., pn) | Gibt ein Tupel wie die Funktion get\$1json\$1object zurück, benötigt aber mehrere Namen. Alle Eingabeparameter und Ausgabespaltentypen sind Zeichenketten. |
| schema\$1of\$1json (json [, Optionen]) | Gibt das Schema im DDL-Format der JSON-Zeichenfolge zurück. |
| to\$1json (expr [, Optionen]) | Gibt eine JSON-Zeichenfolge mit einem bestimmten Strukturwert zurück |
**Beispiele**
```
-- from_json
SELECT from_json('{"a":1, "b":0.8}', 'a INT, b DOUBLE');
+---------------------------+
| from_json({"a":1, "b":0.8}) |
+---------------------------+
| {1, 0.8} |
+---------------------------+
SELECT from_json('{"time":"26/08/2015"}', 'time Timestamp', map('timestampFormat', 'dd/MM/yyyy'));
+--------------------------------+
| from_json({"time":"26/08/2015"}) |
+--------------------------------+
| {2015-08-26 00:00... |
+--------------------------------+
SELECT from_json('{"teacher": "Alice", "student": [{"name": "Bob", "rank": 1}, {"name": "Charlie", "rank": 2}]}', 'STRUCT>>');
+--------------------------------------------------------------------------------------------------------+
| from_json({"teacher": "Alice", "student": [{"name": "Bob", "rank": 1}, {"name": "Charlie", "rank": 2}]}) |
+--------------------------------------------------------------------------------------------------------+
| {Alice, [{Bob, 1}... |
+--------------------------------------------------------------------------------------------------------+
-- get_json_object
SELECT get_json_object('{"a":"b"}', '$.a');
+-------------------------------+
| get_json_object({"a":"b"}, $.a) |
+-------------------------------+
| b |
+-------------------------------+
-- json_array_length
SELECT json_array_length('[1,2,3,4]');
+----------------------------+
| json_array_length([1,2,3,4]) |
+----------------------------+
| 4 |
+----------------------------+
SELECT json_array_length('[1,2,3,{"f1":1,"f2":[5,6]},4]');
+------------------------------------------------+
| json_array_length([1,2,3,{"f1":1,"f2":[5,6]},4]) |
+------------------------------------------------+
| 5 |
+------------------------------------------------+
SELECT json_array_length('[1,2');
+-----------------------+
| json_array_length([1,2) |
+-----------------------+
| NULL |
+-----------------------+
-- json_object_keys
SELECT json_object_keys('{}');
+--------------------+
| json_object_keys({}) |
+--------------------+
| [] |
+--------------------+
SELECT json_object_keys('{"key": "value"}');
+----------------------------------+
| json_object_keys({"key": "value"}) |
+----------------------------------+
| [key] |
+----------------------------------+
SELECT json_object_keys('{"f1":"abc","f2":{"f3":"a", "f4":"b"}}');
+--------------------------------------------------------+
| json_object_keys({"f1":"abc","f2":{"f3":"a", "f4":"b"}}) |
+--------------------------------------------------------+
| [f1, f2] |
+--------------------------------------------------------+
-- json_tuple
SELECT json_tuple('{"a":1, "b":2}', 'a', 'b');
+---+---+
| c0| c1|
+---+---+
| 1| 2|
+---+---+
-- schema_of_json
SELECT schema_of_json('[{"col":0}]');
+---------------------------+
| schema_of_json([{"col":0}]) |
+---------------------------+
| ARRAY
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter[Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql).
****
| Funktion | Description |
| --- | --- |
| Array (expr,...) | Gibt ein Array mit den angegebenen Elementen zurück. |
| array\$1append (Array, Element) | Fügt das Element am Ende des als erstes Argument übergebenen Arrays hinzu. Der Typ des Elements sollte dem Typ der Elemente des Arrays ähneln. Das Null-Element wird ebenfalls an das Array angehängt. Aber wenn das Array übergeben wurde, ist die Ausgabe NULL |
| array\$1compact (Array) | Entfernt Nullwerte aus dem Array. |
| array\$1contains (Array, Wert) | Gibt true zurück, wenn das Array den Wert enthält. |
| array\$1distinct (Array) | Entfernt doppelte Werte aus dem Array. |
| array\$1except (Matrix1, Matrix2) | Gibt ein Array der Elemente in Array1, aber nicht in Array2, ohne Duplikate zurück. |
| array\$1insert (x, pos, wert) | Platziert val in den Index Pos von Array x. Array-Indizes beginnen bei 1. Der maximale negative Index ist -1, für den die Funktion ein neues Element nach dem aktuellen letzten Element einfügt. Bei einem Index über der Arraygröße werden dem Array oder, falls der Index negativ ist, dem Array „Null“ -Elemente vorangestellt. |
| array\$1intersect (Matrix1, Matrix2) | Gibt ein Array der Elemente im Schnittpunkt von array1 und array2 zurück, ohne Duplikate. |
| array\$1join (Array, Trennzeichen [, NullReplacement]) | Verkettet die Elemente des angegebenen Arrays mithilfe des Trennzeichens und einer optionalen Zeichenfolge, um Nullen zu ersetzen. Wenn kein Wert für NullReplacement festgelegt ist, wird jeder Nullwert gefiltert. |
| array\$1max (Array) | Gibt den Maximalwert im Array zurück. NaN ist größer als alle Nicht-NaN-Elemente für den double/float Typ. NULL-Elemente werden übersprungen. |
| array\$1min (Array) | Gibt den Minimalwert im Array zurück. NaN ist größer als alle Nicht-NaN-Elemente für den double/float Typ. NULL-Elemente werden übersprungen. |
| array\$1position (Array, Element) | Gibt den (1-basierten) Index des ersten passenden Elements des Arrays als Long zurück oder 0, wenn keine Übereinstimmung gefunden wurde. |
| array\$1prepend (Array, Element) | Fügt das Element am Anfang des als erstes Argument übergebenen Arrays hinzu. Der Typ des Elements sollte dem Typ der Elemente des Arrays entsprechen. Das Null-Element wird dem Array ebenfalls vorangestellt. Aber wenn das übergebene Array NULL ist, ist die Ausgabe NULL |
| array\$1remove (Array, Element) | Entferne alle Elemente, die dem Element entsprechen, aus dem Array. |
| array\$1repeat (Element, Anzahl) | Gibt das Array zurück, das die Anzahl der Elemente enthält. |
| array\$1union (Matrix1, Matrix2) | Gibt ein Array der Elemente in der Vereinigung von array1 und array2 zurück, ohne Duplikate. |
| arrays\$1overlap (a1, a2) | Gibt true zurück, wenn a1 mindestens ein Nicht-Null-Element enthält, das auch in a2 vorhanden ist. Wenn die Arrays kein gemeinsames Element haben und beide nicht leer sind und eines von ihnen ein Null-Element enthält, wird Null zurückgegeben, andernfalls False. |
| arrays\$1zip (a1, a2,...) | Gibt ein zusammengeführtes Array von Strukturen zurück, in dem die N-te Struktur alle N-ten Werte der Eingabearrays enthält. |
| arrayOfArraysabflachen () | Transformiert ein Array von Arrays in ein einzelnes Array. |
| get (Array, Index) | Gibt das Element eines Arrays an einem angegebenen (0-basierten) Index zurück. Wenn der Index außerhalb der Array-Grenzen zeigt, gibt diese Funktion NULL zurück. |
| Reihenfolge (Start, Stopp, Schritt) | Generiert eine Reihe von Elementen von Anfang bis Ende (einschließlich), die schrittweise inkrementiert werden. Der Typ der zurückgegebenen Elemente entspricht dem Typ der Argumentausdrücke. Unterstützte Typen sind: Byte, Short, Integer, Long, Date, Timestamp. Die Start- und Stoppausdrücke müssen denselben Typ ergeben. Wenn Start- und Stoppausdrücke in den Typ „Datum“ oder „Zeitstempel“ aufgelöst werden, muss der Schrittausdruck in den Typ „Intervall“, „Jahres-Monats-Intervall“ oder „Tages-Zeitintervall“ aufgelöst werden, andernfalls in denselben Typ wie die Start- und Stoppausdrücke. |
| Shuffle (Array) | Gibt eine zufällige Permutation des angegebenen Arrays zurück. |
| slice (x, Start, Länge) | Unterteilt Array x, beginnend mit dem Indexstart (Array-Indizes beginnen bei 1 oder beginnen am Ende, wenn Start negativ ist) mit der angegebenen Länge. |
| sort\$1array (Array [, aufsteigende Reihenfolge]) | Sortiert das Eingabe-Array in aufsteigender oder absteigender Reihenfolge entsprechend der natürlichen Reihenfolge der Array-Elemente. NaN ist größer als alle Nicht-NaN-Elemente für den double/float Typ. Null-Elemente werden in aufsteigender Reihenfolge am Anfang des zurückgegebenen Arrays oder in absteigender Reihenfolge am Ende des zurückgegebenen Arrays platziert. |
**Beispiele**
```
-- array
SELECT array(1, 2, 3);
+--------------+
|array(1, 2, 3)|
+--------------+
| [1, 2, 3]|
+--------------+
-- array_append
SELECT array_append(array('b', 'd', 'c', 'a'), 'd');
+----------------------------------+
|array_append(array(b, d, c, a), d)|
+----------------------------------+
| [b, d, c, a, d]|
+----------------------------------+
SELECT array_append(array(1, 2, 3, null), null);
+----------------------------------------+
|array_append(array(1, 2, 3, NULL), NULL)|
+----------------------------------------+
| [1, 2, 3, NULL, N...|
+----------------------------------------+
SELECT array_append(CAST(null as Array), 2);
+---------------------+
|array_append(NULL, 2)|
+---------------------+
| NULL|
+---------------------+
-- array_compact
SELECT array_compact(array(1, 2, 3, null));
+-----------------------------------+
|array_compact(array(1, 2, 3, NULL))|
+-----------------------------------+
| [1, 2, 3]|
+-----------------------------------+
SELECT array_compact(array("a", "b", "c"));
+-----------------------------+
|array_compact(array(a, b, c))|
+-----------------------------+
| [a, b, c]|
+-----------------------------+
-- array_contains
SELECT array_contains(array(1, 2, 3), 2);
+---------------------------------+
|array_contains(array(1, 2, 3), 2)|
+---------------------------------+
| true|
+---------------------------------+
-- array_distinct
SELECT array_distinct(array(1, 2, 3, null, 3));
+---------------------------------------+
|array_distinct(array(1, 2, 3, NULL, 3))|
+---------------------------------------+
| [1, 2, 3, NULL]|
+---------------------------------------+
-- array_except
SELECT array_except(array(1, 2, 3), array(1, 3, 5));
+--------------------------------------------+
|array_except(array(1, 2, 3), array(1, 3, 5))|
+--------------------------------------------+
| [2]|
+--------------------------------------------+
-- array_insert
SELECT array_insert(array(1, 2, 3, 4), 5, 5);
+-------------------------------------+
|array_insert(array(1, 2, 3, 4), 5, 5)|
+-------------------------------------+
| [1, 2, 3, 4, 5]|
+-------------------------------------+
SELECT array_insert(array(5, 4, 3, 2), -1, 1);
+--------------------------------------+
|array_insert(array(5, 4, 3, 2), -1, 1)|
+--------------------------------------+
| [5, 4, 3, 2, 1]|
+--------------------------------------+
SELECT array_insert(array(5, 3, 2, 1), -4, 4);
+--------------------------------------+
|array_insert(array(5, 3, 2, 1), -4, 4)|
+--------------------------------------+
| [5, 4, 3, 2, 1]|
+--------------------------------------+
-- array_intersect
SELECT array_intersect(array(1, 2, 3), array(1, 3, 5));
+-----------------------------------------------+
|array_intersect(array(1, 2, 3), array(1, 3, 5))|
+-----------------------------------------------+
| [1, 3]|
+-----------------------------------------------+
-- array_join
SELECT array_join(array('hello', 'world'), ' ');
+----------------------------------+
|array_join(array(hello, world), )|
+----------------------------------+
| hello world|
+----------------------------------+
SELECT array_join(array('hello', null ,'world'), ' ');
+----------------------------------------+
|array_join(array(hello, NULL, world), )|
+----------------------------------------+
| hello world|
+----------------------------------------+
SELECT array_join(array('hello', null ,'world'), ' ', ',');
+-------------------------------------------+
|array_join(array(hello, NULL, world), , ,)|
+-------------------------------------------+
| hello , world|
+-------------------------------------------+
-- array_max
SELECT array_max(array(1, 20, null, 3));
+--------------------------------+
|array_max(array(1, 20, NULL, 3))|
+--------------------------------+
| 20|
+--------------------------------+
-- array_min
SELECT array_min(array(1, 20, null, 3));
+--------------------------------+
|array_min(array(1, 20, NULL, 3))|
+--------------------------------+
| 1|
+--------------------------------+
-- array_position
SELECT array_position(array(312, 773, 708, 708), 708);
+----------------------------------------------+
|array_position(array(312, 773, 708, 708), 708)|
+----------------------------------------------+
| 3|
+----------------------------------------------+
SELECT array_position(array(312, 773, 708, 708), 414);
+----------------------------------------------+
|array_position(array(312, 773, 708, 708), 414)|
+----------------------------------------------+
| 0|
+----------------------------------------------+
-- array_prepend
SELECT array_prepend(array('b', 'd', 'c', 'a'), 'd');
+-----------------------------------+
|array_prepend(array(b, d, c, a), d)|
+-----------------------------------+
| [d, b, d, c, a]|
+-----------------------------------+
SELECT array_prepend(array(1, 2, 3, null), null);
+-----------------------------------------+
|array_prepend(array(1, 2, 3, NULL), NULL)|
+-----------------------------------------+
| [NULL, 1, 2, 3, N...|
+-----------------------------------------+
SELECT array_prepend(CAST(null as Array), 2);
+----------------------+
|array_prepend(NULL, 2)|
+----------------------+
| NULL|
+----------------------+
-- array_remove
SELECT array_remove(array(1, 2, 3, null, 3), 3);
+----------------------------------------+
|array_remove(array(1, 2, 3, NULL, 3), 3)|
+----------------------------------------+
| [1, 2, NULL]|
+----------------------------------------+
-- array_repeat
SELECT array_repeat('123', 2);
+--------------------+
|array_repeat(123, 2)|
+--------------------+
| [123, 123]|
+--------------------+
-- array_union
SELECT array_union(array(1, 2, 3), array(1, 3, 5));
+-------------------------------------------+
|array_union(array(1, 2, 3), array(1, 3, 5))|
+-------------------------------------------+
| [1, 2, 3, 5]|
+-------------------------------------------+
-- arrays_overlap
SELECT arrays_overlap(array(1, 2, 3), array(3, 4, 5));
+----------------------------------------------+
|arrays_overlap(array(1, 2, 3), array(3, 4, 5))|
+----------------------------------------------+
| true|
+----------------------------------------------+
-- arrays_zip
SELECT arrays_zip(array(1, 2, 3), array(2, 3, 4));
+------------------------------------------+
|arrays_zip(array(1, 2, 3), array(2, 3, 4))|
+------------------------------------------+
| [{1, 2}, {2, 3}, ...|
+------------------------------------------+
SELECT arrays_zip(array(1, 2), array(2, 3), array(3, 4));
+-------------------------------------------------+
|arrays_zip(array(1, 2), array(2, 3), array(3, 4))|
+-------------------------------------------------+
| [{1, 2, 3}, {2, 3...|
+-------------------------------------------------+
-- flatten
SELECT flatten(array(array(1, 2), array(3, 4)));
+----------------------------------------+
|flatten(array(array(1, 2), array(3, 4)))|
+----------------------------------------+
| [1, 2, 3, 4]|
+----------------------------------------+
-- get
SELECT get(array(1, 2, 3), 0);
+----------------------+
|get(array(1, 2, 3), 0)|
+----------------------+
| 1|
+----------------------+
SELECT get(array(1, 2, 3), 3);
+----------------------+
|get(array(1, 2, 3), 3)|
+----------------------+
| NULL|
+----------------------+
SELECT get(array(1, 2, 3), -1);
+-----------------------+
|get(array(1, 2, 3), -1)|
+-----------------------+
| NULL|
+-----------------------+
-- sequence
SELECT sequence(1, 5);
+---------------+
| sequence(1, 5)|
+---------------+
|[1, 2, 3, 4, 5]|
+---------------+
SELECT sequence(5, 1);
+---------------+
| sequence(5, 1)|
+---------------+
|[5, 4, 3, 2, 1]|
+---------------+
SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval 1 month);
+----------------------------------------------------------------------+
|sequence(to_date(2018-01-01), to_date(2018-03-01), INTERVAL '1' MONTH)|
+----------------------------------------------------------------------+
| [2018-01-01, 2018...|
+----------------------------------------------------------------------+
SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval '0-1' year to month);
+--------------------------------------------------------------------------------+
|sequence(to_date(2018-01-01), to_date(2018-03-01), INTERVAL '0-1' YEAR TO MONTH)|
+--------------------------------------------------------------------------------+
| [2018-01-01, 2018...|
+--------------------------------------------------------------------------------+
-- shuffle
SELECT shuffle(array(1, 20, 3, 5));
+---------------------------+
|shuffle(array(1, 20, 3, 5))|
+---------------------------+
| [5, 1, 20, 3]|
+---------------------------+
SELECT shuffle(array(1, 20, null, 3));
+------------------------------+
|shuffle(array(1, 20, NULL, 3))|
+------------------------------+
| [1, NULL, 20, 3]|
+------------------------------+
-- slice
SELECT slice(array(1, 2, 3, 4), 2, 2);
+------------------------------+
|slice(array(1, 2, 3, 4), 2, 2)|
+------------------------------+
| [2, 3]|
+------------------------------+
SELECT slice(array(1, 2, 3, 4), -2, 2);
+-------------------------------+
|slice(array(1, 2, 3, 4), -2, 2)|
+-------------------------------+
| [3, 4]|
+-------------------------------+
-- sort_array
SELECT sort_array(array('b', 'd', null, 'c', 'a'), true);
+-----------------------------------------+
|sort_array(array(b, d, NULL, c, a), true)|
+-----------------------------------------+
| [NULL, a, b, c, d]|
+-----------------------------------------+
```
#### Fensterfunktionen
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter. [Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql)
Fensterfunktionen arbeiten mit einer Gruppe von Zeilen, die als Fenster bezeichnet werden, und berechnen einen Rückgabewert für jede Zeile auf der Grundlage der Zeilengruppe. Fensterfunktionen sind nützlich, um Aufgaben wie die Berechnung eines gleitenden Durchschnitts, die Berechnung einer kumulativen Statistik oder den Zugriff auf den Wert von Zeilen anhand der relativen Position der aktuellen Zeile auszuführen.
**Syntax**
```
window_function [ nulls_option ] OVER ( [ { PARTITION | DISTRIBUTE } BY partition_col_name = partition_col_val ( [ , ... ] ) ] { ORDER | SORT } BY expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] [ window_frame ] )
```
**Parameter**
+
Fensterfunktion
Rangfestlegungsfunktionen
Syntax: `RANK | DENSE_RANK | PERCENT_RANK | NTILE | ROW_NUMBER `
Analytische Funktionen
Syntax: `CUME_DIST | LAG | LEAD | NTH_VALUE | FIRST_VALUE | LAST_VALUE `
Aggregationsfunktionen
Syntax: `MAX | MIN | COUNT | SUM | AVG | ... `
+ `nulls_option`- Gibt an, ob Nullwerte bei der Auswertung der Fensterfunktion übersprungen werden sollen oder nicht. NULLS RESPEKTIEREN bedeutet, dass Nullwerte nicht übersprungen werden, NULL-Werte IGNORIEREN bedeutet, dass sie übersprungen werden. Falls nicht angegeben, ist die Standardeinstellung RESPECT NULLS.
Syntax: `{ IGNORE | RESPECT } NULLS `
Hinweis: `Only LAG` \$1 `LEAD` \$1 `NTH_VALUE` `FIRST_VALUE` \$1 `LAST_VALUE` kann mit verwendet werden. `IGNORE NULLS`
+ `window_frame`- Gibt an, in welcher Zeile das Fenster beginnen und wo es enden soll.
Syntax: `{ RANGE | ROWS } { frame_start | BETWEEN frame_start AND frame_end }`
frame\$1start und frame\$1end haben die folgende Syntax:
Syntax: `UNBOUNDED PRECEDING | offset PRECEDING | CURRENT ROW | offset FOLLOWING | UNBOUNDED FOLLOWING `
Offset: gibt den Offset von der Position der aktuellen Zeile an.
**Hinweis** Wenn frame\$1end weggelassen wird, wird standardmäßig CURRENT ROW verwendet.
**Beispiele**
```
CREATE TABLE employees (name STRING, dept STRING, salary INT, age INT);
INSERT INTO employees VALUES ("Lisa", "Sales", 10000, 35);
INSERT INTO employees VALUES ("Evan", "Sales", 32000, 38);
INSERT INTO employees VALUES ("Fred", "Engineering", 21000, 28);
INSERT INTO employees VALUES ("Alex", "Sales", 30000, 33);
INSERT INTO employees VALUES ("Tom", "Engineering", 23000, 33);
INSERT INTO employees VALUES ("Jane", "Marketing", 29000, 28);
INSERT INTO employees VALUES ("Jeff", "Marketing", 35000, 38);
INSERT INTO employees VALUES ("Paul", "Engineering", 29000, 23);
INSERT INTO employees VALUES ("Chloe", "Engineering", 23000, 25);
SELECT * FROM employees;
+-----+-----------+------+-----+
| name| dept|salary| age|
+-----+-----------+------+-----+
|Chloe|Engineering| 23000| 25|
| Fred|Engineering| 21000| 28|
| Paul|Engineering| 29000| 23|
|Helen| Marketing| 29000| 40|
| Tom|Engineering| 23000| 33|
| Jane| Marketing| 29000| 28|
| Jeff| Marketing| 35000| 38|
| Evan| Sales| 32000| 38|
| Lisa| Sales| 10000| 35|
| Alex| Sales| 30000| 33|
+-----+-----------+------+-----+
SELECT name, dept, salary, RANK() OVER (PARTITION BY dept ORDER BY salary) AS rank FROM employees;
+-----+-----------+------+----+
| name| dept|salary|rank|
+-----+-----------+------+----+
| Lisa| Sales| 10000| 1|
| Alex| Sales| 30000| 2|
| Evan| Sales| 32000| 3|
| Fred|Engineering| 21000| 1|
| Tom|Engineering| 23000| 2|
|Chloe|Engineering| 23000| 2|
| Paul|Engineering| 29000| 4|
|Helen| Marketing| 29000| 1|
| Jane| Marketing| 29000| 1|
| Jeff| Marketing| 35000| 3|
+-----+-----------+------+----+
SELECT name, dept, salary, DENSE_RANK() OVER (PARTITION BY dept ORDER BY salary ROWS BETWEEN
UNBOUNDED PRECEDING AND CURRENT ROW) AS dense_rank FROM employees;
+-----+-----------+------+----------+
| name| dept|salary|dense_rank|
+-----+-----------+------+----------+
| Lisa| Sales| 10000| 1|
| Alex| Sales| 30000| 2|
| Evan| Sales| 32000| 3|
| Fred|Engineering| 21000| 1|
| Tom|Engineering| 23000| 2|
|Chloe|Engineering| 23000| 2|
| Paul|Engineering| 29000| 3|
|Helen| Marketing| 29000| 1|
| Jane| Marketing| 29000| 1|
| Jeff| Marketing| 35000| 2|
+-----+-----------+------+----------+
SELECT name, dept, age, CUME_DIST() OVER (PARTITION BY dept ORDER BY age
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS cume_dist FROM employees;
+-----+-----------+------+------------------+
| name| dept|age | cume_dist|
+-----+-----------+------+------------------+
| Alex| Sales| 33|0.3333333333333333|
| Lisa| Sales| 35|0.6666666666666666|
| Evan| Sales| 38| 1.0|
| Paul|Engineering| 23| 0.25|
|Chloe|Engineering| 25| 0.75|
| Fred|Engineering| 28| 0.25|
| Tom|Engineering| 33| 1.0|
| Jane| Marketing| 28|0.3333333333333333|
| Jeff| Marketing| 38|0.6666666666666666|
|Helen| Marketing| 40| 1.0|
+-----+-----------+------+------------------+
SELECT name, dept, salary, MIN(salary) OVER (PARTITION BY dept ORDER BY salary) AS min
FROM employees;
+-----+-----------+------+-----+
| name| dept|salary| min|
+-----+-----------+------+-----+
| Lisa| Sales| 10000|10000|
| Alex| Sales| 30000|10000|
| Evan| Sales| 32000|10000|
|Helen| Marketing| 29000|29000|
| Jane| Marketing| 29000|29000|
| Jeff| Marketing| 35000|29000|
| Fred|Engineering| 21000|21000|
| Tom|Engineering| 23000|21000|
|Chloe|Engineering| 23000|21000|
| Paul|Engineering| 29000|21000|
+-----+-----------+------+-----+
SELECT name, salary,
LAG(salary) OVER (PARTITION BY dept ORDER BY salary) AS lag,
LEAD(salary, 1, 0) OVER (PARTITION BY dept ORDER BY salary) AS lead
FROM employees;
+-----+-----------+------+-----+-----+
| name| dept|salary| lag| lead|
+-----+-----------+------+-----+-----+
| Lisa| Sales| 10000|NULL |30000|
| Alex| Sales| 30000|10000|32000|
| Evan| Sales| 32000|30000| 0|
| Fred|Engineering| 21000| NULL|23000|
|Chloe|Engineering| 23000|21000|23000|
| Tom|Engineering| 23000|23000|29000|
| Paul|Engineering| 29000|23000| 0|
|Helen| Marketing| 29000| NULL|29000|
| Jane| Marketing| 29000|29000|35000|
| Jeff| Marketing| 35000|29000| 0|
+-----+-----------+------+-----+-----+
SELECT id, v,
LEAD(v, 0) IGNORE NULLS OVER w lead,
LAG(v, 0) IGNORE NULLS OVER w lag,
NTH_VALUE(v, 2) IGNORE NULLS OVER w nth_value,
FIRST_VALUE(v) IGNORE NULLS OVER w first_value,
LAST_VALUE(v) IGNORE NULLS OVER w last_value
FROM test_ignore_null
WINDOW w AS (ORDER BY id)
ORDER BY id;
+--+----+----+----+---------+-----------+----------+
|id| v|lead| lag|nth_value|first_value|last_value|
+--+----+----+----+---------+-----------+----------+
| 0|NULL|NULL|NULL| NULL| NULL| NULL|
| 1| x| x| x| NULL| x| x|
| 2|NULL|NULL|NULL| NULL| x| x|
| 3|NULL|NULL|NULL| NULL| x| x|
| 4| y| y| y| y| x| y|
| 5|NULL|NULL|NULL| y| x| y|
| 6| z| z| z| y| x| z|
| 7| v| v| v| y| x| v|
| 8|NULL|NULL|NULL| y| x| v|
+--+----+----+----+---------+-----------+----------+
```
#### Konvertierungs-Funktionen
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter. [Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql)
****
| Funktion | Description |
| --- | --- |
| bigint (Ausdruck) | Wandelt den Wert `expr` in den Zieldatentyp `bigint` um. |
| binär (expr) | Wandelt den Wert `expr `in den Zieldatentyp `binary` um. |
| boolescher Wert (expr) | Wandelt den Wert `expr` in den Zieldatentyp `boolean` um. |
| cast (Typ expr AS) | Wandelt den Wert `expr` in den Zieldatentyp `type` um. |
| Datum (expr) | Wandelt den Wert `expr` in den Zieldatentyp `date` um. |
| dezimal (expr) | Wandelt den Wert `expr` in den Zieldatentyp `decimal` um. |
| doppelt (expr) | Wandelt den Wert `expr `in den Zieldatentyp `double` um. |
| float (expr) | Wandelt den Wert `expr `in den Zieldatentyp `float` um. |
| int (Ausdruck) | Wandelt den Wert `expr `in den Zieldatentyp `int` um. |
| smallint (expr) | Wandelt den Wert `expr` in den Zieldatentyp `smallint` um. |
| Zeichenfolge (expr) | Wandelt den Wert `expr `in den Zieldatentyp `string` um. |
| Zeitstempel (expr) | Wandelt den Wert `expr` in den Zieldatentyp `timestamp` um. |
| tinyint (expr) | Wandelt den Wert `expr` in den Zieldatentyp `tinyint` um. |
**Beispiele**
```
-- cast
SELECT cast(field as int);
+---------------+
|CAST(field AS INT)|
+---------------+
| 10|
+---------------+
```
#### Prädikatsfunktionen
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter. [Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql)
****
| Funktion | Description |
| --- | --- |
| \$1 expr | Logisches Nicht. |
| Ausdruck1 < Ausdruck2 | Gibt true zurück, wenn `expr1` kleiner als `expr2` ist. |
| Ausdruck1 <= Ausdruck2 | Gibt true zurück, wenn `expr1` kleiner oder gleich `expr2` ist. |
| Ausdruck1 <=> Ausdruck2 | Gibt dasselbe Ergebnis zurück wie der EQUAL (=) -Operator für Operanden, die nicht Null sind, gibt aber true zurück, wenn beide Null sind, und false, wenn einer von ihnen Null ist. |
| Ausdruck1 = Ausdruck2 | Gibt true zurück, wenn `expr1` gleich `expr2` ist, andernfalls false. |
| Ausdruck1 == Ausdruck2 | Gibt true zurück, wenn `expr1` gleich `expr2` ist, andernfalls false. |
| Ausdruck1 > Ausdruck2 | Gibt true zurück, wenn `expr1` größer als `expr2` ist. |
| Ausdruck1 >= Ausdruck2 | Gibt true zurück, wenn `expr1` größer oder gleich `expr2` ist. |
| expr1 und expr2 | Logisches UND. |
| str, ich mag das Muster [ESCAPE Escape]. | Gibt true zurück, wenn str zwischen `pattern` und `escape` passt, ohne Berücksichtigung der Groß- und Kleinschreibung, null, wenn irgendwelche Argumente Null sind, andernfalls false. |
| Ausdruck1 in (Ausdruck2, Ausdruck3,...) | Gibt true zurück, wenn `expr` einem beliebigen Wert von ValN entspricht. |
| isnan (Ausdruck) | Gibt true zurück, wenn `expr NaN ist, andernfalls false. |
| ist nicht null (expr) | Gibt true zurück, wenn `expr nicht Null ist, andernfalls false. |
| ist null (expr) | Gibt true zurück, wenn `expr null ist, andernfalls false. |
| str ähnliches Muster [ESCAPE Escape] | Gibt true zurück, wenn str `pattern` mit `escape` übereinstimmt, null, wenn irgendwelche Argumente null sind, andernfalls false. |
| nicht expr | Logisches Nicht. |
| expr1 oder expr2 | Logisches ODER. |
| regexp (str, regexp) | Gibt true zurück, wenn `str` mit `regexp` übereinstimmt, andernfalls false. |
| regexp\$1like (str, regexp) | Gibt true zurück, wenn `str` mit `regexp` übereinstimmt, andernfalls false. |
| rlike (str, regexp) | Gibt true zurück, wenn `str` mit `regexp` übereinstimmt, andernfalls false. |
**Beispiele**
```
-- !
SELECT ! true;
+----------+
|(NOT true)|
+----------+
| false|
+----------+
SELECT ! false;
+-----------+
|(NOT false)|
+-----------+
| true|
+-----------+
SELECT ! NULL;
+----------+
|(NOT NULL)|
+----------+
| NULL|
+----------+
-- <
SELECT to_date('2009-07-30 04:17:52') < to_date('2009-07-30 04:17:52');
+-------------------------------------------------------------+
|(to_date(2009-07-30 04:17:52) < to_date(2009-07-30 04:17:52))|
+-------------------------------------------------------------+
| false|
+-------------------------------------------------------------+
SELECT to_date('2009-07-30 04:17:52') < to_date('2009-08-01 04:17:52');
+-------------------------------------------------------------+
|(to_date(2009-07-30 04:17:52) < to_date(2009-08-01 04:17:52))|
+-------------------------------------------------------------+
| true|
+-------------------------------------------------------------+
SELECT 1 < NULL;
+----------+
|(1 < NULL)|
+----------+
| NULL|
+----------+
-- <=
SELECT 2 <= 2;
+--------+
|(2 <= 2)|
+--------+
| true|
+--------+
SELECT 1.0 <= '1';
+----------+
|(1.0 <= 1)|
+----------+
| true|
+----------+
SELECT to_date('2009-07-30 04:17:52') <= to_date('2009-07-30 04:17:52');
+--------------------------------------------------------------+
|(to_date(2009-07-30 04:17:52) <= to_date(2009-07-30 04:17:52))|
+--------------------------------------------------------------+
| true|
+--------------------------------------------------------------+
SELECT to_date('2009-07-30 04:17:52') <= to_date('2009-08-01 04:17:52');
+--------------------------------------------------------------+
|(to_date(2009-07-30 04:17:52) <= to_date(2009-08-01 04:17:52))|
+--------------------------------------------------------------+
| true|
+--------------------------------------------------------------+
SELECT 1 <= NULL;
+-----------+
|(1 <= NULL)|
+-----------+
| NULL|
+-----------+
-- <=>
SELECT 2 <=> 2;
+---------+
|(2 <=> 2)|
+---------+
| true|
+---------+
SELECT 1 <=> '1';
+---------+
|(1 <=> 1)|
+---------+
| true|
+---------+
SELECT true <=> NULL;
+---------------+
|(true <=> NULL)|
+---------------+
| false|
+---------------+
SELECT NULL <=> NULL;
+---------------+
|(NULL <=> NULL)|
+---------------+
| true|
+---------------+
-- =
SELECT 2 = 2;
+-------+
|(2 = 2)|
+-------+
| true|
+-------+
SELECT 1 = '1';
+-------+
|(1 = 1)|
+-------+
| true|
+-------+
SELECT true = NULL;
+-------------+
|(true = NULL)|
+-------------+
| NULL|
+-------------+
SELECT NULL = NULL;
+-------------+
|(NULL = NULL)|
+-------------+
| NULL|
+-------------+
-- ==
SELECT 2 == 2;
+-------+
|(2 = 2)|
+-------+
| true|
+-------+
SELECT 1 == '1';
+-------+
|(1 = 1)|
+-------+
| true|
+-------+
SELECT true == NULL;
+-------------+
|(true = NULL)|
+-------------+
| NULL|
+-------------+
SELECT NULL == NULL;
+-------------+
|(NULL = NULL)|
+-------------+
| NULL|
+-------------+
-- >
SELECT 2 > 1;
+-------+
|(2 > 1)|
+-------+
| true|
+-------+
SELECT 2 > 1.1;
+-------+
|(2 > 1)|
+-------+
| true|
+-------+
SELECT to_date('2009-07-30 04:17:52') > to_date('2009-07-30 04:17:52');
+-------------------------------------------------------------+
|(to_date(2009-07-30 04:17:52) > to_date(2009-07-30 04:17:52))|
+-------------------------------------------------------------+
| false|
+-------------------------------------------------------------+
SELECT to_date('2009-07-30 04:17:52') > to_date('2009-08-01 04:17:52');
+-------------------------------------------------------------+
|(to_date(2009-07-30 04:17:52) > to_date(2009-08-01 04:17:52))|
+-------------------------------------------------------------+
| false|
+-------------------------------------------------------------+
SELECT 1 > NULL;
+----------+
|(1 > NULL)|
+----------+
| NULL|
+----------+
-- >=
SELECT 2 >= 1;
+--------+
|(2 >= 1)|
+--------+
| true|
+--------+
SELECT 2.0 >= '2.1';
+------------+
|(2.0 >= 2.1)|
+------------+
| false|
+------------+
SELECT to_date('2009-07-30 04:17:52') >= to_date('2009-07-30 04:17:52');
+--------------------------------------------------------------+
|(to_date(2009-07-30 04:17:52) >= to_date(2009-07-30 04:17:52))|
+--------------------------------------------------------------+
| true|
+--------------------------------------------------------------+
SELECT to_date('2009-07-30 04:17:52') >= to_date('2009-08-01 04:17:52');
+--------------------------------------------------------------+
|(to_date(2009-07-30 04:17:52) >= to_date(2009-08-01 04:17:52))|
+--------------------------------------------------------------+
| false|
+--------------------------------------------------------------+
SELECT 1 >= NULL;
+-----------+
|(1 >= NULL)|
+-----------+
| NULL|
+-----------+
-- and
SELECT true and true;
+---------------+
|(true AND true)|
+---------------+
| true|
+---------------+
SELECT true and false;
+----------------+
|(true AND false)|
+----------------+
| false|
+----------------+
SELECT true and NULL;
+---------------+
|(true AND NULL)|
+---------------+
| NULL|
+---------------+
SELECT false and NULL;
+----------------+
|(false AND NULL)|
+----------------+
| false|
+----------------+
-- ilike
SELECT ilike('Wagon', '_Agon');
+-------------------+
|ilike(Wagon, _Agon)|
+-------------------+
| true|
+-------------------+
SELECT '%SystemDrive%\Users\John' ilike '\%SystemDrive\%\\users%';
+--------------------------------------------------------+
|ilike(%SystemDrive%\Users\John, \%SystemDrive\%\\users%)|
+--------------------------------------------------------+
| true|
+--------------------------------------------------------+
SELECT '%SystemDrive%\\USERS\\John' ilike '\%SystemDrive\%\\\\Users%';
+--------------------------------------------------------+
|ilike(%SystemDrive%\USERS\John, \%SystemDrive\%\\Users%)|
+--------------------------------------------------------+
| true|
+--------------------------------------------------------+
SELECT '%SystemDrive%/Users/John' ilike '/%SYSTEMDrive/%//Users%' ESCAPE '/';
+--------------------------------------------------------+
|ilike(%SystemDrive%/Users/John, /%SYSTEMDrive/%//Users%)|
+--------------------------------------------------------+
| true|
+--------------------------------------------------------+
-- in
SELECT 1 in(1, 2, 3);
+----------------+
|(1 IN (1, 2, 3))|
+----------------+
| true|
+----------------+
SELECT 1 in(2, 3, 4);
+----------------+
|(1 IN (2, 3, 4))|
+----------------+
| false|
+----------------+
SELECT named_struct('a', 1, 'b', 2) in(named_struct('a', 1, 'b', 1), named_struct('a', 1, 'b', 3));
+----------------------------------------------------------------------------------+
|(named_struct(a, 1, b, 2) IN (named_struct(a, 1, b, 1), named_struct(a, 1, b, 3)))|
+----------------------------------------------------------------------------------+
| false|
+----------------------------------------------------------------------------------+
SELECT named_struct('a', 1, 'b', 2) in(named_struct('a', 1, 'b', 2), named_struct('a', 1, 'b', 3));
+----------------------------------------------------------------------------------+
|(named_struct(a, 1, b, 2) IN (named_struct(a, 1, b, 2), named_struct(a, 1, b, 3)))|
+----------------------------------------------------------------------------------+
| true|
+----------------------------------------------------------------------------------+
-- isnan
SELECT isnan(cast('NaN' as double));
+--------------------------+
|isnan(CAST(NaN AS DOUBLE))|
+--------------------------+
| true|
+--------------------------+
-- isnotnull
SELECT isnotnull(1);
+---------------+
|(1 IS NOT NULL)|
+---------------+
| true|
+---------------+
-- isnull
SELECT isnull(1);
+-----------+
|(1 IS NULL)|
+-----------+
| false|
+-----------+
-- like
SELECT like('Wagon', '_Agon');
+----------------+
|Wagon LIKE _Agon|
+----------------+
| true|
+----------------+
-- not
SELECT not true;
+----------+
|(NOT true)|
+----------+
| false|
+----------+
SELECT not false;
+-----------+
|(NOT false)|
+-----------+
| true|
+-----------+
SELECT not NULL;
+----------+
|(NOT NULL)|
+----------+
| NULL|
+----------+
-- or
SELECT true or false;
+---------------+
|(true OR false)|
+---------------+
| true|
+---------------+
SELECT false or false;
+----------------+
|(false OR false)|
+----------------+
| false|
+----------------+
SELECT true or NULL;
+--------------+
|(true OR NULL)|
+--------------+
| true|
+--------------+
SELECT false or NULL;
+---------------+
|(false OR NULL)|
+---------------+
| NULL|
+---------------+
```
#### Funktionen zuordnen
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter[Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql).
****
| Funktion | Description |
| --- | --- |
| element\$1at (Array, Index) | Gibt das Element eines Arrays am angegebenen (1-basierten) Index zurück. |
| element\$1at (Karte, Schlüssel) | Gibt den Wert für den angegebenen Schlüssel zurück. Die Funktion gibt NULL zurück, wenn der Schlüssel nicht in der Map enthalten ist. |
| map (Schlüssel0, Wert0, Schlüssel1, Wert1,...) | Erzeugt eine Map mit den angegebenen Paaren. key/value |
| map\$1concat (Karte,...) | Gibt die Vereinigung aller angegebenen Maps zurück |
| map\$1contains\$1key (Karte, Schlüssel) | Gibt true zurück, wenn die Map den Schlüssel enthält. |
| map\$1entries (Karte) | Gibt ein ungeordnetes Array aller Einträge in der angegebenen Map zurück. |
| map\$1from\$1arrays (Schlüssel, Werte) | Erzeugt eine Map mit einem Paar der angegebenen Arrays. key/value Alle Elemente in Schlüsseln sollten nicht Null sein |
| map\$1from\$1entries () arrayOfEntries | Gibt eine Map zurück, die aus dem angegebenen Array von Einträgen erstellt wurde. |
| map\$1keys (Karte) | Gibt ein ungeordnetes Array zurück, das die Schlüssel der Map enthält. |
| map\$1values (Karte) | Gibt ein ungeordnetes Array zurück, das die Werte der Map enthält. |
| str\$1to\$1map (Text [, PairDelim [,]]) keyValueDelim | Erstellt eine Map, nachdem der Text mithilfe von Trennzeichen in Schlüssel/Wert-Paare aufgeteilt wurde. Die Standardtrennzeichen sind ',' für `PairDelim` und ':' für ``. keyValueDelim Sowohl `pairDelim` als auch `` werden als reguläre Ausdrücke behandelt. keyValueDelim |
| try\$1element\$1at (Array, Index) | Gibt das Element eines Arrays am angegebenen (1-basierten) Index zurück. Wenn Index 0 ist, gibt das System einen Fehler aus. Wenn der Index < 0 ist, wird auf Elemente vom letzten bis zum ersten zugegriffen. Die Funktion gibt immer NULL zurück, wenn der Index die Länge des Arrays überschreitet. |
| try\$1element\$1at (Map, Schlüssel) | Gibt den Wert für den angegebenen Schlüssel zurück. Die Funktion gibt immer NULL zurück, wenn der Schlüssel nicht in der Map enthalten ist. |
**Beispiele**
```
-- element_at
SELECT element_at(array(1, 2, 3), 2);
+-----------------------------+
|element_at(array(1, 2, 3), 2)|
+-----------------------------+
| 2|
+-----------------------------+
SELECT element_at(map(1, 'a', 2, 'b'), 2);
+------------------------------+
|element_at(map(1, a, 2, b), 2)|
+------------------------------+
| b|
+------------------------------+
-- map
SELECT map(1.0, '2', 3.0, '4');
+--------------------+
| map(1.0, 2, 3.0, 4)|
+--------------------+
|{1.0 -> 2, 3.0 -> 4}|
+--------------------+
-- map_concat
SELECT map_concat(map(1, 'a', 2, 'b'), map(3, 'c'));
+--------------------------------------+
|map_concat(map(1, a, 2, b), map(3, c))|
+--------------------------------------+
| {1 -> a, 2 -> b, ...|
+--------------------------------------+
-- map_contains_key
SELECT map_contains_key(map(1, 'a', 2, 'b'), 1);
+------------------------------------+
|map_contains_key(map(1, a, 2, b), 1)|
+------------------------------------+
| true|
+------------------------------------+
SELECT map_contains_key(map(1, 'a', 2, 'b'), 3);
+------------------------------------+
|map_contains_key(map(1, a, 2, b), 3)|
+------------------------------------+
| false|
+------------------------------------+
-- map_entries
SELECT map_entries(map(1, 'a', 2, 'b'));
+----------------------------+
|map_entries(map(1, a, 2, b))|
+----------------------------+
| [{1, a}, {2, b}]|
+----------------------------+
-- map_from_arrays
SELECT map_from_arrays(array(1.0, 3.0), array('2', '4'));
+---------------------------------------------+
|map_from_arrays(array(1.0, 3.0), array(2, 4))|
+---------------------------------------------+
| {1.0 -> 2, 3.0 -> 4}|
+---------------------------------------------+
-- map_from_entries
SELECT map_from_entries(array(struct(1, 'a'), struct(2, 'b')));
+---------------------------------------------------+
|map_from_entries(array(struct(1, a), struct(2, b)))|
+---------------------------------------------------+
| {1 -> a, 2 -> b}|
+---------------------------------------------------+
-- map_keys
SELECT map_keys(map(1, 'a', 2, 'b'));
+-------------------------+
|map_keys(map(1, a, 2, b))|
+-------------------------+
| [1, 2]|
+-------------------------+
-- map_values
SELECT map_values(map(1, 'a', 2, 'b'));
+---------------------------+
|map_values(map(1, a, 2, b))|
+---------------------------+
| [a, b]|
+---------------------------+
-- str_to_map
SELECT str_to_map('a:1,b:2,c:3', ',', ':');
+-----------------------------+
|str_to_map(a:1,b:2,c:3, ,, :)|
+-----------------------------+
| {a -> 1, b -> 2, ...|
+-----------------------------+
SELECT str_to_map('a');
+-------------------+
|str_to_map(a, ,, :)|
+-------------------+
| {a -> NULL}|
+-------------------+
-- try_element_at
SELECT try_element_at(array(1, 2, 3), 2);
+---------------------------------+
|try_element_at(array(1, 2, 3), 2)|
+---------------------------------+
| 2|
+---------------------------------+
SELECT try_element_at(map(1, 'a', 2, 'b'), 2);
+----------------------------------+
|try_element_at(map(1, a, 2, b), 2)|
+----------------------------------+
| b|
+----------------------------------+
```
#### Mathematische Funktionen
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter[Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql).
****
| Funktion | Description |
| --- | --- |
| Ausdruck1% Ausdruck2 | Gibt den Rest nach `expr1`/`expr2` zurück. |
| Ausdruck1 \$1 Ausdruck2 | Gibt `expr1`\$1`expr2` zurück. |
| Ausdruck1 \$1 Ausdruck2 | Gibt `expr1`\$1`expr2` zurück. |
| Ausdruck1 - Ausdruck2 | Gibt `expr1`-`expr2` zurück. |
| Ausdruck1//Ausdruck2 | Gibt `expr1`/`expr2` zurück. Es führt immer eine Gleitkommadivision durch. |
| abs (expr) | Gibt den absoluten Wert des numerischen Werts oder des Intervallwerts zurück. |
| acos (expr) | Gibt den inversen Kosinus (auch bekannt als Arkuskosinus) von `expr“ zurück, als ob er von `java.lang.Math.acos` berechnet worden wäre. |
| acosh (Ausdruck) | Gibt den inversen hyperbolischen Kosinus von `expr` zurück. |
| asin (expr) | Gibt den Umkehrsinus (auch bekannt als Arkussinus) und den Arkussinus von `expr zurück, als ob er von `java.lang.Math.asin` berechnet worden wäre. |
| asinh (Ausdruck) | Gibt den inversen hyperbolischen Sinus von `expr` zurück. |
| Satan (Ausdruck) | Gibt den umgekehrten Tangens (auch bekannt als Arkustangens) von `expr` zurück, als ob er von `java.lang.Math.Atan` berechnet worden wäre |
| Satan2 (ExprY, ExprX) | Gibt den Winkel im Bogenmaß zwischen der positiven X-Achse einer Ebene und dem durch die Koordinaten (`expRx`, `expRY`) angegebenen Punkt zurück, als ob er von `java.lang.Math.atan2` berechnet worden wäre. |
| atanh (Ausdruck) | Gibt den umgekehrten hyperbolischen Tangens von `expr` zurück. |
| bin (Ausdruck) | Gibt die Zeichenkettendarstellung des langen Werts `expr `zurück, der binär dargestellt wird. |
| bround (expr, d) | Gibt `expr` im Rundungsmodus HALF\$1EVEN auf `d` Dezimalstellen gerundet zurück. |
| cbrt (Ausdruck) | Gibt die Kubikwurzel von `expr zurück. |
| ceil (Ausdruck [, Skala]) | Gibt nach dem Aufrunden die kleinste Zahl zurück, die nicht kleiner als `expr` ist. Ein optionaler `scale`-Parameter kann angegeben werden, um das Rundungsverhalten zu steuern. |
| Decke (expr [, scale]) | Gibt nach dem Aufrunden die kleinste Zahl zurück, die nicht kleiner als `expr` ist. Ein optionaler `scale`-Parameter kann angegeben werden, um das Rundungsverhalten zu steuern. |
| conv (Zahl, from\$1base, to\$1base) | Konvertiert `num` von `from\$1base` nach `to\$1base`. |
| cos (Ausdruck) | Gibt den Kosinus von `expr zurück, als ob er von `java.lang.Math.cos` berechnet worden wäre. |
| cosh (expr) | Gibt den hyperbolischen Kosinus von `expr zurück, als ob er von `java.lang.Math.Cosh` berechnet worden wäre. |
| Kosten (expr) | Gibt den Kotangens von `expr zurück, als ob er von `1/java.lang.Math.TAN` berechnet worden wäre. |
| csc (expr) | Gibt den Kosekans von `expr zurück, als ob er mit `1/java.lang.Math.sin` berechnet worden wäre. |
| Grad (expr) | Konvertiert Radiant in Grad. |
| expr1 div expr2 | Dividiere `expr1` durch `expr2`. Es gibt NULL zurück, wenn ein Operand NULL ist oder `expr2` 0 ist. Das Ergebnis wird in Long umgewandelt. |
| (e) | Gibt die Eulersche Zahl zurück, e. |
| exp (expr) | Setzt e in die Potenz von `expr zurück. |
| expm1 (expr) — Gibt exp (`expr) zurück | 1 |
| faktoriell (expr) | Gibt den Faktorwert von `expr zurück. `expr` ist [0.. 20]. Andernfalls NULL. |
| Etage (expr [, Skala]) | Gibt nach dem Abrunden die größte Zahl zurück, die nicht größer als `expr ist. Ein optionaler `scale`-Parameter kann angegeben werden, um das Rundungsverhalten zu steuern. |
| am größten (expr,...) | Gibt den größten Wert aller Parameter zurück, wobei Nullwerte übersprungen werden. |
| Hexadezimalzahl (Ausdruck) | Konvertiert `expr` nach Hexadezimal. |
| Hypot (Ausdruck1, Ausdruck2) | Gibt sqrt (`expr1`\$1\$12 \$1 `expr2`\$1\$12) zurück. |
| mindestens (expr,...) | Gibt den kleinsten Wert aller Parameter zurück, wobei Nullwerte übersprungen werden. |
| ln (Ausdruck) | Gibt den natürlichen Logarithmus (Basis e) von `expr zurück. |
| log (Basis, Ausdruck) | Gibt den Logarithmus von `expr mit `base` zurück. |
| log10 (Ausdruck) | Gibt den Logarithmus von `expr mit der Basis 10 zurück. |
| log1p (Ausdruck) | Gibt log (1 \$1 `expr) zurück. |
| log2 (Ausdruck) | Gibt den Logarithmus von `expr mit der Basis 2 zurück. |
| Ausdruck1 gegen Ausdruck2 | Gibt den Rest nach `expr1`/`expr2` zurück. |
| negativ (expr) | Gibt den negierten Wert von `expr` zurück. |
| pi () | Gibt Pi zurück. |
| pmod (Ausdruck1, Ausdruck2) | Gibt den positiven Wert von `expr1` mod `expr2` zurück. |
| positiv (expr) | Gibt den Wert von `expr` zurück. |
| pow (Ausdruck1, Ausdruck2) | Potenziert `expr1` mit `expr2`. |
| Leistung (Ausdruck1, Ausdruck2) | Potenziert `expr1` mit `expr2`. |
| Radiant (expr) | Konvertiert Grad in Radiant. |
| Rand ([Ausgangswert]) | Gibt einen Zufallswert mit unabhängigen und identisch verteilten (i.i.d.) gleichmäßig verteilten Werten in [0, 1) zurück. |
| zufällig ([Geschwindigkeit]) | Gibt einen Zufallswert mit unabhängigen und identisch verteilten (i.i.d.) Werten aus der Standardnormalverteilung zurück. |
| zufällig ([Startwert]) | Gibt einen Zufallswert mit unabhängigen und identisch verteilten (i.i.d.) gleichmäßig verteilten Werten in [0, 1) zurück. |
| print (Ausdruck) | Gibt den doppelten Wert zurück, dessen Wert dem Argument am nächsten kommt und einer mathematischen Ganzzahl entspricht. |
| rund (expr, d) | Gibt `expr` im Rundungsmodus HALF\$1UP auf `d` Dezimalstellen gerundet zurück. |
| Sekunde (Ausdruck) | Gibt den Sekans von `expr zurück, als ob er von `1/java.lang.Math.cos` berechnet worden wäre. |
| shiftleft (Basis, Ausdruck) | Bitweises Verschieben nach links. |
| Zeichen (expr) | Gibt -1,0, 0,0 oder 1,0 zurück, wenn `expr negativ, 0 oder positiv ist. |
| Signal (Ausdruck) | Gibt -1,0, 0,0 oder 1,0 zurück, wenn `expr negativ, 0 oder positiv ist. |
| sin (Ausdruck) | Gibt den Sinus von `expr zurück, als ob er von `java.lang.Math.Sin` berechnet worden wäre. |
| sinh (Ausdruck) | Gibt den hyperbolischen Sinus von `expr zurück, als ob er von `java.lang.Math.Sinh` berechnet worden wäre. |
| sqrt (Ausdruck) | Gibt die Quadratwurzel von `expr zurück. |
| tan (expr) | Gibt den Tangens von `expr zurück, als ob er von `java.lang.Math.TAN` berechnet worden wäre. |
| tanh (expr) | Gibt den hyperbolischen Tangens von `expr zurück, als ob er von `java.lang.Math.Tanh` berechnet worden wäre. |
| try\$1add (expr1, expr2) | Gibt die Summe von `expr1` und `expr2` zurück und das Ergebnis ist Null bei Überlauf. Die akzeptierten Eingabetypen sind dieselben wie beim Operator `\$1`. |
| try\$1divide (Dividende, Divisor) | Gibt `dividend`/`divisor` zurück. Es führt immer eine Gleitkommadivision durch. Das Ergebnis ist immer Null, wenn `expr2` 0 ist. `dividend` muss eine Zahl oder ein Intervall sein. `Divisor` muss eine Zahl sein. |
| try\$1multiply (Ausdruck1, Ausdruck2) | Gibt `expr1`\$1`expr2` zurück und das Ergebnis ist Null bei Überlauf. Die akzeptierten Eingabetypen sind dieselben wie beim Operator `\$1`. |
| try\$1subtract (expr1, expr2) | Gibt `expr1`-`expr2` zurück und das Ergebnis ist Null bei Überlauf. Die akzeptierten Eingabetypen sind dieselben wie beim Operator `-`. |
| unhex (Ausdruck) | Konvertiert das hexadezimale `expr `expr` in ein binäres. |
| width\$1bucket (Wert, min\$1value, max\$1value, num\$1bucket) | Gibt die Bucket-Nummer zurück, der `Wert` in einem Äquiwidth-Histogramm mit `num\$1bucket`-Buckets zugewiesen werden würde, im Bereich `min\$1value` bis `max\$1value`.“ |
**Beispiele**
```
-- %
SELECT 2 % 1.8;
+---------+
|(2 % 1.8)|
+---------+
| 0.2|
+---------+
SELECT MOD(2, 1.8);
+-----------+
|mod(2, 1.8)|
+-----------+
| 0.2|
+-----------+
-- *
SELECT 2 * 3;
+-------+
|(2 * 3)|
+-------+
| 6|
+-------+
-- +
SELECT 1 + 2;
+-------+
|(1 + 2)|
+-------+
| 3|
+-------+
-- -
SELECT 2 - 1;
+-------+
|(2 - 1)|
+-------+
| 1|
+-------+
-- /
SELECT 3 / 2;
+-------+
|(3 / 2)|
+-------+
| 1.5|
+-------+
SELECT 2L / 2L;
+-------+
|(2 / 2)|
+-------+
| 1.0|
+-------+
-- abs
SELECT abs(-1);
+-------+
|abs(-1)|
+-------+
| 1|
+-------+
SELECT abs(INTERVAL -'1-1' YEAR TO MONTH);
+----------------------------------+
|abs(INTERVAL '-1-1' YEAR TO MONTH)|
+----------------------------------+
| INTERVAL '1-1' YE...|
+----------------------------------+
-- acos
SELECT acos(1);
+-------+
|ACOS(1)|
+-------+
| 0.0|
+-------+
SELECT acos(2);
+-------+
|ACOS(2)|
+-------+
| NaN|
+-------+
-- acosh
SELECT acosh(1);
+--------+
|ACOSH(1)|
+--------+
| 0.0|
+--------+
SELECT acosh(0);
+--------+
|ACOSH(0)|
+--------+
| NaN|
+--------+
-- asin
SELECT asin(0);
+-------+
|ASIN(0)|
+-------+
| 0.0|
+-------+
SELECT asin(2);
+-------+
|ASIN(2)|
+-------+
| NaN|
+-------+
-- asinh
SELECT asinh(0);
+--------+
|ASINH(0)|
+--------+
| 0.0|
+--------+
-- atan
SELECT atan(0);
+-------+
|ATAN(0)|
+-------+
| 0.0|
+-------+
-- atan2
SELECT atan2(0, 0);
+-----------+
|ATAN2(0, 0)|
+-----------+
| 0.0|
+-----------+
-- atanh
SELECT atanh(0);
+--------+
|ATANH(0)|
+--------+
| 0.0|
+--------+
SELECT atanh(2);
+--------+
|ATANH(2)|
+--------+
| NaN|
+--------+
-- bin
SELECT bin(13);
+-------+
|bin(13)|
+-------+
| 1101|
+-------+
SELECT bin(-13);
+--------------------+
| bin(-13)|
+--------------------+
|11111111111111111...|
+--------------------+
SELECT bin(13.3);
+---------+
|bin(13.3)|
+---------+
| 1101|
+---------+
-- bround
SELECT bround(2.5, 0);
+--------------+
|bround(2.5, 0)|
+--------------+
| 2|
+--------------+
SELECT bround(25, -1);
+--------------+
|bround(25, -1)|
+--------------+
| 20|
+--------------+
-- cbrt
SELECT cbrt(27.0);
+----------+
|CBRT(27.0)|
+----------+
| 3.0|
+----------+
-- ceil
SELECT ceil(-0.1);
+----------+
|CEIL(-0.1)|
+----------+
| 0|
+----------+
SELECT ceil(5);
+-------+
|CEIL(5)|
+-------+
| 5|
+-------+
SELECT ceil(3.1411, 3);
+---------------+
|ceil(3.1411, 3)|
+---------------+
| 3.142|
+---------------+
SELECT ceil(3.1411, -3);
+----------------+
|ceil(3.1411, -3)|
+----------------+
| 1000|
+----------------+
-- ceiling
SELECT ceiling(-0.1);
+-------------+
|ceiling(-0.1)|
+-------------+
| 0|
+-------------+
SELECT ceiling(5);
+----------+
|ceiling(5)|
+----------+
| 5|
+----------+
SELECT ceiling(3.1411, 3);
+------------------+
|ceiling(3.1411, 3)|
+------------------+
| 3.142|
+------------------+
SELECT ceiling(3.1411, -3);
+-------------------+
|ceiling(3.1411, -3)|
+-------------------+
| 1000|
+-------------------+
-- conv
SELECT conv('100', 2, 10);
+----------------+
|conv(100, 2, 10)|
+----------------+
| 4|
+----------------+
SELECT conv(-10, 16, -10);
+------------------+
|conv(-10, 16, -10)|
+------------------+
| -16|
+------------------+
-- cos
SELECT cos(0);
+------+
|COS(0)|
+------+
| 1.0|
+------+
-- cosh
SELECT cosh(0);
+-------+
|COSH(0)|
+-------+
| 1.0|
+-------+
-- cot
SELECT cot(1);
+------------------+
| COT(1)|
+------------------+
|0.6420926159343306|
+------------------+
-- csc
SELECT csc(1);
+------------------+
| CSC(1)|
+------------------+
|1.1883951057781212|
+------------------+
-- degrees
SELECT degrees(3.141592653589793);
+--------------------------+
|DEGREES(3.141592653589793)|
+--------------------------+
| 180.0|
+--------------------------+
-- div
SELECT 3 div 2;
+---------+
|(3 div 2)|
+---------+
| 1|
+---------+
SELECT INTERVAL '1-1' YEAR TO MONTH div INTERVAL '-1' MONTH;
+------------------------------------------------------+
|(INTERVAL '1-1' YEAR TO MONTH div INTERVAL '-1' MONTH)|
+------------------------------------------------------+
| -13|
+------------------------------------------------------+
-- e
SELECT e();
+-----------------+
| E()|
+-----------------+
|2.718281828459045|
+-----------------+
-- exp
SELECT exp(0);
+------+
|EXP(0)|
+------+
| 1.0|
+------+
-- expm1
SELECT expm1(0);
+--------+
|EXPM1(0)|
+--------+
| 0.0|
+--------+
-- factorial
SELECT factorial(5);
+------------+
|factorial(5)|
+------------+
| 120|
+------------+
-- floor
SELECT floor(-0.1);
+-----------+
|FLOOR(-0.1)|
+-----------+
| -1|
+-----------+
SELECT floor(5);
+--------+
|FLOOR(5)|
+--------+
| 5|
+--------+
SELECT floor(3.1411, 3);
+----------------+
|floor(3.1411, 3)|
+----------------+
| 3.141|
+----------------+
SELECT floor(3.1411, -3);
+-----------------+
|floor(3.1411, -3)|
+-----------------+
| 0|
+-----------------+
-- greatest
SELECT greatest(10, 9, 2, 4, 3);
+------------------------+
|greatest(10, 9, 2, 4, 3)|
+------------------------+
| 10|
+------------------------+
-- hex
SELECT hex(17);
+-------+
|hex(17)|
+-------+
| 11|
+-------+
SELECT hex('SQL');
+------------------+
| hex(SQL)|
+------------------+
|53514C|
+------------------+
-- hypot
SELECT hypot(3, 4);
+-----------+
|HYPOT(3, 4)|
+-----------+
| 5.0|
+-----------+
-- least
SELECT least(10, 9, 2, 4, 3);
+---------------------+
|least(10, 9, 2, 4, 3)|
+---------------------+
| 2|
+---------------------+
-- ln
SELECT ln(1);
+-----+
|ln(1)|
+-----+
| 0.0|
+-----+
-- log
SELECT log(10, 100);
+------------+
|LOG(10, 100)|
+------------+
| 2.0|
+------------+
-- log10
SELECT log10(10);
+---------+
|LOG10(10)|
+---------+
| 1.0|
+---------+
-- log1p
SELECT log1p(0);
+--------+
|LOG1P(0)|
+--------+
| 0.0|
+--------+
-- log2
SELECT log2(2);
+-------+
|LOG2(2)|
+-------+
| 1.0|
+-------+
-- mod
SELECT 2 % 1.8;
+---------+
|(2 % 1.8)|
+---------+
| 0.2|
+---------+
SELECT MOD(2, 1.8);
+-----------+
|mod(2, 1.8)|
+-----------+
| 0.2|
+-----------+
-- negative
SELECT negative(1);
+-----------+
|negative(1)|
+-----------+
| -1|
+-----------+
-- pi
SELECT pi();
+-----------------+
| PI()|
+-----------------+
|3.141592653589793|
+-----------------+
-- pmod
SELECT pmod(10, 3);
+-----------+
|pmod(10, 3)|
+-----------+
| 1|
+-----------+
SELECT pmod(-10, 3);
+------------+
|pmod(-10, 3)|
+------------+
| 2|
+------------+
-- positive
SELECT positive(1);
+-----+
|(+ 1)|
+-----+
| 1|
+-----+
-- pow
SELECT pow(2, 3);
+---------+
|pow(2, 3)|
+---------+
| 8.0|
+---------+
-- power
SELECT power(2, 3);
+-----------+
|POWER(2, 3)|
+-----------+
| 8.0|
+-----------+
-- radians
SELECT radians(180);
+-----------------+
| RADIANS(180)|
+-----------------+
|3.141592653589793|
+-----------------+
-- rand
SELECT rand();
+------------------+
| rand()|
+------------------+
|0.7211420708112387|
+------------------+
SELECT rand(0);
+------------------+
| rand(0)|
+------------------+
|0.7604953758285915|
+------------------+
SELECT rand(null);
+------------------+
| rand(NULL)|
+------------------+
|0.7604953758285915|
+------------------+
-- randn
SELECT randn();
+-------------------+
| randn()|
+-------------------+
|-0.8175603217732732|
+-------------------+
SELECT randn(0);
+------------------+
| randn(0)|
+------------------+
|1.6034991609278433|
+------------------+
SELECT randn(null);
+------------------+
| randn(NULL)|
+------------------+
|1.6034991609278433|
+------------------+
-- random
SELECT random();
+-----------------+
| rand()|
+-----------------+
|0.394205008255365|
+-----------------+
SELECT random(0);
+------------------+
| rand(0)|
+------------------+
|0.7604953758285915|
+------------------+
SELECT random(null);
+------------------+
| rand(NULL)|
+------------------+
|0.7604953758285915|
+------------------+
-- rint
SELECT rint(12.3456);
+-------------+
|rint(12.3456)|
+-------------+
| 12.0|
+-------------+
-- round
SELECT round(2.5, 0);
+-------------+
|round(2.5, 0)|
+-------------+
| 3|
+-------------+
-- sec
SELECT sec(0);
+------+
|SEC(0)|
+------+
| 1.0|
+------+
-- shiftleft
SELECT shiftleft(2, 1);
+---------------+
|shiftleft(2, 1)|
+---------------+
| 4|
+---------------+
-- sign
SELECT sign(40);
+--------+
|sign(40)|
+--------+
| 1.0|
+--------+
SELECT sign(INTERVAL -'100' YEAR);
+--------------------------+
|sign(INTERVAL '-100' YEAR)|
+--------------------------+
| -1.0|
+--------------------------+
-- signum
SELECT signum(40);
+----------+
|SIGNUM(40)|
+----------+
| 1.0|
+----------+
SELECT signum(INTERVAL -'100' YEAR);
+----------------------------+
|SIGNUM(INTERVAL '-100' YEAR)|
+----------------------------+
| -1.0|
+----------------------------+
-- sin
SELECT sin(0);
+------+
|SIN(0)|
+------+
| 0.0|
+------+
-- sinh
SELECT sinh(0);
+-------+
|SINH(0)|
+-------+
| 0.0|
+-------+
-- sqrt
SELECT sqrt(4);
+-------+
|SQRT(4)|
+-------+
| 2.0|
+-------+
-- tan
SELECT tan(0);
+------+
|TAN(0)|
+------+
| 0.0|
+------+
-- tanh
SELECT tanh(0);
+-------+
|TANH(0)|
+-------+
| 0.0|
+-------+
-- try_add
SELECT try_add(1, 2);
+-------------+
|try_add(1, 2)|
+-------------+
| 3|
+-------------+
SELECT try_add(2147483647, 1);
+----------------------+
|try_add(2147483647, 1)|
+----------------------+
| NULL|
+----------------------+
SELECT try_add(date'2021-01-01', 1);
+-----------------------------+
|try_add(DATE '2021-01-01', 1)|
+-----------------------------+
| 2021-01-02|
+-----------------------------+
SELECT try_add(date'2021-01-01', interval 1 year);
+---------------------------------------------+
|try_add(DATE '2021-01-01', INTERVAL '1' YEAR)|
+---------------------------------------------+
| 2022-01-01|
+---------------------------------------------+
SELECT try_add(timestamp'2021-01-01 00:00:00', interval 1 day);
+----------------------------------------------------------+
|try_add(TIMESTAMP '2021-01-01 00:00:00', INTERVAL '1' DAY)|
+----------------------------------------------------------+
| 2021-01-02 00:00:00|
+----------------------------------------------------------+
SELECT try_add(interval 1 year, interval 2 year);
+---------------------------------------------+
|try_add(INTERVAL '1' YEAR, INTERVAL '2' YEAR)|
+---------------------------------------------+
| INTERVAL '3' YEAR|
+---------------------------------------------+
-- try_divide
SELECT try_divide(3, 2);
+----------------+
|try_divide(3, 2)|
+----------------+
| 1.5|
+----------------+
SELECT try_divide(2L, 2L);
+----------------+
|try_divide(2, 2)|
+----------------+
| 1.0|
+----------------+
SELECT try_divide(1, 0);
+----------------+
|try_divide(1, 0)|
+----------------+
| NULL|
+----------------+
SELECT try_divide(interval 2 month, 2);
+---------------------------------+
|try_divide(INTERVAL '2' MONTH, 2)|
+---------------------------------+
| INTERVAL '0-1' YE...|
+---------------------------------+
SELECT try_divide(interval 2 month, 0);
+---------------------------------+
|try_divide(INTERVAL '2' MONTH, 0)|
+---------------------------------+
| NULL|
+---------------------------------+
-- try_multiply
SELECT try_multiply(2, 3);
+------------------+
|try_multiply(2, 3)|
+------------------+
| 6|
+------------------+
SELECT try_multiply(-2147483648, 10);
+-----------------------------+
|try_multiply(-2147483648, 10)|
+-----------------------------+
| NULL|
+-----------------------------+
SELECT try_multiply(interval 2 year, 3);
+----------------------------------+
|try_multiply(INTERVAL '2' YEAR, 3)|
+----------------------------------+
| INTERVAL '6-0' YE...|
+----------------------------------+
-- try_subtract
SELECT try_subtract(2, 1);
+------------------+
|try_subtract(2, 1)|
+------------------+
| 1|
+------------------+
SELECT try_subtract(-2147483648, 1);
+----------------------------+
|try_subtract(-2147483648, 1)|
+----------------------------+
| NULL|
+----------------------------+
SELECT try_subtract(date'2021-01-02', 1);
+----------------------------------+
|try_subtract(DATE '2021-01-02', 1)|
+----------------------------------+
| 2021-01-01|
+----------------------------------+
SELECT try_subtract(date'2021-01-01', interval 1 year);
+--------------------------------------------------+
|try_subtract(DATE '2021-01-01', INTERVAL '1' YEAR)|
+--------------------------------------------------+
| 2020-01-01|
+--------------------------------------------------+
SELECT try_subtract(timestamp'2021-01-02 00:00:00', interval 1 day);
+---------------------------------------------------------------+
|try_subtract(TIMESTAMP '2021-01-02 00:00:00', INTERVAL '1' DAY)|
+---------------------------------------------------------------+
| 2021-01-01 00:00:00|
+---------------------------------------------------------------+
SELECT try_subtract(interval 2 year, interval 1 year);
+--------------------------------------------------+
|try_subtract(INTERVAL '2' YEAR, INTERVAL '1' YEAR)|
+--------------------------------------------------+
| INTERVAL '1' YEAR|
+--------------------------------------------------+
-- unhex
SELECT decode(unhex('53514C'), 'UTF-8');
+----------------------------------------+
|decode(unhex(53514C), UTF-8)|
+----------------------------------------+
| SQL|
+----------------------------------------+
-- width_bucket
SELECT width_bucket(5.3, 0.2, 10.6, 5);
+-------------------------------+
|width_bucket(5.3, 0.2, 10.6, 5)|
+-------------------------------+
| 3|
+-------------------------------+
SELECT width_bucket(-2.1, 1.3, 3.4, 3);
+-------------------------------+
|width_bucket(-2.1, 1.3, 3.4, 3)|
+-------------------------------+
| 0|
+-------------------------------+
SELECT width_bucket(8.1, 0.0, 5.7, 4);
+------------------------------+
|width_bucket(8.1, 0.0, 5.7, 4)|
+------------------------------+
| 5|
+------------------------------+
SELECT width_bucket(-0.9, 5.2, 0.5, 2);
+-------------------------------+
|width_bucket(-0.9, 5.2, 0.5, 2)|
+-------------------------------+
| 3|
+-------------------------------+
SELECT width_bucket(INTERVAL '0' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10);
+--------------------------------------------------------------------------+
|width_bucket(INTERVAL '0' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10)|
+--------------------------------------------------------------------------+
| 1|
+--------------------------------------------------------------------------+
SELECT width_bucket(INTERVAL '1' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10);
+--------------------------------------------------------------------------+
|width_bucket(INTERVAL '1' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10)|
+--------------------------------------------------------------------------+
| 2|
+--------------------------------------------------------------------------+
SELECT width_bucket(INTERVAL '0' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10);
+-----------------------------------------------------------------------+
|width_bucket(INTERVAL '0' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10)|
+-----------------------------------------------------------------------+
| 1|
+-----------------------------------------------------------------------+
SELECT width_bucket(INTERVAL '1' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10);
+-----------------------------------------------------------------------+
|width_bucket(INTERVAL '1' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10)|
+-----------------------------------------------------------------------+
| 2|
+-----------------------------------------------------------------------+
```
#### Generatorfunktionen
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diese SQL-Funktionen unterstützen, finden Sie unter[Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql).
****
| Funktion | Description |
| --- | --- |
| explodieren (expr) | Teilt die Elemente des Arrays `expr in mehrere Zeilen oder die Elemente der Map `expr in mehrere Zeilen und Spalten auf. Sofern nicht anders angegeben, verwendet es den Standardspaltennamen `col` für Elemente des Arrays oder `key` und `value` für die Elemente der Map. |
| explode\$1outer (expr) | Teilt die Elemente des Arrays `expr in mehrere Zeilen oder die Elemente der Map `expr in mehrere Zeilen und Spalten auf. Sofern nicht anders angegeben, verwendet es den Standardspaltennamen `col` für Elemente des Arrays oder `key` und `value` für die Elemente der Map. |
| inline (expr) | Löst ein Array von Strukturen in eine Tabelle auf. Verwendet standardmäßig die Spaltennamen col1, col2 usw., sofern nicht anders angegeben. |
| inline\$1outer (expr) | Löst ein Array von Strukturen in eine Tabelle auf. Verwendet standardmäßig die Spaltennamen col1, col2 usw., sofern nicht anders angegeben. |
| posexplode (expr) | Teilt die Elemente des Arrays `expr in mehrere Zeilen mit Positionen oder die Elemente der Map `expr in mehrere Zeilen und Spalten mit Positionen auf. Sofern nicht anders angegeben, verwendet es den Spaltennamen `pos` für die Position, `col` für Elemente des Arrays oder `key` und `value` für Elemente der Map. |
| posexplode\$1outer (expr) | Teilt die Elemente des Arrays `expr in mehrere Zeilen mit Positionen oder die Elemente der Map `expr in mehrere Zeilen und Spalten mit Positionen auf. Sofern nicht anders angegeben, verwendet es den Spaltennamen `pos` für die Position, `col` für Elemente des Arrays oder `key` und `value` für Elemente der Map. |
| stack (n, expr1,..., exprk) | Teilt `expr1`,..., `exprk` in `n` Zeilen auf. Verwendet standardmäßig die Spaltennamen col0, col1 usw., sofern nicht anders angegeben. |
**Beispiele**
```
-- explode
SELECT explode(array(10, 20));
+---+
|col|
+---+
| 10|
| 20|
+---+
SELECT explode(collection => array(10, 20));
+---+
|col|
+---+
| 10|
| 20|
+---+
SELECT * FROM explode(collection => array(10, 20));
+---+
|col|
+---+
| 10|
| 20|
+---+
-- explode_outer
SELECT explode_outer(array(10, 20));
+---+
|col|
+---+
| 10|
| 20|
+---+
SELECT explode_outer(collection => array(10, 20));
+---+
|col|
+---+
| 10|
| 20|
+---+
SELECT * FROM explode_outer(collection => array(10, 20));
+---+
|col|
+---+
| 10|
| 20|
+---+
-- inline
SELECT inline(array(struct(1, 'a'), struct(2, 'b')));
+----+----+
|col1|col2|
+----+----+
| 1| a|
| 2| b|
+----+----+
-- inline_outer
SELECT inline_outer(array(struct(1, 'a'), struct(2, 'b')));
+----+----+
|col1|col2|
+----+----+
| 1| a|
| 2| b|
+----+----+
-- posexplode
SELECT posexplode(array(10,20));
+---+---+
|pos|col|
+---+---+
| 0| 10|
| 1| 20|
+---+---+
SELECT * FROM posexplode(array(10,20));
+---+---+
|pos|col|
+---+---+
| 0| 10|
| 1| 20|
+---+---+
-- posexplode_outer
SELECT posexplode_outer(array(10,20));
+---+---+
|pos|col|
+---+---+
| 0| 10|
| 1| 20|
+---+---+
SELECT * FROM posexplode_outer(array(10,20));
+---+---+
|pos|col|
+---+---+
| 0| 10|
| 1| 20|
+---+---+
-- stack
SELECT stack(2, 1, 2, 3);
+----+----+
|col0|col1|
+----+----+
| 1| 2|
| 3|NULL|
+----+----+
```
#### SELECT-Klausel
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter. [Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql)
OpenSearch SQL unterstützt eine `SELECT` Anweisung, die zum Abrufen von Ergebnismengen aus einer oder mehreren Tabellen verwendet wird. Im folgenden Abschnitt werden die allgemeine Abfragesyntax und die verschiedenen Konstrukte einer Abfrage beschrieben.
**Syntax**
```
select_statement
[ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select_statement, ... ]
[ ORDER BY
{ expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ]
[ , ... ]
}
]
[ SORT BY
{ expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ]
[ , ... ]
}
]
[ WINDOW { named_window [ , WINDOW named_window, ... ] } ]
[ LIMIT { ALL | expression } ]
```
While `select_statement` ist definiert als:
```
SELECT [ ALL | DISTINCT ] { [ [ named_expression ] [ , ... ] ] }
FROM { from_item [ , ... ] }
[ PIVOT clause ]
[ UNPIVOT clause ]
[ LATERAL VIEW clause ] [ ... ]
[ WHERE boolean_expression ]
[ GROUP BY expression [ , ... ] ]
[ HAVING boolean_expression ]
```
**Parameter**
+ **ALLES**
Wählt alle passenden Zeilen aus der Beziehung aus und ist standardmäßig aktiviert.
+ **EINDEUTIG**
Wählt alle passenden Zeilen aus der Beziehung aus, nachdem Duplikate in den Ergebnissen entfernt wurden.
+ **Benannter\$1Ausdruck**
Ein Ausdruck mit einem zugewiesenen Namen. Im Allgemeinen bezeichnet es einen Spaltenausdruck.
Syntax: `expression [[AS] alias]`
+ **from\$1item**
Beziehung zur Tabelle
Beziehung verbinden
Beziehung ausrichten
Relation aufheben
Funktion „Tabellenwert“
Inline-Tabelle
`[ LATERAL ] ( Subquery )`
+ **PIVOT**
Die `PIVOT` Klausel wird für die Datenperspektive verwendet. Sie können die aggregierten Werte auf der Grundlage eines bestimmten Spaltenwerts abrufen.
+ **UNPIVOT**
Die `UNPIVOT` Klausel wandelt Spalten in Zeilen um. Es ist das Gegenteil von`PIVOT`, mit Ausnahme der Aggregation von Werten.
+ **SEITLICHE ANSICHT**
Die `LATERAL VIEW` Klausel wird in Verbindung mit Generatorfunktionen wie`EXPLODE`, verwendet, die eine virtuelle Tabelle mit einer oder mehreren Zeilen generieren.
`LATERAL VIEW`wendet die Zeilen auf jede ursprüngliche Ausgabezeile an.
+ **WO**
Filtert das Ergebnis der `FROM` Klausel auf der Grundlage der angegebenen Prädikate.
+ **GRUPPIEREN NACH**
Gibt die Ausdrücke an, die zum Gruppieren der Zeilen verwendet werden.
Dies wird in Verbindung mit Aggregatfunktionen (`MIN`,,, `MAX``COUNT`, usw.) verwendet `SUM``AVG`, um Zeilen auf der Grundlage der Gruppierungsausdrücke zu gruppieren und Werte in jeder Gruppe zu aggregieren.
Wenn eine `FILTER` Klausel an eine Aggregatfunktion angehängt wird, werden nur die entsprechenden Zeilen an diese Funktion übergeben.
+ **HABEN**
Gibt die Prädikate an, nach denen die von erzeugten Zeilen gefiltert `GROUP BY` werden.
Die `HAVING` Klausel wird verwendet, um Zeilen zu filtern, nachdem die Gruppierung durchgeführt wurde.
Wenn ohne angegeben `HAVING` wird`GROUP BY`, bedeutet dies a `GROUP BY` ohne Gruppierungsausdrücke (globales Aggregat).
+ **SORTIERT NACH**
Gibt eine Reihenfolge der Zeilen der vollständigen Ergebnismenge der Abfrage an.
Die Ausgabezeilen sind partitionsübergreifend angeordnet.
Dieser Parameter schließt sich mit `SORT BY` und gegenseitig aus `DISTRIBUTE BY` und kann nicht zusammen angegeben werden.
+ **SORTIERE NACH**
Gibt eine Reihenfolge an, in der die Zeilen innerhalb jeder Partition angeordnet werden.
Dieser Parameter schließt sich gegenseitig aus `ORDER BY` und kann nicht zusammen angegeben werden.
+ **BESCHRÄNKEN**
Gibt die maximale Anzahl von Zeilen an, die von einer Anweisung oder Unterabfrage zurückgegeben werden können.
Diese Klausel wird meistens in Verbindung mit verwendet, `ORDER BY` um ein deterministisches Ergebnis zu erzeugen.
+ **boolescher\$1Ausdruck**
Gibt einen beliebigen Ausdruck an, der zu einem booleschen Ergebnistyp ausgewertet wird.
Zwei oder mehr Ausdrücke können mithilfe der logischen Operatoren (`AND`,) miteinander kombiniert werden. `OR`
+ **Ausdruck**
Gibt eine Kombination aus einem oder mehreren Werten, Operatoren und SQL-Funktionen an, die zu einem Wert ausgewertet werden.
+ **named\$1window**
Gibt Aliase für eine oder mehrere Quellfensterspezifikationen an.
Auf die Spezifikationen des Quellfensters kann in den Fensterdefinitionen in der Abfrage verwiesen werden.
#### WHERE-Klausel
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter[Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql).
Die `WHERE` Klausel wird verwendet, um die Ergebnisse der `FROM` Klausel einer Abfrage oder Unterabfrage auf der Grundlage der angegebenen Bedingung einzuschränken.
**Syntax**
```
WHERE boolean_expression
```
**Parameter**
+ **boolescher\$1Ausdruck**
Gibt einen beliebigen Ausdruck an, der zu einem booleschen Ergebnistyp ausgewertet wird.
Zwei oder mehr Ausdrücke können mithilfe der logischen Operatoren (`AND`,) miteinander kombiniert werden. `OR`
**Beispiele**
```
CREATE TABLE person (id INT, name STRING, age INT);
INSERT INTO person VALUES
(100, 'John', 30),
(200, 'Mary', NULL),
(300, 'Mike', 80),
(400, 'Dan', 50);
-- Comparison operator in `WHERE` clause.
SELECT * FROM person WHERE id > 200 ORDER BY id;
+---+----+---+
| id|name|age|
+---+----+---+
|300|Mike| 80|
|400| Dan| 50|
+---+----+---+
-- Comparison and logical operators in `WHERE` clause.
SELECT * FROM person WHERE id = 200 OR id = 300 ORDER BY id;
+---+----+----+
| id|name| age|
+---+----+----+
|200|Mary|null|
|300|Mike| 80|
+---+----+----+
-- IS NULL expression in `WHERE` clause.
SELECT * FROM person WHERE id > 300 OR age IS NULL ORDER BY id;
+---+----+----+
| id|name| age|
+---+----+----+
|200|Mary|null|
|400| Dan| 50|
+---+----+----+
-- Function expression in `WHERE` clause.
SELECT * FROM person WHERE length(name) > 3 ORDER BY id;
+---+----+----+
| id|name| age|
+---+----+----+
|100|John| 30|
|200|Mary|null|
|300|Mike| 80|
+---+----+----+
-- `BETWEEN` expression in `WHERE` clause.
SELECT * FROM person WHERE id BETWEEN 200 AND 300 ORDER BY id;
+---+----+----+
| id|name| age|
+---+----+----+
|200|Mary|null|
|300|Mike| 80|
+---+----+----+
-- Scalar Subquery in `WHERE` clause.
SELECT * FROM person WHERE age > (SELECT avg(age) FROM person);
+---+----+---+
| id|name|age|
+---+----+---+
|300|Mike| 80|
+---+----+---+
-- Correlated Subquery in `WHERE` clause.
SELECT id FROM person
WHERE exists (SELECT id FROM person where id = 200);
+---+----+----+
|id |name|age |
+---+----+----+
|200|Mary|null|
+---+----+----+
```
#### GROUP BY-Klausel
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter[Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql).
Die `GROUP BY` Klausel wird verwendet, um die Zeilen auf der Grundlage einer Reihe von angegebenen Gruppierungsausdrücken zu gruppieren und Aggregationen für die Gruppe von Zeilen auf der Grundlage einer oder mehrerer spezifizierter Aggregatfunktionen zu berechnen.
Das System führt auch mehrere Aggregationen für denselben Eingabedatensatz mithilfe von`GROUPING SETS`,, `CUBE` -Klauseln durch. `ROLLUP` Die Gruppierungsausdrücke und erweiterten Aggregationen können in der Klausel gemischt und in einer `GROUP BY` Klausel verschachtelt werden. `GROUPING SETS ` Weitere Einzelheiten finden Sie im Abschnitt. `Mixed/Nested Grouping Analytics `
Wenn eine `FILTER` Klausel an eine Aggregatfunktion angehängt wird, werden nur die entsprechenden Zeilen an diese Funktion übergeben.
**Syntax**
```
GROUP BY group_expression [ , group_expression [ , ... ] ] [ WITH { ROLLUP | CUBE } ]
GROUP BY { group_expression | { ROLLUP | CUBE | GROUPING SETS } (grouping_set [ , ...]) } [ , ... ]
```
Aggregatfunktionen sind zwar wie folgt definiert:
```
aggregate_name ( [ DISTINCT ] expression [ , ... ] ) [ FILTER ( WHERE boolean_expression ) ]
```
**Parameter**
+ **group\$1expression**
Gibt die Kriterien an, nach denen die Zeilen gruppiert werden. Die Gruppierung von Zeilen erfolgt auf der Grundlage der Ergebniswerte der Gruppierungsausdrücke.
Ein Gruppierungsausdruck kann ein Spaltenname wie`GROUP BY a`, eine Spaltenposition wie oder ein Ausdruck wie `GROUP BY 0` sein. `GROUP BY a + b`
+ **grouping\$1set**
Ein Gruppierungssatz wird durch null oder mehr durch Kommas getrennte Ausdrücke in Klammern angegeben. Wenn der Gruppierungssatz nur ein Element enthält, können Klammern weggelassen werden.
Zum Beispiel ist `GROUPING SETS ((a), (b))` identisch zu `GROUPING SETS (a, b)`.
Syntax: `{ ( [ expression [ , ... ] ] ) | expression }`
+ **GRUPPIERUNGSSÄTZE**
Gruppiert die Zeilen für jeden Gruppierungssatz, der danach angegeben wurde. `GROUPING SETS`
`GROUP BY GROUPING SETS ((warehouse), (product))`Ist beispielsweise semantisch gleichbedeutend mit der Vereinigung der Ergebnisse von `GROUP BY warehouse` und. `GROUP BY product` Diese Klausel ist eine Abkürzung für UNION ALL, bei der jeder Teil des `UNION ALL` Operators die Aggregation aller in der Klausel angegebenen Gruppierungssätze durchführt. `GROUPING SETS`
In ähnlicher Weise entspricht sie semantisch der Vereinigung von Ergebnissen von und globalem Aggregat. `GROUP BY GROUPING SETS ((warehouse, product), (product), ())` `GROUP BY warehouse, product, GROUP BY product`
+ **ROLLUP**
Gibt mehrere Aggregationsebenen in einer einzigen Anweisung an. Diese Klausel wird verwendet, um Aggregationen zu berechnen, die auf mehreren Gruppierungssätzen basieren. `ROLLUP`ist eine Abkürzung für. `GROUPING SETS`
Beispiel: `GROUP BY warehouse, product WITH ROLLUP or GROUP BY ROLLUP(warehouse, product)` ist gleichbedeutend mit `GROUP BY GROUPING SETS((warehouse, product), (warehouse), ())`.
`GROUP BY ROLLUP(warehouse, product, (warehouse, location))` ist gleich `GROUP BY GROUPING SETS((warehouse, product, location), (warehouse, product), (warehouse), ())`.
Die N Elemente einer ROLLUP-Spezifikation ergeben N\$11 GROUPING SETS.
+ **CUBE**
Die CUBE-Klausel wird verwendet, um Aggregationen auf der Grundlage einer Kombination von Gruppierungsspalten durchzuführen, die in der GROUP BY-Klausel angegeben sind. CUBE ist eine Abkürzung für GROUPING SETS.
Beispiel: `GROUP BY warehouse, product WITH CUBE or GROUP BY CUBE(warehouse, product)` ist gleichbedeutend mit `GROUP BY GROUPING SETS((warehouse, product), (warehouse), (product), ())`.
`GROUP BY CUBE(warehouse, product, (warehouse, location))` ist gleich `GROUP BY GROUPING SETS((warehouse, product, location), (warehouse, product), (warehouse, location), (product, warehouse, location), (warehouse), (product), (warehouse, product), ())`. Die N Elemente einer `CUBE` Spezifikation ergeben 2^N. `GROUPING SETS`
+ **Analytik für gemischte/verschachtelte Gruppierungen**
Eine `GROUP BY` Klausel kann mehrere group\$1expressions und mehrere enthalten. `CUBE|ROLLUP|GROUPING SETS` `GROUPING SETS`kann auch verschachtelte `CUBE|ROLLUP|GROUPING SETS` Klauseln enthalten, wie,,. `GROUPING SETS(ROLLUP(warehouse, location)` `CUBE(warehouse, location))` `GROUPING SETS(warehouse, GROUPING SETS(location, GROUPING SETS(ROLLUP(warehouse, location),` `CUBE(warehouse, location))))`
`CUBE|ROLLUP`ist nur ein Syntaxzucker für. `GROUPING SETS` In den obigen Abschnitten finden Sie Informationen `CUBE|ROLLUP` zur Übersetzung von`GROUPING SETS`. `group_expression`kann in diesem Kontext als eine einzige Gruppe `GROUPING SETS` behandelt werden.
Für mehrere Elemente `GROUPING SETS` in der `GROUP BY` Klausel generieren wir eine einzelne, `GROUPING SETS` indem wir ein Kreuzprodukt des Originals erstellen. `GROUPING SETS` Für die `GROUPING SETS` in der `GROUPING SETS` Klausel verschachtelte Klausel nehmen wir einfach ihre Gruppierungssätze und entfernen sie.
Beispiel: `GROUP BY warehouse, GROUPING SETS((product), ()), GROUPING SETS((location, size), (location), (size), ()) and GROUP BY warehouse, ROLLUP(product), CUBE(location, size)` ist gleichbedeutend mit `GROUP BY GROUPING SETS( (warehouse, product, location, size), (warehouse, product, location), (warehouse, product, size), (warehouse, product), (warehouse, location, size), (warehouse, location), (warehouse, size), (warehouse))`.
`GROUP BY GROUPING SETS(GROUPING SETS(warehouse), GROUPING SETS((warehouse, product)))` ist gleich `GROUP BY GROUPING SETS((warehouse), (warehouse, product))`.
+ **aggregate\$1name**
Gibt den Namen einer Aggregatfunktion an (`MIN``MAX`,`COUNT`,`SUM`,`AVG`, usw.).
+ **DEUTLICH**
Entfernt Duplikate in Eingabezeilen, bevor sie an Aggregatfunktionen übergeben werden.
+ **FILTERN**
Filtert die Eingabezeilen, für die die `boolean_expression` `WHERE` In-the-Klausel als wahr ausgewertet wird, an die Aggregatfunktion übergeben; andere Zeilen werden verworfen.
**Beispiele**
```
CREATE TABLE dealer (id INT, city STRING, car_model STRING, quantity INT);
INSERT INTO dealer VALUES
(100, 'Fremont', 'Honda Civic', 10),
(100, 'Fremont', 'Honda Accord', 15),
(100, 'Fremont', 'Honda CRV', 7),
(200, 'Dublin', 'Honda Civic', 20),
(200, 'Dublin', 'Honda Accord', 10),
(200, 'Dublin', 'Honda CRV', 3),
(300, 'San Jose', 'Honda Civic', 5),
(300, 'San Jose', 'Honda Accord', 8);
-- Sum of quantity per dealership. Group by `id`.
SELECT id, sum(quantity) FROM dealer GROUP BY id ORDER BY id;
+---+-------------+
| id|sum(quantity)|
+---+-------------+
|100| 32|
|200| 33|
|300| 13|
+---+-------------+
-- Use column position in GROUP by clause.
SELECT id, sum(quantity) FROM dealer GROUP BY 1 ORDER BY 1;
+---+-------------+
| id|sum(quantity)|
+---+-------------+
|100| 32|
|200| 33|
|300| 13|
+---+-------------+
-- Multiple aggregations.
-- 1. Sum of quantity per dealership.
-- 2. Max quantity per dealership.
SELECT id, sum(quantity) AS sum, max(quantity) AS max FROM dealer GROUP BY id ORDER BY id;
+---+---+---+
| id|sum|max|
+---+---+---+
|100| 32| 15|
|200| 33| 20|
|300| 13| 8|
+---+---+---+
-- Count the number of distinct dealer cities per car_model.
SELECT car_model, count(DISTINCT city) AS count FROM dealer GROUP BY car_model;
+------------+-----+
| car_model|count|
+------------+-----+
| Honda Civic| 3|
| Honda CRV| 2|
|Honda Accord| 3|
+------------+-----+
-- Sum of only 'Honda Civic' and 'Honda CRV' quantities per dealership.
SELECT id, sum(quantity) FILTER (
WHERE car_model IN ('Honda Civic', 'Honda CRV')
) AS `sum(quantity)` FROM dealer
GROUP BY id ORDER BY id;
+---+-------------+
| id|sum(quantity)|
+---+-------------+
|100| 17|
|200| 23|
|300| 5|
+---+-------------+
-- Aggregations using multiple sets of grouping columns in a single statement.
-- Following performs aggregations based on four sets of grouping columns.
-- 1. city, car_model
-- 2. city
-- 3. car_model
-- 4. Empty grouping set. Returns quantities for all city and car models.
SELECT city, car_model, sum(quantity) AS sum FROM dealer
GROUP BY GROUPING SETS ((city, car_model), (city), (car_model), ())
ORDER BY city;
+---------+------------+---+
| city| car_model|sum|
+---------+------------+---+
| null| null| 78|
| null| HondaAccord| 33|
| null| HondaCRV| 10|
| null| HondaCivic| 35|
| Dublin| null| 33|
| Dublin| HondaAccord| 10|
| Dublin| HondaCRV| 3|
| Dublin| HondaCivic| 20|
| Fremont| null| 32|
| Fremont| HondaAccord| 15|
| Fremont| HondaCRV| 7|
| Fremont| HondaCivic| 10|
| San Jose| null| 13|
| San Jose| HondaAccord| 8|
| San Jose| HondaCivic| 5|
+---------+------------+---+
-- Group by processing with `ROLLUP` clause.
-- Equivalent GROUP BY GROUPING SETS ((city, car_model), (city), ())
SELECT city, car_model, sum(quantity) AS sum FROM dealer
GROUP BY city, car_model WITH ROLLUP
ORDER BY city, car_model;
+---------+------------+---+
| city| car_model|sum|
+---------+------------+---+
| null| null| 78|
| Dublin| null| 33|
| Dublin| HondaAccord| 10|
| Dublin| HondaCRV| 3|
| Dublin| HondaCivic| 20|
| Fremont| null| 32|
| Fremont| HondaAccord| 15|
| Fremont| HondaCRV| 7|
| Fremont| HondaCivic| 10|
| San Jose| null| 13|
| San Jose| HondaAccord| 8|
| San Jose| HondaCivic| 5|
+---------+------------+---+
-- Group by processing with `CUBE` clause.
-- Equivalent GROUP BY GROUPING SETS ((city, car_model), (city), (car_model), ())
SELECT city, car_model, sum(quantity) AS sum FROM dealer
GROUP BY city, car_model WITH CUBE
ORDER BY city, car_model;
+---------+------------+---+
| city| car_model|sum|
+---------+------------+---+
| null| null| 78|
| null| HondaAccord| 33|
| null| HondaCRV| 10|
| null| HondaCivic| 35|
| Dublin| null| 33|
| Dublin| HondaAccord| 10|
| Dublin| HondaCRV| 3|
| Dublin| HondaCivic| 20|
| Fremont| null| 32|
| Fremont| HondaAccord| 15|
| Fremont| HondaCRV| 7|
| Fremont| HondaCivic| 10|
| San Jose| null| 13|
| San Jose| HondaAccord| 8|
| San Jose| HondaCivic| 5|
+---------+------------+---+
--Prepare data for ignore nulls example
CREATE TABLE person (id INT, name STRING, age INT);
INSERT INTO person VALUES
(100, 'Mary', NULL),
(200, 'John', 30),
(300, 'Mike', 80),
(400, 'Dan', 50);
--Select the first row in column age
SELECT FIRST(age) FROM person;
+--------------------+
| first(age, false) |
+--------------------+
| NULL |
+--------------------+
--Get the first row in column `age` ignore nulls,last row in column `id` and sum of column `id`.
SELECT FIRST(age IGNORE NULLS), LAST(id), SUM(id) FROM person;
+-------------------+------------------+----------+
| first(age, true) | last(id, false) | sum(id) |
+-------------------+------------------+----------+
| 30 | 400 | 1000 |
+-------------------+------------------+----------+
```
#### HAVING-Klausel
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter. [Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql)
Die `HAVING` Klausel wird verwendet, um die Ergebnisse zu filtern, die auf der `GROUP BY` Grundlage der angegebenen Bedingung erzeugt wurden. Sie wird häufig in Verbindung mit einer `GROUP BY` Klausel verwendet.
**Syntax**
```
HAVING boolean_expression
```
**Parameter**
+ **boolescher\$1Ausdruck**
Gibt einen beliebigen Ausdruck an, der zu einem booleschen Ergebnistyp ausgewertet wird. Zwei oder mehr Ausdrücke können mithilfe der logischen Operatoren (`AND`,) miteinander kombiniert werden. `OR`
**Hinweis** Die in der `HAVING` Klausel angegebenen Ausdrücke können sich nur auf Folgendes beziehen:
1. Konstanten
1. Ausdrücke, die vorkommen in `GROUP BY`
1. Aggregationsfunktionen
**Beispiele**
```
CREATE TABLE dealer (id INT, city STRING, car_model STRING, quantity INT);
INSERT INTO dealer VALUES
(100, 'Fremont', 'Honda Civic', 10),
(100, 'Fremont', 'Honda Accord', 15),
(100, 'Fremont', 'Honda CRV', 7),
(200, 'Dublin', 'Honda Civic', 20),
(200, 'Dublin', 'Honda Accord', 10),
(200, 'Dublin', 'Honda CRV', 3),
(300, 'San Jose', 'Honda Civic', 5),
(300, 'San Jose', 'Honda Accord', 8);
-- `HAVING` clause referring to column in `GROUP BY`.
SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING city = 'Fremont';
+-------+---+
| city|sum|
+-------+---+
|Fremont| 32|
+-------+---+
-- `HAVING` clause referring to aggregate function.
SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING sum(quantity) > 15;
+-------+---+
| city|sum|
+-------+---+
| Dublin| 33|
|Fremont| 32|
+-------+---+
-- `HAVING` clause referring to aggregate function by its alias.
SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING sum > 15;
+-------+---+
| city|sum|
+-------+---+
| Dublin| 33|
|Fremont| 32|
+-------+---+
-- `HAVING` clause referring to a different aggregate function than what is present in
-- `SELECT` list.
SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING max(quantity) > 15;
+------+---+
| city|sum|
+------+---+
|Dublin| 33|
+------+---+
-- `HAVING` clause referring to constant expression.
SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING 1 > 0 ORDER BY city;
+--------+---+
| city|sum|
+--------+---+
| Dublin| 33|
| Fremont| 32|
|San Jose| 13|
+--------+---+
-- `HAVING` clause without a `GROUP BY` clause.
SELECT sum(quantity) AS sum FROM dealer HAVING sum(quantity) > 10;
+---+
|sum|
+---+
| 78|
+---+
```
#### ORDER BY-Klausel
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter[Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql).
Die `ORDER BY` Klausel wird verwendet, um die Ergebniszeilen sortiert in der vom Benutzer angegebenen Reihenfolge zurückzugeben. Im Gegensatz zur SORT BY-Klausel garantiert diese Klausel eine vollständige Reihenfolge in der Ausgabe.
**Syntax**
```
ORDER BY { expression [ sort_direction | nulls_sort_order ] [ , ... ] }
```
**Parameter**
+ **SORTIERE NACH**
Gibt eine durch Kommas getrennte Liste von Ausdrücken zusammen mit optionalen Parametern `sort_direction` an`nulls_sort_order`, die zum Sortieren der Zeilen verwendet werden.
+ **sort\$1direction**
Gibt optional an, ob die Zeilen in aufsteigender oder absteigender Reihenfolge sortiert werden sollen.
Die gültigen Werte für die Sortierrichtung gelten für aufsteigend und `ASC` `DESC` für absteigend.
Wenn die Sortierrichtung nicht explizit angegeben ist, werden Zeilen standardmäßig aufsteigend sortiert.
Syntax: `[ ASC | DESC ] `
+ **nulls\$1sort\$1order**
Gibt optional an, ob `NULL` Werte zurückgegeben werden, die nicht NULL sind. before/after
Wenn null\$1sort\$1order nicht angegeben ist, wird zuerst `NULLs` sortiert, wenn die Sortierreihenfolge angegeben ist, `ASC` und NULLS sortiert zuletzt, wenn die Sortierreihenfolge angegeben ist. `DESC`
1. Wenn `NULLS FIRST` angegeben, werden unabhängig von der Sortierreihenfolge zuerst NULL-Werte zurückgegeben.
2. Wenn `NULLS LAST` angegeben, werden NULL-Werte unabhängig von der Sortierreihenfolge zuletzt zurückgegeben.
Syntax: `[ NULLS { FIRST | LAST } ]`
**Beispiele**
```
CREATE TABLE person (id INT, name STRING, age INT);
INSERT INTO person VALUES
(100, 'John', 30),
(200, 'Mary', NULL),
(300, 'Mike', 80),
(400, 'Jerry', NULL),
(500, 'Dan', 50);
-- Sort rows by age. By default rows are sorted in ascending manner with NULL FIRST.
SELECT name, age FROM person ORDER BY age;
+-----+----+
| name| age|
+-----+----+
|Jerry|null|
| Mary|null|
| John| 30|
| Dan| 50|
| Mike| 80|
+-----+----+
-- Sort rows in ascending manner keeping null values to be last.
SELECT name, age FROM person ORDER BY age NULLS LAST;
+-----+----+
| name| age|
+-----+----+
| John| 30|
| Dan| 50|
| Mike| 80|
| Mary|null|
|Jerry|null|
+-----+----+
-- Sort rows by age in descending manner, which defaults to NULL LAST.
SELECT name, age FROM person ORDER BY age DESC;
+-----+----+
| name| age|
+-----+----+
| Mike| 80|
| Dan| 50|
| John| 30|
|Jerry|null|
| Mary|null|
+-----+----+
-- Sort rows in ascending manner keeping null values to be first.
SELECT name, age FROM person ORDER BY age DESC NULLS FIRST;
+-----+----+
| name| age|
+-----+----+
|Jerry|null|
| Mary|null|
| Mike| 80|
| Dan| 50|
| John| 30|
+-----+----+
-- Sort rows based on more than one column with each column having different
-- sort direction.
SELECT * FROM person ORDER BY name ASC, age DESC;
+---+-----+----+
| id| name| age|
+---+-----+----+
|500| Dan| 50|
|400|Jerry|null|
|100| John| 30|
|200| Mary|null|
|300| Mike| 80|
+---+-----+----+
```
#### JOIN-Klausel
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter[Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql).
Ein SQL-Join wird verwendet, um Zeilen aus zwei Beziehungen auf der Grundlage von Join-Kriterien zu kombinieren. Im folgenden Abschnitt werden die allgemeine Join-Syntax und die verschiedenen Arten von Verknüpfungen zusammen mit Beispielen beschrieben.
**Syntax**
```
relation INNER JOIN relation [ join_criteria ]
```
**Parameter**
+ **Beziehung**
Gibt die Beziehung an, die verbunden werden soll.
+ **Verbindungstyp**
Gibt den Verbindungstyp an.
Syntax: `INNER | CROSS | LEFT OUTER`
+ **join\$1criteria**
Gibt an, wie die Zeilen einer Beziehung mit den Zeilen einer anderen Beziehung kombiniert werden.
Syntax: `ON boolean_expression | USING ( column_name [ , ... ] ) `
+ **boolescher\$1Ausdruck**
Gibt einen Ausdruck mit dem Rückgabetyp Boolean an.
**Arten von Verbindungen**
+ **Innerer Zusammenschluss**
Der innere Join muss explizit angegeben werden. Es wählt Zeilen aus, die in beiden Beziehungen übereinstimmende Werte haben.
Syntax: `relation INNER JOIN relation [ join_criteria ] `
+ **Linke Verbindung**
Eine linke Verknüpfung gibt alle Werte aus der linken Beziehung und die übereinstimmenden Werte aus der rechten Beziehung zurück oder hängt NULL an, wenn keine Übereinstimmung vorliegt. Sie wird auch als Left Outer Join bezeichnet.
Syntax: `relation LEFT OUTER JOIN relation [ join_criteria ]`
+ **Kreuzverknüpfung**
Eine Kreuzverknüpfung gibt das kartesische Produkt zweier Beziehungen zurück.
Syntax: `relation CROSS JOIN relation [ join_criteria ]`
**Beispiele**
```
-- Use employee and department tables to demonstrate different type of joins.
SELECT * FROM employee;
+---+-----+------+
| id| name|deptno|
+---+-----+------+
|105|Chloe| 5|
|103| Paul| 3|
|101| John| 1|
|102| Lisa| 2|
|104| Evan| 4|
|106| Amy| 6|
+---+-----+------+
SELECT * FROM department;
+------+-----------+
|deptno| deptname|
+------+-----------+
| 3|Engineering|
| 2| Sales|
| 1| Marketing|
+------+-----------+
-- Use employee and department tables to demonstrate inner join.
SELECT id, name, employee.deptno, deptname
FROM employee INNER JOIN department ON employee.deptno = department.deptno;
+---+-----+------+-----------|
| id| name|deptno| deptname|
+---+-----+------+-----------|
|103| Paul| 3|Engineering|
|101| John| 1| Marketing|
|102| Lisa| 2| Sales|
+---+-----+------+-----------|
-- Use employee and department tables to demonstrate left join.
SELECT id, name, employee.deptno, deptname
FROM employee LEFT JOIN department ON employee.deptno = department.deptno;
+---+-----+------+-----------|
| id| name|deptno| deptname|
+---+-----+------+-----------|
|105|Chloe| 5| NULL|
|103| Paul| 3|Engineering|
|101| John| 1| Marketing|
|102| Lisa| 2| Sales|
|104| Evan| 4| NULL|
|106| Amy| 6| NULL|
+---+-----+------+-----------|
-- Use employee and department tables to demonstrate cross join.
SELECT id, name, employee.deptno, deptname FROM employee CROSS JOIN department;
+---+-----+------+-----------|
| id| name|deptno| deptname|
+---+-----+------+-----------|
|105|Chloe| 5|Engineering|
|105|Chloe| 5| Marketing|
|105|Chloe| 5| Sales|
|103| Paul| 3|Engineering|
|103| Paul| 3| Marketing|
|103| Paul| 3| Sales|
|101| John| 1|Engineering|
|101| John| 1| Marketing|
|101| John| 1| Sales|
|102| Lisa| 2|Engineering|
|102| Lisa| 2| Marketing|
|102| Lisa| 2| Sales|
|104| Evan| 4|Engineering|
|104| Evan| 4| Marketing|
|104| Evan| 4| Sales|
|106| Amy| 4|Engineering|
|106| Amy| 4| Marketing|
|106| Amy| 4| Sales|
+---+-----+------+-----------|
```
#### LIMIT-Klausel
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter. [Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql)
Die `LIMIT` Klausel wird verwendet, um die Anzahl der von der Anweisung zurückgegebenen Zeilen einzuschränken. `SELECT` Im Allgemeinen wird diese Klausel in Verbindung mit verwendet, `ORDER BY` um sicherzustellen, dass die Ergebnisse deterministisch sind.
**Syntax**
```
LIMIT { ALL | integer_expression }
```
**Parameter**
+ **ALLE**
Falls angegeben, gibt die Abfrage alle Zeilen zurück. Mit anderen Worten, es wird kein Limit angewendet, wenn diese Option angegeben ist.
+ **integer\$1expression**
Gibt einen faltbaren Ausdruck an, der eine Ganzzahl zurückgibt.
**Beispiele**
```
CREATE TABLE person (name STRING, age INT);
INSERT INTO person VALUES
('Jane Doe', 25),
('Pat C', 18),
('Nikki W', 16),
('John D', 25),
('Juan L', 18),
('Jorge S', 16);
-- Select the first two rows.
SELECT name, age FROM person ORDER BY name LIMIT 2;
+-------+---+
| name|age|
+-------+---+
| Pat C| 18|
|Jorge S| 16|
+------+---+
-- Specifying ALL option on LIMIT returns all the rows.
SELECT name, age FROM person ORDER BY name LIMIT ALL;
+--------+---+
| name|age|
+--------+---+
| Pat C| 18|
| Jorge S| 16|
| Juan L| 18|
| John D| 25|
| Nikki W| 16|
|Jane Doe| 25|
+--------+---+
-- A function expression as an input to LIMIT.
SELECT name, age FROM person ORDER BY name LIMIT length('OPENSEARCH');
+-------+---+
| name|age|
+-------+---+
| Pat C| 18|
|Jorge S| 16|
| Juan L| 18|
| John D| 25|
|Nikki W| 16|
+-------+---+
```
#### CASE-Klausel
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter[Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql).
Die `CASE` Klausel verwendet eine Regel, um ein bestimmtes Ergebnis auf der Grundlage der angegebenen Bedingung zurückzugeben, ähnlich wie if/else-Anweisungen in anderen Programmiersprachen.
**Syntax**
```
CASE [ expression ] { WHEN boolean_expression THEN then_expression } [ ... ]
[ ELSE else_expression ]
END
```
**Parameter**
+ **boolescher\$1Ausdruck**
Gibt einen beliebigen Ausdruck an, der zu einem booleschen Ergebnistyp ausgewertet wird.
Zwei oder mehr Ausdrücke können mithilfe der logischen Operatoren (`AND`,) miteinander kombiniert werden. `OR`
+ **then\$1expression**
Gibt den Ausdruck then auf der Grundlage der boolean\$1expression-Bedingung an.
`then_expression`und `else_expression` sollten alle vom gleichen Typ sein oder durch einen gemeinsamen Typ erzwingbar sein.
+ **else\$1expression**
Gibt den Standardausdruck an.
`then_expression`und ` else_expression` sollten alle vom gleichen Typ sein oder durch einen gemeinsamen Typ erzwingbar sein.
**Beispiele**
```
CREATE TABLE person (id INT, name STRING, age INT);
INSERT INTO person VALUES
(100, 'John', 30),
(200, 'Mary', NULL),
(300, 'Mike', 80),
(400, 'Dan', 50);
SELECT id, CASE WHEN id > 200 THEN 'bigger' ELSE 'small' END FROM person;
+------+--------------------------------------------------+
| id | CASE WHEN (id > 200) THEN bigger ELSE small END |
+------+--------------------------------------------------+
| 100 | small |
| 200 | small |
| 300 | bigger |
| 400 | bigger |
+------+--------------------------------------------------+
SELECT id, CASE id WHEN 100 then 'bigger' WHEN id > 300 THEN '300' ELSE 'small' END FROM person;
+------+-----------------------------------------------------------------------------------------------+
| id | CASE WHEN (id = 100) THEN bigger WHEN (id = CAST((id > 300) AS INT)) THEN 300 ELSE small END |
+------+-----------------------------------------------------------------------------------------------+
| 100 | bigger |
| 200 | small |
| 300 | small |
| 400 | small |
+------+-----------------------------------------------------------------------------------------------+
```
#### Gemeinsamer Tabellenausdruck
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter[Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql).
Ein allgemeiner Tabellenausdruck (Common Table Expression, CTE) definiert eine temporäre Ergebnismenge, auf die ein Benutzer im Rahmen einer SQL-Anweisung möglicherweise mehrfach verweisen kann. Ein CTE wird hauptsächlich in einer `SELECT` Anweisung verwendet.
**Syntax**
```
WITH common_table_expression [ , ... ]
```
While `common_table_expression` ist definiert als:
```
Syntexpression_name [ ( column_name [ , ... ] ) ] [ AS ] ( query )
```
**Parameter**
+ **Ausdrucksname**
Gibt einen Namen für den allgemeinen Tabellenausdruck an.
+ **query**
Eine `SELECT` Aussage.
**Beispiele**
```
-- CTE with multiple column aliases
WITH t(x, y) AS (SELECT 1, 2)
SELECT * FROM t WHERE x = 1 AND y = 2;
+---+---+
| x| y|
+---+---+
| 1| 2|
+---+---+
-- CTE in CTE definition
WITH t AS (
WITH t2 AS (SELECT 1)
SELECT * FROM t2
)
SELECT * FROM t;
+---+
| 1|
+---+
| 1|
+---+
-- CTE in subquery
SELECT max(c) FROM (
WITH t(c) AS (SELECT 1)
SELECT * FROM t
);
+------+
|max(c)|
+------+
| 1|
+------+
-- CTE in subquery expression
SELECT (
WITH t AS (SELECT 1)
SELECT * FROM t
);
+----------------+
|scalarsubquery()|
+----------------+
| 1|
+----------------+
-- CTE in CREATE VIEW statement
CREATE VIEW v AS
WITH t(a, b, c, d) AS (SELECT 1, 2, 3, 4)
SELECT * FROM t;
SELECT * FROM v;
+---+---+---+---+
| a| b| c| d|
+---+---+---+---+
| 1| 2| 3| 4|
+---+---+---+---+
```
#### EXPLAIN
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter[Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql).
Die `EXPLAIN` Anweisung wird verwendet, um logische/physische Pläne für eine Eingabeanweisung bereitzustellen. Standardmäßig enthält diese Klausel nur Informationen über einen physischen Plan.
**Syntax**
```
EXPLAIN [ EXTENDED | CODEGEN | COST | FORMATTED ] statement
```
**Parameter**
+ **ERWEITERT**
Generiert einen analysierten logischen Plan, einen analysierten logischen Plan, einen optimierten logischen Plan und einen physischen Plan.
Der analysierte logische Plan ist ein ungelöster Plan, der aus der Abfrage extrahiert wurde.
Analysierte logische Pläne werden `unresolvedRelation` umgewandelt, was zu vollständig typisierten `unresolvedAttribute` Objekten führt.
Der optimierte logische Plan wird mithilfe einer Reihe von Optimierungsregeln transformiert, was zum physischen Plan führt.
+ **CODEGEN**
Generiert Code für die Anweisung, falls vorhanden, und einen physischen Plan.
+ **KOSTEN**
Wenn Planknotenstatistiken verfügbar sind, generiert es einen logischen Plan und die Statistiken.
+ **FORMATIERT**
Generiert zwei Abschnitte: eine physische Planskizze und Knotendetails.
+ **statement**
Gibt eine zu erklärende SQL-Anweisung an.
**Beispiele**
```
-- Default Output
EXPLAIN select k, sum(v) from values (1, 2), (1, 3) t(k, v) group by k;
+----------------------------------------------------+
| plan|
+----------------------------------------------------+
| == Physical Plan ==
*(2) HashAggregate(keys=[k#33], functions=[sum(cast(v#34 as bigint))])
+- Exchange hashpartitioning(k#33, 200), true, [id=#59]
+- *(1) HashAggregate(keys=[k#33], functions=[partial_sum(cast(v#34 as bigint))])
+- *(1) LocalTableScan [k#33, v#34]
|
+----------------------------------------------------
-- Using Extended
EXPLAIN EXTENDED select k, sum(v) from values (1, 2), (1, 3) t(k, v) group by k;
+----------------------------------------------------+
| plan|
+----------------------------------------------------+
| == Parsed Logical Plan ==
'Aggregate ['k], ['k, unresolvedalias('sum('v), None)]
+- 'SubqueryAlias `t`
+- 'UnresolvedInlineTable [k, v], [List(1, 2), List(1, 3)]
== Analyzed Logical Plan ==
k: int, sum(v): bigint
Aggregate [k#47], [k#47, sum(cast(v#48 as bigint)) AS sum(v)#50L]
+- SubqueryAlias `t`
+- LocalRelation [k#47, v#48]
== Optimized Logical Plan ==
Aggregate [k#47], [k#47, sum(cast(v#48 as bigint)) AS sum(v)#50L]
+- LocalRelation [k#47, v#48]
== Physical Plan ==
*(2) HashAggregate(keys=[k#47], functions=[sum(cast(v#48 as bigint))], output=[k#47, sum(v)#50L])
+- Exchange hashpartitioning(k#47, 200), true, [id=#79]
+- *(1) HashAggregate(keys=[k#47], functions=[partial_sum(cast(v#48 as bigint))], output=[k#47, sum#52L])
+- *(1) LocalTableScan [k#47, v#48]
|
+----------------------------------------------------+
-- Using Formatted
EXPLAIN FORMATTED select k, sum(v) from values (1, 2), (1, 3) t(k, v) group by k;
+----------------------------------------------------+
| plan|
+----------------------------------------------------+
| == Physical Plan ==
* HashAggregate (4)
+- Exchange (3)
+- * HashAggregate (2)
+- * LocalTableScan (1)
(1) LocalTableScan [codegen id : 1]
Output: [k#19, v#20]
(2) HashAggregate [codegen id : 1]
Input: [k#19, v#20]
(3) Exchange
Input: [k#19, sum#24L]
(4) HashAggregate [codegen id : 2]
Input: [k#19, sum#24L]
|
+----------------------------------------------------+
```
#### LATERALE SUBQUERY-Klausel
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter. [Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql)
`LATERAL SUBQUERY`ist eine Unterabfrage, der das Schlüsselwort vorangestellt ist. `LATERAL` Es bietet eine Möglichkeit, auf Spalten in der vorherigen `FROM` Klausel zu verweisen. Ohne das `LATERAL` Schlüsselwort können Unterabfragen nur auf Spalten in der äußeren Abfrage verweisen, nicht jedoch auf Spalten in der `FROM` Klausel. `LATERAL SUBQUERY`macht die komplizierten Abfragen einfacher und effizienter.
**Syntax**
```
[ LATERAL ] primary_relation [ join_relation ]
```
**Parameter**
+ **primary\$1relation**
Gibt die primäre Beziehung an. Es kann sich dabei um eines der folgenden handeln:
1. Beziehung zur Tabelle
1. Abfrage mit Aliasnamen
Syntax: `( query ) [ [ AS ] alias ] `
1. Beziehung mit Aliasnamen
`Syntax: ( relation ) [ [ AS ] alias ]`
**Beispiele**
```
CREATE TABLE t1 (c1 INT, c2 INT);
INSERT INTO t1 VALUES (0, 1), (1, 2);
CREATE TABLE t2 (c1 INT, c2 INT);
INSERT INTO t2 VALUES (0, 2), (0, 3);
SELECT * FROM t1,
LATERAL (SELECT * FROM t2 WHERE t1.c1 = t2.c1);
+--------+-------+--------+-------+
| t1.c1 | t1.c2 | t2.c1 | t2.c2 |
+-------+--------+--------+-------+
| 0 | 1 | 0 | 3 |
| 0 | 1 | 0 | 2 |
+-------+--------+--------+-------+
SELECT a, b, c FROM t1,
LATERAL (SELECT c1 + c2 AS a),
LATERAL (SELECT c1 - c2 AS b),
LATERAL (SELECT a * b AS c);
+--------+-------+--------+
| a | b | c |
+-------+--------+--------+
| 3 | -1 | -3 |
| 1 | -1 | -1 |
+-------+--------+--------+
```
#### Klausel LATERAL VIEW
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter[Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql).
Die `LATERAL VIEW` Klausel wird in Verbindung mit Generatorfunktionen wie`EXPLODE`, verwendet, die eine virtuelle Tabelle mit einer oder mehreren Zeilen generieren. `LATERAL VIEW`wendet die Zeilen auf jede ursprüngliche Ausgabezeile an.
**Syntax**
```
LATERAL VIEW [ OUTER ] generator_function ( expression [ , ... ] ) [ table_alias ] AS column_alias [ , ... ]
```
**Parameter**
+ **ÄUSSERER**
Falls `OUTER` angegeben, wird Null zurückgegeben, wenn eine Eingabe leer oder Null array/map ist.
+ **generator\$1function**
Spezifiziert eine Generatorfunktion (`EXPLODE``INLINE`, usw.).
+ **table\$1alias**
Der Alias für`generator_function`, der optional ist.
+ **column\$1alias**
Listet die Spaltenaliase von auf`generator_function`, die in Ausgabezeilen verwendet werden können.
Sie können mehrere Aliase verwenden, wenn mehrere `generator_function` Ausgabespalten vorhanden sind.
**Beispiele**
```
CREATE TABLE person (id INT, name STRING, age INT, class INT, address STRING);
INSERT INTO person VALUES
(100, 'John', 30, 1, 'Street 1'),
(200, 'Mary', NULL, 1, 'Street 2'),
(300, 'Mike', 80, 3, 'Street 3'),
(400, 'Dan', 50, 4, 'Street 4');
SELECT * FROM person
LATERAL VIEW EXPLODE(ARRAY(30, 60)) tableName AS c_age
LATERAL VIEW EXPLODE(ARRAY(40, 80)) AS d_age;
+------+-------+-------+--------+-----------+--------+--------+
| id | name | age | class | address | c_age | d_age |
+------+-------+-------+--------+-----------+--------+--------+
| 100 | John | 30 | 1 | Street 1 | 30 | 40 |
| 100 | John | 30 | 1 | Street 1 | 30 | 80 |
| 100 | John | 30 | 1 | Street 1 | 60 | 40 |
| 100 | John | 30 | 1 | Street 1 | 60 | 80 |
| 200 | Mary | NULL | 1 | Street 2 | 30 | 40 |
| 200 | Mary | NULL | 1 | Street 2 | 30 | 80 |
| 200 | Mary | NULL | 1 | Street 2 | 60 | 40 |
| 200 | Mary | NULL | 1 | Street 2 | 60 | 80 |
| 300 | Mike | 80 | 3 | Street 3 | 30 | 40 |
| 300 | Mike | 80 | 3 | Street 3 | 30 | 80 |
| 300 | Mike | 80 | 3 | Street 3 | 60 | 40 |
| 300 | Mike | 80 | 3 | Street 3 | 60 | 80 |
| 400 | Dan | 50 | 4 | Street 4 | 30 | 40 |
| 400 | Dan | 50 | 4 | Street 4 | 30 | 80 |
| 400 | Dan | 50 | 4 | Street 4 | 60 | 40 |
| 400 | Dan | 50 | 4 | Street 4 | 60 | 80 |
+------+-------+-------+--------+-----------+--------+--------+
SELECT c_age, COUNT(1) FROM person
LATERAL VIEW EXPLODE(ARRAY(30, 60)) AS c_age
LATERAL VIEW EXPLODE(ARRAY(40, 80)) AS d_age
GROUP BY c_age;
+--------+-----------+
| c_age | count(1) |
+--------+-----------+
| 60 | 8 |
| 30 | 8 |
+--------+-----------+
SELECT * FROM person
LATERAL VIEW EXPLODE(ARRAY()) tableName AS c_age;
+-----+-------+------+--------+----------+--------+
| id | name | age | class | address | c_age |
+-----+-------+------+--------+----------+--------+
+-----+-------+------+--------+----------+--------+
SELECT * FROM person
LATERAL VIEW OUTER EXPLODE(ARRAY()) tableName AS c_age;
+------+-------+-------+--------+-----------+--------+
| id | name | age | class | address | c_age |
+------+-------+-------+--------+-----------+--------+
| 100 | John | 30 | 1 | Street 1 | NULL |
| 200 | Mary | NULL | 1 | Street 2 | NULL |
| 300 | Mike | 80 | 3 | Street 3 | NULL |
| 400 | Dan | 50 | 4 | Street 4 | NULL |
+------+-------+-------+--------+-----------+--------+
```
#### LIKE-Prädikat
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter. [Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql)
Ein `LIKE` Prädikat wird verwendet, um nach einem bestimmten Muster zu suchen. Dieses Prädikat unterstützt auch mehrere Muster mit Quantifizierern wie`ANY`, `SOME` und. `ALL`
**Syntax**
```
[ NOT ] { LIKE search_pattern [ ESCAPE esc_char ] | [ RLIKE | REGEXP ] regex_pattern }
[ NOT ] { LIKE quantifiers ( search_pattern [ , ... ]) }
```
**Parameter**
+ **search\$1pattern**
Gibt ein Zeichenkettenmuster an, das mit der LIKE-Klausel durchsucht werden soll. Sie kann spezielle Zeichen enthalten, die dem Muster entsprechen:
+ `%`entspricht null oder mehr Zeichen.
+ `_`entspricht genau einem Zeichen.
+ **esc\$1char**
Gibt das Zeichen an, das als Escape-Zeichen verwendet wird. Das Standard-Escape-Zeichen ist. `\`
+ **regex\$1pattern**
Gibt ein Suchmuster für reguläre Ausdrücke an, das mit der OR-Klausel durchsucht werden soll. `RLIKE` `REGEXP`
+ **Quantifizierer**
Definiert die Prädikat-Quantifizierer include`ANY`, und. `SOME` `ALL`
`ANY`oder `SOME` bedeutet, wenn eines der Muster mit der Eingabe übereinstimmt, wird true zurückgegeben.
`ALL`bedeutet, wenn alle Muster mit der Eingabe übereinstimmen, dann wird true zurückgegeben.
**Beispiele**
```
CREATE TABLE person (id INT, name STRING, age INT);
INSERT INTO person VALUES
(100, 'John', 30),
(200, 'Mary', NULL),
(300, 'Mike', 80),
(400, 'Dan', 50),
(500, 'Evan_w', 16);
SELECT * FROM person WHERE name LIKE 'M%';
+---+----+----+
| id|name| age|
+---+----+----+
|300|Mike| 80|
|200|Mary|null|
+---+----+----+
SELECT * FROM person WHERE name LIKE 'M_ry';
+---+----+----+
| id|name| age|
+---+----+----+
|200|Mary|null|
+---+----+----+
SELECT * FROM person WHERE name NOT LIKE 'M_ry';
+---+------+---+
| id| name|age|
+---+------+---+
|500|Evan_W| 16|
|300| Mike| 80|
|100| John| 30|
|400| Dan| 50|
+---+------+---+
SELECT * FROM person WHERE name RLIKE 'M+';
+---+----+----+
| id|name| age|
+---+----+----+
|300|Mike| 80|
|200|Mary|null|
+---+----+----+
SELECT * FROM person WHERE name REGEXP 'M+';
+---+----+----+
| id|name| age|
+---+----+----+
|300|Mike| 80|
|200|Mary|null|
+---+----+----+
SELECT * FROM person WHERE name LIKE '%\_%';
+---+------+---+
| id| name|age|
+---+------+---+
|500|Evan_W| 16|
+---+------+---+
SELECT * FROM person WHERE name LIKE '%$_%' ESCAPE '$';
+---+------+---+
| id| name|age|
+---+------+---+
|500|Evan_W| 16|
+---+------+---+
SELECT * FROM person WHERE name LIKE ALL ('%an%', '%an');
+---+----+----+
| id|name| age|
+---+----+----+
|400| Dan| 50|
+---+----+----+
SELECT * FROM person WHERE name LIKE ANY ('%an%', '%an');
+---+------+---+
| id| name|age|
+---+------+---+
|400| Dan| 50|
|500|Evan_W| 16|
+---+------+---+
SELECT * FROM person WHERE name LIKE SOME ('%an%', '%an');
+---+------+---+
| id| name|age|
+---+------+---+
|400| Dan| 50|
|500|Evan_W| 16|
+---+------+---+
SELECT * FROM person WHERE name NOT LIKE ALL ('%an%', '%an');
+---+----+----+
| id|name| age|
+---+----+----+
|100|John| 30|
|200|Mary|null|
|300|Mike| 80|
+---+----+----+
SELECT * FROM person WHERE name NOT LIKE ANY ('%an%', '%an');
+---+------+----+
| id| name| age|
+---+------+----+
|100| John| 30|
|200| Mary|null|
|300| Mike| 80|
|500|Evan_W| 16|
+---+------+----+
SELECT * FROM person WHERE name NOT LIKE SOME ('%an%', '%an');
+---+------+----+
| id| name| age|
+---+------+----+
|100| John| 30|
|200| Mary|null|
|300| Mike| 80|
|500|Evan_W| 16|
+---+------+----+
```
#### OFFSET
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter[Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql).
Die `OFFSET` Klausel wird verwendet, um die Anzahl der Zeilen anzugeben, die übersprungen werden sollen, bevor mit der Rückgabe der von der `SELECT` Anweisung zurückgegebenen Zeilen begonnen wird. Im Allgemeinen wird diese Klausel in Verbindung mit verwendet, `ORDER BY` um sicherzustellen, dass die Ergebnisse deterministisch sind.
**Syntax**
```
OFFSET integer_expression
```
**Parameter**
+ **integer\$1expression**
Gibt einen faltbaren Ausdruck an, der eine Ganzzahl zurückgibt.
**Beispiele**
```
CREATE TABLE person (name STRING, age INT);
INSERT INTO person VALUES
('Jane Doe', 25),
('Pat C', 18),
('Nikki W', 16),
('Juan L', 25),
('John D', 18),
('Jorge S', 16);
-- Skip the first two rows.
SELECT name, age FROM person ORDER BY name OFFSET 2;
+-------+---+
| name|age|
+-------+---+
| John D| 18|
| Juan L| 25|
|Nikki W| 16|
|Jane Doe| 25|
+-------+---+
-- Skip the first two rows and returns the next three rows.
SELECT name, age FROM person ORDER BY name LIMIT 3 OFFSET 2;
+-------+---+
| name|age|
+-------+---+
| John D| 18|
| Juan L| 25|
|Nikki W| 16|
+-------+---+
-- A function expression as an input to OFFSET.
SELECT name, age FROM person ORDER BY name OFFSET length('WAGON');
+-------+---+
| name|age|
+-------+---+
|Jane Doe| 25|
+-------+---+
```
#### PIVOT-Klausel
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter. [Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql)
Die `PIVOT` Klausel wird für die Datenperspektive verwendet. Wir können die aggregierten Werte auf der Grundlage bestimmter Spaltenwerte abrufen, die dann in mehrere Spalten umgewandelt werden, die in der `SELECT` Klausel verwendet werden. Die `PIVOT` Klausel kann nach dem Tabellennamen oder der Unterabfrage angegeben werden.
**Syntax**
```
PIVOT ( { aggregate_expression [ AS aggregate_expression_alias ] } [ , ... ] FOR column_list IN ( expression_list ) )
```
**Parameter**
+ **aggregate\$1expression**
Gibt einen `(SUM(a)` `COUNT(DISTINCT b)` Aggregatausdruck usw. an.).
+ **aggregate\$1expression\$1alias**
Gibt einen Alias für den Aggregatausdruck an.
+ **column\$1list**
Enthält Spalten in der `FROM` Klausel, die die Spalten angibt, die Sie durch neue Spalten ersetzen möchten. Sie können die Spalten mit Klammern umgeben, z. `(c1, c2)` B.
+ **expression\$1list**
Gibt neue Spalten an, die `column_list` als Aggregationsbedingung zum Abgleichen von Werten verwendet werden. Sie können auch Aliase für sie hinzufügen.
**Beispiele**
```
CREATE TABLE person (id INT, name STRING, age INT, class INT, address STRING);
INSERT INTO person VALUES
(100, 'John', 30, 1, 'Street 1'),
(200, 'Mary', NULL, 1, 'Street 2'),
(300, 'Mike', 80, 3, 'Street 3'),
(400, 'Dan', 50, 4, 'Street 4');
SELECT * FROM person
PIVOT (
SUM(age) AS a, AVG(class) AS c
FOR name IN ('John' AS john, 'Mike' AS mike)
);
+------+-----------+---------+---------+---------+---------+
| id | address | john_a | john_c | mike_a | mike_c |
+------+-----------+---------+---------+---------+---------+
| 200 | Street 2 | NULL | NULL | NULL | NULL |
| 100 | Street 1 | 30 | 1.0 | NULL | NULL |
| 300 | Street 3 | NULL | NULL | 80 | 3.0 |
| 400 | Street 4 | NULL | NULL | NULL | NULL |
+------+-----------+---------+---------+---------+---------+
SELECT * FROM person
PIVOT (
SUM(age) AS a, AVG(class) AS c
FOR (name, age) IN (('John', 30) AS c1, ('Mike', 40) AS c2)
);
+------+-----------+-------+-------+-------+-------+
| id | address | c1_a | c1_c | c2_a | c2_c |
+------+-----------+-------+-------+-------+-------+
| 200 | Street 2 | NULL | NULL | NULL | NULL |
| 100 | Street 1 | 30 | 1.0 | NULL | NULL |
| 300 | Street 3 | NULL | NULL | NULL | NULL |
| 400 | Street 4 | NULL | NULL | NULL | NULL |
+------+-----------+-------+-------+-------+-------+
```
#### Satzoperatoren
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter. [Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql)
Mengenoperatoren werden verwendet, um zwei Eingabebeziehungen zu einer einzigen zu kombinieren. OpenSearch SQL unterstützt drei Arten von Mengenoperatoren:
+ `EXCEPT` oder `MINUS`
+ `INTERSECT`
+ `UNION`
Eingabebeziehungen müssen dieselbe Anzahl von Spalten und kompatible Datentypen für die jeweiligen Spalten haben.
**AUSSER**
`EXCEPT`und `EXCEPT ALL` gibt die Zeilen zurück, die in einer Beziehung gefunden werden, aber nicht in der anderen. `EXCEPT`(alternativ`EXCEPT DISTINCT`) verwendet nur unterschiedliche Zeilen, entfernt aber `EXCEPT ALL` keine Duplikate aus den Ergebniszeilen. Beachten Sie, dass `MINUS` dies ein Alias für `EXCEPT` ist.
**Syntax**
```
[ ( ] relation [ ) ] EXCEPT | MINUS [ ALL | DISTINCT ] [ ( ] relation [ ) ]
```
**Beispiele**
```
-- Use table1 and table2 tables to demonstrate set operators in this page.
SELECT * FROM table1;
+---+
| c|
+---+
| 3|
| 1|
| 2|
| 2|
| 3|
| 4|
+---+
SELECT * FROM table2;
+---+
| c|
+---+
| 5|
| 1|
| 2|
| 2|
+---+
SELECT c FROM table1 EXCEPT SELECT c FROM table2;
+---+
| c|
+---+
| 3|
| 4|
+---+
SELECT c FROM table1 MINUS SELECT c FROM table2;
+---+
| c|
+---+
| 3|
| 4|
+---+
SELECT c FROM table1 EXCEPT ALL (SELECT c FROM table2);
+---+
| c|
+---+
| 3|
| 3|
| 4|
+---+
SELECT c FROM table1 MINUS ALL (SELECT c FROM table2);
+---+
| c|
+---+
| 3|
| 3|
| 4|
+---+
```
**ÜBERSCHNEIDEN**
`INTERSECT`und `INTERSECT ALL` gibt die Zeilen zurück, die in beiden Relationen gefunden wurden. `INTERSECT`(alternativ`INTERSECT DISTINCT`) verwendet nur unterschiedliche Zeilen, entfernt aber `INTERSECT ALL` keine Duplikate aus den Ergebniszeilen.
**Syntax**
```
[ ( ] relation [ ) ] INTERSECT [ ALL | DISTINCT ] [ ( ] relation [ ) ]
```
**Beispiele**
```
(SELECT c FROM table1) INTERSECT (SELECT c FROM table2);
+---+
| c|
+---+
| 1|
| 2|
+---+
(SELECT c FROM table1) INTERSECT DISTINCT (SELECT c FROM table2);
+---+
| c|
+---+
| 1|
| 2|
+---+
(SELECT c FROM table1) INTERSECT ALL (SELECT c FROM table2);
+---+
| c|
+---+
| 1|
| 2|
| 2|
+---+
```
**VEREINIGUNG**
`UNION`und `UNION ALL` gibt die Zeilen zurück, die in einer der Beziehungen gefunden wurden. `UNION`(alternativ`UNION DISTINCT`) verwendet nur unterschiedliche Zeilen, entfernt aber `UNION ALL` keine Duplikate aus den Ergebniszeilen.
**Syntax**
```
[ ( ] relation [ ) ] UNION [ ALL | DISTINCT ] [ ( ] relation [ ) ]
```
**Beispiele**
```
(SELECT c FROM table1) UNION (SELECT c FROM table2);
+---+
| c|
+---+
| 1|
| 3|
| 5|
| 4|
| 2|
+---+
(SELECT c FROM table1) UNION DISTINCT (SELECT c FROM table2);
+---+
| c|
+---+
| 1|
| 3|
| 5|
| 4|
| 2|
+---+
SELECT c FROM table1 UNION ALL (SELECT c FROM table2);
+---+
| c|
+---+
| 3|
| 1|
| 2|
| 2|
| 3|
| 4|
| 5|
| 1|
| 2|
| 2|
+---+
```
#### SORT BY-Klausel
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter[Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql).
Die `SORT BY` Klausel wird verwendet, um die Ergebniszeilen innerhalb jeder Partition sortiert in der vom Benutzer angegebenen Reihenfolge zurückzugeben. Wenn es mehr als eine Partition gibt, `SORT BY` kann ein Ergebnis zurückgegeben werden, das teilweise sortiert ist. Dies unterscheidet sich von der `ORDER BY` Klausel, die eine vollständige Reihenfolge der Ausgabe garantiert.
**Syntax**
```
SORT BY { expression [ sort_direction | nulls_sort_order ] [ , ... ] }
```
**Parameter**
+ **SORTIERE NACH**
Gibt eine durch Kommas getrennte Liste von Ausdrücken zusammen mit den optionalen Parametern sort\$1direction und nulls\$1sort\$1order an, die verwendet werden, um die Zeilen innerhalb jeder Partition zu sortieren.
+ **sort\$1direction**
Gibt optional an, ob die Zeilen in aufsteigender oder absteigender Reihenfolge sortiert werden sollen.
Die gültigen Werte für die Sortierrichtung gelten für aufsteigend und `ASC` `DESC` für absteigend.
Wenn die Sortierrichtung nicht explizit angegeben ist, werden Zeilen standardmäßig aufsteigend sortiert.
Syntax: `[ ASC | DESC ]`
+ **nulls\$1sort\$1order**
Gibt optional an, ob NULL-Werte vor/nach Nicht-NULL-Werten zurückgegeben werden.
Wenn nicht angegeben, `null_sort_order` wird zuerst NULLs sortiert, wenn die Sortierreihenfolge ist, `ASC` und NULLS sortiert zuletzt, wenn die Sortierreihenfolge ist. `DESC`
1. Wenn `NULLS FIRST` angegeben, werden NULL-Werte unabhängig von der Sortierreihenfolge zuerst zurückgegeben.
2. Wenn `NULLS LAST` angegeben, werden NULL-Werte unabhängig von der Sortierreihenfolge zuletzt zurückgegeben.
Syntax: `[ NULLS { FIRST | LAST } ] `
**Beispiele**
```
CREATE TABLE person (zip_code INT, name STRING, age INT);
INSERT INTO person VALUES
(94588, 'Shirley Rodriguez', 50),
(94588, 'Juan Li', 18),
(94588, 'Anil K', 27),
(94588, 'John D', NULL),
(94511, 'David K', 42),
(94511, 'Aryan B.', 18),
(94511, 'Lalit B.', NULL);
-- Sort rows by `name` within each partition in ascending manner
SELECT name, age, zip_code FROM person SORT BY name;
+------------------+----+--------+
| name| age|zip_code|
+------------------+----+--------+
| Anil K| 27| 94588|
| Juan Li| 18| 94588|
| John D|null| 94588|
| Shirley Rodriguez| 50| 94588|
| Aryan B.| 18| 94511|
| David K| 42| 94511|
| Lalit B.|null| 94511|
+------------------+----+--------+
-- Sort rows within each partition using column position.
SELECT name, age, zip_code FROM person SORT BY 1;
+----------------+----+----------+
| name| age|zip_code|
+------------------+----+--------+
| Anil K| 27| 94588|
| Juan Li| 18| 94588|
| John D|null| 94588|
| Shirley Rodriguez| 50| 94588|
| Aryan B.| 18| 94511|
| David K| 42| 94511|
| Lalit B.|null| 94511|
+------------------+----+--------+
-- Sort rows within partition in ascending manner keeping null values to be last.
SELECT age, name, zip_code FROM person SORT BY age NULLS LAST;
+----+------------------+--------+
| age| name|zip_code|
+----+------------------+--------+
| 18| Juan Li| 94588|
| 27| Anil K| 94588|
| 50| Shirley Rodriguez| 94588|
|null| John D| 94588|
| 18| Aryan B.| 94511|
| 42| David K| 94511|
|null| Lalit B.| 94511|
+--------------+--------+--------+
-- Sort rows by age within each partition in descending manner, which defaults to NULL LAST.
SELECT age, name, zip_code FROM person SORT BY age DESC;
+----+------------------+--------+
| age| name|zip_code|
+----+------------------+--------+
| 50| Shirley Rodriguez| 94588|
| 27| Anil K| 94588|
| 18| Juan Li| 94588|
|null| John D| 94588|
| 42| David K| 94511|
| 18| Aryan B.| 94511|
|null| Lalit B.| 94511|
+----+------------------+--------+
-- Sort rows by age within each partition in descending manner keeping null values to be first.
SELECT age, name, zip_code FROM person SORT BY age DESC NULLS FIRST;
+----+------------------+--------+
| age| name|zip_code|
+----+------------------+--------+
|null| John D| 94588|
| 50| Shirley Rodriguez| 94588|
| 27| Anil K| 94588|
| 18| Juan Li| 94588|
|null| Lalit B.| 94511|
| 42| David K| 94511|
| 18| Aryan B.| 94511|
+--------------+--------+--------+
-- Sort rows within each partition based on more than one column with each column having
-- different sort direction.
SELECT name, age, zip_code FROM person
SORT BY name ASC, age DESC;
+------------------+----+--------+
| name| age|zip_code|
+------------------+----+--------+
| Anil K| 27| 94588|
| Juan Li| 18| 94588|
| John D|null| 94588|
| Shirley Rodriguez| 50| 94588|
| Aryan B.| 18| 94511|
| David K| 42| 94511|
| Lalit B.|null| 94511|
+------------------+----+--------+
```
#### UNPIVOT
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen SQL-Befehl unterstützen, finden Sie unter[Unterstützte OpenSearch SQL-Befehle und -Funktionen](#supported-directquery-sql).
Die `UNPIVOT` Klausel wandelt mehrere Spalten in mehrere Zeilen um, die in der Klausel verwendet werden. `SELECT` Die `UNPIVOT` Klausel kann nach dem Tabellennamen oder der Unterabfrage angegeben werden.
**Syntax**
```
UNPIVOT [ { INCLUDE | EXCLUDE } NULLS ] (
{ single_value_column_unpivot | multi_value_column_unpivot }
) [[AS] alias]
single_value_column_unpivot:
values_column
FOR name_column
IN (unpivot_column [[AS] alias] [, ...])
multi_value_column_unpivot:
(values_column [, ...])
FOR name_column
IN ((unpivot_column [, ...]) [[AS] alias] [, ...])
```
**Parameter**
+ **unpivot\$1column**
Enthält Spalten in der `FROM` Klausel, die die Spalten angibt, deren Pivotierung aufgehoben werden soll.
+ **name\$1column**
Der Name der Spalte, die die Namen der Spalten ohne Pivotierung enthält.
+ **values\$1column**
Der Name der Spalte, die die Werte der Spalten ohne Pivotierung enthält.
**Beispiele**
```
CREATE TABLE sales_quarterly (year INT, q1 INT, q2 INT, q3 INT, q4 INT);
INSERT INTO sales_quarterly VALUES
(2020, null, 1000, 2000, 2500),
(2021, 2250, 3200, 4200, 5900),
(2022, 4200, 3100, null, null);
-- column names are used as unpivot columns
SELECT * FROM sales_quarterly
UNPIVOT (
sales FOR quarter IN (q1, q2, q3, q4)
);
+------+---------+-------+
| year | quarter | sales |
+------+---------+-------+
| 2020 | q2 | 1000 |
| 2020 | q3 | 2000 |
| 2020 | q4 | 2500 |
| 2021 | q1 | 2250 |
| 2021 | q2 | 3200 |
| 2021 | q3 | 4200 |
| 2021 | q4 | 5900 |
| 2022 | q1 | 4200 |
| 2022 | q2 | 3100 |
+------+---------+-------+
-- NULL values are excluded by default, they can be included
-- unpivot columns can be alias
-- unpivot result can be referenced via its alias
SELECT up.* FROM sales_quarterly
UNPIVOT INCLUDE NULLS (
sales FOR quarter IN (q1 AS Q1, q2 AS Q2, q3 AS Q3, q4 AS Q4)
) AS up;
+------+---------+-------+
| year | quarter | sales |
+------+---------+-------+
| 2020 | Q1 | NULL |
| 2020 | Q2 | 1000 |
| 2020 | Q3 | 2000 |
| 2020 | Q4 | 2500 |
| 2021 | Q1 | 2250 |
| 2021 | Q2 | 3200 |
| 2021 | Q3 | 4200 |
| 2021 | Q4 | 5900 |
| 2022 | Q1 | 4200 |
| 2022 | Q2 | 3100 |
| 2022 | Q3 | NULL |
| 2022 | Q4 | NULL |
+------+---------+-------+
-- multiple value columns can be unpivoted per row
SELECT * FROM sales_quarterly
UNPIVOT EXCLUDE NULLS (
(first_quarter, second_quarter)
FOR half_of_the_year IN (
(q1, q2) AS H1,
(q3, q4) AS H2
)
);
+------+------------------+---------------+----------------+
| id | half_of_the_year | first_quarter | second_quarter |
+------+------------------+---------------+----------------+
| 2020 | H1 | NULL | 1000 |
| 2020 | H2 | 2000 | 2500 |
| 2021 | H1 | 2250 | 3200 |
| 2021 | H2 | 4200 | 5900 |
| 2022 | H1 | 4200 | 3100 |
+------+------------------+---------------+----------------+
```
# Unterstützte PPL-Befehle
Die folgenden Tabellen zeigen, welche PPL-Befehle OpenSearch Dashboards für die Abfrage von CloudWatch Logs, Amazon S3 oder Security Lake unterstützt und welche Befehle CloudWatch Logs Insights unterstützt. CloudWatch Logs Insights verwendet bei der Abfrage von Logs dieselbe PPL-Syntax wie OpenSearch Dashboards, und in den Tabellen werden beide als CloudWatch Logs bezeichnet. CloudWatch
**Anmerkung**
Wenn Sie Daten außerhalb von OpenSearch Service analysieren, werden Befehle möglicherweise anders ausgeführt als bei Indizes. OpenSearch
**Topics**
+ [Befehle](#supported-ppl-commands)
+ [Funktionen](#supported-ppl-functions)
+ [Zusätzliche Informationen für CloudWatch Logs Insights-Benutzer, die OpenSearch PPL verwenden](#supported-ppl-for-cloudwatch-users)
## Befehle
| PPL-Befehl | Description | CloudWatch Logs | Amazon S3 | Sicherheit, Lake | Beispielbefehl |
| --- | --- | --- | --- | --- | --- |
| [Befehl „Felder“](#supported-ppl-fields-command) | Zeigt eine Reihe von Feldern an, die projiziert werden müssen. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | fields field1, field2
|
| [wo Befehl](#supported-ppl-where-command) | Filtert die Daten auf der Grundlage der von Ihnen angegebenen Bedingungen. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | where field1="success"
| where field2 != "i -023fe0a90929d8822"
| fields field3, col4, col5, col6
| head 1000
|
| [Befehl stats](#supported-ppl-stats-command) | Führt Aggregationen und Berechnungen durch. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | stats count(),
count(`field1`),
min(`field1`),
max(`field1`),
avg(`field1`)
by field2
| head 1000
|
| [Befehl parse](#supported-ppl-parse-command) | Extrahiert ein Muster mit regulären Ausdrücken (Regex) aus einer Zeichenfolge und zeigt das extrahierte Muster an. Das extrahierte Muster kann weiter verwendet werden, um neue Felder zu erstellen oder Daten zu filtern. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | parse `field1` ".*/(?[^/]+$)"
| where field2 = "requestId"
| fields field2, `field2`
| head 1000
|
| [Befehl „Muster“](#supported-ppl-patterns-command) | Extrahiert Protokollmuster aus einem Textfeld und hängt die Ergebnisse an das Suchergebnis an. Durch die Gruppierung von Protokollen nach ihren Mustern ist es einfacher, Statistiken aus großen Mengen von Protokolldaten zur Analyse und Fehlerbehebung zu aggregieren. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/negative_icon.svg)Wird nicht unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | patterns new_field='no_numbers' pattern='[0-9]' message
| fields message, no_numbers
|
| [Befehl sort](#supported-ppl-sort-command) | Sortiert die angezeigten Ergebnisse nach einem Feldnamen. Verwenden Sie **sort - *FieldName***, um in absteigender Reihenfolge zu sortieren. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | stats count(),
count(`field1`),
min(`field1`) as field1Alias,
max(`field1`),
avg(`field1`)
by field2
| sort -field1Alias
| head 1000
|
| [Befehl eval](#supported-ppl-eval-command) | Ändert oder verarbeitet den Wert eines Felds und speichert ihn in einem anderen Feld. Dies ist nützlich, um eine Spalte mathematisch zu modifizieren, Zeichenkettenfunktionen auf eine Spalte anzuwenden oder Datumsfunktionen auf eine Spalte anzuwenden. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | eval field2 = `field1` * 2
| fields field1, field2
| head 20
|
| [Befehl umbenennen](#supported-ppl-rename-command) | Benennt ein oder mehrere Felder im Suchergebnis um. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | rename field2 as field1
| fields field1
|
| [Befehl head](#supported-ppl-head-command) | Beschränkt die angezeigten Abfrageergebnisse auf die ersten N Zeilen. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | fields `@message`
| head 20
|
| [Befehl grok](#supported-ppl-grok-command) | Analysiert ein Textfeld mit einem Grok-Muster, das auf einem regulären Ausdruck basiert, und hängt die Ergebnisse an das Suchergebnis an. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | grok email '.+@%{HOSTNAME:host}'
| fields email |
| [oberster Befehl](#supported-ppl-top-command) | Findet die häufigsten Werte für ein Feld. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | top 2 Field1 by Field2
|
| [Befehl dedup](#supported-ppl-dedup-command) | Entfernt doppelte Einträge auf der Grundlage der von Ihnen angegebenen Felder. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | dedup field1
| fields field1, field2, field3
|
| [Befehl join](#supported-ppl-join-commands) | Verbindet zwei Datensätze miteinander. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | source=customer
| join ON c_custkey = o_custkey orders
| head 10
|
| [Lookup-Befehl](#supported-ppl-lookup-commands) | Bereichert Ihre Suchdaten durch Hinzufügen oder Ersetzen von Daten aus einem Nachschlageindex (Dimensionstabelle). Sie können Felder eines Index um Werte aus einer Dimensionstabelle erweitern und Werte anhängen oder ersetzen, wenn die Suchbedingung erfüllt ist | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/negative_icon.svg)Wird nicht unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | where orderType = 'Cancelled'
| lookup account_list, mkt_id AS mkt_code
replace amount, account_name as name
| stats count(mkt_code), avg(amount)
by name
|
| [Befehl subquery](#supported-ppl-subquery-commands) | Führt komplexe, verschachtelte Abfragen innerhalb Ihrer PPL-Anweisungen (Piped Processing Language) durch. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | where id in [
subquery source=users
| where user in [
subquery source=actions
| where action="login"
| fields user
]
| fields uid
]
|
| [seltener Befehl](#supported-ppl-rare-command) | Findet die seltensten Werte aller Felder in der Feldliste. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | rare Field1 by Field2
|
| [Befehl trendline](#supported-ppl-trendline-commands) | Berechnet die gleitenden Durchschnitte von Feldern. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | trendline sma(2, field1) as field1Alias
|
| [Befehl eventstats](#supported-ppl-eventstats-command) | Reichert Ihre Eventdaten mit berechneten zusammenfassenden Statistiken an. Es analysiert bestimmte Felder innerhalb Ihrer Ereignisse, berechnet verschiedene statistische Kennzahlen und fügt diese Ergebnisse dann als neue Felder an jedes ursprüngliche Ereignis an. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt (außer) `count()` | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | eventstats sum(field1) by field2
|
| [Befehl flatten](#supported-ppl-flatten-command) | Macht ein Feld flach. Das Feld muss diesen Typ haben: `struct or array>` | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | source=table | flatten field1
|
| [Zusammenfassung der Felder](#supported-ppl-field-summary-command) | Berechnet grundlegende Statistiken für jedes Feld (Anzahl, eindeutige Anzahl, Min., Max, Durchschnitt, Standardwert und Mittelwert). | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt (ein Feld pro Abfrage) | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | where field1 != 200
| fieldsummary includefields=field1 nulls=true
|
| [Befehl fillnull](#supported-ppl-fillnull-command) | Füllt Nullfelder mit dem von Ihnen angegebenen Wert. Es kann in einem oder mehreren Feldern verwendet werden. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | fields field1
| eval field2=field1
| fillnull value=0 field1
|
| [Befehl expandieren](#supported-ppl-expand-command) | Zerlegt ein Feld, das mehrere Werte enthält, in separate Zeilen und erstellt für jeden Wert im angegebenen Feld eine neue Zeile. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | expand employee
| stats max(salary) as max
by state, company
|
| [Befehl beschreiben](#supported-ppl-describe-command) | Ruft detaillierte Informationen zur Struktur und zu den Metadaten von Tabellen, Schemas und Katalogen ab | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/negative_icon.svg)Wird nicht unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | describe schema.table
|
## Funktionen
| PPL-Funktion | Description | CloudWatch Logs | Amazon S3 | Sicherheit, Lake | Beispielbefehl |
| --- | --- | --- | --- | --- | --- |
| [PPL-String-Funktionen](#supported-ppl-string-functions) (`CONCAT`, `CONCAT_WS`, `LENGTH`, `LOWER`, `LTRIM`, `POSITION`, `REVERSE`, `RIGHT`, `RTRIM`, `SUBSTRING`, `TRIM`, `UPPER`) | Integrierte Funktionen in PPL, mit denen Zeichenketten- und Textdaten in PPL-Abfragen bearbeitet und transformiert werden können. Zum Beispiel das Konvertieren von Groß- und Kleinschreibung, das Kombinieren von Zeichenketten, das Extrahieren von Teilen und das Bereinigen von Text. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | eval col1Len = LENGTH(col1)
| fields col1Len
|
| [PPL-Funktionen für Datum und Uhrzeit](#supported-ppl-date-time-functions) (`DAY`, `DAYOFMONTH`, `DAY_OF_MONTH`,`DAYOFWEEK`, `DAY_OF_WEEK`, `DAYOFYEAR`, `DAY_OF_YEAR`, `DAYNAME`, `FROM_UNIXTIME`, `HOUR`, `HOUR_OF_DAY`, `LAST_DAY`, `LOCALTIMESTAMP`, `LOCALTIME`, `MAKE_DATE`, `MINUTE`, `MINUTE_OF_HOUR`, `MONTH`, `MONTHNAME`, `MONTH_OF_YEAR`, `NOW`, `QUARTER`, `SECOND`, `SECOND_OF_MINUTE`, `SUBDATE`, `SYSDATE`, `TIMESTAMP`, `UNIX_TIMESTAMP`, `WEEK`, `WEEKDAY`, `WEEK_OF_YEAR`, `DATE_ADD`, `DATE_SUB`, `TIMESTAMPADD`, `TIMESTAMPDIFF`, `UTC_TIMESTAMP`, `CURRENT_TIMEZONE`) | Integrierte Funktionen für die Verarbeitung und Transformation von Datums- und Zeitstempeldaten in PPL-Abfragen. ****Zum Beispiel **date\$1add, date\$1format****, datediff und current\$1date**.**** | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | eval newDate = ADDDATE(DATE('2020-08-26'), 1)
| fields newDate |
| [Funktionen für PPL-Bedingungen](#supported-ppl-condition-functions) (`EXISTS`, `IF`, `IFNULL`, `ISNOTNULL`, `ISNULL`, `NULLIF`) | Integrierte Funktionen, die Berechnungen für mehrere Zeilen durchführen, um einen einzigen zusammengefassten Wert zu erzeugen. Zum Beispiel **Summe**, **Anzahl**, **Durchschnitt**, **Maximum** und **Min**. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | eval field2 = isnull(col1)
| fields field2, col1, field3
|
| [Mathematische Funktionen von PPL](#supported-ppl-math-functions) (`ABS`, `ACOS`, `ASIN`, `ATAN`, `ATAN2`, `CEIL`, `CEILING`, `CONV`, `COS`, `COT`, `CRC32`, `DEGREES`, `E`, `EXP`, `FLOOR`, `LN`, `LOG`, `LOG2`, `LOG10`, `MOD`, `PI`. `POW`, `POWER`, `RADIANS`, `RAND`, `ROUND`, `SIGN`, `SIN`, `SQRT`, `CBRT`) | Integrierte Funktionen zur Durchführung mathematischer Berechnungen und Transformationen in PPL-Abfragen. Zum Beispiel: **abs** (absoluter Wert), **round** (rundet Zahlen), **sqrt** (Quadratwurzel), **pow** (Potenzberechnung) und **ceil** (rundet auf die nächste Ganzzahl auf). | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | eval field2 = ACOS(col1)
| fields col1
|
| [PPL-Ausdrücke](#supported-ppl-expressions) (Arithmetische Operatoren (`+`,`*`)`-`, Prädikatoperatoren (,) `>. <` `IN)` | Integrierte Funktionen für Ausdrücke, insbesondere Wertausdrücke, geben einen Skalarwert zurück. Ausdrücke haben unterschiedliche Typen und Formen. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | where age > (25 + 5)
| fields age
|
| [PPL-IP-Adressfunktionen](#supported-ppl-ip-address-functions) (`CIDRMATCH`) | Integrierte Funktionen für den Umgang mit IP-Adressen wie CIDR. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | where cidrmatch(ip, '***********/24')
| fields ip
|
| [PPL JSON-Funktionen](#supported-ppl-json-functions) (`ARRAY_LENGTH`, `ARRAY_LENGTH`, `JSON`, `JSON_ARRAY`, `JSON_EXTRACT`, `JSON_KEYS`, `JSON_OBJECT`, `JSON_VALID`, `TO_JSON_STRING`) | Integrierte Funktionen für den Umgang mit JSON, einschließlich Arrays, Extrahieren und Validieren. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | eval `json_extract('{"a":"b"}', '$.a')` = json_extract('{"a":"b"}', '$a') |
| [PPL Lambda-Funktionen](#supported-ppl-lambda-functions) (`EXISTS`, `FILTER`, `REDUCE`, `TRANSFORM`) | Integrierte Funktionen für den Umgang mit JSON, einschließlich Arrays, Extrahieren und Validieren. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/negative_icon.svg)Wird nicht unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | eval array = json_array(1, -1, 2),
result = filter(array, x -> x > 0)
| fields result
|
| [Kryptografische PPL-Hash-Funktionen](#supported-ppl-cryptographic-functions) (`MD5`, `SHA1`, `SHA2`) | Integrierte Funktionen, mit denen Sie eindeutige Fingerabdrücke von Daten generieren können, die zur Überprüfung, zum Vergleich oder als Teil komplexerer Sicherheitsprotokolle verwendet werden können. | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/success_icon.svg)Unterstützt | eval `MD5('hello')` = MD5('hello')
| fields `MD5('hello')` |
## Zusätzliche Informationen für CloudWatch Logs Insights-Benutzer, die OpenSearch PPL verwenden
CloudWatch Logs Insights unterstützt zwar die meisten OpenSearch PPL-Befehle und -Funktionen, einige Befehle und Funktionen werden jedoch derzeit nicht unterstützt. Beispielsweise unterstützt es derzeit keine Lookup-Befehle in PPL. Seit dem 2. Juni 2025 unterstützt CloudWatch Logs Insights jetzt die Funktionen JOIN, Unterabfragen, Flatten, Fillnull, Expand, Cidrmatch und JSON in PPL. Eine vollständige Liste der unterstützten Abfragebefehle und -funktionen finden Sie in den Amazon CloudWatch Logs-Spalten in den obigen Tabellen.
### Beispielabfragen und Kontingente
Das Folgende gilt sowohl für CloudWatch Logs Insights-Benutzer als auch für OpenSearch Benutzer, die CloudWatch Daten abfragen.
Informationen zu den Beschränkungen, die bei der Abfrage von CloudWatch Logs from OpenSearch Service gelten, finden Sie unter [CloudWatch Log-Kontingente](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html) im Amazon CloudWatch Logs-Benutzerhandbuch. Die Beschränkungen betreffen die Anzahl der CloudWatch Protokollgruppen, die Sie abfragen können, die maximale Anzahl gleichzeitiger Abfragen, die Sie ausführen können, die maximale Ausführungszeit von Abfragen und die maximale Anzahl von Zeilen, die in Ergebnissen zurückgegeben werden. Die Grenzwerte sind dieselben, unabhängig davon, in welcher Sprache Sie CloudWatch Logs abfragen (nämlich OpenSearch PPL, SQL und Logs Insights QL).
### PPL-Befehle
**Topics**
+ [Kommentar](#supported-ppl-comment)
+ [Korrelationsbefehl](#supported-ppl-correlation-commands)
+ [Befehl dedup](#supported-ppl-dedup-command)
+ [Befehl beschreiben](#supported-ppl-describe-command)
+ [Befehl eval](#supported-ppl-eval-command)
+ [Befehl eventstats](#supported-ppl-eventstats-command)
+ [Befehl erweitern](#supported-ppl-expand-commands)
+ [Befehl erläutern](#supported-ppl-explain-command)
+ [Befehl fillnull](#supported-ppl-fillnull-command)
+ [Befehl „Felder“](#supported-ppl-fields-command)
+ [Befehl flatten](#supported-ppl-flatten-command)
+ [Befehl grok](#supported-ppl-grok-command)
+ [Befehl head](#supported-ppl-head-command)
+ [Befehl join](#supported-ppl-join-commands)
+ [Lookup-Befehl](#supported-ppl-lookup-commands)
+ [Befehl parse](#supported-ppl-parse-command)
+ [Befehl „Muster“](#supported-ppl-patterns-command)
+ [seltener Befehl](#supported-ppl-rare-command)
+ [Befehl umbenennen](#supported-ppl-rename-command)
+ [Suchbefehl](#supported-ppl-search-command)
+ [Befehl sort](#supported-ppl-sort-command)
+ [Befehl stats](#supported-ppl-stats-command)
+ [Befehl subquery](#supported-ppl-subquery-commands)
+ [oberster Befehl](#supported-ppl-top-command)
+ [Befehl trendline](#supported-ppl-trendline-commands)
+ [wo Befehl](#supported-ppl-where-command)
+ [Zusammenfassung der Felder](#supported-ppl-field-summary-command)
+ [Befehl expandieren](#supported-ppl-expand-command)
+ [PPL-Funktionen](#supported-ppl-functions-details)
#### Kommentar
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
PPL unterstützt sowohl Zeilenkommentare als auch Blockkommentare. Das System wertet den Kommentartext nicht aus.
**Zeilenkommentare**
Zeilenkommentare beginnen mit zwei Schrägstrichen//und enden mit einer neuen Zeile.
Beispiel:
```
os> source=accounts | top gender // finds most common gender of all the accounts
fetched rows / total rows = 2/2
+----------+
| gender |
|----------|
| M |
| F |
+----------+
```
**Kommentare blockieren**
Blockkommentare beginnen mit einem Schrägstrich, gefolgt von einem Sternchen\$1 \$1, und enden mit einem Sternchen, gefolgt von einem Schrägstrich \$1/.
Beispiel:
```
os> source=accounts | dedup 2 gender /* dedup the document with gender field keep 2 duplication */ | fields account_number, gender
fetched rows / total rows = 3/3
+------------------+----------+
| account_number | gender |
|------------------+----------|
| 1 | M |
| 6 | M |
| 13 | F |
+------------------+----------+
```
#### Korrelationsbefehl
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Sie können verschiedene Datenquellen anhand gemeinsamer Dimensionen und Zeitrahmen korrelieren.
Diese Korrelation ist entscheidend, wenn Sie es mit großen Datenmengen aus verschiedenen Branchen zu tun haben, die dieselben Zeiträume haben, aber nicht formal synchronisiert sind.
Indem Sie diese verschiedenen Datenquellen auf der Grundlage von Zeitrahmen und ähnlichen Dimensionen korrelieren, können Sie Ihre Daten anreichern und wertvolle Erkenntnisse gewinnen.
**Beispiel**
Der Bereich Observability besteht aus drei unterschiedlichen Datenquellen:
+ Protokolle
+ Kennzahlen
+ Ablaufverfolgungen
Diese Datenquellen haben möglicherweise gemeinsame Dimensionen. Um von einer Datenquelle zur anderen zu wechseln, müssen Sie sie korrekt korrelieren. Mithilfe semantischer Namenskonventionen können Sie gemeinsam genutzte Elemente in Logs, Traces und Metriken identifizieren.
Beispiel:
```
{
"@timestamp": "2018-07-02T22:23:00.186Z",
"aws": {
"elb": {
"backend": {
"http": {
"response": {
"status_code": 500
}
},
"ip": "********",
"port": "80"
},
...
"target_port": [
"10.0.0.1:80"
],
"target_status_code": [
"500"
],
"traceId": "Root=1-58337262-36d228ad5d99923122bbe354",
"type": "http"
}
},
"cloud": {
"provider": "aws"
},
"http": {
"request": {
...
},
"communication": {
"source": {
"address": "**************",
"ip": "**************",
"port": 2817
}
},
"traceId": "Root=1-58337262-36d228ad5d99923122bbe354"
}
```
Dieses Beispiel zeigt ein AWS ELB-Protokoll, das von einem Dienst empfangen wird, der sich auf befindet. AWS Es zeigt eine Backend-HTTP-Antwort mit dem Statuscode 500, was auf einen Fehler hinweist. Dies könnte eine Warnung auslösen oder Teil Ihres regulären Überwachungsprozesses sein. Ihr nächster Schritt besteht darin, relevante Daten zu diesem Ereignis für eine gründliche Untersuchung zu sammeln.
Auch wenn Sie versucht sein könnten, alle Daten im Zusammenhang mit dem Zeitrahmen abzufragen, kann dieser Ansatz überwältigend sein. Sie könnten am Ende zu viele Informationen haben und mehr Zeit damit verbringen, irrelevante Daten herauszufiltern, als die Ursache zu ermitteln.
Stattdessen können Sie einen gezielteren Ansatz verfolgen, indem Sie Daten aus verschiedenen Quellen korrelieren. Sie können diese Dimensionen für die Korrelation verwenden:
+ **IP** - `"ip": "10.0.0.1" | "ip": "**************"`
+ **Anschluss** - `"port": 2817 | "target_port": "10.0.0.1:80"`
Vorausgesetzt, Sie haben Zugriff auf zusätzliche Traces und Metrikindizes und sind mit Ihrer Schemastruktur vertraut, können Sie eine genauere Korrelationsabfrage erstellen.
Hier ist ein Beispiel für ein Trace-Indexdokument, das HTTP-Informationen enthält, die Sie möglicherweise korrelieren möchten:
```
{
"traceId": "c1d985bd02e1dbb85b444011f19a1ecc",
"spanId": "55a698828fe06a42",
"traceState": [],
"parentSpanId": "",
"name": "mysql",
"kind": "CLIENT",
"@timestamp": "2021-11-13T20:20:39+00:00",
"events": [
{
"@timestamp": "2021-03-25T17:21:03+00:00",
...
}
],
"links": [
{
"traceId": "c1d985bd02e1dbb85b444011f19a1ecc",
"spanId": "55a698828fe06a42w2",
},
"droppedAttributesCount": 0
}
],
"resource": {
"service@name": "database",
"telemetry@sdk@name": "opentelemetry",
"host@hostname": "ip-172-31-10-8.us-west-2.compute.internal"
},
"status": {
...
},
"attributes": {
"http": {
"user_agent": {
"original": "Mozilla/5.0"
},
"network": {
...
}
},
"request": {
...
}
},
"response": {
"status_code": "200",
"body": {
"size": 500
}
},
"client": {
"server": {
"socket": {
"address": "***********",
"domain": "example.com",
"port": 80
},
"address": "***********",
"port": 80
},
"resend_count": 0,
"url": {
"full": "http://example.com"
}
},
"server": {
"route": "/index",
"address": "***********",
"port": 8080,
"socket": {
...
},
"client": {
...
}
},
"url": {
...
}
}
}
}
}
```
Bei diesem Ansatz können Sie die `traceId` und die HTTPs sehen client/server `ip`, die mit den Elb-Protokollen korreliert werden können, um das Verhalten und den Zustand des Systems besser zu verstehen.
**Neuer Befehl zur Korrelationsabfrage**
Hier ist der neue Befehl, der diese Art von Untersuchung ermöglichen würde:
```
source alb_logs, traces | where alb_logs.ip="10.0.0.1" AND alb_logs.cloud.provider="aws"|
correlate exact fields(traceId, ip) scope(@timestamp, 1D) mapping(alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId )
```
Jeder Teil des Befehls macht Folgendes:
1. `source alb_logs, traces`- Dadurch werden die Datenquellen ausgewählt, die Sie korrelieren möchten.
1. `where ip="10.0.0.1" AND cloud.provider="aws"`- Dadurch wird der Umfang Ihrer Suche eingegrenzt.
1. `correlate exact fields(traceId, ip)`- Dadurch wird das System angewiesen, Daten auf der Grundlage exakter Übereinstimmungen der folgenden Felder zu korrelieren:
+ Das `ip` Feld hat eine explizite Filterbedingung, sodass es bei der Korrelation für alle Datenquellen verwendet wird.
+ Das `traceId` Feld hat keinen expliziten Filter, sodass es in allen Datenquellen mit denselben TraceIDs übereinstimmt.
Die Feldnamen geben die logische Bedeutung der Funktion innerhalb des Korrelationsbefehls an. Die tatsächliche Verbindungsbedingung hängt von der von Ihnen angegebenen Zuordnungsanweisung ab.
Der Begriff `exact` bedeutet, dass bei den Korrelationsanweisungen alle Felder übereinstimmen müssen, um die Abfrageanweisung zu erfüllen.
Der Begriff `approximate` wird versuchen, im besten Fall eine Übereinstimmung herzustellen, und Zeilen mit teilweisen Übereinstimmungen werden nicht zurückgewiesen.
**Adressierung unterschiedlicher Feldzuordnungen**
In Fällen, in denen dasselbe logische Feld (z. B.`ip`) in Ihren Datenquellen unterschiedliche Namen hat, müssen Sie die explizite Zuordnung von Pfadfeldern bereitstellen. Um dieses Problem zu lösen, können Sie Ihre Korrelationsbedingungen so erweitern, dass sie unterschiedlichen Feldnamen mit ähnlicher logischer Bedeutung entsprechen. So könnten Sie das tun:
```
alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId
```
Für jedes Feld, das an der Korrelationsverknüpfung beteiligt ist, sollten Sie eine entsprechende Zuordnungsanweisung angeben, die alle Tabellen enthält, die mit diesem Korrelationsbefehl verknüpft werden sollen.
**Beispiel**
In diesem Beispiel gibt es zwei Quellen: `alb_logs, traces`
Es gibt 2 Felder: `traceId, ip`
Es gibt 2 Zuordnungsanweisungen: `alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId`
**Festlegung des Zeitrahmens für die Korrelation**
Um die Arbeit der Ausführungs-Engine (Treiber) zu vereinfachen, können Sie die Scope-Anweisung hinzufügen. Dadurch wird die Verbindungsabfrage explizit auf den Zeitpunkt geleitet, zu dem sie für diese Suche gelten soll.
`scope(@timestamp, 1D)`i
In diesem Beispiel konzentriert sich der Suchbereich auf Tagesbasis, sodass Korrelationen, die am selben Tag auftreten, gruppiert werden. Dieser Scoping-Mechanismus vereinfacht und ermöglicht eine bessere Kontrolle der Ergebnisse und ermöglicht eine schrittweise Auflösung der Suche, die Ihren Anforderungen entspricht.
**Unterstützung von Treibern**
Der neue Korrelationsbefehl ist eigentlich ein „versteckter“ Join-Befehl. Daher unterstützen nur die folgenden PPL-Treiber diesen Befehl. In diesen Treibern wird der Korrelationsbefehl direkt in den entsprechenden logischen Catalyst Join-Plan übersetzt.
**Beispiel**
`source alb_logs, traces, metrics | where ip="10.0.0.1" AND cloud.provider="aws"| correlate exact on (ip, port) scope(@timestamp, 2018-07-02T22:23:00, 1 D)`
**Logischer Plan:**
```
'Project [*]
+- 'Join Inner, ('ip && 'port)
:- 'Filter (('ip === "10.0.0.1" & 'cloud.provider === "aws") & inTimeScope('@timestamp, "2018-07-02T22:23:00", "1 D"))
+- 'UnresolvedRelation [alb_logs]
+- 'Join Inner, ('ip & 'port)
:- 'Filter (('ip === "10.0.0.1" & 'cloud.provider === "aws") & inTimeScope('@timestamp, "2018-07-02T22:23:00", "1 D"))
+- 'UnresolvedRelation [traces]
+- 'Filter (('ip === "10.0.0.1" & 'cloud.provider === "aws") & inTimeScope('@timestamp, "2018-07-02T22:23:00", "1 D"))
+- 'UnresolvedRelation [metrics]
```
Die Catalyst-Engine optimiert diese Abfrage entsprechend der effizientesten Join-Reihenfolge.
#### Befehl dedup
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Verwenden Sie den `dedup` Befehl, um identische Dokumente basierend auf bestimmten Feldern aus Ihren Suchergebnissen zu entfernen.
**Syntax**
Verwenden Sie die folgende Syntax:
```
dedup [int] [keepempty=] [consecutive=]
```
**`int`**
+ Optional.
+ Der `dedup` Befehl behält mehrere Ereignisse für jede Kombination bei, wenn Sie dies angeben. Die Zahl für muss größer als 0 sein. Wenn Sie keine Zahl angeben, wird nur das erste Ereignis beibehalten. Alle anderen Duplikate werden aus den Ergebnissen entfernt.
+ Standard: 1
**`keepempty`**
+ Optional.
+ Falls wahr, werden Dokumente beibehalten, in denen ein Feld in der Feldliste einen NULL-Wert hat oder FEHLT.
+ Standard: false
**`consecutive`**
+ Optional.
+ Wenn der Wert wahr ist, werden nur Ereignisse mit aufeinanderfolgenden doppelten Wertekombinationen entfernt.
+ Standard: false
**`field-list`**
+ Zwingend erforderlich.
+ Eine durch Kommas getrennte Liste von Feldern. Es ist mindestens ein Feld erforderlich.
**Beispiel 1: Deduplizierung nach einem Feld**
Dieses Beispiel zeigt, wie Dokumente mithilfe des Felds „Geschlecht“ dedupliziert werden.
PPL-Abfrage:
```
os> source=accounts | dedup gender | fields account_number, gender;
fetched rows / total rows = 2/2
+------------------+----------+
| account_number | gender |
|------------------+----------|
| 1 | M |
| 13 | F |
+------------------+----------+
```
**Beispiel 2: Behalte 2 doppelte Dokumente**
Das Beispiel zeigt, wie Dokumente mit dem Feld Geschlecht dedupliziert werden, wobei zwei Duplikate beibehalten werden.
PPL-Abfrage:
```
os> source=accounts | dedup 2 gender | fields account_number, gender;
fetched rows / total rows = 3/3
+------------------+----------+
| account_number | gender |
|------------------+----------|
| 1 | M |
| 6 | M |
| 13 | F |
+------------------+----------+
```
**Beispiel 3: Behalten oder ignorieren Sie das leere Feld standardmäßig**
Das Beispiel zeigt, wie das Dokument dedupliziert wird, indem das Nullwertfeld beibehalten wird.
PPL-Abfrage:
```
os> source=accounts | dedup email keepempty=true | fields account_number, email;
fetched rows / total rows = 4/4
+------------------+-----------------------+
| account_number | email |
+------------------+-----------------------+
| 1 | john_doe@example.com |
| 6 | jane_doe@example.com |
| 13 | null |
| 18 | juan_li@example.com |
+------------------+-----------------------+
```
Das Beispiel zeigt, wie das Dokument dedupliziert wird, indem das leere Wertfeld ignoriert wird.
PPL-Abfrage:
```
os> source=accounts | dedup email | fields account_number, email;
fetched rows / total rows = 3/3
+------------------+-----------------------+
| account_number | email |
+------------------+-----------------------+
| 1 | john_doe@example.com |
| 6 | jane_doe@example.com |
| 18 | juan_li@example.com |
+------------------+-----------------------+
```
**Beispiel 4: Dedup in aufeinanderfolgenden Dokumenten**
Das Beispiel zeigt, wie man in aufeinanderfolgenden Dokumenten dedupliziert.
PPL-Abfrage:
```
os> source=accounts | dedup gender consecutive=true | fields account_number, gender;
fetched rows / total rows = 3/3
+------------------+----------+
| account_number | gender |
+------------------+----------+
| 1 | M |
| 13 | F |
| 18 | M |
+------------------+----------+
```
**Weitere Beispiele**
+ `source = table | dedup a | fields a,b,c`
+ `source = table | dedup a,b | fields a,b,c`
+ `source = table | dedup a keepempty=true | fields a,b,c`
+ `source = table | dedup a,b keepempty=true | fields a,b,c`
+ `source = table | dedup 1 a | fields a,b,c`
+ `source = table | dedup 1 a,b | fields a,b,c`
+ `source = table | dedup 1 a keepempty=true | fields a,b,c`
+ `source = table | dedup 1 a,b keepempty=true | fields a,b,c`
+ `source = table | dedup 2 a | fields a,b,c`
+ `source = table | dedup 2 a,b | fields a,b,c`
+ `source = table | dedup 2 a keepempty=true | fields a,b,c`
+ `source = table | dedup 2 a,b keepempty=true | fields a,b,c`
+ `source = table | dedup 1 a consecutive=true| fields a,b,c`(aufeinanderfolgende Deduplizierung wird nicht unterstützt)
**Einschränkung**
+ Für `| dedup 2 a, b keepempty=false`
```
DataFrameDropColumns('_row_number_)
+- Filter ('_row_number_ <= 2) // allowed duplication = 2
+- Window [row_number() windowspecdefinition('a, 'b, 'a ASC NULLS FIRST, 'b ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS _row_number_], ['a, 'b], ['a ASC NULLS FIRST, 'b ASC NULLS FIRST]
+- Filter (isnotnull('a) AND isnotnull('b)) // keepempty=false
+- Project
+- UnresolvedRelation
```
+ Für `| dedup 2 a, b keepempty=true`
```
Union
:- DataFrameDropColumns('_row_number_)
: +- Filter ('_row_number_ <= 2)
: +- Window [row_number() windowspecdefinition('a, 'b, 'a ASC NULLS FIRST, 'b ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS _row_number_], ['a, 'b], ['a ASC NULLS FIRST, 'b ASC NULLS FIRST]
: +- Filter (isnotnull('a) AND isnotnull('b))
: +- Project
: +- UnresolvedRelation
+- Filter (isnull('a) OR isnull('b))
+- Project
+- UnresolvedRelation
```
#### Befehl beschreiben
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Verwenden Sie den `describe` Befehl, um detaillierte Informationen zur Struktur und zu den Metadaten von Tabellen, Schemas und Katalogen abzurufen. Im Folgenden finden Sie verschiedene Beispiele und Anwendungsfälle für den `describe` Befehl.
**Describe**
+ `describe table`Dieser Befehl entspricht dem `DESCRIBE EXTENDED table` SQL-Befehl
+ `describe schema.table`
+ `describe schema.`table``
+ `describe catalog.schema.table`
+ `describe catalog.schema.`table``
+ `describe `catalog`.`schema`.`table``
#### Befehl eval
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Der `eval` Befehl wertet den Ausdruck aus und fügt das Ergebnis an das Suchergebnis an.
**Syntax**
Verwenden Sie die folgende Syntax:
```
eval = ["," = ]...
```
+ `field`: Obligatorisch. Wenn der Feldname nicht existiert, wird ein neues Feld hinzugefügt. Wenn der Feldname bereits existiert, wird er überschrieben.
+ `expression`: Obligatorisch. Jeder Ausdruck, der vom System unterstützt wird.
**Beispiel 1: Erstellen Sie das neue Feld**
Dieses Beispiel zeigt, wie Sie für jedes Dokument ein neues `doubleAge` Feld erstellen. Das neue `doubleAge` ist das Bewertungsergebnis des Alters multipliziert mit 2.
PPL-Abfrage:
```
os> source=accounts | eval doubleAge = age * 2 | fields age, doubleAge ;
fetched rows / total rows = 4/4
+-------+-------------+
| age | doubleAge |
|-------+-------------|
| 32 | 64 |
| 36 | 72 |
| 28 | 56 |
| 33 | 66 |
+-------+-------------+
```
**Beispiel 2: Überschreiben Sie das bestehende Feld**
Dieses Beispiel zeigt, wie das bestehende Altersfeld mit Alter plus 1 überschrieben wird.
PPL-Abfrage:
```
os> source=accounts | eval age = age + 1 | fields age ;
fetched rows / total rows = 4/4
+-------+
| age |
|-------|
| 33 |
| 37 |
| 29 |
| 34 |
+-------+
```
**Beispiel 3: Erstellen Sie das neue Feld mit dem in Eval definierten Feld**
Dieses Beispiel zeigt, wie ein neues `ddAge` Feld mit einem im Befehl eval definierten Feld erstellt wird. Das neue Feld `ddAge` ist das Auswertungsergebnis `doubleAge` multipliziert mit 2, wobei `doubleAge` es im Befehl eval definiert ist.
PPL-Abfrage:
```
os> source=accounts | eval doubleAge = age * 2, ddAge = doubleAge * 2 | fields age, doubleAge, ddAge ;
fetched rows / total rows = 4/4
+-------+-------------+---------+
| age | doubleAge | ddAge |
|-------+-------------+---------|
| 32 | 64 | 128 |
| 36 | 72 | 144 |
| 28 | 56 | 112 |
| 33 | 66 | 132 |
+-------+-------------+---------+
```
Annahmen:`a`,`b`, `c` sind vorhandene Felder in `table`
**Weitere Beispiele**
+ `source = table | eval f = 1 | fields a,b,c,f`
+ `source = table | eval f = 1`(gibt A-, B-, C- und F-Felder aus)
+ `source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t`
+ `source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5`
+ `source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = b | stats avg(f) by h`
+ `source = table | eval f = ispresent(a)`
+ `source = table | eval r = coalesce(a, b, c) | fields r`
+ `source = table | eval e = isempty(a) | fields e`
+ `source = table | eval e = isblank(a) | fields e`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))`
+ `source = table | eval f = a in ('foo', 'bar') | fields f`
+ `source = table | eval f = a not in ('foo', 'bar') | fields f`
**Bewertung mit Fallbeispiel:**
```
source = table | eval e = eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Unknown')
```
**Eval mit einem anderen Fallbeispiel:**
Annahmen:`a`,`b`, `c` sind existierende Felder in `table`
**Weitere Beispiele**
+ `source = table | eval f = 1 | fields a,b,c,f`
+ `source = table | eval f = 1`(gibt A-, B-, C- und F-Felder aus)
+ `source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t`
+ `source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5`
+ `source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = b | stats avg(f) by h`
+ `source = table | eval f = ispresent(a)`
+ `source = table | eval r = coalesce(a, b, c) | fields r`
+ `source = table | eval e = isempty(a) | fields e`
+ `source = table | eval e = isblank(a) | fields e`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))`
+ `source = table | eval f = a in ('foo', 'bar') | fields f`
+ `source = table | eval f = a not in ('foo', 'bar') | fields f`
**Bewertung mit Fallbeispiel:**
```
source = table | eval e = eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Unknown')
```
**Eval mit einem anderen Fallbeispiel:**
```
source = table | where ispresent(a) |
eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code'
)
| stats count() by status_category
```
**Einschränkungen**
+ Das Überschreiben vorhandener Felder wird nicht unterstützt. Abfragen, die dies versuchen, lösen Ausnahmen mit der Meldung „Die Referenz 'a' ist mehrdeutig“ aus.
```
- `source = table | eval a = 10 | fields a,b,c`
- `source = table | eval a = a * 2 | stats avg(a)`
- `source = table | eval a = abs(a) | where a > 0`
- `source = table | eval a = signum(a) | where a < 0`
```
#### Befehl eventstats
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Verwenden Sie den `eventstats` Befehl, um Ihre Ereignisdaten mit berechneten Übersichtsstatistiken anzureichern. Dabei werden bestimmte Felder innerhalb Ihrer Ereignisse analysiert, verschiedene statistische Kennzahlen berechnet und diese Ergebnisse dann als neue Felder an jedes ursprüngliche Ereignis angehängt.
**Die wichtigsten Aspekte von Eventstats**
1. Es führt Berechnungen für den gesamten Ergebnissatz oder innerhalb definierter Gruppen durch.
1. Die ursprünglichen Ereignisse bleiben erhalten, und es werden neue Felder hinzugefügt, um die statistischen Ergebnisse zu enthalten.
1. Der Befehl ist besonders nützlich für vergleichende Analysen, die Identifizierung von Ausreißern oder die Bereitstellung von zusätzlichem Kontext für einzelne Ereignisse.
**Unterschied zwischen Stats und Eventstats**
Die `eventstats` Befehle `stats` und werden beide zur Berechnung von Statistiken verwendet, weisen jedoch einige wesentliche Unterschiede in ihrer Funktionsweise und ihrem Ergebnis auf.
**Ausgabeformat**
+ `stats`: Erzeugt eine Übersichtstabelle, die nur die berechneten Statistiken enthält.
+ `eventstats`: Fügt die berechneten Statistiken als neue Felder zu den vorhandenen Ereignissen hinzu, wobei die Originaldaten erhalten bleiben.
**Aufbewahrung von Ereignissen**
+ `stats`: Reduziert die Ergebnismenge auf die statistische Zusammenfassung, wobei einzelne Ereignisse verworfen werden.
+ `eventstats`: Behält alle ursprünglichen Ereignisse bei und fügt neue Felder mit den berechneten Statistiken hinzu.
**Anwendungsfälle**
+ `stats`: Am besten für die Erstellung von Übersichtsberichten oder Dashboards geeignet. Wird oft als letzter Befehl verwendet, um Ergebnisse zusammenzufassen.
+ `eventstats`: Nützlich, wenn Sie Ereignisse zur weiteren Analyse oder Filterung mit statistischem Kontext anreichern müssen. Kann während der Suche verwendet werden, um Statistiken hinzuzufügen, die in nachfolgenden Befehlen verwendet werden können.
**Syntax**
Verwenden Sie die folgende Syntax:
```
eventstats ... [by-clause]
```
**Aggregation**
+ Zwingend erforderlich.
+ Eine Aggregationsfunktion.
+ Das Argument der Aggregation muss ein Feld sein.
**Nebenklausel**
+ Optional.
+ Syntax: `by [span-expression,] [field,]...`
+ Die by-Klausel kann Felder und Ausdrücke wie Skalarfunktionen und Aggregationsfunktionen enthalten. Sie können die Span-Klausel auch verwenden, um ein bestimmtes Feld in Gruppen mit gleichen Intervallen aufzuteilen. Der Befehl eventstats führt dann eine Aggregation auf der Grundlage dieser Span-Buckets durch.
+ Standard: Wenn Sie keine by-Klausel angeben, aggregiert der Befehl eventstats die gesamte Ergebnismenge.
**Span-Ausdruck**
+ Fakultativ, höchstens einer.
+ Syntax: `span(field_expr, interval_expr)`
+ Die Einheit des Intervallausdrucks ist standardmäßig die natürliche Einheit. Für Felder vom Typ Datum und Uhrzeit müssen Sie jedoch die Einheit im Intervallausdruck angeben, wenn Sie Datums-/Uhrzeiteinheiten verwenden.
Um das Feld beispielsweise nach 10 Jahren `age` in Gruppen aufzuteilen, verwenden Sie. `span(age, 10)` Bei zeitbasierten Feldern können Sie ein `timestamp` Feld mithilfe von in stündliche Intervalle unterteilen. `span(timestamp, 1h)`
**Verfügbare Zeiteinheiten**
| Einheiten für das Spanenintervall |
| --- |
| Millisekunde (ms) |
| Sekunde (n) |
| Minute (m, Groß- und Kleinschreibung beachten) |
| Stunde (h) |
| Tag (d) |
| Woche (w) |
| Monat (M, Groß- und Kleinschreibung beachten) |
| Quartal (q) |
| Jahr (y) |
**Aggregationsfunktionen**
**`COUNT`**
`COUNT`gibt die Anzahl der Ausdrücke in den Zeilen zurück, die mit einer SELECT-Anweisung abgerufen wurden.
Verwenden Sie Abfragen für CloudWatch Logs, `COUNT` wird nicht unterstützt.
Beispiel:
```
os> source=accounts | eventstats count();
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+--------------------+------------+--------------------------+--------+-------+---------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | count() |
+----------------+----------+-----------+----------+-----+--------+--------------------+------------+--------------------------+--------+-------+---------+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 4 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | AnyCompany | marymajor@anycompany.com | Dante | TN | 4 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 4 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 4 |
+----------------+----------+-----------+----------+-----+--------+--------------------+------------+--------------------------+--------+-------+---------+
```
**`SUM`**
`SUM(expr)`gibt die Summe von expr zurück.
Beispiel:
```
os> source=accounts | eventstats sum(age) by gender;
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+--------------------------+--------+-------+--------------------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | sum(age) by gender |
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+--------------------------+--------+-------+--------------------+
| 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 101 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | AnyCompany | marymajor@anycompany.com | Dante | TN | 101 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 28 |
| 18 | 4180 | Juan | Li | 33 | M | 467 Example Court | | juanli@exampleorg.com | Orick | MD | 101 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+--------------------------+--------+-------+--------------------+
```
**`AVG`**
`AVG(expr)`gibt den Durchschnittswert von expr zurück.
Beispiel:
```
os> source=accounts | eventstats avg(age) by gender;
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+---------------------------+--------+-------+--------------------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | avg(age) by gender |
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+---------------------------+--------+-------+--------------------+
| 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 33.67 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 33.67 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 28.00 |
| 18 | 4180 | Juan | Li | 33 | M | 467 Example Court | | juanli@exampleorg.com | Orick | MD | 33.67 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------+
```
**MAX**
`MAX(expr)`Gibt den Maximalwert von expr zurück.
Beispiel
```
os> source=accounts | eventstats max(age);
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | max(age) |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
| 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 36 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 36 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 36 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 36 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
```
**MIN**
`MIN(expr)`Gibt den Minimalwert von expr zurück.
Beispiel
```
os> source=accounts | eventstats min(age);
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | min(age) |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
| 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 28 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 28 |
| 13 | 32838 | Nikki | Wolf | 28 | F | *** Any Street | AnyOrg | | Nogal | VA | 28 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 28 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
```
**STDDEV\$1SAMP**
`STDDEV_SAMP(expr)`Gibt die Standardabweichung der Stichprobe von expr zurück.
Beispiel
```
os> source=accounts | eventstats stddev_samp(age);
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | stddev_samp(age) |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 3.304037933599835 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 3.304037933599835 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 3.304037933599835 |
| 18 | 4180 | Juan | Li | 33 | M | 467 Example Court | | juanli@exampleorg.com | Orick | MD | 3.304037933599835 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
```
**STDDEV\$1POP**
`STDDEV_POP(expr)`Gibt die Standardabweichung der Grundgesamtheit von expr zurück.
Beispiel
```
os> source=accounts | eventstats stddev_pop(age);
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | stddev_pop(age) |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 2.**************** |
| 6 | 5686 | Mary | Major | 36 | M | *** Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 2.**************** |
| 13 | 32838 | Nikki | Wolf | 28 | F | *** Any Street | AnyOrg | | Nogal | VA | 2.**************** |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 2.**************** |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
```
**PERCENTILE oder PERCENTILE\$1APPROX**
`PERCENTILE(expr, percent)`oder `PERCENTILE_APPROX(expr, percent)` Gibt den ungefähren Perzentilwert von expr zum angegebenen Prozentsatz zurück.
**Prozent**
+ Die Zahl muss eine Konstante zwischen 0 und 100 sein.
Beispiel
```
os> source=accounts | eventstats percentile(age, 90) by gender;
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------------------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | percentile(age, 90) by gender |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------------------+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 36 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 36 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 28 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 36 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------------------+
```
**Beispiel 1: Berechnet den Durchschnitt, die Summe und die Anzahl eines Felds nach Gruppen**
Das Beispiel zeigt die Berechnung des Durchschnittsalters, der Summe des Alters und der Anzahl der Ereignisse aller Konten, gruppiert nach Geschlecht.
```
os> source=accounts | eventstats avg(age) as avg_age, sum(age) as sum_age, count() as count by gender;
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+-----------+-------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | avg_age | sum_age | count |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+-----------+-------+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 33.666667 | 101 | 3 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 33.666667 | 101 | 3 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 28.000000 | 28 | 1 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 33.666667 | 101 | 3 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+-----------+-------+
```
**Beispiel 2: Berechne die Anzahl anhand einer Spanne**
In diesem Beispiel wird die Anzahl der Altersstufen im Intervall von 10 Jahren berechnet.
```
os> source=accounts | eventstats count(age) by span(age, 10) as age_span
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+----------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | age_span |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+----------+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 3 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 3 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 1 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 3 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+----------+
```
**Beispiel 3: Berechnet die Anzahl anhand eines Geschlechts und einer Spanne**
Im Beispiel wird die Anzahl der Altersgruppen im Intervall von 5 Jahren berechnet und nach Geschlecht gruppiert.
```
os> source=accounts | eventstats count() as cnt by span(age, 5) as age_span, gender
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | cnt |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 2 |
| 6 | 5686 | Mary | Majo | 36 | M | 671 Example Street | Any Company | hattiebond@anycompany.com | Dante | TN | 1 |
| 13 | 32838 | Nikki | Wolf | 28 | F | *** Any Street | AnyOrg | | Nogal | VA | 1 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 2 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+
```
**Usage**
+ `source = table | eventstats avg(a)`
+ `source = table | where a < 50 | eventstats avg(c)`
+ `source = table | eventstats max(c) by b`
+ `source = table | eventstats count(c) by b | head 5`
+ `source = table | eventstats distinct_count(c)`
+ `source = table | eventstats stddev_samp(c)`
+ `source = table | eventstats stddev_pop(c)`
+ `source = table | eventstats percentile(c, 90)`
+ `source = table | eventstats percentile_approx(c, 99)`
**Aggregationen mit Span**
+ `source = table | eventstats count(a) by span(a, 10) as a_span`
+ `source = table | eventstats sum(age) by span(age, 5) as age_span | head 2`
+ `source = table | eventstats avg(age) by span(age, 20) as age_span, country | sort - age_span | head 2`
**Aggregationen mit Zeitfensterspanne (Tumble-Windowing-Funktion)**
+ `source = table | eventstats sum(productsAmount) by span(transactionDate, 1d) as age_date | sort age_date`
+ `source = table | eventstats sum(productsAmount) by span(transactionDate, 1w) as age_date, productId`
**Aggregationen werden nach mehreren Ebenen gruppiert**
+ `source = table | eventstats avg(age) as avg_state_age by country, state | eventstats avg(avg_state_age) as avg_country_age by country`
+ `source = table | eventstats avg(age) as avg_city_age by country, state, city | eval new_avg_city_age = avg_city_age - 1 | eventstats avg(new_avg_city_age) as avg_state_age by country, state | where avg_state_age > 18 | eventstats avg(avg_state_age) as avg_adult_country_age by country`
#### Befehl erweitern
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Verwenden Sie den `expand` Befehl, um ein Feld des folgenden Typs zu reduzieren:
+ `Array`
+ `Map`
**Syntax**
Verwenden Sie die folgende Syntax:
```
expand [As alias]
```
**field**
+ Das Feld, das erweitert (aufgelöst) werden soll. Muss von einem unterstützten Typ sein.
**alias**
+ Optional. Der Name, der anstelle des ursprünglichen Feldnamens verwendet werden soll.
**Usage**
Der `expand` Befehl erzeugt eine Zeile für jedes Element im angegebenen Array- oder Zuordnungsfeld, wobei:
+ Array-Elemente werden zu einzelnen Zeilen.
+ Map-Schlüssel-Wert-Paare werden in separate Zeilen aufgeteilt, wobei jeder Schlüsselwert als Zeile dargestellt wird.
+ Wenn ein Alias angegeben wird, werden die explodierten Werte unter dem Alias statt unter dem ursprünglichen Feldnamen dargestellt.
+ Dies kann in Kombination mit anderen Befehlen wie, und verwendet werden `stats``eval`, um Daten nach der `parse` Erweiterung zu bearbeiten oder zu extrahieren.
**Beispiele**
+ `source = table | expand employee | stats max(salary) as max by state, company`
+ `source = table | expand employee as worker | stats max(salary) as max by state, company`
+ `source = table | expand employee as worker | eval bonus = salary * 3 | fields worker, bonus`
+ `source = table | expand employee | parse description '(?.+@.+)' | fields employee, email`
+ `source = table | eval array=json_array(1, 2, 3) | expand array as uid | fields name, occupation, uid`
+ `source = table | expand multi_valueA as multiA | expand multi_valueB as multiB`
#### Befehl erläutern
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Der `explain` Befehl hilft Ihnen dabei, die Ausführungspläne für Abfragen zu verstehen, sodass Sie Ihre Abfragen analysieren und optimieren können, um eine bessere Leistung zu erzielen. Diese Einführung bietet einen kurzen Überblick über den Zweck des Befehls explain und seine Bedeutung für die Abfrageoptimierung.
**Comment**
+ `source=accounts | top gender // finds most common gender of all the accounts`(Kommentar zur Zeile)
+ `source=accounts | dedup 2 gender /* dedup the document with gender field keep 2 duplication */ | fields account_number, gender`(Kommentar blockieren)
**Describe**
+ `describe table`Dieser Befehl entspricht dem `DESCRIBE EXTENDED table` SQL-Befehl
+ `describe schema.table`
+ `describe schema.`table``
+ `describe catalog.schema.table`
+ `describe catalog.schema.`table``
+ `describe `catalog`.`schema`.`table``
**Explain**
+ `explain simple | source = table | where a = 1 | fields a,b,c`
+ `explain extended | source = table`
+ `explain codegen | source = table | dedup a | fields a,b,c`
+ `explain cost | source = table | sort a | fields a,b,c`
+ `explain formatted | source = table | fields - a`
+ `explain simple | describe table`
**Felder**
+ `source = table`
+ `source = table | fields a,b,c`
+ `source = table | fields + a,b,c`
+ `source = table | fields - b,c`
+ `source = table | eval b1 = b | fields - b1,c`
**Zusammenfassung der Felder**
+ `source = t | fieldsummary includefields=status_code nulls=false`
+ `source = t | fieldsummary includefields= id, status_code, request_path nulls=true`
+ `source = t | where status_code != 200 | fieldsummary includefields= status_code nulls=true`
**Verschachteltes Feld**
+ `source = catalog.schema.table1, catalog.schema.table2 | fields A.nested1, B.nested1`
+ `source = catalog.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield`
+ `source = catalog.schema.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield`
**Filter**
+ `source = table | where a = 1 | fields a,b,c`
+ `source = table | where a >= 1 | fields a,b,c`
+ `source = table | where a < 1 | fields a,b,c`
+ `source = table | where b != 'test' | fields a,b,c`
+ `source = table | where c = 'test' | fields a,b,c | head 3`
+ `source = table | where ispresent(b)`
+ `source = table | where isnull(coalesce(a, b)) | fields a,b,c | head 3`
+ `source = table | where isempty(a)`
+ `source = table | where isblank(a)`
+ `source = table | where case(length(a) > 6, 'True' else 'False') = 'True'`
+ `source = table | where a not in (1, 2, 3) | fields a,b,c`
+ `source = table | where a between 1 and 4`- Hinweis: Dies gibt a >= 1 und a <= 4 zurück, d. h. [1, 4]
+ `source = table | where b not between '2024-09-10' and '2025-09-10'`- Hinweis: Dies gibt b >= '\$1\$1\$1\$1\$1\$1\$1\$1\$1\$1' und b <= '2025-09-10' zurück
+ `source = table | where cidrmatch(ip, '***********/24')`
+ `source = table | where cidrmatch(ipv6, '2003:db8::/32')`
+ `source = table | trendline sma(2, temperature) as temp_trend`
**IP-bezogene Abfragen**
+ `source = table | where cidrmatch(ip, '**************')`
+ `source = table | where isV6 = false and isValid = true and cidrmatch(ipAddress, '**************')`
+ `source = table | where isV6 = true | eval inRange = case(cidrmatch(ipAddress, '2003:***::/32'), 'in' else 'out') | fields ip, inRange`
**Komplexe Filter**
```
source = table | eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code')
| where case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code'
) = 'Incorrect HTTP status code'
```
```
source = table
| eval factor = case(a > 15, a - 14, isnull(b), a - 7, a < 3, a + 1 else 1)
| where case(factor = 2, 'even', factor = 4, 'even', factor = 6, 'even', factor = 8, 'even' else 'odd') = 'even'
| stats count() by factor
```
**Filter mit logischen Bedingungen**
+ `source = table | where c = 'test' AND a = 1 | fields a,b,c`
+ `source = table | where c != 'test' OR a > 1 | fields a,b,c | head 1`
+ `source = table | where c = 'test' NOT a > 1 | fields a,b,c`
**Eval**
Annahmen:`a`,`b`, `c` sind bestehende Felder in `table`
+ `source = table | eval f = 1 | fields a,b,c,f`
+ `source = table | eval f = 1`(gibt A-, B-, C- und F-Felder aus)
+ `source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t`
+ `source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5`
+ `source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = b | stats avg(f) by h`
+ `source = table | eval f = ispresent(a)`
+ `source = table | eval r = coalesce(a, b, c) | fields r`
+ `source = table | eval e = isempty(a) | fields e`
+ `source = table | eval e = isblank(a) | fields e`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))`
+ `source = table | eval digest = md5(fieldName) | fields digest`
+ `source = table | eval digest = sha1(fieldName) | fields digest`
+ `source = table | eval digest = sha2(fieldName,256) | fields digest`
+ `source = table | eval digest = sha2(fieldName,512) | fields digest`
#### Befehl fillnull
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
**Description**
Verwenden Sie den `fillnull` Befehl, um Nullwerte in einem oder mehreren Feldern Ihrer Suchergebnisse durch einen bestimmten Wert zu ersetzen.
**Syntax**
Verwenden Sie die folgende Syntax:
```
fillnull [with in ["," ]] | [using = ["," = ]]
```
+ Null-Replacement: Obligatorisch. Der Wert, der verwendet wird, um Nullwerte zu ersetzen.
+ nullable-field: Obligatorisch. Feldreferenz. Die Nullwerte in diesem Feld werden durch den unter Null-Replacement angegebenen Wert ersetzt.
**Beispiel 1: Füllen Sie ein Feld mit Null aus**
Das Beispiel zeigt, wie Fillnull für ein einzelnes Feld verwendet wird:
```
os> source=logs | fields status_code | eval input=status_code | fillnull with 0 in status_code;
| input | status_code |
|-------|-------------|
| 403 | 403 |
| 403 | 403 |
| NULL | 0 |
| NULL | 0 |
| 200 | 200 |
| 404 | 404 |
| 500 | 500 |
| NULL | 0 |
| 500 | 500 |
| 404 | 404 |
| 200 | 200 |
| 500 | 500 |
| NULL | 0 |
| NULL | 0 |
| 404 | 404 |
```
**Beispiel 2: Fillnull wurde auf mehrere Felder angewendet**
Das Beispiel zeigt, dass Fillnull auf mehrere Felder angewendet wurde.
```
os> source=logs | fields request_path, timestamp | eval input_request_path=request_path, input_timestamp = timestamp | fillnull with '???' in request_path, timestamp;
| input_request_path | input_timestamp | request_path | timestamp |
|------------------------------------------------------------------------------------|
| /contact | NULL | /contact | ??? |
| /home | NULL | /home | ??? |
| /about | 2023-10-01 10:30:00 | /about | 2023-10-01 10:30:00 |
| /home | 2023-10-01 10:15:00 | /home | 2023-10-01 10:15:00 |
| NULL | 2023-10-01 10:20:00 | ??? | 2023-10-01 10:20:00 |
| NULL | 2023-10-01 11:05:00 | ??? | 2023-10-01 11:05:00 |
| /about | NULL | /about | ??? |
| /home | 2023-10-01 10:00:00 | /home | 2023-10-01 10:00:00 |
| /contact | NULL | /contact | ??? |
| NULL | 2023-10-01 10:05:00 | ??? | 2023-10-01 10:05:00 |
| NULL | 2023-10-01 10:50:00 | ??? | 2023-10-01 10:50:00 |
| /services | NULL | /services | ??? |
| /home | 2023-10-01 10:45:00 | /home | 2023-10-01 10:45:00 |
| /services | 2023-10-01 11:00:00 | /services | 2023-10-01 11:00:00 |
| NULL | 2023-10-01 10:35:00 | ??? | 2023-10-01 10:35:00 |
```
**Beispiel 3: Fillnull wurde auf mehrere Felder mit verschiedenen Null-Ersatzwerten angewendet.**
Das Beispiel zeigt Fillnull mit verschiedenen Werten, die verwendet werden, um Nullen zu ersetzen.
+ `/error`im `request_path` Feld
+ `1970-01-01 00:00:00`im `timestamp` Feld
```
os> source=logs | fields request_path, timestamp | eval input_request_path=request_path, input_timestamp = timestamp | fillnull using request_path = '/error', timestamp='1970-01-01 00:00:00';
| input_request_path | input_timestamp | request_path | timestamp |
|------------------------------------------------------------------------------------|
| /contact | NULL | /contact | 1970-01-01 00:00:00 |
| /home | NULL | /home | 1970-01-01 00:00:00 |
| /about | 2023-10-01 10:30:00 | /about | 2023-10-01 10:30:00 |
| /home | 2023-10-01 10:15:00 | /home | 2023-10-01 10:15:00 |
| NULL | 2023-10-01 10:20:00 | /error | 2023-10-01 10:20:00 |
| NULL | 2023-10-01 11:05:00 | /error | 2023-10-01 11:05:00 |
| /about | NULL | /about | 1970-01-01 00:00:00 |
| /home | 2023-10-01 10:00:00 | /home | 2023-10-01 10:00:00 |
| /contact | NULL | /contact | 1970-01-01 00:00:00 |
| NULL | 2023-10-01 10:05:00 | /error | 2023-10-01 10:05:00 |
| NULL | 2023-10-01 10:50:00 | /error | 2023-10-01 10:50:00 |
| /services | NULL | /services | 1970-01-01 00:00:00 |
| /home | 2023-10-01 10:45:00 | /home | 2023-10-01 10:45:00 |
| /services | 2023-10-01 11:00:00 | /services | 2023-10-01 11:00:00 |
| NULL | 2023-10-01 10:35:00 | /error | 2023-10-01 10:35:00 |
```
#### Befehl „Felder“
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Verwenden Sie den `fields` Befehl, um Felder im Suchergebnis beizubehalten oder zu entfernen.
**Syntax**
Verwenden Sie die folgende Syntax:
```
field [+|-]
```
+ `index`: Optional.
Wenn das Plus (\$1) verwendet wird, werden nur die in der Feldliste angegebenen Felder beibehalten.
Wenn das Minuszeichen (-) verwendet wird, werden alle in der Feldliste angegebenen Felder entfernt.
*Standard*: \$1
+ `field list`: Obligatorisch. Eine durch Kommas getrennte Liste von Feldern, die beibehalten oder entfernt werden sollen.
**Beispiel 1: Wählen Sie bestimmte Felder aus dem Ergebnis aus**
Dieses Beispiel zeigt, wie `lastname` Felder `account_number``firstname`, und aus Suchergebnissen abgerufen werden.
PPL-Abfrage:
```
os> source=accounts | fields account_number, firstname, lastname;
fetched rows / total rows = 4/4
+------------------+-------------+------------+
| account_number | firstname | lastname |
|------------------+-------------+------------|
| 1 | Jane | Doe |
| 6 | John | Doe |
| 13 | Jorge | Souza |
| 18 | Juan | Li |
+------------------+-------------+------------+
```
**Beispiel 2: Ausgewählte Felder aus dem Ergebnis entfernen**
Dieses Beispiel zeigt, wie das `account_number` Feld aus den Suchergebnissen entfernt wird.
PPL-Abfrage:
```
os> source=accounts | fields account_number, firstname, lastname | fields - account_number ;
fetched rows / total rows = 4/4
+-------------+------------+
| firstname | lastname |
|-------------+------------|
| Jane | Doe |
| John | Doe |
| Jorge | Souza |
| Juan | Li |
+-------------+------------+
```
**Weitere Beispiele**
+ `source = table`
+ `source = table | fields a,b,c`
+ `source = table | fields + a,b,c`
+ `source = table | fields - b,c`
+ `source = table | eval b1 = b | fields - b1,c`
Beispiel für verschachtelte Felder:
```
`source = catalog.schema.table1, catalog.schema.table2 | fields A.nested1, B.nested1`
`source = catalog.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield`
`source = catalog.schema.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield`
```
#### Befehl flatten
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Verwenden Sie den Befehl flatten, um Felder der folgenden Typen zu erweitern:
+ `struct`
+ `array>`
**Syntax**
Verwenden Sie die folgende Syntax:
```
flatten
```
+ *Feld*: Das Feld, das reduziert werden soll. Das Feld muss einen unterstützten Typ haben.
**Schema**
| col\$1name | data\$1type |
| --- | --- |
| \$1Zeit | Zeichenfolge |
| Brücken | array |
| city | Zeichenfolge |
| Farbe | Struktur |
| country | Zeichenfolge |
**Daten**
| \$1Zeit | Brücken | city | Tür | country |
| --- | --- | --- | --- | --- |
| 2024-09-13T 12:00:00 | [\$1801, Tower Bridge\$1, \$1928, London Bridge\$1] | London | \$135, 51,5074, -0,1278\$1 | England |
| 2024-09-13T 12:00:00 | [\$1232, Pont Neuf\$1, \$1160, Pont Alexandre III\$1] | Paris | \$135, 48,8566, 2,3522\$1 | Frankreich |
| 2024-09-13T 12:00:00 | [\$148, Rialtobrücke\$1, \$111, Seufzerbrücke\$1] | Venedig | \$12, 45.4408, 12.3155\$1 | Italien |
| 2024-09-13T 12:00:00 | [\$1\$1\$1\$1, Karlsbrücke\$1, \$1343, Legionsbrücke\$1] | Prag | \$1200, 50,0755, 14,4378\$1 | Tschechische Republik |
| 2024-09-13T 12:00:00 | [\$1375, Kettenbrücke\$1, \$1333, Liberty Bridge\$1] | Budapest | \$196, 47,4979, 19,0402\$1 | Ungarn |
| 1990-09-13T 12:00:00 | NULL | Warschau | NULL | Polen |
**Beispiel 1: Struktur abflachen**
Dieses Beispiel zeigt, wie ein Strukturfeld geglättet wird.
PPL-Abfrage:
```
source=table | flatten coor
```
| \$1Zeit | Brücken | city | country | alt | lat | long |
| --- | --- | --- | --- | --- | --- | --- |
| 2024-09-13T 12:00:00 | [\$1801, Tower Bridge\$1, \$1928, London Bridge\$1] | London | England | 35 | 51,5074 | -0,1278 |
| 2024-09-13T 12:00:00 | [\$1232, Pont Neuf\$1, \$1160, Pont Alexandre III\$1] | Paris | Frankreich | 35 | 48,8566 | 2,3522 |
| 2024-09-13T 12:00:00 | [\$148, Rialtobrücke\$1, \$111, Seufzerbrücke\$1] | Venedig | Italien | 2 | 45.4408 | 12,3155 |
| 2024-09-13T 12:00:00 | [\$1516, Karlsbrücke\$1, \$1343, Legionsbrücke\$1] | Prag | Tschechische Republik | 200 | 50,0755 | 14,4378 |
| 2024-09-13T 12:00:00 | [\$1375, Kettenbrücke\$1, \$1333, Liberty Bridge\$1] | Budapest | Ungarn | 96 | 47,4979 | 19,0402 |
| 1990-09-13T 12:00:00 | NULL | Warschau | Polen | NULL | NULL | NULL |
**Beispiel 2: Array abflachen**
Das Beispiel zeigt, wie ein Array von Strukturfeldern geglättet wird.
PPL-Abfrage:
```
source=table | flatten bridges
```
| \$1Zeit | city | Farbe | country | length | Name |
| --- | --- | --- | --- | --- | --- |
| 2024-09-13T 12:00:00 | London | \$135, 51,5074, -0,1278\$1 | England | 801 | Turmbrücke |
| 2024-09-13T 12:00:00 | London | \$135, 51,5074, -0,1278\$1 | England | 928 | Londoner Brücke |
| 2024-09-13T 12:00:00 | Paris | \$135, 48,8566, 2,3522\$1 | Frankreich | 232 | Brücke Neuf |
| 2024-09-13T 12:00:00 | Paris | \$135, 48,8566, 2,3522\$1 | Frankreich | 160 | Pont Alexandre III |
| 2024-09-13T 12:00:00 | Venedig | \$12, 45.4408, 12.3155\$1 | Italien | 48 | Rialto-Brücke |
| 2024-09-13T 12:00:00 | Venedig | \$12, 45.4408, 12.3155\$1 | Italien | 11 | Seufzerbrücke |
| 2024-09-13T 12:00:00 | Prag | \$1200, 50,0755, 14,4378\$1 | Tschechische Republik | 516 | Karlsbrücke |
| 2024-09-13T 12:00:00 | Prag | \$1200, 50,0755, 14,4378\$1 | Tschechische Republik | 343 | Legion-Brücke |
| 2024-09-13T 12:00:00 | Budapest | \$196, 47,4979, 19,0402\$1 | Ungarn | 375 | Kettenbrücke |
| 2024-09-13T 12:00:00 | Budapest | \$196, 47,4979, 19,0402\$1 | Ungarn | 333 | Freiheitsbrücke |
| 1990-09-13T 12:00:00 | Warschau | NULL | Polen | NULL | NULL |
**Beispiel 3: Array und Struktur reduzieren**
Dieses Beispiel zeigt, wie mehrere Felder geglättet werden.
PPL-Abfrage:
```
source=table | flatten bridges | flatten coor
```
| \$1Zeit | city | country | length | Name | alt | lat | long |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 2024-09-13T 12:00:00 | London | England | 801 | Turmbrücke | 35 | 51.5074 | -0,1278 |
| 2024-09-13T 12:00:00 | London | England | 928 | Londoner Brücke | 35 | 51,5074 | -0,1278 |
| 2024-09-13T 12:00:00 | Paris | Frankreich | 232 | Pont Neuf | 35 | 48,8566 | 2,3522 |
| 2024-09-13T 12:00:00 | Paris | Frankreich | 160 | Pont Alexandre III | 35 | 48,8566 | 2,3522 |
| 2024-09-13T 12:00:00 | Venedig | Italien | 48 | Rialto-Brücke | 2 | 45.4408 | 12,3155 |
| 2024-09-13T 12:00:00 | Venedig | Italien | 11 | Seufzerbrücke | 2 | 45.4408 | 12,3155 |
| 2024-09-13T 12:00:00 | Prag | Tschechische Republik | 516 | Karlsbrücke | 200 | 50.0755 | 14,4378 |
| 2024-09-13T 12:00:00 | Prag | Tschechische Republik | 343 | Legion-Brücke | 200 | 50.0755 | 14,4378 |
| 2024-09-13T 12:00:00 | Budapest | Ungarn | 375 | Kettenbrücke | 96 | 47.4979 | 19,0402 |
| 2024-09-13T 12:00:00 | Budapest | Ungarn | 333 | Freiheitsbrücke | 96 | 47.4979 | 19,0402 |
| 1990-09-13T 12:00:00 | Warschau | Polen | NULL | NULL | NULL | NULL | NULL |
#### Befehl grok
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Der `grok` Befehl analysiert ein Textfeld mit einem Grok-Muster und hängt die Ergebnisse an das Suchergebnis an.
**Syntax**
Verwenden Sie die folgende Syntax:
```
grok
```
**field**
+ Zwingend erforderlich.
+ Das Feld muss ein Textfeld sein.
**pattern**
+ Zwingend erforderlich.
+ Das Grok-Muster, das verwendet wird, um neue Felder aus dem angegebenen Textfeld zu extrahieren.
+ Wenn bereits ein neuer Feldname existiert, ersetzt er das ursprüngliche Feld.
**Grok-Muster**
Das Grok-Muster wird verwendet, um das Textfeld jedes Dokuments abzugleichen und neue Felder zu extrahieren.
**Beispiel 1: Erstellen Sie das neue Feld**
Dieses Beispiel zeigt, wie Sie `host` für jedes Dokument ein neues Feld erstellen. `host`wird der Hostname danach `@` im `email` Feld sein. Die Analyse eines Nullfeldes gibt eine leere Zeichenfolge zurück.
```
os> source=accounts | grok email '.+@%{HOSTNAME:host}' | fields email, host ;
fetched rows / total rows = 4/4
+-------------------------+-------------+
| email | host |
|-------------------------+-------------|
| jane_doe@example.com | example.com |
| arnav_desai@example.net | example.net |
| null | |
| juan_li@example.org | example.org |
+-------------------------+-------------+
```
**Beispiel 2: Überschreiben Sie das bestehende Feld**
Dieses Beispiel zeigt, wie das vorhandene `address` Feld überschrieben wird, wobei die Hausnummer entfernt wird.
```
os> source=accounts | grok address '%{NUMBER} %{GREEDYDATA:address}' | fields address ;
fetched rows / total rows = 4/4
+------------------+
| address |
|------------------|
| Example Lane |
| Any Street |
| Main Street |
| Example Court |
+------------------+
```
**Beispiel 3: Verwendung von Grok zum Analysieren von Protokollen**
Dieses Beispiel zeigt, wie man Grok verwendet, um Rohprotokolle zu analysieren.
```
os> source=apache | grok message '%{COMMONAPACHELOG}' | fields COMMONAPACHELOG, timestamp, response, bytes ;
fetched rows / total rows = 4/4
+-----------------------------------------------------------------------------------------------------------------------------+----------------------------+------------+---------+
| COMMONAPACHELOG | timestamp | response | bytes |
|-----------------------------------------------------------------------------------------------------------------------------+----------------------------+------------+---------|
| 177.95.8.74 - upton5450 [28/Sep/2022:10:15:57 -0700] "HEAD /e-business/mindshare HTTP/1.0" 404 19927 | 28/Sep/2022:10:15:57 -0700 | 404 | 19927 |
| 127.45.152.6 - pouros8756 [28/Sep/2022:10:15:57 -0700] "GET /architectures/convergence/niches/mindshare HTTP/1.0" 100 28722 | 28/Sep/2022:10:15:57 -0700 | 100 | 28722 |
| *************** - - [28/Sep/2022:10:15:57 -0700] "PATCH /strategize/out-of-the-box HTTP/1.0" 401 27439 | 28/Sep/2022:10:15:57 -0700 | 401 | 27439 |
| ************** - - [28/Sep/2022:10:15:57 -0700] "POST /users HTTP/1.1" 301 9481 | 28/Sep/2022:10:15:57 -0700 | 301 | 9481 |
+-----------------------------------------------------------------------------------------------------------------------------+----------------------------+------------+---------+
```
**Einschränkungen**
Der Befehl grok hat dieselben Einschränkungen wie der Befehl parse.
#### Befehl head
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Verwenden Sie den `head` Befehl, um die ersten N der angegebenen Ergebnisse nach einem optionalen Offset in der Suchreihenfolge zurückzugeben.
**Syntax**
Verwenden Sie die folgende Syntax:
```
head [] [from ]
```
****
+ Optionale Ganzzahl.
+ Die Anzahl der zurückzugebenden Ergebnisse.
+ Standard: 10
****
+ Ganzzahl nach optional`from`.
+ Die Anzahl der Ergebnisse, die übersprungen werden sollen.
+ Standard: 0
**Beispiel 1: Holen Sie sich die ersten 10 Ergebnisse**
Dieses Beispiel zeigt, wie maximal 10 Ergebnisse aus dem Kontenindex abgerufen werden können.
PPL-Abfrage:
```
os> source=accounts | fields firstname, age | head;
fetched rows / total rows = 4/4
+-------------+-------+
| firstname | age |
|-------------+-------|
| Jane | 32 |
| John | 36 |
| Jorge | 28 |
| Juan | 33 |
+-------------+-------+
```
**Beispiel 2: Holen Sie sich die ersten N Ergebnisse**
Das Beispiel zeigt die ersten N Ergebnisse aus dem Kontenindex.
PPL-Abfrage:
```
os> source=accounts | fields firstname, age | head 3;
fetched rows / total rows = 3/3
+-------------+-------+
| firstname | age |
|-------------+-------|
| Jane | 32 |
| John | 36 |
| Jorge | 28 |
+-------------+-------+
```
**Beispiel 3: Holen Sie sich die ersten N Ergebnisse nach Offset M**
Dieses Beispiel zeigt, wie die ersten N Ergebnisse abgerufen werden, nachdem M Ergebnisse aus dem Kontenindex übersprungen wurden.
PPL-Abfrage:
```
os> source=accounts | fields firstname, age | head 3 from 1;
fetched rows / total rows = 3/3
+-------------+-------+
| firstname | age |
|-------------+-------|
| John | 36 |
| Jorge | 28 |
| Juan | 33 |
+-------------+-------+
```
#### Befehl join
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Mit dem Befehl join können Sie Daten aus mehreren Quellen auf der Grundlage gemeinsamer Felder kombinieren, sodass Sie komplexe Analysen durchführen und tiefere Einblicke aus Ihren verteilten Datensätzen gewinnen können
**Schema**
Es gibt mindestens zwei Indizes, `otel-v1-apm-span-*` (groß) und `otel-v1-apm-service-map` (klein).
Relevante Felder aus Indizes:
**`otel-v1-apm-span-*`**
+ traceId — Ein eindeutiger Bezeichner für einen Trace. Alle Spans aus derselben Trace haben dieselbe traceId.
+ spanID — Ein eindeutiger Bezeichner für einen Bereich innerhalb eines Traces, der bei der Erstellung des Spans zugewiesen wird.
+ parentSpanId - Die SpanID des übergeordneten Bereichs dieser Spanne. Wenn es sich um einen Wurzelbereich handelt, muss dieses Feld leer sein.
+ durationInNanos - Der Unterschied in Nanosekunden zwischen StartTime und EndTime. (Das ist `latency` in der Benutzeroberfläche)
+ serviceName — Die Ressource, aus der der Span stammt.
+ traceGroup — Der Name des Root-Spans des Traces.
**`otel-v1-apm-service-map`**
+ serviceName — Der Name des Dienstes, der den Span ausgegeben hat.
+ destination.domain — Der ServiceName des Dienstes, der von diesem Client aufgerufen wird.
+ destination.resource — Der Span-Name (API, Operation usw.), der von diesem Client aufgerufen wird.
+ target.domain — Der ServiceName des Dienstes, der von einem Client aufgerufen wird.
+ target.resource — Der Span-Name (API, Operation usw.), der von einem Client aufgerufen wird.
+ traceGroupName — Der Span-Name der obersten Ebene, mit dem die Anforderungskette gestartet wurde.
**Anforderung**
Support **join** bei der Berechnung der folgenden Werte:
Kombinieren Sie für jeden Service den Span-Index mit dem Service Map-Index, um Metriken unter verschiedenen Filtertypen zu berechnen.
Diese Beispielabfrage berechnet die Latenz, wenn sie nach der Trace-Gruppe `client_cancel_order` für den `order` Service gefiltert wird.
```
SELECT avg(durationInNanos)
FROM `otel-v1-apm-span-000001` t1
WHERE t1.serviceName = `order`
AND ((t1.name in
(SELECT target.resource
FROM `otel-v1-apm-service-map`
WHERE serviceName = `order`
AND traceGroupName = `client_cancel_order`)
AND t1.parentSpanId != NULL)
OR (t1.parentSpanId = NULL
AND t1.name = `client_cancel_order`))
AND t1.traceId in
(SELECT traceId
FROM `otel-v1-apm-span-000001`
WHERE serviceName = `order`)
```
**Migrieren Sie zu PPL**
Syntax des Join-Befehls
```
SEARCH source=
|
| [joinType] JOIN
[leftAlias]
ON joinCriteria
|
```
**Umschreiben**
```
SEARCH source=otel-v1-apm-span-000001
| WHERE serviceName = 'order'
| JOIN left=t1 right=t2
ON t1.traceId = t2.traceId AND t2.serviceName = 'order'
otel-v1-apm-span-000001 -- self inner join
| EVAL s_name = t1.name -- rename to avoid ambiguous
| EVAL s_parentSpanId = t1.parentSpanId -- RENAME command would be better when it is supported
| EVAL s_durationInNanos = t1.durationInNanos
| FIELDS s_name, s_parentSpanId, s_durationInNanos -- reduce colunms in join
| LEFT JOIN left=s1 right=t3
ON s_name = t3.target.resource AND t3.serviceName = 'order' AND t3.traceGroupName = 'client_cancel_order'
otel-v1-apm-service-map
| WHERE (s_parentSpanId IS NOT NULL OR (s_parentSpanId IS NULL AND s_name = 'client_cancel_order'))
| STATS avg(s_durationInNanos) -- no need to add alias if there is no ambiguous
```
**Verbindungstyp**
+ Syntax: `INNER | LEFT OUTER | CROSS`
+ Optional
+ Der Typ der auszuführenden Verknüpfung. Die Standardeinstellung ist `INNER` wenn nicht angegeben.
**Linker Alias**
+ Syntax: `left = `
+ Optional
+ Der Alias der Unterabfrage, der mit der linken Join-Seite verwendet werden soll, um mehrdeutige Benennungen zu vermeiden.
**Verbindungskriterien**
+ Syntax: ``
+ Erforderlich
+ Die Syntax beginnt mit. `ON` Es könnte ein beliebiger Vergleichsausdruck sein. Im Allgemeinen sehen die Verbindungskriterien wie folgt aus`.=.`.
Beispiel: `l.id = r.id`. Wenn das Join-Kriterium mehrere Bedingungen enthält, können Sie zwischen jedem Vergleichsausdruck einen `OR` Operator angeben`AND`. Beispiel, `l.id = r.id AND l.email = r.email AND (r.age > 65 OR r.age < 18)`.
**Weitere Beispiele**
Migration von einer SQL-Abfrage (TPC-H Q13):
```
SELECT c_count, COUNT(*) AS custdist
FROM
( SELECT c_custkey, COUNT(o_orderkey) c_count
FROM customer LEFT OUTER JOIN orders ON c_custkey = o_custkey
AND o_comment NOT LIKE '%unusual%packages%'
GROUP BY c_custkey
) AS c_orders
GROUP BY c_count
ORDER BY custdist DESC, c_count DESC;
```
Mit der PPL-Join-Abfrage neu geschrieben:
```
SEARCH source=customer
| FIELDS c_custkey
| LEFT OUTER JOIN
ON c_custkey = o_custkey AND o_comment NOT LIKE '%unusual%packages%'
orders
| STATS count(o_orderkey) AS c_count BY c_custkey
| STATS count() AS custdist BY c_count
| SORT - custdist, - c_count
```
Einschränkung: Untersuchen werden in Join Right Side nicht unterstützt.
Wenn Teilsuchen unterstützt werden, können Sie die obige PPL-Abfrage wie folgt umschreiben:
```
SEARCH source=customer
| FIELDS c_custkey
| LEFT OUTER JOIN
ON c_custkey = o_custkey
[
SEARCH source=orders
| WHERE o_comment NOT LIKE '%unusual%packages%'
| FIELDS o_orderkey, o_custkey
]
| STATS count(o_orderkey) AS c_count BY c_custkey
| STATS count() AS custdist BY c_count
| SORT - custdist, - c_count
```
#### Lookup-Befehl
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Verwenden Sie den `lookup` Befehl, um Ihre Suchdaten anzureichern, indem Sie Daten aus einem Nachschlageindex (Dimensionstabelle) hinzufügen oder ersetzen. Mit diesem Befehl können Sie Felder eines Index mit Werten aus einer Dimensionstabelle erweitern. Sie können ihn auch verwenden, um Werte anzuhängen oder zu ersetzen, wenn die Suchbedingungen erfüllt sind. Der `lookup` Befehl eignet sich besser als der `Join` Befehl, um Quelldaten mit einem statischen Datensatz anzureichern.
**Syntax**
Verwenden Sie die folgende Syntax:
```
SEARCH source=
|
| LOOKUP ( [AS ])...
[(REPLACE | APPEND) ( [AS ])...]
|
```
**LookupIndex**
+ Erforderlich
+ Der Name des Nachschlageindex (Dimensionstabelle).
**lookupMappingField**
+ Erforderlich
+ Ein Zuordnungsschlüssel im Lookup-Index, analog zu einem Join-Schlüssel aus der rechten Tabelle. Sie können mehrere Felder angeben, die durch Kommas getrennt sind.
**sourceMappingField**
+ Optional.
+ Standard: < lookupMappingField >.
+ Ein Zuordnungsschlüssel aus der Quellabfrage, analog zu einem Join-Schlüssel von der linken Seite.
**Eingabefeld**
+ Optional.
+ Standard: Alle Felder des Lookup-Index, in denen übereinstimmende Werte gefunden wurden.
+ Ein Feld im Nachschlageindex, in dem übereinstimmende Werte auf die Ergebnisausgabe angewendet werden. Sie können mehrere Felder angeben, die durch Kommas getrennt sind.
**Ausgabefeld**
+ Optional.
+ Standard: ``.
+ Ein Feld in der Ausgabe. Sie können mehrere Ausgabefelder angeben. Wenn Sie einen vorhandenen Feldnamen aus der Quellabfrage angeben, werden seine Werte durch übereinstimmende Werte aus InputField ersetzt oder angefügt. Wenn Sie einen neuen Feldnamen angeben, wird dieser den Ergebnissen hinzugefügt.
**ERSETZEN \$1 ANHÄNGEN**
+ Optional.
+ Standard: REPLACE
+ Gibt an, wie übereinstimmende Werte behandelt werden sollen. Wenn Sie REPLACE angeben, überschreiben übereinstimmende Werte im Feld die Werte im Ergebnis. Wenn Sie angeben`APPEND`, werden übereinstimmende Werte im Feld nur an die fehlenden Werte im Ergebnis angehängt.
**Usage**
+ ID ALS CID NACHSCHLAGEN, E-Mail ALS E-Mail ERSETZEN
+ NAME NACHSCHLAGEN E-Mail ALS E-Mail ERSETZEN
+ LOOKUP-ID ALS CID, Name, Adresse ANFÜGEN, E-Mail ALS E-Mail
+ LOOKUP-ID
**Beispiel**
Sehen Sie sich die folgenden Beispiele an.
```
SEARCH source=
| WHERE orderType = 'Cancelled'
| LOOKUP account_list, mkt_id AS mkt_code REPLACE amount, account_name AS name
| STATS count(mkt_code), avg(amount) BY name
```
```
SEARCH source=
| DEDUP market_id
| EVAL category=replace(category, "-", ".")
| EVAL category=ltrim(category, "dvp.")
| LOOKUP bounce_category category AS category APPEND classification
```
```
SEARCH source=
| LOOKUP bounce_category category
```
#### Befehl parse
Der `parse` Befehl analysiert ein Textfeld mit einem regulären Ausdruck und hängt das Ergebnis an das Suchergebnis an.
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
**Syntax**
Verwenden Sie die folgende Syntax:
```
parse
```
**`field`**
+ Zwingend erforderlich.
+ Das Feld muss ein Textfeld sein.
**`pattern`**
+ Obligatorische Zeichenfolge.
+ Dies ist das Muster für reguläre Ausdrücke, das verwendet wird, um neue Felder aus dem angegebenen Textfeld zu extrahieren.
+ Wenn bereits ein neuer Feldname vorhanden ist, ersetzt er das ursprüngliche Feld.
**Regulärer Ausdruck**
Das Muster für reguläre Ausdrücke wird verwendet, um das gesamte Textfeld jedes Dokuments mit der Java-Regex-Engine abzugleichen. Jede benannte Capture-Gruppe im Ausdruck wird zu einem neuen `STRING` Feld.
**Beispiel 1: Erstellen Sie ein neues Feld**
Das Beispiel zeigt, wie `host` für jedes Dokument ein neues Feld erstellt wird. `host`wird der Hostname danach `@` im `email` Feld sein. Die Analyse eines Nullfeldes gibt eine leere Zeichenfolge zurück.
PPL-Abfrage:
```
os> source=accounts | parse email '.+@(?.+)' | fields email, host ;
fetched rows / total rows = 4/4
+-----------------------+-------------+
| email | host |
|-----------------------+-------------|
| jane_doe@example.com | example.com |
| john_doe@example.net | example.net |
| null | |
| juan_li@example.org | example.org |
+-----------------------+-------------+
```
**Beispiel 2: Überschreiben Sie ein vorhandenes Feld**
Das Beispiel zeigt, wie das vorhandene `address` Feld überschrieben wird, wobei die Hausnummer entfernt wird.
PPL-Abfrage:
```
os> source=accounts | parse address '\d+ (?.+)' | fields address ;
fetched rows / total rows = 4/4
+------------------+
| address |
|------------------|
| Example Lane |
| Example Street |
| Example Avenue |
| Example Court |
+------------------+
```
**Beispiel 3: Filtern und sortieren Sie nach einem gecasteten, analysierten Feld**
Das Beispiel zeigt, wie Straßennummern sortiert werden, die in dem `address` Feld höher als 500 sind.
PPL-Abfrage:
```
os> source=accounts | parse address '(?\d+) (?.+)' | where cast(streetNumber as int) > 500 | sort num(streetNumber) | fields streetNumber, street ;
fetched rows / total rows = 3/3
+----------------+----------------+
| streetNumber | street |
|----------------+----------------|
| *** | Example Street |
| *** | Example Avenue |
| 880 | Example Lane |
+----------------+----------------+
```
**Einschränkungen**
Der Parse-Befehl weist einige Einschränkungen auf:
+ Durch Parse definierte Felder können nicht erneut analysiert werden.
Der folgende Befehl funktioniert nicht:
```
source=accounts | parse address '\d+ (?.+)' | parse street '\w+ (?\w+)'
```
+ Durch Parse definierte Felder können nicht mit anderen Befehlen überschrieben werden.
`where`passt zu keinem Dokument, da es nicht überschrieben `street` werden kann:
```
source=accounts | parse address '\d+ (?.+)' | eval street='1' | where street='1' ;
```
+ Das von parse verwendete Textfeld kann nicht überschrieben werden.
`street`wird nicht erfolgreich analysiert, da es überschrieben wird: `address`
```
source=accounts | parse address '\d+ (?.+)' | eval address='1' ;
```
+ Durch Parse definierte Felder können nicht gefiltert oder sortiert werden, nachdem sie im Befehl verwendet wurden. `stats`
`where`im folgenden Befehl funktioniert nicht:
```
source=accounts | parse email '.+@(?.+)' | stats avg(age) by host | where host=pyrami.com ;
```
#### Befehl „Muster“
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Der `patterns` Befehl extrahiert Protokollmuster aus einem Textfeld und fügt die Ergebnisse an das Suchergebnis an. Durch die Gruppierung von Protokollen nach ihren Mustern ist es einfacher, Statistiken aus großen Mengen von Protokolldaten zur Analyse und Fehlerbehebung zu aggregieren.
**Syntax**
Verwenden Sie die folgende Syntax:
```
patterns [new_field=] [pattern=]
```
**new-field-name**
+ Optionale Zeichenfolge.
+ Dies ist der Name des neuen Felds für extrahierte Muster.
+ Der Standardwert ist `patterns_field`.
+ Wenn der Name bereits existiert, ersetzt er das ursprüngliche Feld.
**pattern**
+ Optionale Zeichenfolge.
+ Dies ist das Regex-Muster von Zeichen, die aus dem Textfeld herausgefiltert werden sollen.
+ Falls nicht, besteht das Standardmuster aus alphanumerischen Zeichen (). `[a-zA-Z\d]`
**field**
+ Zwingend erforderlich.
+ Das Feld muss ein Textfeld sein.
**Beispiel 1: Erstellen Sie das neue Feld**
Das Beispiel zeigt, wie in `email` jedem Dokument extraktierte Satzzeichen verwendet werden. Beim Analysieren eines Nullfeldes wird eine leere Zeichenfolge zurückgegeben.
PPL-Abfrage:
```
os> source=accounts | patterns email | fields email, patterns_field ;
fetched rows / total rows = 4/4
+-----------------------+------------------+
| email | patterns_field |
|-----------------------+------------------|
| jane_doe@example.com | @. |
| john_doe@example.net | @. |
| null | |
| juan_li@example.org | @. |
+-----------------------+------------------+
```
**Beispiel 2: Extrahieren von Protokollmustern**
Das Beispiel zeigt, wie Interpunktionen mithilfe der Standardmuster aus einem unformatierten Protokollfeld extrahiert werden.
PPL-Abfrage:
```
os> source=apache | patterns message | fields message, patterns_field ;
fetched rows / total rows = 4/4
+-----------------------------------------------------------------------------------------------------------------------------+---------------------------------+
| message | patterns_field |
|-----------------------------------------------------------------------------------------------------------------------------+---------------------------------|
| 177.95.8.74 - upton5450 [28/Sep/2022:10:15:57 -0700] "HEAD /e-business/mindshare HTTP/1.0" 404 19927 | ... - [//::: -] " /-/ /." |
| ************ - pouros8756 [28/Sep/2022:10:15:57 -0700] "GET /architectures/convergence/niches/mindshare HTTP/1.0" 100 28722 | ... - [//::: -] " //// /." |
| *************** - - [28/Sep/2022:10:15:57 -0700] "PATCH /strategize/out-of-the-box HTTP/1.0" 401 27439 | ... - - [//::: -] " //--- /." |
| ************** - - [28/Sep/2022:10:15:57 -0700] "POST /users HTTP/1.1" 301 9481 | ... - - [//::: -] " / /." |
+-----------------------------------------------------------------------------------------------------------------------------+---------------------------------+
```
**Beispiel 3: Extrahieren Sie Protokollmuster mit einem benutzerdefinierten Regex-Muster**
Das Beispiel zeigt, wie Interpunktionen mithilfe benutzerdefinierter Muster aus einem unformatierten Protokollfeld extrahiert werden.
PPL-Abfrage:
```
os> source=apache | patterns new_field='no_numbers' pattern='[0-9]' message | fields message, no_numbers ;
fetched rows / total rows = 4/4
+-----------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------+
| message | no_numbers |
|-----------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------|
| 177.95.8.74 - upton5450 [28/Sep/2022:10:15:57 -0700] "HEAD /e-business/mindshare HTTP/1.0" 404 19927 | ... - upton [/Sep/::: -] "HEAD /e-business/mindshare HTTP/." |
| 127.45.152.6 - pouros8756 [28/Sep/2022:10:15:57 -0700] "GET /architectures/convergence/niches/mindshare HTTP/1.0" 100 28722 | ... - pouros [/Sep/::: -] "GET /architectures/convergence/niches/mindshare HTTP/." |
| *************** - - [28/Sep/2022:10:15:57 -0700] "PATCH /strategize/out-of-the-box HTTP/1.0" 401 27439 | ... - - [/Sep/::: -] "PATCH /strategize/out-of-the-box HTTP/." |
| ************** - - [28/Sep/2022:10:15:57 -0700] "POST /users HTTP/1.1" 301 9481 | ... - - [/Sep/::: -] "POST /users HTTP/." |
+-----------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------+
```
**Einschränkung**
Der Befehl patterns hat dieselben Einschränkungen wie der Befehl parse.
#### seltener Befehl
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Verwenden Sie den `rare` Befehl, um das am wenigsten gemeinsame Wertetupel aller Felder in der Feldliste zu finden.
**Anmerkung**
Für jedes einzelne Wertetupel der Gruppierungsfelder werden maximal 10 Ergebnisse zurückgegeben.
**Syntax**
Verwenden Sie die folgende Syntax:
```
rare [N] [by-clause] rare_approx [N] [by-clause]
```
**Feldliste**
+ Zwingend erforderlich.
+ Eine kommagetrennte Liste von Feldnamen.
**Nebenklausel**
+ Optional.
+ Ein oder mehrere Felder, nach denen die Ergebnisse gruppiert werden sollen.
**N**
+ Die Anzahl der zurückzugebenden Ergebnisse.
+ Standard: 10
**selten\$1ca**
+ Die ungefähre Anzahl der seltenen (n) Felder unter Verwendung des Algorithmus „Geschätzte [Kardinalität](https://spark.apache.org/docs/latest/sql-ref-functions-builtin.html) nach \$1\$1“. HyperLogLog
**Beispiel 1: Finden Sie die am wenigsten gemeinsamen Werte in einem Feld**
In diesem Beispiel wird das Geschlecht aller Konten ermittelt, das am wenigsten gemeinsam ist.
PPL-Abfrage:
```
os> source=accounts | rare gender;
os> source=accounts | rare_approx 10 gender;
os> source=accounts | rare_approx gender;
fetched rows / total rows = 2/2
+----------+
| gender |
|----------|
| F |
| M |
+----------+
```
**Beispiel 2: Finden Sie die am wenigsten gemeinsamen Werte, geordnet nach Geschlecht**
In diesem Beispiel wird das Alter aller nach Geschlecht gruppierten Konten ermittelt, das am seltensten vorkommt.
PPL-Abfrage:
```
os> source=accounts | rare 5 age by gender;
os> source=accounts | rare_approx 5 age by gender;
fetched rows / total rows = 4/4
+----------+-------+
| gender | age |
|----------+-------|
| F | 28 |
| M | 32 |
| M | 33 |
| M | 36 |
+----------+-------+
```
#### Befehl umbenennen
Verwenden Sie den `rename` Befehl, um die Namen eines oder mehrerer Felder im Suchergebnis zu ändern.
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
**Syntax**
Verwenden Sie die folgende Syntax:
```
rename AS ["," AS ]...
```
**Quellfeld**
+ Zwingend erforderlich.
+ Dies ist der Name des Feldes, das Sie umbenennen möchten.
**Zielfeld**
+ Zwingend erforderlich.
+ Dies ist der Name, in den Sie umbenennen möchten.
**Beispiel 1: Benennen Sie ein Feld um**
Dieses Beispiel zeigt, wie ein einzelnes Feld umbenannt wird.
PPL-Abfrage:
```
os> source=accounts | rename account_number as an | fields an;
fetched rows / total rows = 4/4
+------+
| an |
|------|
| 1 |
| 6 |
| 13 |
| 18 |
+------+
```
**Beispiel 2: Benennen Sie mehrere Felder um**
Dieses Beispiel zeigt, wie mehrere Felder umbenannt werden.
PPL-Abfrage:
```
os> source=accounts | rename account_number as an, employer as emp | fields an, emp;
fetched rows / total rows = 4/4
+------+---------+
| an | emp |
|------+---------|
| 1 | Pyrami |
| 6 | Netagy |
| 13 | Quility |
| 18 | null |
+------+---------+
```
**Einschränkungen**
+ Das Überschreiben eines vorhandenen Felds wird nicht unterstützt:
```
source=accounts | grok address '%{NUMBER} %{GREEDYDATA:address}' | fields address
```
#### Suchbefehl
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Verwenden Sie den `search` Befehl, um Dokumente aus einem Index abzurufen. Der `search` Befehl kann nur als erster Befehl in einer PPL-Abfrage verwendet werden.
**Syntax**
Verwenden Sie die folgende Syntax:
```
search source=[:] [boolean-expression]
```
**search**
+ Optional.
+ Suchschlüsselwörter, die weggelassen werden können.
**index**
+ Zwingend erforderlich.
+ Der Suchbefehl muss angeben, aus welchem Index abgefragt werden soll.
+ Bei clusterübergreifenden Suchen kann dem Indexnamen ein Präfix `:` vorangestellt werden.
**boolischer Ausdruck**
+ Optional.
+ Jeder Ausdruck, der einen booleschen Wert ergibt.
**Beispiel 1: Alle Daten abrufen**
Das Beispiel zeigt, wie das gesamte Dokument aus dem Kontoindex abgerufen werden kann.
PPL-Abfrage:
```
os> source=accounts;
+------------------+-------------+----------------------+-----------+----------+--------+----------------+---------+-------+-----------------------+------------+
| account_number | firstname | address | balance | gender | city | employer | state | age | email | lastname |
|------------------+-------------+----------------------+-----------+----------+--------+----------------+---------+-------+-----------------------+------------|
| 1 | Jorge | *** Any Lane | 39225 | M | Brogan | ExampleCorp | IL | 32 | jane_doe@example.com | Souza |
| 6 | John | *** Example Street | 5686 | M | Dante | AnyCorp | TN | 36 | john_doe@example.com | Doe |
| 13 | Jane | *** Any Street | ***** | F | Nogal | ExampleCompany | VA | 28 | null | Doe |
| 18 | Juan | *** Example Court | 4180 | M | Orick | null | MD | 33 | juan_li@example.org | Li |
+------------------+-------------+----------------------+-----------+----------+--------+----------------+---------+-------+-----------------------+------------+
```
**Beispiel 2: Daten mit Bedingung abrufen**
Das Beispiel zeigt, wie das gesamte Dokument aus dem Kontoindex mit abgerufen werden kann.
PPL-Abfrage:
```
os> SEARCH source=accounts account_number=1 or gender="F";
+------------------+-------------+--------------------+-----------+----------+--------+----------------+---------+-------+-------------------------+------------+
| account_number | firstname | address | balance | gender | city | employer | state | age | email - | lastname |
|------------------+-------------+--------------------+-----------+----------+--------+----------------+---------+-------+-------------------------+------------|
| 1 | Jorge | *** Any Lane | ***** | M | Brogan | ExampleCorp | IL | 32 | jorge_souza@example.com | Souza |
| 13 | Jane | *** Any Street | ***** | F | Nogal | ExampleCompany | VA | 28 | null | Doe |
+------------------+-------------+--------------------+-----------+----------+--------+-----------------+---------+-------+------------------------+------------+
```
#### Befehl sort
Verwenden Sie den `sort` Befehl, um das Suchergebnis nach bestimmten Feldern zu sortieren.
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
**Syntax**
Verwenden Sie die folgende Syntax:
```
sort <[+|-] sort-field>...
```
**[\$1\$1-]**
+ Optional.
+ Das Plus [\$1] steht für eine aufsteigende Reihenfolge, bei NULL/MISSING der die Werte an erster Stelle stehen.
+ Das Minus [-] steht für absteigende Reihenfolge, wobei die NULL/MISSING Werte zuletzt stehen.
+ Standard: Aufsteigende Reihenfolge mit den NULL/MISSING Werten an erster Stelle.
**Sortierfeld**
+ Zwingend erforderlich.
+ Das Feld, das für die Sortierung verwendet wird.
**Beispiel 1: Sortiert nach einem Feld**
Das Beispiel zeigt, wie das Dokument mit dem Altersfeld in aufsteigender Reihenfolge sortiert wird.
PPL-Abfrage:
```
os> source=accounts | sort age | fields account_number, age;
fetched rows / total rows = 4/4
+------------------+-------+
| account_number | age |
|------------------+-------|
| 13 | 28 |
| 1 | 32 |
| 18 | 33 |
| 6 | 36 |
+------------------+-------+
```
**Beispiel 2: Sortiere nach einem Feld und gib alle Ergebnisse zurück**
Das Beispiel zeigt, wie das Dokument mit dem Altersfeld in aufsteigender Reihenfolge sortiert wird.
PPL-Abfrage:
```
os> source=accounts | sort age | fields account_number, age;
fetched rows / total rows = 4/4
+------------------+-------+
| account_number | age |
|------------------+-------|
| 13 | 28 |
| 1 | 32 |
| 18 | 33 |
| 6 | 36 |
+------------------+-------+
```
**Beispiel 3: Sortiert nach einem Feld in absteigender Reihenfolge**
Das Beispiel zeigt, wie das Dokument mit dem Altersfeld in absteigender Reihenfolge sortiert wird.
PPL-Abfrage:
```
os> source=accounts | sort - age | fields account_number, age;
fetched rows / total rows = 4/4
+------------------+-------+
| account_number | age |
|------------------+-------|
| 6 | 36 |
| 18 | 33 |
| 1 | 32 |
| 13 | 28 |
+------------------+-------+
```
**Beispiel 4: Nach mehreren Feldern sortieren**
Das Beispiel zeigt, wie das Dokument mit dem Geschlechtsfeld in aufsteigender Reihenfolge und dem Altersfeld in absteigender Reihenfolge sortiert wird.
PPL-Abfrage:
```
os> source=accounts | sort + gender, - age | fields account_number, gender, age;
fetched rows / total rows = 4/4
+------------------+----------+-------+
| account_number | gender | age |
|------------------+----------+-------|
| 13 | F | 28 |
| 6 | M | 36 |
| 18 | M | 33 |
| 1 | M | 32 |
+------------------+----------+-------+
```
**Beispiel 5: Nach Feld sortieren, Nullwert enthalten**
Das Beispiel zeigt, wie das Arbeitgeberfeld nach der Standardoption sortiert wird (aufsteigende Reihenfolge und Null zuerst). Das Ergebnis zeigt, dass der Nullwert in der ersten Zeile steht.
PPL-Abfrage:
```
os> source=accounts | sort employer | fields employer;
fetched rows / total rows = 4/4
+------------+
| employer |
|------------|
| null |
| AnyCompany |
| AnyCorp |
| AnyOrgty |
+------------+
```
#### Befehl stats
Verwenden Sie den `stats` Befehl, um die Aggregation anhand des Suchergebnisses zu berechnen.
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
**Behandlung von NULL-/FEHLENDEN Werten**
**Behandlung von NULL-/FEHLENDEN Werten**
| Funktion | NULL | MISSING |
| --- | --- | --- |
| COUNT | Nicht gezählt | Nicht gezählt |
| SUM | Ignore | Ignore |
| AVG | Ignore | Ignore |
| MAX | Ignore | Ignore |
| MIN | Ignore | Ignore |
**Syntax**
Verwenden Sie die folgende Syntax:
```
stats ... [by-clause]
```
**Aggregation**
+ Zwingend erforderlich.
+ Eine Aggregationsfunktion, die auf ein Feld angewendet wird.
**Nebenklausel**
+ Optional.
+ Syntax: `by [span-expression,] [field,]...`
+ Gibt Felder und Ausdrücke für die Gruppierung der Aggregationsergebnisse an. Die Nebenklausel ermöglicht es Ihnen, Ihre Aggregationsergebnisse mithilfe von Feldern und Ausdrücken zu gruppieren. Sie können Skalarfunktionen, Aggregationsfunktionen und sogar Span-Ausdrücke verwenden, um bestimmte Felder in Gruppen mit gleichen Intervallen aufzuteilen.
+ Standard: Wenn kein Wert angegeben `` ist, gibt der Befehl stats eine einzelne Zeile zurück, die die Aggregation über die gesamte Ergebnismenge darstellt.
**Span-Ausdruck**
+ Fakultativ, höchstens einer.
+ Syntax: `span(field_expr, interval_expr)`
+ Die Einheit des Intervallausdrucks ist standardmäßig die natürliche Einheit. Wenn es sich bei dem Feld um ein Feld vom Typ Datum und Uhrzeit handelt und das Intervall in date/time Einheiten angegeben ist, geben Sie die Einheit im Intervallausdruck an.
+ Wenn Sie das `age` Feld beispielsweise nach 10 Jahren in Bereiche aufteilen, sieht das so aus. `span(age, 10)` Um ein Zeitstempelfeld in stündliche Intervalle aufzuteilen, verwenden Sie. `span(timestamp, 1h)`
**Verfügbare Zeiteinheiten**
| Einheiten für das Spanenintervall |
| --- |
| Millisekunde (ms) |
| Sekunde (n) |
| Minute (m, Groß- und Kleinschreibung beachten) |
| Stunde (h) |
| Tag (d) |
| Woche (w) |
| Monat (M, Groß- und Kleinschreibung beachten) |
| Quartal (q) |
| Jahr (y) |
**Aggregationsfunktionen**
**`COUNT`**
Gibt die Anzahl der Ausdrücke in den Zeilen zurück, die mit einer SELECT-Anweisung abgerufen wurden.
Beispiel:
```
os> source=accounts | stats count();
fetched rows / total rows = 1/1
+-----------+
| count() |
|-----------|
| 4 |
+-----------+
```
**`SUM`**
Wird verwendet`SUM(expr)`, um die Summe der Ausdrücke zurückzugeben.
Beispiel
```
os> source=accounts | stats sum(age) by gender;
fetched rows / total rows = 2/2
+------------+----------+
| sum(age) | gender |
|------------+----------|
| 28 | F |
| 101 | M |
+------------+----------+
```
**`AVG`**
Wird verwendet`AVG(expr)`, um den Durchschnittswert von expr zurückzugeben.
Beispiel
```
os> source=accounts | stats avg(age) by gender;
fetched rows / total rows = 2/2
+--------------------+----------+
| avg(age) | gender |
|--------------------+----------|
| 28.0 | F |
| 33.666666666666664 | M |
+--------------------+----------+
```
**`MAX`**
Wird verwendet`MAX(expr)`, um den Maximalwert von expr zurückzugeben.
Beispiel
```
os> source=accounts | stats max(age);
fetched rows / total rows = 1/1
+------------+
| max(age) |
|------------|
| 36 |
+------------+
```
**`MIN`**
Wird verwendet`MIN(expr)`, um den Minimalwert von expr zurückzugeben.
Beispiel
```
os> source=accounts | stats min(age);
fetched rows / total rows = 1/1
+------------+
| min(age) |
|------------|
| 28 |
+------------+
```
**`STDDEV_SAMP`**
Wird verwendet`STDDEV_SAMP(expr)`, um die Standardabweichung der Stichprobe von expr zurückzugeben.
Beispiel:
```
os> source=accounts | stats stddev_samp(age);
fetched rows / total rows = 1/1
+--------------------+
| stddev_samp(age) |
|--------------------|
| 3.304037933599835 |
+--------------------+
```
**STDDEV\$1POP**
Wird verwendet`STDDEV_POP(expr)`, um die Standardabweichung der Grundgesamtheit von Expr zurückzugeben.
Beispiel:
```
os> source=accounts | stats stddev_pop(age);
fetched rows / total rows = 1/1
+--------------------+
| stddev_pop(age) |
|--------------------|
| 2.**************** |
+--------------------+
```
**DAUERN**
Wird verwendet`TAKE(field [, size])`, um die ursprünglichen Werte eines Felds zurückzugeben. Es gibt keine Garantie für die Reihenfolge der Werte.
**field**
+ Zwingend erforderlich.
+ Das Feld muss ein Textfeld sein.
**size**
+ Optionale Ganzzahl.
+ Die Anzahl der Werte sollte zurückgegeben werden.
+ Die Standardeinstellung ist 10.
**Beispiel**
```
os> source=accounts | stats take(firstname);
fetched rows / total rows = 1/1
+-----------------------------+
| take(firstname) |
|-----------------------------|
| [Jane, Mary, Nikki, Juan |
+-----------------------------+
```
**PERCENTILE oder PERCENTILE\$1APPROX**
Verwenden Sie `PERCENTILE(expr, percent)` oder`PERCENTILE_APPROX(expr, percent)`, um den ungefähren Perzentilwert von expr zum angegebenen Prozentsatz zurückzugeben.
**Prozent**
+ Die Zahl muss eine Konstante zwischen 0 und 100 sein.
**Beispiel**
```
os> source=accounts | stats percentile(age, 90) by gender;
fetched rows / total rows = 2/2
+-----------------------+----------+
| percentile(age, 90) | gender |
|-----------------------+----------|
| 28 | F |
| 36 | M |
+-----------------------+----------+
```
**Beispiel 1: Berechne die Anzahl der Ereignisse**
Das Beispiel zeigt, wie die Anzahl der Ereignisse in den Konten berechnet wird.
```
os> source=accounts | stats count();
fetched rows / total rows = 1/1
+-----------+
| count() |
|-----------|
| 4 |
+-----------+
```
**Beispiel 2: Berechnet den Durchschnitt eines Felds**
Das Beispiel zeigt, wie das Durchschnittsalter für alle Konten berechnet wird.
```
os> source=accounts | stats avg(age);
fetched rows / total rows = 1/1
+------------+
| avg(age) |
|------------|
| 32.25 |
+------------+
```
**Beispiel 3: Berechnet den Durchschnitt eines Felds nach Gruppen**
Das Beispiel zeigt, wie das Durchschnittsalter für alle Konten, gruppiert nach Geschlecht, berechnet wird.
```
os> source=accounts | stats avg(age) by gender;
fetched rows / total rows = 2/2
+--------------------+----------+
| avg(age) | gender |
|--------------------+----------|
| 28.0 | F |
| 33.666666666666664 | M |
+--------------------+----------+
```
**Beispiel 4: Berechnet den Durchschnitt, die Summe und die Anzahl eines Felds nach Gruppen**
Das Beispiel zeigt, wie das Durchschnittsalter, das Gesamtalter und die Anzahl der Ereignisse für alle Konten, gruppiert nach Geschlecht, berechnet werden.
```
os> source=accounts | stats avg(age), sum(age), count() by gender;
fetched rows / total rows = 2/2
+--------------------+------------+-----------+----------+
| avg(age) | sum(age) | count() | gender |
|--------------------+------------+-----------+----------|
| 28.0 | 28 | 1 | F |
| 33.666666666666664 | 101 | 3 | M |
+--------------------+------------+-----------+----------+
```
**Beispiel 5: Berechnet das Maximum eines Felds**
Das Beispiel berechnet das Höchstalter für alle Konten.
```
os> source=accounts | stats max(age);
fetched rows / total rows = 1/1
+------------+
| max(age) |
|------------|
| 36 |
+------------+
```
**Beispiel 6: Berechnet das Maximum und das Minimum eines Felds nach Gruppen**
Das Beispiel berechnet die Werte für das Höchst- und Mindestalter für alle Konten, gruppiert nach Geschlecht.
```
os> source=accounts | stats max(age), min(age) by gender;
fetched rows / total rows = 2/2
+------------+------------+----------+
| max(age) | min(age) | gender |
|------------+------------+----------|
| 28 | 28 | F |
| 36 | 32 | M |
+------------+------------+----------+
```
**Beispiel 7: Berechnet die eindeutige Anzahl eines Felds**
Um die Anzahl der unterschiedlichen Werte eines Felds zu ermitteln, können Sie stattdessen die Funktion `DISTINCT_COUNT` (oder`DC`) verwenden`COUNT`. In diesem Beispiel werden sowohl die Anzahl als auch die eindeutige Anzahl der Geschlechter aller Konten berechnet.
```
os> source=accounts | stats count(gender), distinct_count(gender);
fetched rows / total rows = 1/1
+-----------------+--------------------------+
| count(gender) | distinct_count(gender) |
|-----------------+--------------------------|
| 4 | 2 |
+-----------------+--------------------------+
```
**Beispiel 8: Berechnet die Anzahl anhand einer Spanne**
In diesem Beispiel wird die Anzahl der Altersstufen im Intervall von 10 Jahren berechnet.
```
os> source=accounts | stats count(age) by span(age, 10) as age_span
fetched rows / total rows = 2/2
+--------------+------------+
| count(age) | age_span |
|--------------+------------|
| 1 | 20 |
| 3 | 30 |
+--------------+------------+
```
**Beispiel 9: Berechnet die Anzahl anhand eines Geschlechts und einer Spanne**
In diesem Beispiel werden Datensätze gezählt, die nach Geschlecht und Alter gruppiert sind, und zwar über einen Zeitraum von 5 Jahren.
```
os> source=accounts | stats count() as cnt by span(age, 5) as age_span, gender
fetched rows / total rows = 3/3
+-------+------------+----------+
| cnt | age_span | gender |
|-------+------------+----------|
| 1 | 25 | F |
| 2 | 30 | M |
| 1 | 35 | M |
+-------+------------+----------+
```
Der Span-Ausdruck wird immer als erster Gruppierungsschlüssel angezeigt, unabhängig von der im Befehl angegebenen Reihenfolge.
```
os> source=accounts | stats count() as cnt by gender, span(age, 5) as age_span
fetched rows / total rows = 3/3
+-------+------------+----------+
| cnt | age_span | gender |
|-------+------------+----------|
| 1 | 25 | F |
| 2 | 30 | M |
| 1 | 35 | M |
+-------+------------+----------+
```
**Beispiel 10: Berechnet die Anzahl und ruft die E-Mail-Liste nach Geschlecht und Spanne ab**
Im Beispiel wird die Anzahl der Altersgruppen im Intervall von 10 Jahren und die Gruppierung nach Geschlecht ermittelt. Zusätzlich wird für jede Zeile eine Liste mit maximal 5 E-Mails abgerufen.
```
os> source=accounts | stats count() as cnt, take(email, 5) by span(age, 5) as age_span, gender
fetched rows / total rows = 3/3
+-------+----------------------------------------------------+------------+----------+
| cnt | take(email, 5) | age_span | gender |
|-------+----------------------------------------------------+------------+----------|
| 1 | [] | 25 | F |
| 2 | [janedoe@anycompany.com,juanli@examplecompany.org] | 30 | M |
| 1 | [marymajor@examplecorp.com] | 35 | M |
+-------+----------------------------------------------------+------------+----------+
```
**Beispiel 11: Berechnet das Perzentil eines Feldes**
Das Beispiel zeigt, wie das Perzentil des 90. Alters aller Konten berechnet wird.
```
os> source=accounts | stats percentile(age, 90);
fetched rows / total rows = 1/1
+-----------------------+
| percentile(age, 90) |
|-----------------------|
| 36 |
+-----------------------+
```
**Beispiel 12: Berechnet das Perzentil eines Felds nach Gruppen**
Das Beispiel zeigt, wie der Perzentil für das 90. Lebensjahr aller nach Geschlecht gruppierten Konten berechnet wird.
```
os> source=accounts | stats percentile(age, 90) by gender;
fetched rows / total rows = 2/2
+-----------------------+----------+
| percentile(age, 90) | gender |
|-----------------------+----------|
| 28 | F |
| 36 | M |
+-----------------------+----------+
```
**Beispiel 13: Berechnet das Perzentil anhand eines Geschlechts und einer Spanne**
Im Beispiel wird das Perzentil für das 90. Lebensjahr im Abstand von 10 Jahren berechnet und nach Geschlecht gruppiert.
```
os> source=accounts | stats percentile(age, 90) as p90 by span(age, 10) as age_span, gender
fetched rows / total rows = 2/2
+-------+------------+----------+
| p90 | age_span | gender |
|-------+------------+----------|
| 28 | 20 | F |
| 36 | 30 | M |
+-------+------------+----------+
```
```
- `source = table | stats avg(a) `
- `source = table | where a < 50 | stats avg(c) `
- `source = table | stats max(c) by b`
- `source = table | stats count(c) by b | head 5`
- `source = table | stats distinct_count(c)`
- `source = table | stats stddev_samp(c)`
- `source = table | stats stddev_pop(c)`
- `source = table | stats percentile(c, 90)`
- `source = table | stats percentile_approx(c, 99)`
```
**Aggregationen mit Spanne**
```
- `source = table | stats count(a) by span(a, 10) as a_span`
- `source = table | stats sum(age) by span(age, 5) as age_span | head 2`
- `source = table | stats avg(age) by span(age, 20) as age_span, country | sort - age_span | head 2`
```
**Aggregationen mit Timewindow Span (Tumble-Windowing-Funktion)**
```
- `source = table | stats sum(productsAmount) by span(transactionDate, 1d) as age_date | sort age_date`
- `source = table | stats sum(productsAmount) by span(transactionDate, 1w) as age_date, productId`
```
**Aggregationen werden nach mehreren Ebenen gruppiert**
```
- `source = table | stats avg(age) as avg_state_age by country, state | stats avg(avg_state_age) as avg_country_age by country`
- `source = table | stats avg(age) as avg_city_age by country, state, city | eval new_avg_city_age = avg_city_age - 1 | stats avg(new_avg_city_age) as avg_state_age by country, state | where avg_state_age > 18 | stats avg(avg_state_age) as avg_adult_country_age by country`
```
#### Befehl subquery
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Verwenden Sie den `subquery` Befehl, um komplexe, verschachtelte Abfragen innerhalb Ihrer PPL-Anweisungen (Piped Processing Language) auszuführen.
```
source=logs | where field in [ subquery source=events | where condition | fields field ]
```
In diesem Beispiel wird die primäre Suche (`source=logs`) nach Ergebnissen der Unterabfrage () gefiltert. `source=events`
Der Befehl subquery unterstützt mehrere Verschachtelungsebenen für komplexe Datenanalysen.
**Beispiel für eine verschachtelte Unterabfrage**
```
source=logs | where id in [ subquery source=users | where user in [ subquery source=actions | where action="login" | fields user] | fields uid ]
```
**InSubquery Verwendung**
+ `source = outer | where a in [ source = inner | fields b ]`
+ `source = outer | where (a) in [ source = inner | fields b ]`
+ `source = outer | where (a,b,c) in [ source = inner | fields d,e,f ]`
+ `source = outer | where a not in [ source = inner | fields b ]`
+ `source = outer | where (a) not in [ source = inner | fields b ]`
+ `source = outer | where (a,b,c) not in [ source = inner | fields d,e,f ]`
+ `source = outer a in [ source = inner | fields b ]`(Suchfilterung mit Unterabfrage)
+ `source = outer a not in [ source = inner | fields b ]`(Suchfilterung mit Unterabfrage)
+ `source = outer | where a in [ source = inner1 | where b not in [ source = inner2 | fields c ] | fields b ]`(verschachtelt)
+ `source = table1 | inner join left = l right = r on l.a = r.a AND r.a in [ source = inner | fields d ] | fields l.a, r.a, b, c`(als Verbindungsfilter)
**Beispiele für die SQL-Migration mit PPL in Subquery**
TPC-H Q4 (in der Unterabfrage mit Aggregation)
```
select
o_orderpriority,
count(*) as order_count
from
orders
where
o_orderdate >= date '1993-07-01'
and o_orderdate < date '1993-07-01' + interval '3' month
and o_orderkey in (
select
l_orderkey
from
lineitem
where l_commitdate < l_receiptdate
)
group by
o_orderpriority
order by
o_orderpriority
```
Durch InSubquery PPL-Abfrage neu geschrieben:
```
source = orders
| where o_orderdate >= "1993-07-01" and o_orderdate < "1993-10-01" and o_orderkey IN
[ source = lineitem
| where l_commitdate < l_receiptdate
| fields l_orderkey
]
| stats count(1) as order_count by o_orderpriority
| sort o_orderpriority
| fields o_orderpriority, order_count
```
TPC-H Q20 (verschachtelt in einer Unterabfrage)
```
select
s_name,
s_address
from
supplier,
nation
where
s_suppkey in (
select
ps_suppkey
from
partsupp
where
ps_partkey in (
select
p_partkey
from
part
where
p_name like 'forest%'
)
)
and s_nationkey = n_nationkey
and n_name = 'CANADA'
order by
s_name
```
Durch InSubquery PPL-Abfrage neu geschrieben:
```
source = supplier
| where s_suppkey IN [
source = partsupp
| where ps_partkey IN [
source = part
| where like(p_name, "forest%")
| fields p_partkey
]
| fields ps_suppkey
]
| inner join left=l right=r on s_nationkey = n_nationkey and n_name = 'CANADA'
nation
| sort s_name
```
**ExistsSubquery Verwendung**
Annahmen:`a`, `b` sind Felder der äußeren Tabelle,`c`, `d` sind Felder der inneren Tabelle,`e`, `f` sind Felder der inneren Tabelle 2.
+ `source = outer | where exists [ source = inner | where a = c ]`
+ `source = outer | where not exists [ source = inner | where a = c ]`
+ `source = outer | where exists [ source = inner | where a = c and b = d ]`
+ `source = outer | where not exists [ source = inner | where a = c and b = d ]`
+ `source = outer exists [ source = inner | where a = c ]`(Suchfilterung mit Unterabfrage)
+ `source = outer not exists [ source = inner | where a = c ]`(Suchfilterung mit Unterabfrage)
+ `source = table as t1 exists [ source = table as t2 | where t1.a = t2.a ]`(Der Tabellenalias ist in der vorhandenen Unterabfrage nützlich)
+ `source = outer | where exists [ source = inner1 | where a = c and exists [ source = inner2 | where c = e ] ]`(verschachtelt)
+ `source = outer | where exists [ source = inner1 | where a = c | where exists [ source = inner2 | where c = e ] ]`(verschachtelt)
+ `source = outer | where exists [ source = inner | where c > 10 ]`(unkorreliert existiert)
+ `source = outer | where not exists [ source = inner | where c > 10 ]`(unkorreliert existiert)
+ `source = outer | where exists [ source = inner ] | eval l = "nonEmpty" | fields l`(es gibt ein spezielles unkorreliertes Objekt)
**ScalarSubquery Verwendung**
Annahmen:`a`, `b` sind Felder der äußeren Tabelle,`c`, `d` sind Felder der inneren Tabelle,`e`, `f` sind Felder der Tabelle verschachtelt
**Unkorrelierte skalare Unterabfrage**
In der Auswahl:
+ `source = outer | eval m = [ source = inner | stats max(c) ] | fields m, a`
+ `source = outer | eval m = [ source = inner | stats max(c) ] + b | fields m, a`
Wo:
+ `source = outer | where a > [ source = inner | stats min(c) ] | fields a`
Im Suchfilter:
+ `source = outer a > [ source = inner | stats min(c) ] | fields a`
**Korrelierte skalare Unterabfrage**
In der Auswahl:
+ `source = outer | eval m = [ source = inner | where outer.b = inner.d | stats max(c) ] | fields m, a`
+ `source = outer | eval m = [ source = inner | where b = d | stats max(c) ] | fields m, a`
+ `source = outer | eval m = [ source = inner | where outer.b > inner.d | stats max(c) ] | fields m, a`
Wo:
+ `source = outer | where a = [ source = inner | where outer.b = inner.d | stats max(c) ]`
+ `source = outer | where a = [ source = inner | where b = d | stats max(c) ]`
+ `source = outer | where [ source = inner | where outer.b = inner.d OR inner.d = 1 | stats count() ] > 0 | fields a`
Im Suchfilter:
+ `source = outer a = [ source = inner | where b = d | stats max(c) ]`
+ `source = outer [ source = inner | where outer.b = inner.d OR inner.d = 1 | stats count() ] > 0 | fields a`
**Verschachtelte skalare Unterabfrage**
+ `source = outer | where a = [ source = inner | stats max(c) | sort c ] OR b = [ source = inner | where c = 1 | stats min(d) | sort d ]`
+ `source = outer | where a = [ source = inner | where c = [ source = nested | stats max(e) by f | sort f ] | stats max(d) by c | sort c | head 1 ]`
**(Beziehung) Unterabfrage**
`InSubquery`, `ExistsSubquery` und `ScalarSubquery` sind alles Unterabfrageausdrücke. Es `RelationSubquery` handelt sich jedoch nicht um einen Unterabfrageausdruck, sondern um einen Unterabfrageplan, der häufig in der Join- oder From-Klausel verwendet wird.
+ `source = table1 | join left = l right = r [ source = table2 | where d > 10 | head 5 ]`(Unterabfrage in Join auf der rechten Seite)
+ `source = [ source = table1 | join left = l right = r [ source = table2 | where d > 10 | head 5 ] | stats count(a) by b ] as outer | head 1`
**Zusätzlicher Kontext**
`InSubquery``ExistsSubquery`, und `ScalarSubquery` sind Unterabfrageausdrücke, die häufig in `where` Klauseln und Suchfiltern verwendet werden.
Wo Befehl:
```
| where | ...
```
Suchfilter:
```
search source=* | ...
```
Ein Unterabfrageausdruck könnte in einem booleschen Ausdruck verwendet werden:
```
| where orders.order_id in [ source=returns | where return_reason="damaged" | field order_id ]
```
Das `orders.order_id in [ source=... ]` ist ein. ``
Im Allgemeinen nennen wir diese Art von Unterabfrageklausel den `InSubquery` Ausdruck. Es ist ein``.
**Unterabfrage mit unterschiedlichen Join-Typen**
Beispiel für die Verwendung eines `ScalarSubquery`:
```
source=employees
| join source=sales on employees.employee_id = sales.employee_id
| where sales.sale_amount > [ source=targets | where target_met="true" | fields target_value ]
```
Im Gegensatz zu InSubquery ExistsSubquery ScalarSubquery, und RelationSubquery ist a kein Unterabfrageausdruck. Stattdessen handelt es sich um einen Unterabfrageplan.
```
SEARCH source=customer
| FIELDS c_custkey
| LEFT OUTER JOIN left = c, right = o ON c.c_custkey = o.o_custkey
[
SEARCH source=orders
| WHERE o_comment NOT LIKE '%unusual%packages%'
| FIELDS o_orderkey, o_custkey
]
| STATS ...
```
#### oberster Befehl
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Verwenden Sie den `top` Befehl, um das häufigste Wertetupel aller Felder in der Feldliste zu finden.
**Syntax**
Verwenden Sie die folgende Syntax:
```
top [N] [by-clause] top_approx [N] [by-clause]
```
**N**
+ Die Anzahl der zurückzugebenden Ergebnisse.
+ Standard: 10
**Feldliste**
+ Zwingend erforderlich.
+ Eine kommagetrennte Liste von Feldnamen.
**Nebenklausel**
+ Optional.
+ Ein oder mehrere Felder, nach denen die Ergebnisse gruppiert werden sollen.
**top\$1approx**
+ Eine ungefähre Anzahl der (n) obersten Felder unter Verwendung des Algorithmus „Geschätzte [Kardinalität](https://spark.apache.org/docs/latest/sql-ref-functions-builtin.html) nach \$1\$1“. HyperLogLog
**Beispiel 1: Finden Sie die häufigsten Werte in einem Feld**
In diesem Beispiel wird das häufigste Geschlecht für alle Konten ermittelt.
PPL-Abfrage:
```
os> source=accounts | top gender;
os> source=accounts | top_approx gender;
fetched rows / total rows = 2/2
+----------+
| gender |
|----------|
| M |
| F |
+----------+
```
**Beispiel 2: Finden Sie die häufigsten Werte in einem Feld (begrenzt auf 1)**
In diesem Beispiel wird das häufigste Geschlecht für alle Konten ermittelt.
PPL-Abfrage:
```
os> source=accounts | top_approx 1 gender;
fetched rows / total rows = 1/1
+----------+
| gender |
|----------|
| M |
+----------+
```
**Beispiel 3: Finden Sie die gängigsten Werte, gruppiert nach Geschlecht**
In diesem Beispiel wird das häufigste Alter für alle Konten ermittelt, gruppiert nach Geschlecht.
PPL-Abfrage:
```
os> source=accounts | top 1 age by gender;
os> source=accounts | top_approx 1 age by gender;
fetched rows / total rows = 2/2
+----------+-------+
| gender | age |
|----------+-------|
| F | 28 |
| M | 32 |
+----------+-------+
```
#### Befehl trendline
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Verwenden Sie den `trendline` Befehl, um gleitende Durchschnitte von Feldern zu berechnen.
**Syntax**
Verwenden Sie die folgende Syntax
```
TRENDLINE [sort <[+|-] sort-field>] SMA(number-of-datapoints, field) [AS alias] [SMA(number-of-datapoints, field) [AS alias]]...
```
**[\$1\$1-]**
+ Optional.
+ Das Plus [\$1] steht für aufsteigende Reihenfolge, wobei die NULL/MISSING Werte an erster Stelle stehen.
+ Das Minus [-] steht für absteigende Reihenfolge, wobei die NULL/MISSING Werte zuletzt stehen.
+ Standard: Aufsteigende Reihenfolge mit den NULL/MISSING Werten an erster Stelle.
**Sortierfeld**
+ Obligatorisch, wenn die Sortierung verwendet wird.
+ Das für die Sortierung verwendete Feld.
**number-of-datapoints**
+ Zwingend erforderlich.
+ Die Anzahl der Datenpunkte, die den gleitenden Durchschnitt berechnen.
+ Muss größer als Null sein.
**field**
+ Zwingend erforderlich.
+ Der Name des Feldes, für das der gleitende Durchschnitt berechnet werden soll.
**alias**
+ Optional.
+ Der Name der resultierenden Spalte, die den gleitenden Durchschnitt enthält.
Nur der Typ Simple Moving Average (SMA) wird unterstützt. Er wird wie folgt berechnet:
```
f[i]: The value of field 'f' in the i-th data-point
n: The number of data-points in the moving window (period)
t: The current time index
SMA(t) = (1/n) * Σ(f[i]), where i = t-n+1 to t
```
**Beispiel 1: Berechne den einfachen gleitenden Durchschnitt für eine Zeitreihe von Temperaturen**
Das Beispiel berechnet den einfachen gleitenden Durchschnitt über Temperaturen anhand von zwei Datenpunkten.
PPL-Abfrage:
```
os> source=t | trendline sma(2, temperature) as temp_trend;
fetched rows / total rows = 5/5
+-----------+---------+--------------------+----------+
|temperature|device-id| timestamp|temp_trend|
+-----------+---------+--------------------+----------+
| 12| 1492|2023-04-06 17:07:...| NULL|
| 12| 1492|2023-04-06 17:07:...| 12.0|
| 13| 256|2023-04-06 17:07:...| 12.5|
| 14| 257|2023-04-06 17:07:...| 13.5|
| 15| 258|2023-04-06 17:07:...| 14.5|
+-----------+---------+--------------------+----------+
```
**Beispiel 2: Berechnung einfacher gleitender Durchschnitte für eine Zeitreihe von Temperaturen mit Sortierung**
Das Beispiel berechnet zwei einfache gleitende Durchschnittswerte über Temperaturen anhand von zwei und drei Datenpunkten, die absteigend nach der Geräte-ID sortiert sind.
PPL-Abfrage:
```
os> source=t | trendline sort - device-id sma(2, temperature) as temp_trend_2 sma(3, temperature) as temp_trend_3;
fetched rows / total rows = 5/5
+-----------+---------+--------------------+------------+------------------+
|temperature|device-id| timestamp|temp_trend_2| temp_trend_3|
+-----------+---------+--------------------+------------+------------------+
| 15| 258|2023-04-06 17:07:...| NULL| NULL|
| 14| 257|2023-04-06 17:07:...| 14.5| NULL|
| 13| 256|2023-04-06 17:07:...| 13.5| 14.0|
| 12| 1492|2023-04-06 17:07:...| 12.5| 13.0|
| 12| 1492|2023-04-06 17:07:...| 12.0|12.333333333333334|
+-----------+---------+--------------------+------------+------------------+
```
#### wo Befehl
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Der `where` Befehl verwendet einen Bool-Ausdruck, um das Suchergebnis zu filtern. Das Ergebnis wird nur zurückgegeben, wenn der bool-Ausdruck den Wert true ergibt.
**Syntax**
Verwenden Sie die folgende Syntax:
```
where
```
**boolischer Ausdruck**
+ Optional.
+ Jeder Ausdruck, der zu einem booleschen Wert ausgewertet werden könnte.
**Beispiel 1: Filtert den Ergebnissatz mit einer Bedingung**
Das Beispiel zeigt, wie Dokumente aus dem Kontenindex abgerufen werden, die bestimmte Bedingungen erfüllen.
PPL-Abfrage:
```
os> source=accounts | where account_number=1 or gender="F" | fields account_number, gender;
fetched rows / total rows = 2/2
+------------------+----------+
| account_number | gender |
|------------------+----------|
| 1 | M |
| 13 | F |
+------------------+----------+
```
**Weitere Beispiele**
**Filter mit logischen Bedingungen**
+ `source = table | where c = 'test' AND a = 1 | fields a,b,c`
+ `source = table | where c != 'test' OR a > 1 | fields a,b,c | head 1`
+ `source = table | where c = 'test' NOT a > 1 | fields a,b,c`
+ `source = table | where a = 1 | fields a,b,c`
+ `source = table | where a >= 1 | fields a,b,c`
+ `source = table | where a < 1 | fields a,b,c`
+ `source = table | where b != 'test' | fields a,b,c`
+ `source = table | where c = 'test' | fields a,b,c | head 3`
+ `source = table | where ispresent(b)`
+ `source = table | where isnull(coalesce(a, b)) | fields a,b,c | head 3`
+ `source = table | where isempty(a)`
+ `source = table | where isblank(a)`
+ `source = table | where case(length(a) > 6, 'True' else 'False') = 'True'`
+ `source = table | where a between 1 and 4`- Hinweis: Dies gibt a >= 1 und a <= 4 zurück, also [1, 4]
+ `source = table | where b not between '2024-09-10' and '2025-09-10'`- Hinweis: Dies gibt b >= '\$1\$1\$1\$1\$1\$1\$1\$1\$1\$1' und b <= '2025-09-10' zurück
+ `source = table | where cidrmatch(ip, '***********/24')`
+ `source = table | where cidrmatch(ipv6, '2003:db8::/32')`
```
source = table | eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code')
| where case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code'
) = 'Incorrect HTTP status code'
```
```
source = table
| eval factor = case(a > 15, a - 14, isnull(b), a - 7, a < 3, a + 1 else 1)
| where case(factor = 2, 'even', factor = 4, 'even', factor = 6, 'even', factor = 8, 'even' else 'odd') = 'even'
| stats count() by factor
```
#### Zusammenfassung der Felder
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diesen PPL-Befehl unterstützen, finden Sie unter. [Befehle](#supported-ppl-commands)
Verwenden Sie den `fieldsummary` Befehl, um grundlegende Statistiken für jedes Feld (Anzahl, eindeutige Anzahl, Min., Max, Avg, Stddev, Mittelwert) zu berechnen und den Datentyp für jedes Feld zu bestimmen. Dieser Befehl kann mit jeder vorhergehenden Pipe verwendet werden und berücksichtigt sie.
**Syntax**
Verwenden Sie die folgende Syntax: Für CloudWatch Logs-Anwendungsfälle wird nur ein Feld in einer Abfrage unterstützt.
```
... | fieldsummary (nulls=true/false)
```
**Felder einschließen**
+ Liste aller Spalten, die zusammen mit Statistiken in einer einheitlichen Ergebnismenge gesammelt werden sollen.
**Null-Werte**
+ Optional.
+ Wenn dieser Wert auf „true“ gesetzt ist, werden Nullwerte in die Aggregationsberechnungen einbezogen (ersetzen Sie Null durch Null für numerische Werte).
**Beispiel 1**
PPL-Abfrage:
```
os> source = t | where status_code != 200 | fieldsummary includefields= status_code nulls=true
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| Fields | COUNT | COUNT_DISTINCT | MIN | MAX | AVG | MEAN | STDDEV | NUlls | TYPEOF |
|------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| "status_code" | 2 | 2 | 301 | 403 | 352.0 | 352.0 | 72.12489168102785 | 0 | "int" |
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
```
**Beispiel 2**
PPL-Abfrage:
```
os> source = t | fieldsummary includefields= id, status_code, request_path nulls=true
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| Fields | COUNT | COUNT_DISTINCT | MIN | MAX | AVG | MEAN | STDDEV | NUlls | TYPEOF |
|------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| "id" | 6 | 6 | 1 | 6 | 3.5 | 3.5 | 1.8708286933869707 | 0 | "int" |
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| "status_code" | 4 | 3 | 200 | 403 | 184.0 | 184.0 | 161.16699413961905 | 2 | "int" |
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| "request_path" | 2 | 2 | /about| /home | 0.0 | 0.0 | 0 | 2 |"string"|
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
```
#### Befehl expandieren
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diese PPL-Funktion unterstützen, finden Sie unter. [Funktionen](#supported-ppl-functions)
Verwenden Sie den `expand` Befehl, um ein Feld vom Typ Array oder Map zu reduzieren, sodass für jedes Element oder jedes Schlüssel-Wert-Paar einzelne Zeilen erzeugt werden.
**Syntax**
Verwenden Sie die folgende Syntax:
```
expand [As alias]
```
**field**
+ Das Feld, das erweitert (aufgelöst) werden soll.
+ Das Feld muss einen unterstützten Typ haben.
**alias**
+ Optional.
+ Der Name, der anstelle des ursprünglichen Feldnamens verwendet werden soll.
**Richtlinien für die Verwendung**
Der Befehl expand erzeugt eine Zeile für jedes Element im angegebenen Array- oder Zuordnungsfeld, wobei:
+ Array-Elemente werden zu einzelnen Zeilen.
+ Map-Schlüssel-Wert-Paare werden in separate Zeilen aufgeteilt, wobei jeder Schlüsselwert als Zeile dargestellt wird.
+ Wenn ein Alias angegeben wird, werden die explodierten Werte unter dem Alias statt unter dem ursprünglichen Feldnamen dargestellt.
Sie können diesen Befehl in Kombination mit anderen Befehlen wie stats, eval und parse verwenden, um Daten nach der Erweiterung zu bearbeiten oder zu extrahieren.
**Beispiele**
+ `source = table | expand employee | stats max(salary) as max by state, company `
+ `source = table | expand employee as worker | stats max(salary) as max by state, company `
+ `source = table | expand employee as worker | eval bonus = salary * 3 | fields worker, bonus`
+ `source = table | expand employee | parse description '(?.+@.+)' | fields employee, email`
+ `source = table | eval array=json_array(1, 2, 3) | expand array as uid | fields name, occupation, uid `
+ `source = table | expand multi_valueA as multiA | expand multi_valueB as multiB`
Sie können den Befehl expand in Kombination mit anderen Befehlen wie eval, stats und anderen verwenden. Durch die Verwendung mehrerer Erweiterungsbefehle wird ein kartesisches Produkt aller internen Elemente in jeder zusammengesetzten Anordnung oder Map erstellt.
**Effektive SQL-Pushdown-Abfrage**
Der Befehl expand wird mithilfe von LATERAL VIEW explode in eine äquivalente SQL-Operation übersetzt, was eine effiziente Auflösung von Arrays oder Maps auf SQL-Abfrageebene ermöglicht.
```
SELECT customer exploded_productId
FROM table
LATERAL VIEW explode(productId) AS exploded_productId
```
Der Befehl explode bietet die folgenden Funktionen:
+ Es handelt sich um eine Spaltenoperation, die eine neue Spalte zurückgibt.
+ Dabei wird für jedes Element in der aufgelösten Spalte eine neue Zeile erstellt.
+ Interne Nullen werden als Teil des explodierten Felds ignoriert (keine Zeile steht created/exploded für Null).
#### PPL-Funktionen
**Topics**
+ [Funktionen für PPL-Bedingungen](#supported-ppl-condition-functions)
+ [Kryptografische PPL-Hash-Funktionen](#supported-ppl-cryptographic-functions)
+ [PPL-Funktionen für Datum und Uhrzeit](#supported-ppl-date-time-functions)
+ [PPL-Ausdrücke](#supported-ppl-expressions)
+ [PPL-IP-Adressfunktionen](#supported-ppl-ip-address-functions)
+ [PPL JSON-Funktionen](#supported-ppl-json-functions)
+ [PPL Lambda-Funktionen](#supported-ppl-lambda-functions)
+ [Mathematische Funktionen von PPL](#supported-ppl-math-functions)
+ [PPL-String-Funktionen](#supported-ppl-string-functions)
+ [Funktionen zur Konvertierung des PPL-Typs](#supported-ppl-type-conversion-functions)
##### Funktionen für PPL-Bedingungen
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diese PPL-Funktion unterstützen, finden Sie unter. [Funktionen](#supported-ppl-functions)
##### ISNULL
**Beschreibung**: `isnull(field)` gibt true zurück, wenn das Feld Null ist.
**Typ des Arguments:**
+ Alle unterstützten Datentypen.
**Rückgabetyp:**
+ BOOLEAN
**Beispiel:**
```
os> source=accounts | eval result = isnull(employer) | fields result, employer, firstname
fetched rows / total rows = 4/4
+----------+-------------+-------------+
| result | employer | firstname |
|----------+-------------+-------------|
| False | AnyCompany | Mary |
| False | ExampleCorp | Jane |
| False | ExampleOrg | Nikki |
| True | null | Juan |
+----------+-------------+-------------+
```
##### IST NICHT NULL
**Beschreibung**: `isnotnull(field)` gibt true zurück, wenn das Feld nicht Null ist.
**Typ des Arguments:**
+ Alle unterstützten Datentypen.
**Rückgabetyp:**
+ BOOLEAN
**Beispiel:**
```
os> source=accounts | where not isnotnull(employer) | fields account_number, employer
fetched rows / total rows = 1/1
+------------------+------------+
| account_number | employer |
|------------------+------------|
| 18 | null |
+------------------+------------+
```
##### EXISTS
**Beispiel:**
```
os> source=accounts | where exists(email) | fields account_number, email
fetched rows / total rows = 1/1
```
##### WENN NULL
**Beschreibung**: `ifnull(field1, field2)` gibt zurück, `field2` ob `field1` es Null ist.
**Typ des Arguments:**
+ Alle unterstützten Datentypen.
+ Wenn die beiden Parameter unterschiedliche Typen haben, schlägt die Funktion die Semantikprüfung fehl.
**Rückgabetyp:**
+ Beliebig
**Beispiel:**
```
os> source=accounts | eval result = ifnull(employer, 'default') | fields result, employer, firstname
fetched rows / total rows = 4/4
+------------+------------+-------------+
| result | employer | firstname |
|------------+------------+-------------|
| AnyCompany | AnyCompany | Mary |
| ExampleCorp| ExampleCorp| Jane |
| ExampleOrg | ExampleOrg | Nikki |
| default | null | Juan |
+------------+------------+-------------+
```
##### NULLIF
**Beschreibung**: Geben Sie Null `nullif(field1, field2)` zurück, wenn zwei Parameter identisch sind, andernfalls geben Sie Feld1 zurück.
**Typ des Arguments:**
+ Alle unterstützten Datentypen.
+ Wenn die beiden Parameter unterschiedliche Typen haben, schlägt die Funktion die Semantikprüfung fehl.
**Rückgabetyp:**
+ Beliebig
**Beispiel:**
```
os> source=accounts | eval result = nullif(employer, 'AnyCompany') | fields result, employer, firstname
fetched rows / total rows = 4/4
+----------------+----------------+-------------+
| result | employer | firstname |
|----------------+----------------+-------------|
| null | AnyCompany | Mary |
| ExampleCorp | ExampleCorp | Jane |
| ExampleOrg | ExampleOrg | Nikki |
| null | null | Juan |
+----------------+----------------+-------------+
```
##### IF
**Beschreibung**: `if(condition, expr1, expr2)` gibt zurück`expr1`, ob die Bedingung wahr ist, andernfalls kehrt sie zurück`expr2`.
**Typ des Arguments:**
+ Alle unterstützten Datentypen.
+ Wenn die beiden Parameter unterschiedliche Typen haben, schlägt die Funktion die Semantikprüfung fehl.
**Rückgabetyp:**
+ Beliebig
**Beispiel:**
```
os> source=accounts | eval result = if(true, firstname, lastname) | fields result, firstname, lastname
fetched rows / total rows = 4/4
+----------+-------------+----------+
| result | firstname | lastname |
|----------+-------------+----------|
| Jane | Jane | Doe |
| Mary | Mary | Major |
| Pat | Pat | Candella |
| Dale | Jorge | Souza |
+----------+-----------+------------+
os> source=accounts | eval result = if(false, firstname, lastname) | fields result, firstname, lastname
fetched rows / total rows = 4/4
+----------+-------------+------------+
| result | firstname | lastname |
|----------+-------------+------------|
| Doe | Jane | Doe |
| Major | Mary | Major |
| Candella | Pat | Candella |
| Souza | Jorge | Souza |
+----------+-------------+------------+
os> source=accounts | eval is_vip = if(age > 30 AND isnotnull(employer), true, false) | fields is_vip, firstname, lastname
fetched rows / total rows = 4/4
+----------+-------------+------------+
| is_vip | firstname | lastname |
|----------+-------------+------------|
| True | Jane | Doe |
| True | Mary | Major |
| False | Pat | Candella |
| False | Jorge | Souza |
+----------+-------------+------------+
```
##### Kryptografische PPL-Hash-Funktionen
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diese PPL-Funktion unterstützen, finden Sie unter. [Funktionen](#supported-ppl-functions)
##### MD5
MD5 berechnet den MD5 Digest und gibt den Wert als 32-stellige Hexadezimalzeichenfolge zurück.
**Verwendung:** `md5('hello')`
**Art des Arguments:**
+ STRING
**Rückgabetyp:**
+ STRING
**Beispiel:**
```
os> source=people | eval `MD5('hello')` = MD5('hello') | fields `MD5('hello')`
fetched rows / total rows = 1/1
+----------------------------------+
| MD5('hello') |
|----------------------------------|
| <32 character hex string> |
+----------------------------------+
```
##### SHA1
SHA1 gibt das Hex-String-Ergebnis von SHA-1 zurück.
**Verwendungszweck:** `sha1('hello')`
**Art des Arguments:**
+ STRING
**Rückgabetyp:**
+ STRING
**Beispiel:**
```
os> source=people | eval `SHA1('hello')` = SHA1('hello') | fields `SHA1('hello')`
fetched rows / total rows = 1/1
+------------------------------------------+
| SHA1('hello') |
|------------------------------------------|
| <40-character SHA-1 hash result> |
+------------------------------------------+
```
##### SHA2
SHA2 gibt das Hex-String-Ergebnis der SHA-2-Familie von Hashfunktionen (SHA-224, SHA-256, SHA-384 und SHA-512) zurück. NumBits gibt die gewünschte Bitlänge des Ergebnisses an, das einen Wert von 224, 256, 384, 512 haben muss
**Verwendung:**
+ `sha2('hello',256)`
+ `sha2('hello',512)`
**Typ des Arguments:**
+ ZEICHENFOLGE, GANZZAHL
**Rückgabetyp:**
+ STRING
**Beispiel:**
```
os> source=people | eval `SHA2('hello',256)` = SHA2('hello',256) | fields `SHA2('hello',256)`
fetched rows / total rows = 1/1
+------------------------------------------------------------------+
| SHA2('hello',256) |
|------------------------------------------------------------------|
| <64-character SHA-256 hash result> |
+------------------------------------------------------------------+
os> source=people | eval `SHA2('hello',512)` = SHA2('hello',512) | fields `SHA2('hello',512)`
fetched rows / total rows = 1/1
+------------------------------------------------------------------+
| SHA2('hello',512) | |
|------------------------------------------------------------------|
| <128-character SHA-512 hash result> |
+------------------------------------------------------------------+
```
##### PPL-Funktionen für Datum und Uhrzeit
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diese PPL-Funktion unterstützen, finden Sie unter. [Funktionen](#supported-ppl-functions)
##### `DAY`
**Verwendung**: `DAY(date)` Extrahiert den Tag des Monats für ein Datum im Bereich von 1 bis 31.
**Typ des Arguments**: STRING/DATE/TIMESTAMP
**Rückgabetyp**: INTEGER
**Synonyme**:`DAYOFMONTH`, `DAY_OF_MONTH`
**Beispiel:**
```
os> source=people | eval `DAY(DATE('2020-08-26'))` = DAY(DATE('2020-08-26')) | fields `DAY(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+---------------------------+
| DAY(DATE('2020-08-26')) |
|---------------------------|
| 26 |
+---------------------------+
```
##### `DAYOFMONTH`
**Verwendung**: `DAYOFMONTH(date)` Extrahiert den Tag des Monats für ein Datum im Bereich von 1 bis 31.
**Typ des Arguments**: STRING/DATE/TIMESTAMP
**Rückgabetyp**: INTEGER
**Synonyme**:`DAY`, `DAY_OF_MONTH`
**Beispiel:**
```
os> source=people | eval `DAYOFMONTH(DATE('2020-08-26'))` = DAYOFMONTH(DATE('2020-08-26')) | fields `DAYOFMONTH(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+----------------------------------+
| DAYOFMONTH(DATE('2020-08-26')) |
|----------------------------------|
| 26 |
+----------------------------------+
```
##### `DAY_OF_MONTH`
**Verwendung**: `DAY_OF_MONTH(DATE)` Extrahiert den Tag des Monats für ein Datum im Bereich von 1 bis 31.
**Typ des Arguments**: STRING/DATE/TIMESTAMP
**Rückgabetyp**: INTEGER
**Synonyme**:`DAY`, `DAYOFMONTH`
**Beispiel:**
```
os> source=people | eval `DAY_OF_MONTH(DATE('2020-08-26'))` = DAY_OF_MONTH(DATE('2020-08-26')) | fields `DAY_OF_MONTH(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+------------------------------------+
| DAY_OF_MONTH(DATE('2020-08-26')) |
|------------------------------------|
| 26 |
+------------------------------------+
```
##### `DAYOFWEEK`
**Verwendung**: `DAYOFWEEK(DATE)` Gibt den Wochentagsindex für ein Datum zurück (1 = Sonntag, 2 = Montag,..., 7 = Samstag).
**Typ des Arguments**: STRING/DATE/TIMESTAMP
**Rückgabetyp**: INTEGER
**Synonyme**: `DAY_OF_WEEK`
**Beispiel:**
```
os> source=people | eval `DAYOFWEEK(DATE('2020-08-26'))` = DAYOFWEEK(DATE('2020-08-26')) | fields `DAYOFWEEK(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+---------------------------------+
| DAYOFWEEK(DATE('2020-08-26')) |
|---------------------------------|
| 4 |
+---------------------------------+
```
##### `DAY_OF_WEEK`
**Verwendung**: `DAY_OF_WEEK(DATE)` Gibt den Wochentagsindex für ein Datum zurück (1 = Sonntag, 2 = Montag,..., 7 = Samstag).
**Typ des Arguments**: STRING/DATE/TIMESTAMP
**Rückgabetyp**: INTEGER
**Synonyme**: `DAYOFWEEK`
**Beispiel:**
```
os> source=people | eval `DAY_OF_WEEK(DATE('2020-08-26'))` = DAY_OF_WEEK(DATE('2020-08-26')) | fields `DAY_OF_WEEK(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-----------------------------------+
| DAY_OF_WEEK(DATE('2020-08-26')) |
|-----------------------------------|
| 4 |
+-----------------------------------+
```
##### `DAYOFYEAR`
**Verwendung**: `DAYOFYEAR(DATE)` Gibt den Tag des Jahres für ein Datum im Bereich von 1 bis 366 zurück.
**Typ des Arguments**: STRING/DATE/TIMESTAMP
**Rückgabetyp**: INTEGER
**Synonyme**: `DAY_OF_YEAR`
**Beispiel:**
```
os> source=people | eval `DAYOFYEAR(DATE('2020-08-26'))` = DAYOFYEAR(DATE('2020-08-26')) | fields `DAYOFYEAR(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+---------------------------------+
| DAYOFYEAR(DATE('2020-08-26')) |
|---------------------------------|
| 239 |
+---------------------------------+
```
##### `DAY_OF_YEAR`
**Verwendung**: `DAY_OF_YEAR(DATE)` Gibt den Tag des Jahres für ein Datum im Bereich von 1 bis 366 zurück.
**Typ des Arguments**: STRING/DATE/TIMESTAMP
**Rückgabetyp**: INTEGER
**Synonyme**: `DAYOFYEAR`
**Beispiel:**
```
os> source=people | eval `DAY_OF_YEAR(DATE('2020-08-26'))` = DAY_OF_YEAR(DATE('2020-08-26')) | fields `DAY_OF_YEAR(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-----------------------------------+
| DAY_OF_YEAR(DATE('2020-08-26')) |
|-----------------------------------|
| 239 |
+-----------------------------------+
```
##### `DAYNAME`
**Verwendung**: `DAYNAME(DATE)` Gibt den Namen des Wochentags für ein Datum zurück, einschließlich Montag, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag und Sonntag.
**Typ des Arguments**: STRING/DATE/TIMESTAMP
**Rückgabetyp**: STRING
**Beispiel:**
```
os> source=people | eval `DAYNAME(DATE('2020-08-26'))` = DAYNAME(DATE('2020-08-26')) | fields `DAYNAME(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-------------------------------+
| DAYNAME(DATE('2020-08-26')) |
|-------------------------------|
| Wednesday |
+-------------------------------+
```
##### `FROM_UNIXTIME`
**Verwendung**: `FROM_UNIXTIME` Gibt eine Darstellung des angegebenen Arguments als Zeitstempel oder Zeichenkettenwert zurück. Diese Funktion führt eine umgekehrte Konvertierung der `UNIX_TIMESTAMP` Funktion durch.
Wenn Sie ein zweites Argument angeben, `FROM_UNIXTIME` verwendet es, um das Ergebnis ähnlich der `DATE_FORMAT` Funktion zu formatieren.
Wenn der Zeitstempel außerhalb des Bereichs 1970-01-01 00:00:00 bis 3001-01-18 23:59:59.999 999 (0 bis 32536771199.999999 Epochenzeit) liegt, gibt die Funktion zurück. `NULL`
**Argumenttyp**: DOUBLE, STRING
**Rückgabetyp Map**:
DOPPELT -> ZEITSTEMPEL
DOPPELT, ZEICHENFOLGE -> ZEICHENFOLGE
**Beispiele:**
```
os> source=people | eval `FROM_UNIXTIME(1220249547)` = FROM_UNIXTIME(1220249547) | fields `FROM_UNIXTIME(1220249547)`
fetched rows / total rows = 1/1
+-----------------------------+
| FROM_UNIXTIME(1220249547) |
|-----------------------------|
| 2008-09-01 06:12:27 |
+-----------------------------+
os> source=people | eval `FROM_UNIXTIME(1220249547, 'HH:mm:ss')` = FROM_UNIXTIME(1220249547, 'HH:mm:ss') | fields `FROM_UNIXTIME(1220249547, 'HH:mm:ss')`
fetched rows / total rows = 1/1
+-----------------------------------------+
| FROM_UNIXTIME(1220249547, 'HH:mm:ss') |
|-----------------------------------------|
| 06:12:27 |
+-----------------------------------------+
```
##### `HOUR`
**Verwendung**: `HOUR(TIME)` extrahiert den Stundenwert für die Zeit.
Im Gegensatz zu einer Standardzeit kann der Zeitwert in dieser Funktion einen Bereich von mehr als 23 haben. Daher `HOUR(TIME)` kann der Rückgabewert von größer als 23 sein.
**Typ des Arguments**: STRING/TIME/TIMESTAMP
**Rückgabetyp**: INTEGER
**Synonyme**: `HOUR_OF_DAY`
**Beispiel:**
```
os> source=people | eval `HOUR(TIME('01:02:03'))` = HOUR(TIME('01:02:03')) | fields `HOUR(TIME('01:02:03'))`
fetched rows / total rows = 1/1
+--------------------------+
| HOUR(TIME('01:02:03')) |
|--------------------------|
| 1 |
+--------------------------+
```
##### `HOUR_OF_DAY`
**Verwendung**: `HOUR_OF_DAY(TIME)` Extrahiert den Stundenwert aus der angegebenen Zeit.
Im Gegensatz zu einer Standardzeit kann der Zeitwert in dieser Funktion einen Bereich von mehr als 23 haben. Daher `HOUR_OF_DAY(TIME)` kann der Rückgabewert von größer als 23 sein.
**Typ des Arguments**: STRING/TIME/TIMESTAMP
**Rückgabetyp**: INTEGER
**Synonyme**: `HOUR`
**Beispiel:**
```
os> source=people | eval `HOUR_OF_DAY(TIME('01:02:03'))` = HOUR_OF_DAY(TIME('01:02:03')) | fields `HOUR_OF_DAY(TIME('01:02:03'))`
fetched rows / total rows = 1/1
+---------------------------------+
| HOUR_OF_DAY(TIME('01:02:03')) |
|---------------------------------|
| 1 |
+---------------------------------+
```
##### `LAST_DAY`
**Verwendung**: `LAST_DAY` Gibt den letzten Tag des Monats als DATE-Wert für das angegebene Datumsargument zurück.
**Typ des Arguments**: DATE/STRING/TIMESTAMP/TIME
**Rückgabetyp**: DATUM
**Beispiel:**
```
os> source=people | eval `last_day('2023-02-06')` = last_day('2023-02-06') | fields `last_day('2023-02-06')`
fetched rows / total rows = 1/1
+--------------------------+
| last_day('2023-02-06') |
|--------------------------|
| 2023-02-28 |
+--------------------------+
```
##### `LOCALTIMESTAMP`
**Verwendung**: `LOCALTIMESTAMP()` ist ein Synonym für`NOW()`.
**Beispiel:**
```
> source=people | eval `LOCALTIMESTAMP()` = LOCALTIMESTAMP() | fields `LOCALTIMESTAMP()`
fetched rows / total rows = 1/1
+---------------------+
| LOCALTIMESTAMP() |
|---------------------|
| 2022-08-02 15:54:19 |
+---------------------+
```
##### `LOCALTIME`
**Verwendung**: `LOCALTIME()` ist ein Synonym für. `NOW()`
**Beispiel:**
```
> source=people | eval `LOCALTIME()` = LOCALTIME() | fields `LOCALTIME()`
fetched rows / total rows = 1/1
+---------------------+
| LOCALTIME() |
|---------------------|
| 2022-08-02 15:54:19 |
+---------------------+
```
##### `MAKE_DATE`
**Verwendung**: `MAKE_DATE` Gibt einen Datumswert zurück, der auf den angegebenen Jahres-, Monats- und Tageswerten basiert. Alle Argumente werden auf ganze Zahlen gerundet.
**Spezifikationen**: 1. MAKE\$1DATE (GANZZAHL, GANZZAHL, GANZZAHL) -> DATUM
**Argumenttyp**: INTEGER, INTEGER, INTEGER
**Rückgabetyp**: DATE
**Beispiel:**
```
os> source=people | eval `MAKE_DATE(1945, 5, 9)` = MAKEDATE(1945, 5, 9) | fields `MAKEDATE(1945, 5, 9)`
fetched rows / total rows = 1/1
+------------------------+
| MAKEDATE(1945, 5, 9) |
|------------------------|
| 1945-05-09 |
+------------------------+
```
##### `MINUTE`
**Verwendung**: `MINUTE(TIME)` Gibt die Minutenkomponente der angegebenen Zeit als Ganzzahl im Bereich 0 bis 59 zurück.
**Typ des Arguments**: STRING/TIME/TIMESTAMP
**Rückgabetyp**: INTEGER
**Synonyme**: `MINUTE_OF_HOUR`
**Beispiel:**
```
os> source=people | eval `MINUTE(TIME('01:02:03'))` = MINUTE(TIME('01:02:03')) | fields `MINUTE(TIME('01:02:03'))`
fetched rows / total rows = 1/1
+----------------------------+
| MINUTE(TIME('01:02:03')) |
|----------------------------|
| 2 |
+----------------------------+
```
##### `MINUTE_OF_HOUR`
**Verwendung**: `MINUTE_OF_HOUR(TIME)` Gibt die Minutenkomponente der angegebenen Zeit als Ganzzahl im Bereich von 0 bis 59 zurück.
**Typ des Arguments**: STRING/TIME/TIMESTAMP
**Rückgabetyp**: INTEGER
**Synonyme**: `MINUTE`
**Beispiel:**
```
os> source=people | eval `MINUTE_OF_HOUR(TIME('01:02:03'))` = MINUTE_OF_HOUR(TIME('01:02:03')) | fields `MINUTE_OF_HOUR(TIME('01:02:03'))`
fetched rows / total rows = 1/1
+------------------------------------+
| MINUTE_OF_HOUR(TIME('01:02:03')) |
|------------------------------------|
| 2 |
+------------------------------------+
```
##### `MONTH`
**Verwendung**: `MONTH(DATE)` Gibt den Monat des angegebenen Datums als Ganzzahl im Bereich 1 bis 12 zurück (wobei 1 für Januar und 12 für Dezember steht).
**Typ des Arguments**: STRING/DATE/TIMESTAMP
**Rückgabetyp**: INTEGER
**Synonyme**: `MONTH_OF_YEAR`
**Beispiel:**
```
os> source=people | eval `MONTH(DATE('2020-08-26'))` = MONTH(DATE('2020-08-26')) | fields `MONTH(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-----------------------------+
| MONTH(DATE('2020-08-26')) |
|-----------------------------|
| 8 |
+-----------------------------+
```
##### `MONTHNAME`
**Verwendung**: `MONTHNAME(DATE)` Gibt den Monat des angegebenen Datums als Ganzzahl im Bereich 1 bis 12 zurück (wobei 1 für Januar und 12 für Dezember steht).
**Typ des Arguments**: STRING/DATE/TIMESTAMP
**Rückgabetyp**: INTEGER
**Synonyme**: `MONTH_OF_YEAR`
**Beispiel:**
```
os> source=people | eval `MONTHNAME(DATE('2020-08-26'))` = MONTHNAME(DATE('2020-08-26')) | fields `MONTHNAME(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+---------------------------------+
| MONTHNAME(DATE('2020-08-26')) |
|---------------------------------|
| August |
+---------------------------------+
```
##### `MONTH_OF_YEAR`
**Verwendung**: `MONTH_OF_YEAR(DATE)` Gibt den Monat des angegebenen Datums als Ganzzahl im Bereich 1 bis 12 zurück (wobei 1 für Januar und 12 für Dezember steht).
**Typ des Arguments**: STRING/DATE/TIMESTAMP
**Rückgabetyp**: INTEGER
**Synonyme**: `MONTH`
**Beispiel:**
```
os> source=people | eval `MONTH_OF_YEAR(DATE('2020-08-26'))` = MONTH_OF_YEAR(DATE('2020-08-26')) | fields `MONTH_OF_YEAR(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-------------------------------------+
| MONTH_OF_YEAR(DATE('2020-08-26')) |
|-------------------------------------|
| 8 |
+-------------------------------------+
```
##### `NOW`
**Verwendung**: `NOW` Gibt das aktuelle Datum und die aktuelle Uhrzeit als `TIMESTAMP` Wert im YYYY-MM-DD Format 'hh:mm:ss' zurück. Der Wert wird in der Cluster-Zeitzone ausgedrückt.
**Anmerkung**
`NOW()`gibt eine konstante Zeit zurück, die angibt, wann die Anweisung ausgeführt wurde. Dies unterscheidet sich von`SYSDATE()`, welche den genauen Zeitpunkt der Ausführung zurückgibt.
**Rückgabetyp**: TIMESTAMP
**Spezifikation**: NOW () -> TIMESTAMP
**Beispiel:**
```
os> source=people | eval `value_1` = NOW(), `value_2` = NOW() | fields `value_1`, `value_2`
fetched rows / total rows = 1/1
+---------------------+---------------------+
| value_1 | value_2 |
|---------------------+---------------------|
| 2022-08-02 15:39:05 | 2022-08-02 15:39:05 |
+---------------------+---------------------+
```
##### `QUARTER`
**Verwendung**: `QUARTER(DATE)` Gibt das Quartal des Jahres für das angegebene Datum als Ganzzahl im Bereich 1 bis 4 zurück.
**Typ des Arguments**: STRING/DATE/TIMESTAMP
**Rückgabetyp**: INTEGER
**Beispiel:**
```
os> source=people | eval `QUARTER(DATE('2020-08-26'))` = QUARTER(DATE('2020-08-26')) | fields `QUARTER(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-------------------------------+
| QUARTER(DATE('2020-08-26')) |
|-------------------------------|
| 3 |
+-------------------------------+
```
##### `SECOND`
**Verwendung**: `SECOND(TIME)` Gibt die zweite Komponente der angegebenen Zeit als Ganzzahl im Bereich 0 bis 59 zurück.
**Typ des Arguments**: STRING/TIME/TIMESTAMP
**Rückgabetyp**: INTEGER
**Synonyme**: `SECOND_OF_MINUTE`
**Beispiel:**
```
os> source=people | eval `SECOND(TIME('01:02:03'))` = SECOND(TIME('01:02:03')) | fields `SECOND(TIME('01:02:03'))`
fetched rows / total rows = 1/1
+----------------------------+
| SECOND(TIME('01:02:03')) |
|----------------------------|
| 3 |
+----------------------------+
```
##### `SECOND_OF_MINUTE`
**Verwendung**: `SECOND_OF_MINUTE(TIME)` Gibt die zweite Komponente der angegebenen Zeit als Ganzzahl im Bereich 0 bis 59 zurück.
**Typ des Arguments**: STRING/TIME/TIMESTAMP
**Rückgabetyp**: INTEGER
**Synonyme**: `SECOND`
**Beispiel:**
```
os> source=people | eval `SECOND_OF_MINUTE(TIME('01:02:03'))` = SECOND_OF_MINUTE(TIME('01:02:03')) | fields `SECOND_OF_MINUTE(TIME('01:02:03'))`
fetched rows / total rows = 1/1
+--------------------------------------+
| SECOND_OF_MINUTE(TIME('01:02:03')) |
|--------------------------------------|
| 3 |
+--------------------------------------+
```
##### `SUBDATE`
**Verwendung**: `SUBDATE(DATE, DAYS)` subtrahiert das zweite Argument (wie `DATE` oder`DAYS`) vom angegebenen Datum.
**Argumenttyp: DATE/TIMESTAMP**, LONG
**Rückgabetypzuordnung**: (DATE, LONG) -> DATE
**Antonymen**: `ADDDATE`
**Beispiel:**
```
os> source=people | eval `'2008-01-02' - 31d` = SUBDATE(DATE('2008-01-02'), 31), `'2020-08-26' - 1` = SUBDATE(DATE('2020-08-26'), 1), `ts '2020-08-26 01:01:01' - 1` = SUBDATE(TIMESTAMP('2020-08-26 01:01:01'), 1) | fields `'2008-01-02' - 31d`, `'2020-08-26' - 1`, `ts '2020-08-26 01:01:01' - 1`
fetched rows / total rows = 1/1
+----------------------+--------------------+--------------------------------+
| '2008-01-02' - 31d | '2020-08-26' - 1 | ts '2020-08-26 01:01:01' - 1 |
|----------------------+--------------------+--------------------------------|
| 2007-12-02 00:00:00 | 2020-08-25 | 2020-08-25 01:01:01 |
+----------------------+--------------------+--------------------------------+
```
##### `SYSDATE`
**Verwendung**: `SYSDATE()` Gibt das aktuelle Datum und die aktuelle Uhrzeit als `TIMESTAMP` Wert im YYYY-MM-DD Format 'hh:mm:ss.nnnnnn' zurück.
`SYSDATE()`gibt die genaue Uhrzeit zurück, zu der es ausgeführt wird. Dies unterscheidet sich von NOW (), das eine konstante Zeit zurückgibt, die angibt, wann die Anweisung ausgeführt wurde.
**Optionaler Argumenttyp**: INTEGER (0 bis 6) — Gibt die Anzahl der Ziffern für Sekundenbruchteile im Rückgabewert an.
**Rückgabetyp: TIMESTAMP**
**Beispiel:**
```
os> source=people | eval `SYSDATE()` = SYSDATE() | fields `SYSDATE()`
fetched rows / total rows = 1/1
+----------------------------+
| SYSDATE() |
|----------------------------|
| 2022-08-02 15:39:05.123456 |
+----------------------------+
```
##### `TIMESTAMP`
**Verwendung**: `TIMESTAMP(EXPR)` Konstruiert einen Zeitstempeltyp mit der Eingabezeichenfolge `expr` als Zeitstempel.
`TIMESTAMP(expr)`Konstruiert mit einem einzigen Argument einen Zeitstempel aus der Eingabe. Wenn es `expr` sich um eine Zeichenfolge handelt, wird sie als Zeitstempel interpretiert. Bei Argumenten, die keine Zeichenketten sind, wandelt die Funktion mithilfe der UTC-Zeitzone in einen Zeitstempel `expr` um. Wenn ein `TIME` Wert `expr` ist, wendet die Funktion vor der Umwandlung das heutige Datum an.
Bei Verwendung mit zwei Argumenten wird der Zeitausdruck (`expr2`) zum Datums- oder Zeitstempelausdruck (`expr1`) `TIMESTAMP(expr1, expr2)` hinzugefügt und das Ergebnis als Zeitstempelwert zurückgegeben.
Typ des **Arguments**: STRING/DATE/TIME/TIMESTAMP
**Rückgabetyp Map**:
(STRING/DATE/TIME/TIMESTAMP) -> ZEITSTEMPEL
(STRING/DATE/TIME/TIMESTAMP, STRING/DATE/TIME/TIMESTAMP) -> ZEITSTEMPEL
**Beispiel:**
```
os> source=people | eval `TIMESTAMP('2020-08-26 13:49:00')` = TIMESTAMP('2020-08-26 13:49:00'), `TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42'))` = TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42')) | fields `TIMESTAMP('2020-08-26 13:49:00')`, `TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42'))`
fetched rows / total rows = 1/1
+------------------------------------+------------------------------------------------------+
| TIMESTAMP('2020-08-26 13:49:00') | TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42')) |
|------------------------------------+------------------------------------------------------|
| 2020-08-26 13:49:00 | 2020-08-27 02:04:42 |
+------------------------------------+------------------------------------------------------+
```
##### `UNIX_TIMESTAMP`
**Verwendung**: `UNIX_TIMESTAMP` Konvertiert ein gegebenes Datumsargument in Unix-Zeit (Sekunden seit der Epoche, die Anfang 1970 begann). Wenn kein Argument angegeben wird, gibt es die aktuelle Unix-Zeit zurück.
Das Datumsargument kann eine`DATE`, eine `TIMESTAMP` Zeichenfolge oder eine Zahl in einem der folgenden Formate sein: `YYMMDD``YYMMDDhhmmss`,`YYYYMMDD`, oder`YYYYMMDDhhmmss`. Wenn das Argument eine Zeitkomponente enthält, kann es optional Sekundenbruchteile enthalten.
Wenn das Argument ein ungültiges Format hat oder außerhalb des Bereichs von 1970-01-01 00:00:00 bis 3001-01-18 23:59:59.999 999 (0 bis 32536771199.999999 in Epochenzeit) liegt, gibt die Funktion zurück. `NULL`
Die Funktion akzeptiert, oder als `DATE` Argumenttypen oder `DOUBLE` kein Argument. `TIMESTAMP` Sie gibt immer einen `DOUBLE` Wert zurück, der den Unix-Zeitstempel darstellt.
Für die umgekehrte Konvertierung können Sie die Funktion FROM\$1UNIXTIME verwenden.
**Argumenttyp:/DOUBLE/DATE/TIMESTAMP**
**Rückgabetyp**: DOUBLE
**Beispiel:**
```
os> source=people | eval `UNIX_TIMESTAMP(double)` = UNIX_TIMESTAMP(20771122143845), `UNIX_TIMESTAMP(timestamp)` = UNIX_TIMESTAMP(TIMESTAMP('1996-11-15 17:05:42')) | fields `UNIX_TIMESTAMP(double)`, `UNIX_TIMESTAMP(timestamp)`
fetched rows / total rows = 1/1
+--------------------------+-----------------------------+
| UNIX_TIMESTAMP(double) | UNIX_TIMESTAMP(timestamp) |
|--------------------------+-----------------------------|
| 3404817525.0 | 848077542.0 |
+--------------------------+-----------------------------+
```
##### `WEEK`
**Verwendung**: `WEEK(DATE)` Gibt die Wochennummer für ein bestimmtes Datum zurück.
**Typ des Arguments**: DATE/TIMESTAMP/STRING
**Rückgabetyp**: INTEGER
**Synonyme**: `WEEK_OF_YEAR`
**Beispiel:**
```
os> source=people | eval `WEEK(DATE('2008-02-20'))` = WEEK(DATE('2008-02-20')) | fields `WEEK(DATE('2008-02-20'))`
fetched rows / total rows = 1/1
+----------------------------+
| WEEK(DATE('2008-02-20')) |
|----------------------------|
| 8 |
+----------------------------+
```
##### `WEEKDAY`
**Verwendung**: `WEEKDAY(DATE)` Gibt den Wochentagsindex für das Datum zurück (0 = Montag, 1 = Dienstag,..., 6 = Sonntag).
Sie ähnelt der `dayofweek` Funktion, gibt jedoch für jeden Tag unterschiedliche Indizes zurück.
**Typ des Arguments:** STRING/DATE/TIME/TIMESTAMP
**Rückgabetyp**: INTEGER
**Beispiel:**
```
os> source=people | eval `weekday(DATE('2020-08-26'))` = weekday(DATE('2020-08-26')) | eval `weekday(DATE('2020-08-27'))` = weekday(DATE('2020-08-27')) | fields `weekday(DATE('2020-08-26'))`, `weekday(DATE('2020-08-27'))`
fetched rows / total rows = 1/1
+-------------------------------+-------------------------------+
| weekday(DATE('2020-08-26')) | weekday(DATE('2020-08-27')) |
|-------------------------------+-------------------------------|
| 2 | 3 |
+-------------------------------+-------------------------------+
```
##### `WEEK_OF_YEAR`
**Verwendung**: `WEEK_OF_YEAR(DATE)` Gibt die Wochennummer für das angegebene Datum zurück.
**Typ des Arguments**: DATE/TIMESTAMP/STRING
**Rückgabetyp**: INTEGER
**Synonyme**: `WEEK`
**Beispiel:**
```
os> source=people | eval `WEEK_OF_YEAR(DATE('2008-02-20'))` = WEEK(DATE('2008-02-20'))| fields `WEEK_OF_YEAR(DATE('2008-02-20'))`
fetched rows / total rows = 1/1
+------------------------------------+
| WEEK_OF_YEAR(DATE('2008-02-20')) |
|------------------------------------|
| 8 |
+------------------------------------+
```
##### `YEAR`
**Verwendung**: `YEAR(DATE)` Gibt das Jahr für das Datum im Bereich 1000 bis 9999 oder 0 für das Datum „Null“ zurück.
**Typ des Arguments:** STRING/DATE/TIMESTAMP
**Rückgabetyp**: INTEGER
**Beispiel:**
```
os> source=people | eval `YEAR(DATE('2020-08-26'))` = YEAR(DATE('2020-08-26')) | fields `YEAR(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+----------------------------+
| YEAR(DATE('2020-08-26')) |
|----------------------------|
| 2020 |
+----------------------------+
```
##### `DATE_ADD`
**Verwendung**: `DATE_ADD(date, INTERVAL expr unit)` Fügt dem angegebenen Datum das angegebene Intervall hinzu.
**Argumenttyp**: DATE, INTERVAL
**Rückgabetyp**: DATE
**Antonymen**: `DATE_SUB`
**Beispiel:**
```
os> source=people | eval `'2020-08-26' + 1d` = DATE_ADD(DATE('2020-08-26'), INTERVAL 1 DAY) | fields `'2020-08-26' + 1d`
fetched rows / total rows = 1/1
+---------------------+
| '2020-08-26' + 1d |
|---------------------|
| 2020-08-27 |
+---------------------+
```
##### `DATE_SUB`
**Verwendung**: `DATE_SUB(date, INTERVAL expr unit)` subtrahiert das Intervall expr vom Datum.
**Argumenttyp: DATE**, INTERVAL
**Rückgabetyp**: DATE
**Antonymen**: `DATE_ADD`
**Beispiel:**
```
os> source=people | eval `'2008-01-02' - 31d` = DATE_SUB(DATE('2008-01-02'), INTERVAL 31 DAY) | fields `'2008-01-02' - 31d`
fetched rows / total rows = 1/1
+---------------------+
| '2008-01-02' - 31d |
|---------------------|
| 2007-12-02 |
+---------------------+
```
##### `TIMESTAMPADD`
**Verwendung**: Gibt einen `TIMESTAMP` Wert zurück, nachdem ein bestimmtes Zeitintervall zu einem bestimmten Datum hinzugefügt wurde.
**Argumente**:
+ Intervall: INTERVALL (SEKUNDE, MINUTE, STUNDE, TAG, WOCHE, MONAT, QUARTAL, JAHR)
+ Ganzzahl: GANZZAHL
+ Datum: DATE, TIMESTAMP oder STRING
Wenn Sie a `STRING` als Datumsargument angeben, formatieren Sie es als `TIMESTAMP` gültiges Argument. Die Funktion konvertiert ein `DATE` Argument automatisch in ein`TIMESTAMP`.
**Beispiele:**
```
os> source=people | eval `TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00')` = TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00') | eval `TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00')` = TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00') | fields `TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00')`, `TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00')`
fetched rows / total rows = 1/1
+----------------------------------------------+--------------------------------------------------+
| TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00') | TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00') |
|----------------------------------------------+--------------------------------------------------|
| 2000-01-18 00:00:00 | 1999-10-01 00:00:00 |
+----------------------------------------------+--------------------------------------------------+
```
##### `TIMESTAMPDIFF`
**Verwendung**: `TIMESTAMPDIFF(interval, start, end)` Gibt die Differenz zwischen Start und Ende date/times in angegebenen Intervalleinheiten zurück.
**Argumente**:
+ Intervall: INTERVALL (SEKUNDE, MINUTE, STUNDE, TAG, WOCHE, MONAT, QUARTAL, JAHR)
+ Start: DATUM, ZEITSTEMPEL oder ZEICHENFOLGE
+ Ende: DATE, TIMESTAMP oder STRING
Die Funktion konvertiert Argumente `TIMESTAMP` bei Bedarf automatisch in. Formatieren Sie `STRING` Argumente als gültiges `TIMESTAMP` s.
**Beispiele:**
```
os> source=people | eval `TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00')` = TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00') | eval `TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00'))` = TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00')) | fields `TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00')`, `TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00'))`
fetched rows / total rows = 1/1
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------+
| TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00') | TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00')) |
|-------------------------------------------------------------------+-------------------------------------------------------------------------------------------|
| 4 | -23 |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------+
```
##### `UTC_TIMESTAMP`
**Verwendung**: `UTC_TIMESTAMP` Gibt den aktuellen UTC-Zeitstempel als Wert in 'YYYY-MM-DD hh:mm:ss' zurück.
Rückgabetyp**:** TIMESTAMP
**Spezifikation**: UTC\$1TIMESTAMP () -> TIMESTAMP
**Beispiel:**
```
> source=people | eval `UTC_TIMESTAMP()` = UTC_TIMESTAMP() | fields `UTC_TIMESTAMP()`
fetched rows / total rows = 1/1
+---------------------+
| UTC_TIMESTAMP() |
|---------------------|
| 2022-10-03 17:54:28 |
+---------------------+
```
##### `CURRENT_TIMEZONE`
**Syntax**: `CURRENT_TIMEZONE` gibt die aktuelle lokale Zeitzone zurück.
**Rückgabetyp**: STRING
**Beispiel:**
```
> source=people | eval `CURRENT_TIMEZONE()` = CURRENT_TIMEZONE() | fields `CURRENT_TIMEZONE()`
fetched rows / total rows = 1/1
+------------------------+
| CURRENT_TIMEZONE() |
|------------------------|
| America/Chicago |
+------------------------+
```
##### PPL-Ausdrücke
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diese PPL-Funktion unterstützen, finden Sie unter. [Funktionen](#supported-ppl-functions)
Ausdrücke, insbesondere Wertausdrücke, geben einen Skalarwert zurück. Ausdrücke haben unterschiedliche Typen und Formen. Beispielsweise gibt es Literalwerte als Atomausdrücke und darauf aufbauende Arithmetik-, Prädikat- und Funktionsausdrücke. Sie können Ausdrücke in verschiedenen Klauseln verwenden, z. B. mithilfe von arithmetischen Ausdrücken in Befehlen und. `Filter` `Stats`
**Operatoren**
Ein arithmetischer Ausdruck ist ein Ausdruck, der aus numerischen Literalen und binären arithmetischen Operatoren wie folgt besteht:
1. `+`: Hinzufügen.
1. `-`: Subtrahieren.
1. `*`: Multiplizieren.
1. `/`: Dividieren (Bei ganzen Zahlen ist das Ergebnis eine ganze Zahl, wobei der Bruchteil verworfen wird)
1. `%`: Modulo (Nur für ganze Zahlen verwenden; das Ergebnis ist der Rest der Division)
**Vorrang**
Verwenden Sie Klammern, um die Rangfolge arithmetischer Operatoren zu steuern. Andernfalls werden Operatoren mit höherer Priorität zuerst ausgeführt.
**Typkonvertierung**
Die implizite Typkonvertierung wird beim Nachschlagen von Operatorsignaturen durchgeführt. Beispielsweise entspricht eine Ganzzahl und `+` eine reelle Zahl einer Signatur`+(double,double)`, was zu einer reellen Zahl führt. Diese Regel gilt auch für Funktionsaufrufen.
Beispiel für verschiedene Arten von arithmetischen Ausdrücken:
```
os> source=accounts | where age > (25 + 5) | fields age ;
fetched rows / total rows = 3/3
+-------+
| age |
|-------|
| 32 |
| 36 |
| 33 |
+-------+
```
**Prädikatoperatoren**
Ein Prädikatoperator ist ein Ausdruck, der als wahr ausgewertet wird. Der Vergleich von `NULL` Werten `MISSING` und Werten folgt den folgenden Regeln:
+ Ein `MISSING` Wert entspricht nur einem `MISSING` Wert und ist kleiner als andere Werte.
+ Ein `NULL` Wert entspricht einem `NULL` Wert, ist größer als ein `MISSING` Wert, aber kleiner als alle anderen Werte.
**Operatoren**
**Prädikat-Operatoren**
| Name | Description |
| --- | --- |
| > | Größer als Operator |
| >= | Operator größer als oder gleich |
| < | Kleiner als Operator |
| \$1= | Nicht gleicher Operator |
| <= | Operator „Kleiner als“ oder „gleich“ |
| = | Gleicher Operator |
| LIKE | Einfacher Musterabgleich |
| IN | NULL-Wert-Test |
| AND | AND-Operator |
| OR | OR-Operator |
| XOR | XOR-Operator |
| NOT | NICHT NULL-Werttest |
Sie können Datums- und Uhrzeitangaben vergleichen. Beim Vergleich verschiedener Datetime-Typen (z. B. `DATE` und`TIME`) werden beide in umgewandelt. `DATETIME` Für die Konvertierung gelten die folgenden Regeln:
+ `TIME`gilt für das heutige Datum.
+ `DATE`wird um Mitternacht gedolmetscht.
**Grundlegender Prädikatoperator**
Beispiel für Vergleichsoperatoren:
```
os> source=accounts | where age > 33 | fields age ;
fetched rows / total rows = 1/1
+-------+
| age |
|-------|
| 36 |
+-------+
```
**`IN`**
Beispiel für das `IN` Operator-Testfeld in Wertelisten:
```
os> source=accounts | where age in (32, 33) | fields age ;
fetched rows / total rows = 2/2
+-------+
| age |
|-------|
| 32 |
| 33 |
+-------+
```
**`OR`**
Beispiel für den `OR` Operator:
```
os> source=accounts | where age = 32 OR age = 33 | fields age ;
fetched rows / total rows = 2/2
+-------+
| age |
|-------|
| 32 |
| 33 |
+-------+
```
**`NOT`**
Beispiel für den `NOT` Operator:
```
os> source=accounts | where age not in (32, 33) | fields age ;
fetched rows / total rows = 2/2
+-------+
| age |
|-------|
| 36 |
| 28 |
+-------+
```
##### PPL-IP-Adressfunktionen
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diese PPL-Funktion unterstützen, finden Sie unter. [Funktionen](#supported-ppl-functions)
##### `CIDRMATCH`
**Verwendung**: `CIDRMATCH(ip, cidr)` Überprüft, ob die angegebene IP-Adresse innerhalb des angegebenen CIDR-Bereichs liegt.
**Typ des Arguments:**
+ ZEICHENFOLGE, ZEICHENFOLGE
+ Rückgabetyp: BOOLEAN
**Beispiel:**
```
os> source=ips | where cidrmatch(ip, '***********/24') | fields ip
fetched rows / total rows = 1/1
+--------------+
| ip |
|--------------|
| *********** |
+--------------+
os> source=ipsv6 | where cidrmatch(ip, '2003:db8::/32') | fields ip
fetched rows / total rows = 1/1
+-----------------------------------------+
| ip |
|-----------------------------------------|
| 2003:0db8:****:****:****:****:****:0000 |
+-----------------------------------------+
```
**Anmerkung**
`ip`kann eine IPv4 oder eine IPv6 Adresse sein.
`cidr`kann ein IPv4 oder ein IPv6 Block sein.
`ip`und `cidr` muss entweder beides IPv4 oder beides sein IPv6.
`ip`und `cidr` müssen sowohl gültig als auch nicht leer/nicht null sein.
##### PPL JSON-Funktionen
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diese PPL-Funktion unterstützen, finden Sie unter. [Funktionen](#supported-ppl-functions)
##### `JSON`
**Verwendung**: `json(value)` Prüft, ob eine Zeichenfolge im JSON-Format analysiert werden kann. Die Funktion gibt die ursprüngliche Zeichenfolge zurück, wenn sie gültiges JSON ist, oder null, wenn sie ungültig ist.
**Argumenttyp**: STRING
**Rückgabetyp**: STRING/NULL. Ein STRING-Ausdruck eines gültigen JSON-Objektformats.
**Beispiele:**
```
os> source=people | eval `valid_json()` = json('[1,2,3,{"f1":1,"f2":[5,6]},4]') | fields valid_json
fetched rows / total rows = 1/1
+---------------------------------+
| valid_json |
+---------------------------------+
| [1,2,3,{"f1":1,"f2":[5,6]},4] |
+---------------------------------+
os> source=people | eval `invalid_json()` = json('{"invalid": "json"') | fields invalid_json
fetched rows / total rows = 1/1
+----------------+
| invalid_json |
+----------------+
| null |
+----------------+
```
##### `JSON_OBJECT`
**Verwendung**: `json_object(, [, , ]...)` Gibt ein JSON-Objekt von Mitgliedern von Schlüssel-Wert-Paaren zurück.
**Typ des Arguments:**
+ A muss STRING sein.
+ A kann ein beliebiger Datentyp sein.
**Rückgabetyp**: JSON\$1OBJECT. Ein StructType Ausdruck eines gültigen JSON-Objekts.
**Beispiele:**
```
os> source=people | eval result = json_object('key', 123.45) | fields result
fetched rows / total rows = 1/1
+------------------+
| result |
+------------------+
| {"key":123.45} |
+------------------+
os> source=people | eval result = json_object('outer', json_object('inner', 123.45)) | fields result
fetched rows / total rows = 1/1
+------------------------------+
| result |
+------------------------------+
| {"outer":{"inner":123.45}} |
+------------------------------+
```
##### `JSON_ARRAY`
**Verwendung**: `json_array(...)` erstellt ein JSON-ARRAY anhand einer Werteliste.
**Argumenttyp**: A `` kann ein beliebiger Wert sein, z. B. eine Zeichenfolge, eine Zahl oder ein boolescher Wert.
**Rückgabetyp: ARRAY**. Ein Array mit einem beliebigen unterstützten Datentyp für ein gültiges JSON-Array.
**Beispiele:**
```
os> source=people | eval `json_array` = json_array(1, 2, 0, -1, 1.1, -0.11)
fetched rows / total rows = 1/1
+------------------------------+
| json_array |
+------------------------------+
| [1.0,2.0,0.0,-1.0,1.1,-0.11] |
+------------------------------+
os> source=people | eval `json_array_object` = json_object("array", json_array(1, 2, 0, -1, 1.1, -0.11))
fetched rows / total rows = 1/1
+----------------------------------------+
| json_array_object |
+----------------------------------------+
| {"array":[1.0,2.0,0.0,-1.0,1.1,-0.11]} |
+----------------------------------------+
```
##### `TO_JSON_STRING`
**Verwendung**: `to_json_string(jsonObject)` Gibt eine JSON-Zeichenfolge mit einem bestimmten JSON-Objektwert zurück.
**Argumenttyp**: JSON\$1OBJECT
**Rückgabetyp**: STRING
**Beispiele:**
```
os> source=people | eval `json_string` = to_json_string(json_array(1, 2, 0, -1, 1.1, -0.11)) | fields json_string
fetched rows / total rows = 1/1
+--------------------------------+
| json_string |
+--------------------------------+
| [1.0,2.0,0.0,-1.0,1.1,-0.11] |
+--------------------------------+
os> source=people | eval `json_string` = to_json_string(json_object('key', 123.45)) | fields json_string
fetched rows / total rows = 1/1
+-----------------+
| json_string |
+-----------------+
| {'key', 123.45} |
+-----------------+
```
##### `ARRAY_LENGTH`
**Verwendung**: `array_length(jsonArray)` Gibt die Anzahl der Elemente im äußersten Array zurück.
**Argumenttyp**: ARRAY. Ein ARRAY- oder JSON\$1ARRAY-Objekt.
**Rückgabetyp**: INTEGER
**Beispiel:**
```
os> source=people | eval `json_array` = json_array_length(json_array(1,2,3,4)), `empty_array` = json_array_length(json_array())
fetched rows / total rows = 1/1
+--------------+---------------+
| json_array | empty_array |
+--------------+---------------+
| 4 | 0 |
+--------------+---------------+
```
##### `JSON_EXTRACT`
**Verwendung**: `json_extract(jsonStr, path)` Extrahiert ein JSON-Objekt aus einer JSON-Zeichenfolge, die auf dem angegebenen JSON-Pfad basiert. Die Funktion gibt Null zurück, wenn die eingegebene JSON-Zeichenfolge ungültig ist.
**Argumenttyp**: STRING, STRING
**Rückgabetyp**: STRING
+ Ein STRING-Ausdruck eines gültigen JSON-Objektformats.
+ `NULL`wird im Falle eines ungültigen JSON-Codes zurückgegeben.
**Beispiele:**
```
os> source=people | eval `json_extract('{"a":"b"}', '$.a')` = json_extract('{"a":"b"}', '$a')
fetched rows / total rows = 1/1
+----------------------------------+
| json_extract('{"a":"b"}', 'a') |
+----------------------------------+
| b |
+----------------------------------+
os> source=people | eval `json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[1].b')` = json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[1].b')
fetched rows / total rows = 1/1
+-----------------------------------------------------------+
| json_extract('{"a":[{"b":1.0},{"b":2.0}]}', '$.a[1].b') |
+-----------------------------------------------------------+
| 2.0 |
+-----------------------------------------------------------+
os> source=people | eval `json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[*].b')` = json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[*].b')
fetched rows / total rows = 1/1
+-----------------------------------------------------------+
| json_extract('{"a":[{"b":1.0},{"b":2.0}]}', '$.a[*].b') |
+-----------------------------------------------------------+
| [1.0,2.0] |
+-----------------------------------------------------------+
os> source=people | eval `invalid_json` = json_extract('{"invalid": "json"')
fetched rows / total rows = 1/1
+----------------+
| invalid_json |
+----------------+
| null |
+----------------+
```
##### `JSON_KEYS`
**Verwendung**: `json_keys(jsonStr)` gibt alle Schlüssel des äußersten JSON-Objekts als Array zurück.
**Argumenttyp**: STRING. Ein STRING-Ausdruck in einem gültigen JSON-Objektformat.
**Rückgabetyp**: ARRAY [STRING]. Die Funktion gibt `NULL` für jede andere gültige JSON-Zeichenfolge eine leere Zeichenfolge oder eine ungültige JSON-Zeichenfolge zurück.
**Beispiele:**
```
os> source=people | eval `keys` = json_keys('{"f1":"abc","f2":{"f3":"a","f4":"b"}}')
fetched rows / total rows = 1/1
+------------+
| keus |
+------------+
| [f1, f2] |
+------------+
os> source=people | eval `keys` = json_keys('[1,2,3,{"f1":1,"f2":[5,6]},4]')
fetched rows / total rows = 1/1
+--------+
| keys |
+--------+
| null |
+--------+
```
##### `JSON_VALID`
**Verwendung**: `json_valid(jsonStr)` wertet aus, ob eine JSON-Zeichenfolge eine gültige JSON-Syntax verwendet, und gibt TRUE oder FALSE zurück.
**Argumenttyp**: STRING
**Rückgabetyp**: BOOLEAN
**Beispiele:**
```
os> source=people | eval `valid_json` = json_valid('[1,2,3,4]'), `invalid_json` = json_valid('{"invalid": "json"') | feilds `valid_json`, `invalid_json`
fetched rows / total rows = 1/1
+--------------+----------------+
| valid_json | invalid_json |
+--------------+----------------+
| True | False |
+--------------+----------------+
os> source=accounts | where json_valid('[1,2,3,4]') and isnull(email) | fields account_number, email
fetched rows / total rows = 1/1
+------------------+---------+
| account_number | email |
|------------------+---------|
| 13 | null |
+------------------+---------+
```
##### PPL Lambda-Funktionen
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diese PPL-Funktion unterstützen, finden Sie unter. [Funktionen](#supported-ppl-functions)
##### `EXISTS`
**Verwendung**: `exists(array, lambda)` bewertet, ob ein Lambda-Prädikat für ein oder mehrere Elemente im Array gilt.
**Argumenttyp: ARRAY**, LAMBDA
**Rückgabetyp**: BOOLEAN. Gibt zurück`TRUE`, ob mindestens ein Element im Array das Lambda-Prädikat erfüllt, andernfalls. `FALSE`
**Beispiele:**
```
os> source=people | eval array = json_array(1, -1, 2), result = exists(array, x -> x > 0) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| true |
+-----------+
os> source=people | eval array = json_array(-1, -3, -2), result = exists(array, x -> x > 0) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| false |
+-----------+
```
##### `FILTER`
**Verwendung**: `filter(array, lambda)` Filtert das Eingabearray mit der angegebenen Lambda-Funktion.
**Argumenttyp**: ARRAY, LAMBDA
**Rückgabetyp**: ARRAY. Ein ARRAY, das alle Elemente im Eingabearray enthält, die das Lambda-Prädikat erfüllen.
**Beispiele:**
```
os> source=people | eval array = json_array(1, -1, 2), result = filter(array, x -> x > 0) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| [1, 2] |
+-----------+
os> source=people | eval array = json_array(-1, -3, -2), result = filter(array, x -> x > 0) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| [] |
+-----------+
```
##### `TRANSFORM`
**Verwendung**: `transform(array, lambda)` transformiert Elemente in einem Array mithilfe der Lambda-Transformationsfunktion. Das zweite Argument impliziert den Index des Elements, wenn die binäre Lambda-Funktion verwendet wird. Dies ähnelt a `map` in der funktionalen Programmierung.
**Argumenttyp**: ARRAY, LAMBDA
**Rückgabetyp**: ARRAY. Ein ARRAY, das das Ergebnis der Anwendung der Lambda-Transformationsfunktion auf jedes Element im Eingabearray enthält.
**Beispiele:**
```
os> source=people | eval array = json_array(1, 2, 3), result = transform(array, x -> x + 1) | fields result
fetched rows / total rows = 1/1
+--------------+
| result |
+--------------+
| [2, 3, 4] |
+--------------+
os> source=people | eval array = json_array(1, 2, 3), result = transform(array, (x, i) -> x + i) | fields result
fetched rows / total rows = 1/1
+--------------+
| result |
+--------------+
| [1, 3, 5] |
+--------------+
```
##### `REDUCE`
**Verwendung**: `reduce(array, start, merge_lambda, finish_lambda)` reduziert ein Array auf einen einzigen Wert, indem Lambda-Funktionen angewendet werden. Die Funktion wendet merge\$1lambda auf den Startwert und alle Array-Elemente an und wendet das dann auf das Ergebnis an. `finish_lambda`
**Argumenttyp**: ARRAY, ANY, LAMBDA, LAMBDA
**Rückgabetyp**: ANY. Das Endergebnis der Anwendung der Lambda-Funktionen auf den Startwert und das Eingabearray.
**Beispiele:**
```
os> source=people | eval array = json_array(1, 2, 3), result = reduce(array, 0, (acc, x) -> acc + x) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| 6 |
+-----------+
os> source=people | eval array = json_array(1, 2, 3), result = reduce(array, 10, (acc, x) -> acc + x) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| 16 |
+-----------+
os> source=people | eval array = json_array(1, 2, 3), result = reduce(array, 0, (acc, x) -> acc + x, acc -> acc * 10) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| 60 |
+-----------+
```
##### Mathematische Funktionen von PPL
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diese PPL-Funktion unterstützen, finden Sie unter. [Funktionen](#supported-ppl-functions)
##### `ABS`
**Verwendung**: `ABS(x) ` Berechnet den absoluten Wert von x.
**Typ des Arguments:** INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp:** INTEGER/LONG/FLOAT/DOUBLE
**Beispiel:**
```
os> source=people | eval `ABS(-1)` = ABS(-1) | fields `ABS(-1)`
fetched rows / total rows = 1/1
+-----------+
| ABS(-1) |
|-----------|
| 1 |
+-----------+
```
##### `ACOS`
**Verwendung**: `ACOS(x)` berechnet den Arkuskosinus von x. Es wird zurückgegeben`NULL`, wenn x nicht im Bereich von -1 bis 1 liegt.
**Typ des Arguments**: INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp**: DOUBLE
**Beispiel:**
```
os> source=people | eval `ACOS(0)` = ACOS(0) | fields `ACOS(0)`
fetched rows / total rows = 1/1
+--------------------+
| ACOS(0) |
|--------------------|
| 1.5707963267948966 |
+--------------------+
```
##### `ASIN`
**Verwendung**: `asin(x)` berechnet den Arkussinus von x. Es wird zurückgegeben`NULL`, wenn x nicht im Bereich von -1 bis 1 liegt.
**Typ des Arguments**: INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp**: DOUBLE
**Beispiel:**
```
os> source=people | eval `ASIN(0)` = ASIN(0) | fields `ASIN(0)`
fetched rows / total rows = 1/1
+-----------+
| ASIN(0) |
|-----------|
| 0.0 |
+-----------+
```
##### `ATAN`
**Syntax**: `ATAN(x)` berechnet die Arkustangente von x. `atan(y, x)` Berechnet die Arkustangente von y/x, mit der Ausnahme, dass die Vorzeichen beider Argumente den Quadranten des Ergebnisses bestimmen.
**Typ des Arguments:** INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp**: DOUBLE
**Beispiel:**
```
os> source=people | eval `ATAN(2)` = ATAN(2), `ATAN(2, 3)` = ATAN(2, 3) | fields `ATAN(2)`, `ATAN(2, 3)`
fetched rows / total rows = 1/1
+--------------------+--------------------+
| ATAN(2) | ATAN(2, 3) |
|--------------------+--------------------|
| 1.1071487177940904 | 0.5880026035475675 |
+--------------------+--------------------+
```
##### `ATAN2`
**Verwendung**: `ATAN2(y, x)` Berechnet den Arkustangens von y/x, mit der Ausnahme, dass die Vorzeichen beider Argumente den Quadranten des Ergebnisses bestimmen.
**Typ des Arguments:** INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp**: DOUBLE
**Beispiel:**
```
os> source=people | eval `ATAN2(2, 3)` = ATAN2(2, 3) | fields `ATAN2(2, 3)`
fetched rows / total rows = 1/1
+--------------------+
| ATAN2(2, 3) |
|--------------------|
| 0.5880026035475675 |
+--------------------+
```
##### `CBRT`
**Verwendung**: `CBRT` berechnet die Kubikwurzel einer Zahl.
**Typ des Arguments:** INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp**: DOUBLE:
INTEGER/LONG/FLOAT/DOUBLE-> DOPPELT
**Beispiel:**
```
opensearchsql> source=location | eval `CBRT(8)` = CBRT(8), `CBRT(9.261)` = CBRT(9.261), `CBRT(-27)` = CBRT(-27) | fields `CBRT(8)`, `CBRT(9.261)`, `CBRT(-27)`;
fetched rows / total rows = 2/2
+-----------+---------------+-------------+
| CBRT(8) | CBRT(9.261) | CBRT(-27) |
|-----------+---------------+-------------|
| 2.0 | 2.1 | -3.0 |
| 2.0 | 2.1 | -3.0 |
+-----------+---------------+-------------+
```
##### `CEIL`
**Verwendung**: Ein Alias für die `CEILING` Funktion. `CEILING(T)`nimmt die Obergrenze des Wertes T an.
**Einschränkung**: funktioniert `CEILING` nur erwartungsgemäß, wenn der Typ IEEE 754 Double beim Speichern eine Dezimalzahl anzeigt.
**Argumenttyp**: INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp**: LONG
**Beispiel:**
```
os> source=people | eval `CEILING(0)` = CEILING(0), `CEILING(50.00005)` = CEILING(50.00005), `CEILING(-50.00005)` = CEILING(-50.00005) | fields `CEILING(0)`, `CEILING(50.00005)`, `CEILING(-50.00005)`
fetched rows / total rows = 1/1
+--------------+---------------------+----------------------+
| CEILING(0) | CEILING(50.00005) | CEILING(-50.00005) |
|--------------+---------------------+----------------------|
| 0 | 51 | -50 |
+--------------+---------------------+----------------------+
os> source=people | eval `CEILING(3147483647.12345)` = CEILING(3147483647.12345), `CEILING(113147483647.12345)` = CEILING(113147483647.12345), `CEILING(3147483647.00001)` = CEILING(3147483647.00001) | fields `CEILING(3147483647.12345)`, `CEILING(113147483647.12345)`, `CEILING(3147483647.00001)`
fetched rows / total rows = 1/1
+-----------------------------+-------------------------------+-----------------------------+
| CEILING(3147483647.12345) | CEILING(113147483647.12345) | CEILING(3147483647.00001) |
|-----------------------------+-------------------------------+-----------------------------|
| 3147483648 | 113147483648 | 3147483648 |
+-----------------------------+-------------------------------+-----------------------------+
```
##### `CONV`
**Verwendung**: `CONV(x, a, b)` Konvertiert die Zahl x von einer Basis in eine B-Basis.
**Argumenttyp**: x: STRING, a: INTEGER, b: INTEGER
**Rückgabetyp**: STRING
**Beispiel:**
```
os> source=people | eval `CONV('12', 10, 16)` = CONV('12', 10, 16), `CONV('2C', 16, 10)` = CONV('2C', 16, 10), `CONV(12, 10, 2)` = CONV(12, 10, 2), `CONV(1111, 2, 10)` = CONV(1111, 2, 10) | fields `CONV('12', 10, 16)`, `CONV('2C', 16, 10)`, `CONV(12, 10, 2)`, `CONV(1111, 2, 10)`
fetched rows / total rows = 1/1
+----------------------+----------------------+-------------------+---------------------+
| CONV('12', 10, 16) | CONV('2C', 16, 10) | CONV(12, 10, 2) | CONV(1111, 2, 10) |
|----------------------+----------------------+-------------------+---------------------|
| c | 44 | 1100 | 15 |
+----------------------+----------------------+-------------------+---------------------+
```
##### `COS`
**Verwendung**: `COS(x)` Berechnet den Kosinus von x, wobei x im Bogenmaß angegeben wird.
**Typ des Arguments:** INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp:** DOUBLE
**Beispiel:**
```
os> source=people | eval `COS(0)` = COS(0) | fields `COS(0)`
fetched rows / total rows = 1/1
+----------+
| COS(0) |
|----------|
| 1.0 |
+----------+
```
##### `COT`
**Verwendung**: `COT(x)` berechnet den Kotangens von x. Es gibt einen out-of-range Fehler zurück, wenn x gleich 0 ist.
**Typ des Arguments**: INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp**: DOUBLE
**Beispiel:**
```
os> source=people | eval `COT(1)` = COT(1) | fields `COT(1)`
fetched rows / total rows = 1/1
+--------------------+
| COT(1) |
|--------------------|
| 0.6420926159343306 |
+--------------------+
```
##### `CRC32`
**Verwendung**: `CRC32` Berechnet einen Wert für die zyklische Redundanzprüfung und gibt einen 32-Bit-Wert ohne Vorzeichen zurück.
**Argumenttyp: STRING**
**Rückgabetyp**: LONG
**Beispiel:**
```
os> source=people | eval `CRC32('MySQL')` = CRC32('MySQL') | fields `CRC32('MySQL')`
fetched rows / total rows = 1/1
+------------------+
| CRC32('MySQL') |
|------------------|
| 3259397556 |
+------------------+
```
##### `DEGREES`
**Verwendung**: `DEGREES(x)` wandelt X von Radiant in Grad um.
**Typ des Arguments:** INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp**: DOUBLE
**Beispiel:**
```
os> source=people | eval `DEGREES(1.57)` = DEGREES(1.57) | fields `DEGREES(1.57)`
fetched rows / total rows = 1/1
+-------------------+
| DEGREES(1.57) |
|-------------------|
| 89.95437383553924 |
+-------------------+
```
##### `E`
**Verwendung**: `E()` gibt die Euler-Zahl zurück.
**Rückgabetyp: DOUBLE**
**Beispiel:**
```
os> source=people | eval `E()` = E() | fields `E()`
fetched rows / total rows = 1/1
+-------------------+
| E() |
|-------------------|
| 2.718281828459045 |
+-------------------+
```
##### `EXP`
**Verwendungszweck**: `EXP(x)` gibt e potenziert mit x zurück.
**Typ des Arguments**: INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp**: DOUBLE
**Beispiel:**
```
os> source=people | eval `EXP(2)` = EXP(2) | fields `EXP(2)`
fetched rows / total rows = 1/1
+------------------+
| EXP(2) |
|------------------|
| 7.38905609893065 |
+------------------+
```
##### `FLOOR`
**Verwendungszweck**: `FLOOR(T)` Nimmt den unteren Teil des Werts T ein.
**Einschränkung**: funktioniert `FLOOR` nur erwartungsgemäß, wenn der Typ IEEE 754 Double beim Speichern eine Dezimalzahl anzeigt.
**Argumenttyp**: INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp**: LONG
**Beispiel:**
```
os> source=people | eval `FLOOR(0)` = FLOOR(0), `FLOOR(50.00005)` = FLOOR(50.00005), `FLOOR(-50.00005)` = FLOOR(-50.00005) | fields `FLOOR(0)`, `FLOOR(50.00005)`, `FLOOR(-50.00005)`
fetched rows / total rows = 1/1
+------------+-------------------+--------------------+
| FLOOR(0) | FLOOR(50.00005) | FLOOR(-50.00005) |
|------------+-------------------+--------------------|
| 0 | 50 | -51 |
+------------+-------------------+--------------------+
os> source=people | eval `FLOOR(3147483647.12345)` = FLOOR(3147483647.12345), `FLOOR(113147483647.12345)` = FLOOR(113147483647.12345), `FLOOR(3147483647.00001)` = FLOOR(3147483647.00001) | fields `FLOOR(3147483647.12345)`, `FLOOR(113147483647.12345)`, `FLOOR(3147483647.00001)`
fetched rows / total rows = 1/1
+---------------------------+-----------------------------+---------------------------+
| FLOOR(3147483647.12345) | FLOOR(113147483647.12345) | FLOOR(3147483647.00001) |
|---------------------------+-----------------------------+---------------------------|
| 3147483647 | 113147483647 | 3147483647 |
+---------------------------+-----------------------------+---------------------------+
os> source=people | eval `FLOOR(282474973688888.022)` = FLOOR(282474973688888.022), `FLOOR(9223372036854775807.022)` = FLOOR(9223372036854775807.022), `FLOOR(9223372036854775807.0000001)` = FLOOR(9223372036854775807.0000001) | fields `FLOOR(282474973688888.022)`, `FLOOR(9223372036854775807.022)`, `FLOOR(9223372036854775807.0000001)`
fetched rows / total rows = 1/1
+------------------------------+----------------------------------+--------------------------------------+
| FLOOR(282474973688888.022) | FLOOR(9223372036854775807.022) | FLOOR(9223372036854775807.0000001) |
|------------------------------+----------------------------------+--------------------------------------|
| 282474973688888 | 9223372036854775807 | 9223372036854775807 |
+------------------------------+----------------------------------+--------------------------------------+
```
##### `LN`
**Verwendung**: `LN(x)` Gibt den natürlichen Logarithmus von x zurück.
Typ des **Arguments**: INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp**: DOUBLE
**Beispiel:**
```
os> source=people | eval `LN(2)` = LN(2) | fields `LN(2)`
fetched rows / total rows = 1/1
+--------------------+
| LN(2) |
|--------------------|
| 0.6931471805599453 |
+--------------------+
```
##### `LOG`
**Verwendung**: `LOG(x)` Gibt den natürlichen Logarithmus von x zurück, der dem Logarithmus zur Basis e von X entspricht. log (B, x) entspricht log (x) /log (B).
Typ des Arguments**:** INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp**: DOUBLE
**Beispiel:**
```
os> source=people | eval `LOG(2)` = LOG(2), `LOG(2, 8)` = LOG(2, 8) | fields `LOG(2)`, `LOG(2, 8)`
fetched rows / total rows = 1/1
+--------------------+-------------+
| LOG(2) | LOG(2, 8) |
|--------------------+-------------|
| 0.6931471805599453 | 3.0 |
+--------------------+-------------+
```
##### `LOG2`
**Verwendung**: `LOG2(x)` entspricht`log(x)`/`log(2)`.
**Typ des Arguments**: INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp**: DOUBLE
**Beispiel:**
```
os> source=people | eval `LOG2(8)` = LOG2(8) | fields `LOG2(8)`
fetched rows / total rows = 1/1
+-----------+
| LOG2(8) |
|-----------|
| 3.0 |
+-----------+
```
##### `LOG10`
**Verwendung**: `LOG10(x)` entspricht`log(x)`/`log(10)`.
**Typ des Arguments**: INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp**: DOUBLE
**Beispiel:**
```
os> source=people | eval `LOG10(100)` = LOG10(100) | fields `LOG10(100)`
fetched rows / total rows = 1/1
+--------------+
| LOG10(100) |
|--------------|
| 2.0 |
+--------------+
```
##### `MOD`
**Verwendung**: `MOD(n, m)` berechnet den Rest der Zahl n geteilt durch m.
**Typ des Arguments:** INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp**: Breiterer Typ zwischen den Typen von n und m, wenn m ein Wert ungleich Null ist. Wenn m gleich 0 ist, wird NULL zurückgegeben.
**Beispiel:**
```
os> source=people | eval `MOD(3, 2)` = MOD(3, 2), `MOD(3.1, 2)` = MOD(3.1, 2) | fields `MOD(3, 2)`, `MOD(3.1, 2)`
fetched rows / total rows = 1/1
+-------------+---------------+
| MOD(3, 2) | MOD(3.1, 2) |
|-------------+---------------|
| 1 | 1.1 |
+-------------+---------------+
```
##### `PI`
**Syntax**: `PI() ` gibt die Konstante Pi zurück.
**Rückgabetyp**: DOUBLE
**Beispiel:**
```
os> source=people | eval `PI()` = PI() | fields `PI()`
fetched rows / total rows = 1/1
+-------------------+
| PI() |
|-------------------|
| 3.141592653589793 |
+-------------------+
```
##### `POW`
**Verwendung**: `POW(x, y)` Berechnet den Wert von x potenziert mit y. Schlechte Eingaben geben ein `NULL` Ergebnis zurück.
**Typ des Arguments**: INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp**: DOUBLE
**Synonyme**: `POWER(_, _)`
**Beispiel:**
```
os> source=people | eval `POW(3, 2)` = POW(3, 2), `POW(-3, 2)` = POW(-3, 2), `POW(3, -2)` = POW(3, -2) | fields `POW(3, 2)`, `POW(-3, 2)`, `POW(3, -2)`
fetched rows / total rows = 1/1
+-------------+--------------+--------------------+
| POW(3, 2) | POW(-3, 2) | POW(3, -2) |
|-------------+--------------+--------------------|
| 9.0 | 9.0 | 0.1111111111111111 |
+-------------+--------------+--------------------+
```
##### POWER
**Verwendung**: `POWER(x, y)` berechnet den Wert von x potenziert mit y. Schlechte Eingaben geben ein `NULL` Ergebnis zurück.
**Typ des Arguments**: INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp**: DOUBLE
**Synonyme**: `POW(_, _)`
**Beispiel:**
```
os> source=people | eval `POWER(3, 2)` = POWER(3, 2), `POWER(-3, 2)` = POWER(-3, 2), `POWER(3, -2)` = POWER(3, -2) | fields `POWER(3, 2)`, `POWER(-3, 2)`, `POWER(3, -2)`
fetched rows / total rows = 1/1
+---------------+----------------+--------------------+
| POWER(3, 2) | POWER(-3, 2) | POWER(3, -2) |
|---------------+----------------+--------------------|
| 9.0 | 9.0 | 0.1111111111111111 |
+---------------+----------------+--------------------+
```
##### `RADIANS`
**Verwendung**: `RADIANS(x)` wandelt X von Grad in Radiant um.
**Typ des Arguments:** INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp**: DOUBLE
**Beispiel:**
```
os> source=people | eval `RADIANS(90)` = RADIANS(90) | fields `RADIANS(90)`
fetched rows / total rows = 1/1
+--------------------+
| RADIANS(90) |
|--------------------|
| 1.5707963267948966 |
+--------------------+
```
##### `RAND`
**Verwendung**:`RAND()`/`RAND(N)`gibt einen zufälligen Gleitkommawert im Bereich 0 <= Wert < 1,0 zurück. Wenn Sie die Ganzzahl N angeben, initialisiert die Funktion den Startwert vor der Ausführung. Eine Folge dieses Verhaltens ist, dass bei einem identischen Argument N jedes Mal derselbe Wert `rand(N)` zurückgegeben wird, wodurch eine wiederholbare Folge von Spaltenwerten entsteht.
**Argumenttyp: INTEGER**
**Rückgabetyp**: FLOAT
**Beispiel:**
```
os> source=people | eval `RAND(3)` = RAND(3) | fields `RAND(3)`
fetched rows / total rows = 1/1
+------------+
| RAND(3) |
|------------|
| 0.73105735 |
+------------+
```
##### `ROUND`
**Verwendung**: `ROUND(x, d)` rundet das Argument x auf d Dezimalstellen ab. Wenn Sie d nicht angeben, wird standardmäßig 0 verwendet.
**Typ des Arguments:** INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp Map**:
+ (GANZZAHL/LANG [, GANZZAHL]) -> LANG
+ (GLEITKOMMAZAHL/DOPPELT [, GANZZAHL]) -> LANG
**Beispiel:**
```
os> source=people | eval `ROUND(12.34)` = ROUND(12.34), `ROUND(12.34, 1)` = ROUND(12.34, 1), `ROUND(12.34, -1)` = ROUND(12.34, -1), `ROUND(12, 1)` = ROUND(12, 1) | fields `ROUND(12.34)`, `ROUND(12.34, 1)`, `ROUND(12.34, -1)`, `ROUND(12, 1)`
fetched rows / total rows = 1/1
+----------------+-------------------+--------------------+----------------+
| ROUND(12.34) | ROUND(12.34, 1) | ROUND(12.34, -1) | ROUND(12, 1) |
|----------------+-------------------+--------------------+----------------|
| 12.0 | 12.3 | 10.0 | 12 |
+----------------+-------------------+--------------------+----------------+
```
##### `SIGN`
**Verwendung**: `SIGN` Gibt das Vorzeichen des Arguments als -1, 0 oder 1 zurück, je nachdem, ob die Zahl negativ, Null oder positiv ist.
**Typ des Arguments**: INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp:** INTEGER
**Beispiel:**
```
os> source=people | eval `SIGN(1)` = SIGN(1), `SIGN(0)` = SIGN(0), `SIGN(-1.1)` = SIGN(-1.1) | fields `SIGN(1)`, `SIGN(0)`, `SIGN(-1.1)`
fetched rows / total rows = 1/1
+-----------+-----------+--------------+
| SIGN(1) | SIGN(0) | SIGN(-1.1) |
|-----------+-----------+--------------|
| 1 | 0 | -1 |
+-----------+-----------+--------------+
```
##### `SIN`
**Verwendung**: `sin(x)` Berechnet den Sinus von x, wobei x im Bogenmaß angegeben wird.
**Typ des Arguments:** INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp:** DOUBLE
**Beispiel:**
```
os> source=people | eval `SIN(0)` = SIN(0) | fields `SIN(0)`
fetched rows / total rows = 1/1
+----------+
| SIN(0) |
|----------|
| 0.0 |
+----------+
```
##### `SQRT`
**Verwendung**: `SQRT` berechnet die Quadratwurzel einer nicht negativen Zahl.
**Typ des Arguments:** INTEGER/LONG/FLOAT/DOUBLE
**Rückgabetyp Map:**
+ (Nicht negativ) INTEGER/LONG/FLOAT/DOUBLE -> DOPPELT
+ (Negativ) INTEGER/LONG/FLOAT/DOUBLE -> NULL
**Beispiel:**
```
os> source=people | eval `SQRT(4)` = SQRT(4), `SQRT(4.41)` = SQRT(4.41) | fields `SQRT(4)`, `SQRT(4.41)`
fetched rows / total rows = 1/1
+-----------+--------------+
| SQRT(4) | SQRT(4.41) |
|-----------+--------------|
| 2.0 | 2.1 |
+-----------+--------------+
```
##### PPL-String-Funktionen
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diese PPL-Funktion unterstützen, finden Sie unter. [Funktionen](#supported-ppl-functions)
##### `CONCAT`
**Verwendung**: `CONCAT(str1, str2, ...., str_9)` Addiert bis zu 9 Zeichenketten zusammen.
**Typ des Arguments:**
+ ZEICHENFOLGE, ZEICHENFOLGE,..., ZEICHENFOLGE
+ Rückgabetyp: STRING
**Beispiel:**
```
os> source=people | eval `CONCAT('hello', 'world')` = CONCAT('hello', 'world'), `CONCAT('hello ', 'whole ', 'world', '!')` = CONCAT('hello ', 'whole ', 'world', '!') | fields `CONCAT('hello', 'world')`, `CONCAT('hello ', 'whole ', 'world', '!')`
fetched rows / total rows = 1/1
+----------------------------+--------------------------------------------+
| CONCAT('hello', 'world') | CONCAT('hello ', 'whole ', 'world', '!') |
|----------------------------+--------------------------------------------|
| helloworld | hello whole world! |
+----------------------------+--------------------------------------------+
```
##### `CONCAT_WS`
**Verwendung**: `CONCAT_WS(sep, str1, str2)` verkettet zwei oder mehr Zeichenketten unter Verwendung eines angegebenen Trennzeichens zwischen ihnen.
**Typ des Arguments:**
+ ZEICHENFOLGE, ZEICHENFOLGE,..., ZEICHENFOLGE
+ Rückgabetyp: STRING
**Beispiel:**
```
os> source=people | eval `CONCAT_WS(',', 'hello', 'world')` = CONCAT_WS(',', 'hello', 'world') | fields `CONCAT_WS(',', 'hello', 'world')`
fetched rows / total rows = 1/1
+------------------------------------+
| CONCAT_WS(',', 'hello', 'world') |
|------------------------------------|
| hello,world |
+------------------------------------+
```
##### `LENGTH`
**Verwendung**: `length(str)` Gibt die Länge der Eingabezeichenfolge in Byte zurück.
**Typ des Arguments:**
+ STRING
+ Rückgabetyp: INTEGER
**Beispiel:**
```
os> source=people | eval `LENGTH('helloworld')` = LENGTH('helloworld') | fields `LENGTH('helloworld')`
fetched rows / total rows = 1/1
+------------------------+
| LENGTH('helloworld') |
|------------------------|
| 10 |
+------------------------+
```
##### `LOWER`
**Verwendung**: `lower(string)` Konvertiert die Eingabezeichenfolge in Kleinbuchstaben.
**Typ des Arguments:**
+ STRING
+ Rückgabetyp: STRING
**Beispiel:**
```
os> source=people | eval `LOWER('helloworld')` = LOWER('helloworld'), `LOWER('HELLOWORLD')` = LOWER('HELLOWORLD') | fields `LOWER('helloworld')`, `LOWER('HELLOWORLD')`
fetched rows / total rows = 1/1
+-----------------------+-----------------------+
| LOWER('helloworld') | LOWER('HELLOWORLD') |
|-----------------------+-----------------------|
| helloworld | helloworld |
+-----------------------+-----------------------+
```
##### `LTRIM`
**Verwendung**: `ltrim(str)` entfernt führende Leerzeichen aus der Eingabezeichenfolge.
**Typ des Arguments:**
+ STRING
+ Rückgabetyp: STRING
**Beispiel:**
```
os> source=people | eval `LTRIM(' hello')` = LTRIM(' hello'), `LTRIM('hello ')` = LTRIM('hello ') | fields `LTRIM(' hello')`, `LTRIM('hello ')`
fetched rows / total rows = 1/1
+---------------------+---------------------+
| LTRIM(' hello') | LTRIM('hello ') |
|---------------------+---------------------|
| hello | hello |
+---------------------+---------------------+
```
##### `POSITION`
**Syntax**: `POSITION(substr IN str)` Gibt die Position des ersten Vorkommens einer Teilzeichenfolge in einer Zeichenfolge zurück. Es gibt 0 zurück, wenn die Teilzeichenfolge nicht in der Zeichenfolge enthalten ist. Sie gibt NULL zurück, wenn ein Argument NULL ist.
**Typ des Arguments:**
+ ZEICHENFOLGE, ZEICHENFOLGE
+ Rückgabetyp INTEGER
**Beispiel:**
```
os> source=people | eval `POSITION('world' IN 'helloworld')` = POSITION('world' IN 'helloworld'), `POSITION('invalid' IN 'helloworld')`= POSITION('invalid' IN 'helloworld') | fields `POSITION('world' IN 'helloworld')`, `POSITION('invalid' IN 'helloworld')`
fetched rows / total rows = 1/1
+-------------------------------------+---------------------------------------+
| POSITION('world' IN 'helloworld') | POSITION('invalid' IN 'helloworld') |
|-------------------------------------+---------------------------------------|
| 6 | 0 |
+-------------------------------------+---------------------------------------+
```
##### `REVERSE`
**Verwendung**: `REVERSE(str)` Gibt die umgekehrte Zeichenfolge der Eingabezeichenfolge zurück.
**Typ des Arguments:**
+ STRING
+ Rückgabetyp: STRING
**Beispiel:**
```
os> source=people | eval `REVERSE('abcde')` = REVERSE('abcde') | fields `REVERSE('abcde')`
fetched rows / total rows = 1/1
+--------------------+
| REVERSE('abcde') |
|--------------------|
| edcba |
+--------------------+
```
##### `RIGHT`
**Verwendung**: `right(str, len)` Gibt die am weitesten rechts stehenden Zeichen der Eingabezeichenfolge zurück. Es gibt 0 zurück, wenn die Teilzeichenfolge nicht in der Zeichenfolge enthalten ist. Sie gibt NULL zurück, wenn ein Argument NULL ist.
**Typ des Arguments:**
+ ZEICHENFOLGE, GANZZAHL
+ Rückgabetyp: STRING
**Beispiel:**
```
os> source=people | eval `RIGHT('helloworld', 5)` = RIGHT('helloworld', 5), `RIGHT('HELLOWORLD', 0)` = RIGHT('HELLOWORLD', 0) | fields `RIGHT('helloworld', 5)`, `RIGHT('HELLOWORLD', 0)`
fetched rows / total rows = 1/1
+--------------------------+--------------------------+
| RIGHT('helloworld', 5) | RIGHT('HELLOWORLD', 0) |
|--------------------------+--------------------------|
| world | |
+--------------------------+--------------------------+
```
##### `RTRIM`
**Verwendung**: `rtrim(str)` schneidet nachfolgende Leerzeichen aus der Eingabezeichenfolge ab.
**Typ des Arguments:**
+ STRING
+ Rückgabetyp: **STRING**
**Beispiel:**
```
os> source=people | eval `RTRIM(' hello')` = RTRIM(' hello'), `RTRIM('hello ')` = RTRIM('hello ') | fields `RTRIM(' hello')`, `RTRIM('hello ')`
fetched rows / total rows = 1/1
+---------------------+---------------------+
| RTRIM(' hello') | RTRIM('hello ') |
|---------------------+---------------------|
| hello | hello |
+---------------------+---------------------+
```
##### `SUBSTRING`
**Verwendungszweck**: `substring(str, start)` oder `substring(str, start, length)` gibt eine Teilzeichenfolge der Eingabezeichenfolge zurück. Ohne Angabe einer Länge wird die gesamte Zeichenfolge von der Startposition zurückgegeben.
**Typ des Arguments:**
+ ZEICHENFOLGE, GANZZAHL, GANZZAHL
+ Rückgabetyp: STRING
**Beispiel:**
```
os> source=people | eval `SUBSTRING('helloworld', 5)` = SUBSTRING('helloworld', 5), `SUBSTRING('helloworld', 5, 3)` = SUBSTRING('helloworld', 5, 3) | fields `SUBSTRING('helloworld', 5)`, `SUBSTRING('helloworld', 5, 3)`
fetched rows / total rows = 1/1
+------------------------------+---------------------------------+
| SUBSTRING('helloworld', 5) | SUBSTRING('helloworld', 5, 3) |
|------------------------------+---------------------------------|
| oworld | owo |
+------------------------------+---------------------------------+
```
##### `TRIM`
**Verwendung**: `trim(string)` entfernt führende und abschließende Leerzeichen aus der Eingabezeichenfolge.
**Typ des Arguments:**
+ STRING
+ Rückgabetyp: **STRING**
**Beispiel:**
```
os> source=people | eval `TRIM(' hello')` = TRIM(' hello'), `TRIM('hello ')` = TRIM('hello ') | fields `TRIM(' hello')`, `TRIM('hello ')`
fetched rows / total rows = 1/1
+--------------------+--------------------+
| TRIM(' hello') | TRIM('hello ') |
|--------------------+--------------------|
| hello | hello |
+--------------------+--------------------+
```
##### `UPPER`
**Verwendung**: `upper(string)` Konvertiert die Eingabezeichenfolge in Großbuchstaben.
**Typ des Arguments:**
+ STRING
+ Rückgabetyp: STRING
**Beispiel:**
```
os> source=people | eval `UPPER('helloworld')` = UPPER('helloworld'), `UPPER('HELLOWORLD')` = UPPER('HELLOWORLD') | fields `UPPER('helloworld')`, `UPPER('HELLOWORLD')`
fetched rows / total rows = 1/1
+-----------------------+-----------------------+
| UPPER('helloworld') | UPPER('HELLOWORLD') |
|-----------------------+-----------------------|
| HELLOWORLD | HELLOWORLD |
+-----------------------+-----------------------+
```
##### Funktionen zur Konvertierung des PPL-Typs
**Anmerkung**
Informationen darüber, welche AWS Datenquellenintegrationen diese PPL-Funktion unterstützen, finden Sie unter. [Funktionen](#supported-ppl-functions)
##### `TRIM`
**Verwendung**: wandelt `cast(expr as dateType)` den `expr` in den um `dataType` und gibt den Wert von zurück. `dataType`
Es gelten die folgenden Konvertierungsregeln:
**Geben Sie Konvertierungsregeln ein**
| Src/Target | STRING | NUMBER | BOOLEAN | TIMESTAMP (ZEITSTEMPEL) | DATE | TIME |
| --- | --- | --- | --- | --- | --- | --- |
| STRING | | Hinweis 1 | Anmerkung 1 | TIMESTAMP() | DATUM() | TIME() |
| NUMBER | Anmerkung 1 | | v\$1 =0 | – | – | – |
| BOOLEAN | Hinweis 1 | v? 1:0 | | – | – | – |
| TIMESTAMP (ZEITSTEMPEL) | Anmerkung 1 | – | – | | DATUM() | TIME() |
| DATE | Anmerkung 1 | – | – | – | | – |
| TIME | Anmerkung 1 | – | – | – | – | |
**Beispiel für die Umwandlung in eine Zeichenfolge:**
```
os> source=people | eval `cbool` = CAST(true as string), `cint` = CAST(1 as string), `cdate` = CAST(CAST('2012-08-07' as date) as string) | fields `cbool`, `cint`, `cdate`
fetched rows / total rows = 1/1
+---------+--------+------------+
| cbool | cint | cdate |
|---------+--------+------------|
| true | 1 | 2012-08-07 |
+---------+--------+------------+
```
**Beispiel für die Umwandlung in eine Zahl:**
```
os> source=people | eval `cbool` = CAST(true as int), `cstring` = CAST('1' as int) | fields `cbool`, `cstring`
fetched rows / total rows = 1/1
+---------+-----------+
| cbool | cstring |
|---------+-----------|
| 1 | 1 |
+---------+-----------+
```
**Beispiel für die aktuelle Besetzung:**
```
os> source=people | eval `cdate` = CAST('2012-08-07' as date), `ctime` = CAST('01:01:01' as time), `ctimestamp` = CAST('2012-08-07 01:01:01' as timestamp) | fields `cdate`, `ctime`, `ctimestamp`
fetched rows / total rows = 1/1
+------------+----------+---------------------+
| cdate | ctime | ctimestamp |
|------------+----------+---------------------|
| 2012-08-07 | 01:01:01 | 2012-08-07 01:01:01 |
+------------+----------+---------------------+
```
**Beispiel für eine verkettete Besetzung:**
```
os> source=people | eval `cbool` = CAST(CAST(true as string) as boolean) | fields `cbool`
fetched rows / total rows = 1/1
+---------+
| cbool |
|---------|
| True |
+---------+
```