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