Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # SELECT command **Wichtig** Amazon S3 Select ist für Neukunden nicht mehr verfügbar. Bestandskunden von Amazon S3 Select können das Feature weiterhin wie gewohnt nutzen. [Weitere Informationen](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) Amazon S3 Select unterstützt nur den SQL-Befehl `SELECT`. Die folgenden ANSI-Standardklauseln werden für `SELECT` unterstützt: + `SELECT` table + `FROM`-Klausel + `WHERE`-Klausel + `LIMIT`-Klausel **Anmerkung** Amazon S3 Select-Abfragen unterstützen derzeit keine Unterabfragen oder Joins. ## SELECT table Die `SELECT`-Liste nennt die Spalten, Funktionen und Ausdrücke, die die Abfrage zurückgeben soll. Der Liste stellt die Ausgabe der Abfrage dar. ``` SELECT * SELECT projection1 AS column_alias_1, projection2 AS column_alias_2 ``` Bei der ersten `SELECT`-Form mit dem `*` (Sternchen) werden alle Zeilen zurückgegeben, die die Bedingung der `WHERE`-Klausel erfüllen. Die zweite Form von `SELECT` erzeugt eine Zeile mit benutzerdefinierten skalaren Ausgabeausdrücken **`projection1`** und **`projection2`** für jede Spalte. ## FROM-Klausel Amazon S3 Select unterstützt die folgenden Formen der `FROM`-Klausel: ``` FROM table_name FROM table_name alias FROM table_name AS alias ``` In jeder Form der `FROM`-Klausel steht `table_name` für das `S3Object`, das abgefragt wird. Benutzer traditioneller relationaler Datenbanken können sich dies als Datenbankschema mit mehreren Ansichten einer Tabelle vorstellen. Gemäß Standard-SQL erstellt die `FROM`-Klausel Zeilen, die in der `WHERE`-Klausel gefiltert und in der Liste `SELECT` projiziert werden. Im Fall von JSON-Objekten, die in Amazon S3 Select gespeichert sind, können Sie auch die folgenden Formate der `FROM`-Klausel verwenden: ``` FROM S3Object[*].path FROM S3Object[*].path alias FROM S3Object[*].path AS alias ``` Unter Verwendung dieses Format der `FROM`-Klausel können Sie aus Arrays oder Objekten innerhalb eines JSON-Objekts auswählen. Sie können „`path`“ unter Verwendung einer der folgenden Formen angeben: + Nach Name (in einem Objekt): `.name` oder `['name']` + Nach Index (in einem Array): `[index]` + Nach Platzhalterzeichen (in einem Objekt): `.*` + Nach Platzhalterzeichen (in einem Array): `[*]` **Anmerkung** Das Format der `FROM`-Klausel funktioniert nur mit JSON-Objekten. Platzhalterzeichen übermitteln stets mindestens einen Datensatz. Wenn es keinen übereinstimmenden Datensatz gibt, übermittelt Amazon S3 Select den Wert `MISSING`. Während der Ausgabeserialisierung (nach Abschluss der Abfrage) ersetzt Amazon S3 Select `MISSING`-Werte durch leere Datensätze. Aggregierte Funktionen (`AVG`, `COUNT`, `MAX`, `MIN` und `SUM`) überspringen `MISSING`-Werte. Wenn Sie bei Verwendung eines Platzhalterzeichens keinen Alias angeben, können Sie auf die Zeile verweisen, die das letzte Element im Pfad verwendet. Sie könnten beispielsweise alle Preise aus einer Liste von Büchern unter Verwendung der Abfrage `SELECT price FROM S3Object[*].books[*].price` auswählen. Wenn der Pfad mit einem Platzhalterzeichen anstelle eines Namens endet, können Sie den Wert `_1` verwenden, um auf die Zeile zu verweisen. Beispielsweise könnten Sie anstelle von `SELECT price FROM S3Object[*].books[*].price` die Abfrage `SELECT _1.price FROM S3Object[*].books[*]` verwenden. Amazon S3 Select behandelt ein JSON-Dokument stets als Array aus Werten auf Root-Ebene. Daher muss die `FROM`-Klausel mit `S3Object[*]` beginnen, auch wenn das von Ihnen abgefragte JSON-Objekt nur ein Root-Element hat. Aus Kompatibilitätsgründen ermöglicht Amazon S3 Select Ihnen das Auslassen des Platzhalterzeichens, wenn Sie keinen Pfad einfügen. Daher ist die vollständige Klausel `FROM S3Object` gleichwertig mit `FROM S3Object[*] as S3Object`. Wenn Sie einen Pfad einfügen, müssen Sie auch das Platzhalterzeichen verwenden. Daher sind sowohl `FROM S3Object` als auch `FROM S3Object[*].path` gültige Klauseln, nicht aber `FROM S3Object.path`. **Example** **Beispiele:** *Beispiel 1* Dieses Beispiel zeigt Ergebnisse unter Verwendung des folgenden Datensatzes und der folgenden Abfrage: ``` { "Rules": [ {"id": "1"}, {"expr": "y > x"}, {"id": "2", "expr": "z = DEBUG"} ]} { "created": "June 27", "modified": "July 6" } ``` ``` SELECT id FROM S3Object[*].Rules[*].id ``` ``` {"id":"1"} {} {"id":"2"} {} ``` Amazon S3 Select produziert die einzelnen Ergebnisse aus den folgenden Gründen: + `{"id":"id-1"}` – `S3Object[0].Rules[0].id` produzierte eine Übereinstimmung. + `{}` – `S3Object[0].Rules[1].id` produzierte keine Übereinstimmung mit einem Datensatz. Daher übermittelte Amazon S3 Select den Wert „`MISSING`“, der anschließend während der Ausgabeserialisierung in einen leeren Datensatz geändert und zurückgegeben wurde. + `{"id":"id-2"}` – `S3Object[0].Rules[2].id` produzierte eine Übereinstimmung. + `{}` – `S3Object[1]` produzierte keine Übereinstimmung mit `Rules`. Daher übermittelte Amazon S3 Select den Wert „`MISSING`“, der anschließend während der Ausgabeserialisierung in einen leeren Datensatz geändert und zurückgegeben wurde. Wenn Sie nicht möchten, dass Amazon S3 Select leere Datensätze zurückgibt, wenn keine Übereinstimmung gefunden wird, können Sie einen Test auf den -Wert ausführe `MISSING`. Die folgende Abfrage gibt dieselben Ergebnisse wie die vorherige Abfrage zurück, jedoch mit Auslassung der leeren Werte: ``` SELECT id FROM S3Object[*].Rules[*].id WHERE id IS NOT MISSING ``` ``` {"id":"1"} {"id":"2"} ``` *Beispiel 2* Dieses Beispiel zeigt Ergebnisse unter Verwendung des folgenden Datensatzes und der folgenden Abfragen: ``` { "created": "936864000", "dir_name": "important_docs", "files": [ { "name": "." }, { "name": ".." }, { "name": ".aws" }, { "name": "downloads" } ], "owner": "Amazon S3" } { "created": "936864000", "dir_name": "other_docs", "files": [ { "name": "." }, { "name": ".." }, { "name": "my stuff" }, { "name": "backup" } ], "owner": "User" } ``` ``` SELECT d.dir_name, d.files FROM S3Object[*] d ``` ``` {"dir_name":"important_docs","files":[{"name":"."},{"name":".."},{"name":".aws"},{"name":"downloads"}]} {"dir_name":"other_docs","files":[{"name":"."},{"name":".."},{"name":"my stuff"},{"name":"backup"}]} ``` ``` SELECT _1.dir_name, _1.owner FROM S3Object[*] ``` ``` {"dir_name":"important_docs","owner":"Amazon S3"} {"dir_name":"other_docs","owner":"User"} ``` ## WHERE-Klausel Die `WHERE`-Klausel hat die folgende Syntax: ``` WHERE condition ``` Die `WHERE`-Klausel filtert Zeilen basierend auf den Wert für „`condition`“. Eine Bedingung ist ein Ausdruck, der als Ergebnis einen booleschen Wert zurückgibt. Nur Zeilen, deren Bedingung als `TRUE` ausgewertet wird, werden als Ergebnis zurückgegeben. ## LIMIT-Klausel Die `LIMIT`-Klausel hat die folgende Syntax: ``` LIMIT number ``` Die `LIMIT`-Klausel begrenzt die Anzahl der von der Abfrage zurückgegebenen Datensätze basierend auf den Wert für „`number`“. ## Attributzugriff Die Klauseln `SELECT` und `WHERE` können mithilfe einer der nachfolgend genannten Methoden auf einen Datensatz verweisen. Das ist abhängig davon, ob die abzufragende Datei im CSV- oder JSON-Format vorliegt. ### CSV + **Spaltennummern** – Sie können auf die *Nte* Spalte einer Zeile mit dem Spaltennamen `_N` verweisen, wobei *`N`* die Spaltenposition angibt. Der Positionszähler beginnt mit 1. Die erste Spalte heißt demnach `_1`, die zweite Spalte heißt `_2`. Sie können mit `_N` oder `alias._N` auf eine Spalte verweisen. Beispielsweise sind sowohl `_2` und `myAlias._2` gültige Möglichkeiten, um auf eine Spalte in der `SELECT`-Liste und der `WHERE`-Klausel zu verweisen. + **Spalten-Header** – Bei Objekten im CSV-Format, die eine Kopfzeile enthalten, sind die Header für die `SELECT`-Liste und die `WHERE`-Klausel verfügbar. Besonders in `SELECT`- und `WHERE`-Klauselausdrücken in traditionellem SQL können Sie mit `alias.column_name` oder `column_name` auf die Spalten verweisen. ### JSON + **Dokument** – Sie können auf JSON-Dokumentfelder als `alias.name` zugreifen. Auch der Zugriff auf verschachtelte Felder ist möglich, z. B `alias.name1.name2.name3`. + **Liste** – Sie können über nullbasierte Indizes mit dem Operator `[]` auf Elemente in einer JSON-Liste zugreifen. Beispielsweise lässt sich das zweite Element einer Liste mithilfe von `alias[1]` aufrufen. Sie können den Zugriff auf Listenelemente mit dem Zugriff auf Felder kombinieren, z. B `alias.name1.name2[1].name3`. + **Beispiele:** Betrachten Sie dieses JSON-Objekt als Beispieldatensatz: ``` {"name": "Susan Smith", "org": "engineering", "projects": [ {"project_name":"project1", "completed":false}, {"project_name":"project2", "completed":true} ] } ``` *Beispiel 1* Die folgende Abfrage gibt die folgenden Ergebnisse zurück: ``` Select s.name from S3Object s ``` ``` {"name":"Susan Smith"} ``` *Beispiel 2* Die folgende Abfrage gibt die folgenden Ergebnisse zurück: ``` Select s.projects[0].project_name from S3Object s ``` ``` {"project_name":"project1"} ``` ## Groß-/Kleinschreibung bei Header- und Attributnamen In Amazon S3 Select können Sie mithilfe von doppelten Anführungszeichen angeben, dass bei Spalten-Headern (für CSV-Objekte) und Attributen (für JSON-Objekte) die Groß-/Kleinschreibung beachtet werden muss. Ohne doppelte Anführungszeichen muss die Groß-/Kleinschreibung bei Objekt-Headern und -attributen nicht berücksichtigt werden. Im Falle einer Zweideutigkeit wird ein Fehler ausgegeben. In den folgenden Beispielen handelt es sich entweder um 1) Amazon-S3-Objekte im CSV-Format mit spezifizierten Spalten-Headern und mit auf „`"Use"`“ festgelegtem `FileHeaderInfo`-Wert für die Abfrageanforderung oder um 2) Amazon-S3-Objekte im JSON-Format mit spezifizierten Attributen. *Beispiel 1:* Das abzufragende Objekt hat den Header oder das Attribut „`NAME`“. + Mit folgendem Ausdruck werden Werte von dem Objekt erfolgreich zurückgegeben. Da keine Anführungszeichen vorhanden sind, berücksichtigt die Abfrage die Groß- und Kleinschreibung nicht. ``` SELECT s.name from S3Object s ``` + Der folgende Ausdruck führt zum Fehler 400 „`MissingHeaderName`“. Da Anführungszeichen vorhanden sind, berücksichtigt die Abfrage die Groß- und Kleinschreibung. ``` SELECT s."name" from S3Object s ``` *Beispiel 2:* Das abzufragende Amazon S3-Objekt hat einen Header oder ein Attribut mit „`NAME`“ sowie einen anderen Header oder ein anderes Attribut mit „`name`“. + Der folgende Ausdruck führt zum Fehler 400 „`AmbiguousFieldName`“. Da keine Anführungszeichen vorhanden sind, wird die Groß-/Kleinschreibung nicht beachtet, aber es gibt zwei Übereinstimmungen, weshalb der Fehler ausgegeben wird. ``` SELECT s.name from S3Object s ``` + Mit folgendem Ausdruck werden Werte von dem Objekt erfolgreich zurückgegeben. Da Anführungszeichen vorhanden sind, berücksichtigt die Abfrage die Groß- und Kleinschreibung, weshalb es keine Mehrdeutigkeit gibt. ``` SELECT s."NAME" from S3Object s ``` ## Verwenden von reservierten Schlüsselwörtern als benutzerdefinierte Begriffe Amazon S3 Select verfügt über eine Reihe reservierter Schlüsselwörter, die zur Ausführung der SQL-Ausdrücke benötigt werden, mit denen Objektinhalte abgefragt werden. Zu den reservierten Schlüsselwörtern zählen Funktionsnamen, Datentypen, Operatoren etc. Gelegentlich könnten sich benutzerdefinierte Begriffe – wie z. B. Spalten-Header (bei CSV-Dateien) oder Attribute (bei JSON-Objekten) – mit einem reservierten Schlüsselwort decken. In diesem Fall geben Sie mithilfe von doppelten Anführungszeichen an, dass Sie absichtlich einen benutzerdefinierten Begriff verwenden, der mit einem reservierten Schlüsselwort übereinstimmt. Andernfalls wird ein 400-Parse-Fehler ausgegeben. Eine vollständige Liste der reservierten Schlüsselwörter finden Sie unter [Reservierte Schlüsselwörter](s3-select-sql-reference-keyword-list.md). Im folgenden Beispiel handelt es sich entweder um 1) ein Amazon-S3-Objekt im CSV-Format mit spezifizierten Spalten-Headern und mit auf „`"Use"`“ festgelegtem `FileHeaderInfo`-Wert für die Abfrageanforderung oder um 2) ein Amazon-S3-Objekt im JSON-Format mit spezifizierten Attributen. *Beispiel:* Das abzufragende Objekt hat einen Header oder ein Attribut mit dem Namen „`CAST`“, der ein reserviertes Schlüsselwort ist. + Mit folgendem Ausdruck werden Werte von dem Objekt erfolgreich zurückgegeben. Da die Abfrage Anführungszeichen enthält, verwendet S3 Select den benutzerdefinierten Header oder das benutzerdefinierte Attribut. ``` SELECT s."CAST" from S3Object s ``` + Der folgende Ausdruck führt zu einem Analysefehler 400. Da in der Abfrage keine Anführungszeichen verwendet werden, steht `CAST` im Konflikt mit einem reservierten Schlüsselwort. ``` SELECT s.CAST from S3Object s ``` ## Skalare Ausdrücke Innerhalb der `WHERE`-Klausel und der `SELECT`-Liste können Sie *skalare SQL-Ausdrücke* verwenden. Dies sind Ausdrücke, die skalare Werte zurückgeben. Sie haben das folgende Format: + ***`literal`*** Ein SQL-Literal + ***`column_reference`*** Ein Verweis auf eine Spalte in der Form `column_name` oder `alias.column_name`. + **`unary_op`** **`expression`** In diesem Fall ist ****`unary_op`**** ein unärer SQL-Operator. + **`expression`** **`binary_op`** ***`expression`*** In diesem Fall ist ****`binary_op`**** ein binärer SQL-Operator. + **`func_name`** In diesem Fall ist **`func_name`** der Name der aufzurufenden skalaren Funktion. + ***`expression`*** `[ NOT ] BETWEEN` ****`expression`**** `AND` ****`expression`**** + ***`expression`*** `LIKE` ****`expression`**** [ `ESCAPE` ***`expression`*** ]