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.

# SQL-Referenz für Amazon S3 Select
<a name="s3-select-sql-reference"></a>

**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/) 

In dieser Referenz finden Sie eine Beschreibung der Structured Query Language (SQL)-Elemente, die von Amazon S3 Select unterstützt werden.

**Topics**
+ [SELECT command](s3-select-sql-reference-select.md)
+ [Datentypen](s3-select-sql-reference-data-types.md)
+ [Operatoren](s3-select-sql-reference-operators.md)
+ [Reservierte Schlüsselwörter](s3-select-sql-reference-keyword-list.md)
+ [SQL-Funktionen](s3-select-sql-reference-sql-functions.md)

# SELECT command
<a name="s3-select-sql-reference-select"></a>

**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
<a name="s3-select-sql-reference-select-list"></a>

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
<a name="s3-select-sql-reference-from"></a>

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
<a name="s3-select-sql-reference-where"></a>

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
<a name="s3-select-sql-reference-limit"></a>

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
<a name="s3-select-sql-reference-attribute-access"></a>

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
<a name="s3-select-sql-reference-attribute-access-csv"></a>
+ **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
<a name="s3-select-sql-reference-attribute-access-json"></a>
+ **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
<a name="s3-select-sql-reference-case-sensitivity"></a>

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
<a name="s3-select-sql-reference-using-keywords"></a>

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
<a name="s3-select-sql-reference-scalar"></a>

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

# Datentypen
<a name="s3-select-sql-reference-data-types"></a>

**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 mehrere primitive Datentypen.

## Datentypkonvertierungen
<a name="s3-select-sql-reference-data-conversion"></a>

Allgemein sollte die Funktion `CAST` verwendet werden, wenn sie definiert ist. Falls `CAST` nicht definiert ist, werden alle Eingabedaten als Zeichenfolge betrachtet. In diesem Fall müssen Sie Ihre Eingabedaten bei Bedarf in die relevanten Datentypen umwandeln.

Weitere Informationen zur Funktion `CAST` finden Sie unter [CAST](s3-select-sql-reference-conversion.md#s3-select-sql-reference-cast).

## Unterstützte Datentypen
<a name="s3-select-sql-reference-supported-data-types"></a>

Amazon S3 Select unterstützt die folgenden primitiven Datentypen.


|  Name  |  Beschreibung  |  Beispiele  | 
| --- | --- | --- | 
| `bool` | Ein boolescher Wert, entweder `TRUE` oder `FALSE`. | `FALSE` | 
| `int`, `integer` | Eine 8-Byte-Ganzzahl im Bereich -9.223.372.036.854.775.808 bis 9.223.372.036.854.775.807.  | `100000` | 
| `string` | Eine UTF8 -kodierte Zeichenfolge mit variabler Länge. Das Standardlimit ist 1 Zeichen. Das maximale Zeichenlimit beträgt 2.147.483.647.  | `'xyz'` | 
| `float` | Eine 8-Byte-Gleitkommazahl.  | `CAST(0.456 AS FLOAT)` | 
| `decimal`, `numeric` |  Eine Zahl mit der Basis 10 mit einer maximalen Genauigkeit von 38 (d. h. maximale Anzahl signifikanter Ziffern) und einer Größe zwischen -231 und 231-1 (d. h. der Exponent der Basis 10).  Amazon S3 Select ignoriert die Skalierung und Genauigkeit, wenn Sie beide gleichzeitig bereitstellen.   | `123.456 ` | 
| `timestamp` |  Zeitstempel stellen einen bestimmten Zeitpunkt dar, enthalten immer einen lokalen Versatz und können beliebig genau sein. Im Textformat befolgen Zeitstempel den [W3C-Hinweis zu Datums- und Zeitformaten](https://www.w3.org/TR/NOTE-datetime), müssen jedoch mit dem Buchstaben „`T`“ enden, wenn die Präzision der Zeitstempel nicht mindestens ein ganzer Tag ist. Sekundenbruchteile mit mindestens einer Stelle bis zu beliebig vielen Stellen sind zulässig. Der lokale Zeitversatz kann entweder als Versatz im Format Stunde:Minute von UTC-Zeit oder als Buchstabe „`Z`“ zur Angabe einer lokalen UTC-Zeit angegeben werden. Lokale Zeitversätze sind für Zeitstempel mit Uhrzeit erforderlich, für reine Datumswerte jedoch nicht zulässig.  | `CAST('2007-04-05T14:30Z' AS TIMESTAMP)` | 

### Unterstützte Parquet-Typen
<a name="s3-select-sql-reference-supported-data-types-parquet"></a>

Amazon S3 Select unterstützt die folgenden Parquet-Typen.
+ `DATE`
+ `DECIMAL`
+ `ENUM`
+ `INT(8)`
+ `INT(16)`
+ `INT(32)`
+ `INT(64)`
+ `LIST`
**Anmerkung**  
Für die Ausgabe vom Parquet-Typ `LIST` unterstützt Amazon S3 Select nur das JSON-Format. Wenn die Abfrage die Daten jedoch auf einfache Werte beschränkt, kann der Parquet-Typ `LIST` auch im CSV-Format abgefragt werden.
+ `STRING`
+ `TIMESTAMP`-unterstützte Präzision (`MILLIS`/`MICROS`/`NANOS`)
**Anmerkung**  
Zeitstempel, die als `INT(96)` gespeichert werden, werden nicht unterstützt.   
Aufgrund des Bereichs des Typs `INT(64)` können Zeitstempel in der Einheit `NANOS` nur Werte zwischen `1677-09-21 00:12:43` und `2262-04-11 23:47:16` darstellen. Werte, die außerhalb dieses Bereichs liegen, können mit der `NANOS`-Einheit nicht dargestellt werden.

### Zuordnung von Parquet-Typen zu unterstützten Datentypen in Amazon S3 Select
<a name="s3-select-sql-reference-supported-data-types-parquet-mapping"></a>


| Parquet-Typen | Unterstützte Datentypen | 
| --- | --- | 
| `DATE` |  `timestamp`  | 
|  `DECIMAL`  |  `decimal`, `numeric`  | 
|  `ENUM`  |  `string`  | 
|  `INT(8)`  |  `int`, `integer`  | 
|  `INT(16)`  | `int`, `integer` | 
| `INT(32)` | `int`, `integer` | 
|  `INT(64)`  |  `decimal`, `numeric`  | 
|  `LIST`  |  Jeder Parquet-Typ in der Liste wird auf den entsprechenden Datentyp abgebildet.  | 
|  `STRING`  |  `string`  | 
|  `TIMESTAMP`  |  `timestamp`  | 

# Operatoren
<a name="s3-select-sql-reference-operators"></a>

**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 die folgenden Operatoren.

## Logische Operatoren
<a name="s3-select-sql-reference-loical-ops"></a>
+ `AND`
+ `NOT`
+ `OR`

## Vergleichsoperatoren
<a name="s3-select-sql-reference-compare-ops"></a>
+ `<` 
+ `>` 
+ `<=`
+ `>=`
+ `=`
+ `<>`
+ `!=`
+ `BETWEEN`
+ `IN` – Beispiel: `IN ('a', 'b', 'c')`

  

## Mustervergleichsoperatoren
<a name="s3-select-sql-reference-pattern"></a>
+ `LIKE`
+ `_` (Vergleicht ein beliebiges Zeichen)
+ `%` (Vergleicht eine beliebige Zeichenreihenfolge)

## Einheitliche Operatoren
<a name="s3-select-sql-reference-unitary-ops"></a>
+ `IS NULL`
+ `IS NOT NULL`

## Mathematische Operatoren
<a name="s3-select-sql-referencemath-ops"></a>

Es werden Addition, Subtraktion, Multiplikation, Division und Modulo wie folgt unterstützt:
+ \$1
+ -
+ \$1
+ /
+ %

## Rangfolge der Operatoren
<a name="s3-select-sql-reference-op-Precedence"></a>

Die folgende Tabelle zeigt die Rangfolge der Operatoren in absteigender Reihenfolge.


|  Operator oder Element  |  Assoziativität |  Erforderlich  | 
| --- | --- | --- | 
| `-`  | rechts  | unär minus  | 
| `*`, `/`, `%`  | links  | Multiplikation, Division und Modulo  | 
| `+`, `-`  | links  | Addition und Subtraktion  | 
| `IN` |  | Mitgliedschaft festlegen  | 
| `BETWEEN` |  | in Bereich enthalten  | 
| `LIKE` |  | Zeichenfolgenübereinstimmung  | 
| `<``>` |  | kleiner als, größer als  | 
| `=` | rechts  | Gleichheit, Zuweisung | 
| `NOT` | rechts | logische Negation  | 
| `AND` | links | logische Verbindung  | 
| `OR` | links | logische Disjunktion  | 

# Reservierte Schlüsselwörter
<a name="s3-select-sql-reference-keyword-list"></a>

**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/) 

Nachfolgend finden Sie eine Liste der reservierten Schlüsselwörter für Amazon S3 Select. Zu diesen Schlüsselwörtern zählen Funktionsnamen, Datentypen, Operatoren und so weiter, die zur Ausführung der SQL-Ausdrücke benötigt werden, mit denen Objektinhalte abgefragt werden.

```
absolute
action
add
all
allocate
alter
and
any
are
as
asc
assertion
at
authorization
avg
bag
begin
between
bit
bit_length
blob
bool
boolean
both
by
cascade
cascaded
case
cast
catalog
char
char_length
character
character_length
check
clob
close
coalesce
collate
collation
column
commit
connect
connection
constraint
constraints
continue
convert
corresponding
count
create
cross
current
current_date
current_time
current_timestamp
current_user
cursor
date
day
deallocate
dec
decimal
declare
default
deferrable
deferred
delete
desc
describe
descriptor
diagnostics
disconnect
distinct
domain
double
drop
else
end
end-exec
escape
except
exception
exec
execute
exists
external
extract
false
fetch
first
float
for
foreign
found
from
full
get
global
go
goto
grant
group
having
hour
identity
immediate
in
indicator
initially
inner
input
insensitive
insert
int
integer
intersect
interval
into
is
isolation
join
key
language
last
leading
left
level
like
limit
list
local
lower
match
max
min
minute
missing
module
month
names
national
natural
nchar
next
no
not
null
nullif
numeric
octet_length
of
on
only
open
option
or
order
outer
output
overlaps
pad
partial
pivot
position
precision
prepare
preserve
primary
prior
privileges
procedure
public
read
real
references
relative
restrict
revoke
right
rollback
rows
schema
scroll
second
section
select
session
session_user
set
sexp
size
smallint
some
space
sql
sqlcode
sqlerror
sqlstate
string
struct
substring
sum
symbol
system_user
table
temporary
then
time
timestamp
timezone_hour
timezone_minute
to
trailing
transaction
translate
translation
trim
true
tuple
union
unique
unknown
unpivot
update
upper
usage
user
using
value
values
varchar
varying
view
when
whenever
where
with
work
write
year
zone
```

# SQL-Funktionen
<a name="s3-select-sql-reference-sql-functions"></a>

**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 die folgenden SQL-Funktionen.

**Topics**
+ [Aggregationsfunktionen](s3-select-sql-reference-aggregate.md)
+ [Konditionale Funktionen](s3-select-sql-reference-conditional.md)
+ [Konvertierungs-Funktionen](s3-select-sql-reference-conversion.md)
+ [Datumsfunktionen](s3-select-sql-reference-date.md)
+ [Zeichenfolgenfunktionen](s3-select-sql-reference-string.md)

# Aggregationsfunktionen
<a name="s3-select-sql-reference-aggregate"></a>

**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 die folgenden aggregierten Funktionen.


| Funktion | Argumenttyp | Rückgabetyp | 
| --- | --- | --- | 
| `AVG(expression)` | `INT`, `FLOAT`, `DECIMAL` | `DECIMAL` für ein `INT`-Argument, `FLOAT` für ein Gleitkomma-Argument; andernfalls gleich dem Argumentdatentyp. | 
| `COUNT` |  `-`  | `INT` | 
| `MAX(expression)` | `INT`, `DECIMAL` | Entspricht dem Argumenttyp. | 
| `MIN(expression)` | `INT`, `DECIMAL` | Entspricht dem Argumenttyp. | 
| `SUM(expression)` | `INT`, `FLOAT`, `DOUBLE`, `DECIMAL` | `INT` für ein `INT`-Argument, `FLOAT` für ein Gleitkomma-Argument; andernfalls gleich dem Argumentdatentyp. | 

## SUMBeispiel für
<a name="s3-select-sql-reference-aggregate-case-examples"></a>

Verwenden Sie einen `SUM`-Ausdruck, um die gesamten Objektgrößen eines Ordners in einem [S3-Bestandslistenbericht](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-inventory.html) zusammenzufassen.

Der folgende S3-Bestandslistenbericht ist eine CSV-Datei, die mit GZIP komprimiert wurde. Sie hat drei Spalten.
+ Die erste Spalte enthält den Namen des S3-Buckets (*`DOC-EXAMPLE-BUCKET`*), für den der S3-Bestandslistenbericht bestimmt ist.
+ Die zweite Spalte enthält den Objektschlüsselnamen, der das Objekt eindeutig im Bucket identifiziert.

  Der `example-folder/`-Wert in der ersten Zeile steht für den Ordner `example-folder`. Wenn Sie in Amazon S3 einen Ordner in Ihrem Bucket anlegen, erstellt S3 ein 0-Byte-Objekt mit einem Schlüssel, der auf den von Ihnen angegebenen Ordnernamen festgelegt ist.

  Der `example-folder/object1`-Wert in der zweiten Zeile steht für das Objekt `object1` im Ordner `example-folder`.

  Der `example-folder/object2`-Wert in der dritten Zeile steht für das Objekt `object2` im Ordner `example-folder`.

  Weitere Informationen über S3-Ordner finden Sie unter [Organisieren von Objekten in der Amazon S3-Konsole mithilfe von Ordnern](using-folders.md).
+ Die dritte Spalte enthält die Objektgröße in Byte.

```
"DOC-EXAMPLE-BUCKET","example-folder/","0"
"DOC-EXAMPLE-BUCKET","example-folder/object1","2011267"
"DOC-EXAMPLE-BUCKET","example-folder/object2","1570024"
```

Zur Nutzung eines `SUM`-Ausdrucks für die Berechnung der Gesamtgröße des Ordners `example-folder` führen Sie die SQL-Abfrage mit Amazon S3 Select aus.

```
SELECT SUM(CAST(_3 as INT)) FROM s3object s WHERE _2 LIKE 'example-folder/%' AND _2 != 'example-folder/';
```

Abfrageergebnis: 

```
3581291
```

# Konditionale Funktionen
<a name="s3-select-sql-reference-conditional"></a>

**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 die folgenden bedingten Funktionen.

**Topics**
+ [CASE](#s3-select-sql-reference-case)
+ [COALESCE](#s3-select-sql-reference-coalesce)
+ [NULLIF](#s3-select-sql-reference-nullif)

## CASE
<a name="s3-select-sql-reference-case"></a>

Der `CASE`-Ausdruck ist ein bedingter Ausdruck, der sich mit den `if/then/else`-Anweisungen anderer Sprachen vergleichen lässt. `CASE` wird verwendet, um ein Ergebnis anzugeben, wenn es mehrere Bedingungen gibt. Es gibt zwei Arten von `CASE`-Ausdrücken: einfach und gesucht.

In einfachen `CASE`-Ausdrücken wird ein Ausdruck mit einem Wert verglichen. Wenn keine Übereinstimmung gefunden wird, wird die in der `THEN`-Klausel angegebene Aktion angewendet. Wenn keine Übereinstimmung gefunden wird, wird die in der `ELSE`-Klausel angegebene Aktion angewendet.

In gesuchten `CASE`-Ausdrücken wird jeder `CASE`-Ausdruck auf der Basis eines booleschen Ausdrucks evaluiert und die `CASE`-Anweisung gibt den ersten übereinstimmenden `CASE`-Ausdruck zurück. Wenn in den `WHEN`-Klauseln kein übereinstimmender `CASE`-Ausdruck gefunden wird, wird die Aktion in der `ELSE`-Klausel zurückgegeben.

### Syntax
<a name="s3-select-sql-reference-case-syntax"></a>

**Anmerkung**  
Derzeit unterstützt Amazon S3 Select weder `ORDER BY` noch Abfragen, die neue Zeilen enthalten. Achten Sie darauf, Abfragen ohne Zeilenumbrüche zu verwenden.

Die folgende Zeichenfolge ist eine einfache `CASE`-Aussage, die verwendet wird, um Bedingungen abzugleichen:

```
CASE expression WHEN value THEN result [WHEN...] [ELSE result] END					
```

Die folgende Zeichenfolge ist eine gesuchte `CASE`-Anweisung, die verwendet wird, um jede Bedingung auszuwerten:

```
CASE WHEN boolean condition THEN result [WHEN ...] [ELSE result] END					
```

### Beispiele
<a name="s3-select-sql-reference-case-examples"></a>

**Anmerkung**  
Wenn Sie die Amazon-S3-Konsole verwenden, um die folgenden Beispiele auszuführen, und Ihre CSV-Datei eine Kopfzeile enthält, wählen Sie **Exclude the first line of CSV data** (Die erste CSV-Datenzeile ausschließen) aus. 

**Beispiel 1:** Verwenden Sie einen einfachen `CASE`-Ausdruck, um `New York City` in einer Abfrage durch `Big Apple` zu ersetzen. Alle anderen Städtenamen werden durch `other` ersetzt.

```
SELECT venuecity, CASE venuecity WHEN 'New York City' THEN 'Big Apple' ELSE 'other' END FROM S3Object;
```

Abfrageergebnis: 

```
venuecity        |   case
-----------------+-----------
Los Angeles      | other
New York City    | Big Apple
San Francisco    | other
Baltimore        | other
...
```

**Beispiel 2:** Verwenden Sie einen gesuchten `CASE`-Ausdruck, um Gruppennummern basierend auf dem `pricepaid`-Wert für einzelne Ticketverkäufe zuzuweisen:

```
SELECT pricepaid, CASE WHEN CAST(pricepaid as FLOAT) < 10000 THEN 'group 1' WHEN CAST(pricepaid as FLOAT) > 10000 THEN 'group 2' ELSE 'group 3' END FROM S3Object;					
```

Abfrageergebnis: 

```
pricepaid |  case
-----------+---------
12624.00 | group 2
10000.00 | group 3
10000.00 | group 3
9996.00 | group 1
9988.00 | group 1
...
```

## COALESCE
<a name="s3-select-sql-reference-coalesce"></a>

`COALESCE` wertet die Argumente nacheinander aus und gibt den ersten unbekannten Wert zurück, das heißt, den ersten Wert, der nicht null oder nicht fehlend ist. Null- und fehlende Werte werden von der Funktion nicht übernommen.

### Syntax
<a name="s3-select-sql-reference-coalesce-syntax"></a>

```
COALESCE ( expression, expression, ... )
```

### Parameters
<a name="s3-select-sql-reference-coalesce-parameters"></a>

 *`expression`*   
Der Zielausdruck, der von der Funktion verwendet wird.

### Beispiele
<a name="s3-select-sql-reference-coalesce-examples"></a>

```
COALESCE(1)                -- 1
COALESCE(null)             -- null
COALESCE(null, null)       -- null
COALESCE(missing)          -- null
COALESCE(missing, missing) -- null
COALESCE(1, null)          -- 1
COALESCE(null, null, 1)    -- 1
COALESCE(null, 'string')   -- 'string'
COALESCE(missing, 1)       -- 1
```

## NULLIF
<a name="s3-select-sql-reference-nullif"></a>

Bei zwei Ausdrücken, die das gleiche Auswertungsergebnis haben, gibt `NULLIF` `NULL` zurück. Andernfalls gibt `NULLIF` das Auswertungsergebnis für den ersten Ausdruck zurück.

### Syntax
<a name="s3-select-sql-reference-nullif-syntax"></a>

```
NULLIF ( expression1, expression2 )
```

### Parameters
<a name="s3-select-sql-reference-nullif-parameters"></a>

 `expression1, expression2`   
Die Zielausdrücke, die von der Funktion verwendet werden.

### Beispiele
<a name="s3-select-sql-reference-nullif-examples"></a>

```
NULLIF(1, 1)             -- null
NULLIF(1, 2)             -- 1
NULLIF(1.0, 1)           -- null
NULLIF(1, '1')           -- 1
NULLIF([1], [1])         -- null
NULLIF(1, NULL)          -- 1
NULLIF(NULL, 1)          -- null
NULLIF(null, null)       -- null
NULLIF(missing, null)    -- null
NULLIF(missing, missing) -- null
```

# Konvertierungs-Funktionen
<a name="s3-select-sql-reference-conversion"></a>

**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 die folgende Konvertierungsfunktion.

**Topics**
+ [CAST](#s3-select-sql-reference-cast)

## CAST
<a name="s3-select-sql-reference-cast"></a>

Die `CAST`-Funktion konvertiert ein Element, z. B. einen Ausdruck zur Auswertung eines einzelnen Werts, von einem Typ in einen anderen. 

### Syntax
<a name="s3-select-sql-reference-cast-syntax"></a>

```
CAST ( expression AS data_type )
```

### Parameters
<a name="s3-select-sql-reference-cast-parameters"></a>

 *`expression`*   
Eine Kombination von Werten, Operatoren und SQL-Funktionen, die zu einem Wert ausgewertet werden können

 *`data_type`*   
Der Zieldatentyp, z. B. `INT`, in den der Ausdruck umgewandelt werden soll Eine Liste der unterstützten Datentypen finden Sie unter [Datentypen](s3-select-sql-reference-data-types.md).

### Beispiele
<a name="s3-select-sql-reference-cast-examples"></a>

```
CAST('2007-04-05T14:30Z' AS TIMESTAMP)
CAST(0.456 AS FLOAT)
```

# Datumsfunktionen
<a name="s3-select-sql-reference-date"></a>

**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 die folgenden Datumsfunktionen.

**Topics**
+ [DATE\$1ADD](#s3-select-sql-reference-date-add)
+ [DATE\$1DIFF](#s3-select-sql-reference-date-diff)
+ [EXTRACT](#s3-select-sql-reference-extract)
+ [TO\$1STRING](#s3-select-sql-reference-to-string)
+ [TO\$1TIMESTAMP](#s3-select-sql-reference-to-timestamp)
+ [UTCNOW](#s3-select-sql-reference-utcnow)

## DATE\$1ADD
<a name="s3-select-sql-reference-date-add"></a>

Bei einem Datumsteil, einer Menge und einem Zeitstempel gibt `DATE_ADD` einen aktualisierten Zeitstempel zurück, indem der Datumsteil anhand der Menge modifiziert wird.

### Syntax
<a name="s3-select-sql-reference-date-add-syntax"></a>

```
DATE_ADD( date_part, quantity, timestamp )
```

### Parameters
<a name="s3-select-sql-reference-date-add-parameters"></a>

*`date_part`*   
Gibt den zu modifizierenden Teil des Datums an. Dabei kann es sich um einen der folgenden Werte handeln:  
+ Jahr
+ Monat
+ Tag
+ Stunde
+ Minute
+ Sekunde

 *`quantity`*   
Der Wert, der auf den aktualisierten Zeitstempel anzuwenden ist. Positive „`quantity`“-Werte werden zum „date\$1part“-Wert des Zeitstempels addiert, negative Werte werden subtrahiert.

 *`timestamp`*   
Der Zielzeitstempel, der von der Funktion verwendet wird.

### Beispiele
<a name="s3-select-sql-reference-date-add-examples"></a>

```
DATE_ADD(year, 5, `2010-01-01T`)                -- 2015-01-01 (equivalent to 2015-01-01T)
DATE_ADD(month, 1, `2010T`)                     -- 2010-02T (result will add precision as necessary)
DATE_ADD(month, 13, `2010T`)                    -- 2011-02T
DATE_ADD(day, -1, `2017-01-10T`)                -- 2017-01-09 (equivalent to 2017-01-09T)
DATE_ADD(hour, 1, `2017T`)                      -- 2017-01-01T01:00-00:00
DATE_ADD(hour, 1, `2017-01-02T03:04Z`)          -- 2017-01-02T04:04Z
DATE_ADD(minute, 1, `2017-01-02T03:04:05.006Z`) -- 2017-01-02T03:05:05.006Z
DATE_ADD(second, 1, `2017-01-02T03:04:05.006Z`) -- 2017-01-02T03:04:06.006Z
```

## DATE\$1DIFF
<a name="s3-select-sql-reference-date-diff"></a>

Bei einem Datumsteil und zwei gültigen Zeitstempeln gibt `DATE_DIFF` die Differenz in Datumsteilen an. Sofern der `date_part`-Wert von `timestamp1` größer ist als der `date_part`-Wert von `timestamp2`, wird eine negative Ganzzahl zurückgegeben. Wenn der `date_part`-Wert von `timestamp1` kleiner ist als der `date_part`-Wert von `timestamp2`, wird eine positive Ganzzahl zurückgegeben.

### Syntax
<a name="s3-select-sql-reference-date-diff-syntax"></a>

```
DATE_DIFF( date_part, timestamp1, timestamp2 )
```

### Parameters
<a name="s3-select-sql-reference-date-diff-parameters"></a>

 **`date_part`**   
Gibt den zu vergleichenden Teil der Zeitstempel an. Die Definition von `date_part` finden Sie unter [DATE\$1ADD](#s3-select-sql-reference-date-add).

 **`timestamp1`**   
Der erste Zeitstempel für den Vergleich.

 **`timestamp2`**   
Der zweite Zeitstempel für den Vergleich.

### Beispiele
<a name="s3-select-sql-reference-date-diff-examples"></a>

```
DATE_DIFF(year, `2010-01-01T`, `2011-01-01T`)            -- 1
DATE_DIFF(year, `2010T`, `2010-05T`)                     -- 4 (2010T is equivalent to 2010-01-01T00:00:00.000Z)
DATE_DIFF(month, `2010T`, `2011T`)                       -- 12
DATE_DIFF(month, `2011T`, `2010T`)                       -- -12
DATE_DIFF(day, `2010-01-01T23:00`, `2010-01-02T01:00`) -- 0 (need to be at least 24h apart to be 1 day apart)
```

## EXTRACT
<a name="s3-select-sql-reference-extract"></a>

Bei einem Datumsteil und einem Zeitstempel gibt `EXTRACT` den Datumsteilwert des Zeitstempels zurück.

### Syntax
<a name="s3-select-sql-reference-extract-syntax"></a>

```
EXTRACT( date_part FROM timestamp )
```

### Parameters
<a name="s3-select-sql-reference-extract-parameters"></a>

 **`date_part`**   
Gibt den zu extrahierenden Teil der Zeitstempel an. Dabei kann es sich um einen der folgenden Werte handeln:  
+ `YEAR`
+ `MONTH`
+ `DAY`
+ `HOUR`
+ `MINUTE`
+ `SECOND`
+ `TIMEZONE_HOUR`
+ `TIMEZONE_MINUTE`

 **`timestamp`**   
Der Zielzeitstempel, der von der Funktion verwendet wird.

### Beispiele
<a name="s3-select-sql-reference-extract-examples"></a>

```
EXTRACT(YEAR FROM `2010-01-01T`)                           -- 2010
EXTRACT(MONTH FROM `2010T`)                                -- 1 (equivalent to 2010-01-01T00:00:00.000Z)
EXTRACT(MONTH FROM `2010-10T`)                             -- 10
EXTRACT(HOUR FROM `2017-01-02T03:04:05+07:08`)             -- 3
EXTRACT(MINUTE FROM `2017-01-02T03:04:05+07:08`)           -- 4
EXTRACT(TIMEZONE_HOUR FROM `2017-01-02T03:04:05+07:08`)    -- 7
EXTRACT(TIMEZONE_MINUTE FROM `2017-01-02T03:04:05+07:08`)  -- 8
```

## TO\$1STRING
<a name="s3-select-sql-reference-to-string"></a>

Bei einem Zeitstempel und einem Formatmuster gibt `TO_STRING` eine Zeichenfolgendarstellung des Zeitstempels im angegebenen Format zurück.

### Syntax
<a name="s3-select-sql-reference-size-syntax"></a>

```
TO_STRING ( timestamp time_format_pattern )
```

### Parameters
<a name="s3-select-sql-reference-size-parameters"></a>

 *`timestamp`*   
Der Zielzeitstempel, der von der Funktion verwendet wird.

 *`time_format_pattern`*   
Eine Zeichenfolge mit folgenden speziellen Zeichenbedeutungen:      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonS3/latest/userguide/s3-select-sql-reference-date.html)

### Beispiele
<a name="s3-select-sql-reference-size-examples"></a>

```
TO_STRING(`1969-07-20T20:18Z`,  'MMMM d, y')                    -- "July 20, 1969"
TO_STRING(`1969-07-20T20:18Z`, 'MMM d, yyyy')                   -- "Jul 20, 1969"
TO_STRING(`1969-07-20T20:18Z`, 'M-d-yy')                        -- "7-20-69"
TO_STRING(`1969-07-20T20:18Z`, 'MM-d-y')                        -- "07-20-1969"
TO_STRING(`1969-07-20T20:18Z`, 'MMMM d, y h:m a')               -- "July 20, 1969 8:18 PM"
TO_STRING(`1969-07-20T20:18Z`, 'y-MM-dd''T''H:m:ssX')           -- "1969-07-20T20:18:00Z"
TO_STRING(`1969-07-20T20:18+08:00Z`, 'y-MM-dd''T''H:m:ssX')     -- "1969-07-20T20:18:00Z"
TO_STRING(`1969-07-20T20:18+08:00`, 'y-MM-dd''T''H:m:ssXXXX')   -- "1969-07-20T20:18:00+0800"
TO_STRING(`1969-07-20T20:18+08:00`, 'y-MM-dd''T''H:m:ssXXXXX')  -- "1969-07-20T20:18:00+08:00"
```

## TO\$1TIMESTAMP
<a name="s3-select-sql-reference-to-timestamp"></a>

Bei einer Zeichenfolge wandelt `TO_TIMESTAMP` diese in einen Zeitstempel um. `TO_TIMESTAMP` ist der umgekehrte Vorgang von `TO_STRING`.

### Syntax
<a name="s3-select-sql-reference-to-timestamp-syntax"></a>

```
TO_TIMESTAMP ( string )
```

### Parameters
<a name="s3-select-sql-reference-to-timestamp-parameters"></a>

 *`string`*   
Die Zielzeichenfolge, die von der Funktion verwendet wird.

### Beispiele
<a name="s3-select-sql-reference-to-timestamp-examples"></a>

```
TO_TIMESTAMP('2007T')                         -- `2007T`
TO_TIMESTAMP('2007-02-23T12:14:33.079-08:00') -- `2007-02-23T12:14:33.079-08:00`
```

## UTCNOW
<a name="s3-select-sql-reference-utcnow"></a>

`UTCNOW` gibt die aktuelle Zeit in UTC als Zeitstempel zurück.

### Syntax
<a name="s3-select-sql-reference-utcnow-syntax"></a>

```
UTCNOW()
```

### Parameters
<a name="s3-select-sql-reference-utcnow-parameters"></a>

`UTCNOW` nutzt keine Parameter.

### Beispiele
<a name="s3-select-sql-reference-utcnow-examples"></a>

```
UTCNOW() -- 2017-10-13T16:02:11.123Z
```

# Zeichenfolgenfunktionen
<a name="s3-select-sql-reference-string"></a>

**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 die folgenden String-Funktionen.

**Topics**
+ [CHAR\$1LENGTH, CHARACTER\$1LENGTH](#s3-select-sql-reference-char-length)
+ [LOWER](#s3-select-sql-reference-lower)
+ [SUBSTRING](#s3-select-sql-reference-substring)
+ [TRIM](#s3-select-sql-reference-trim)
+ [UPPER](#s3-select-sql-reference-upper)

## CHAR\$1LENGTH, CHARACTER\$1LENGTH
<a name="s3-select-sql-reference-char-length"></a>

`CHAR_LENGTH` (oder `CHARACTER_LENGTH`) zählt die Anzahl der Zeichen in der angegebenen Zeichenfolge.

**Anmerkung**  
`CHAR_LENGTH` und `CHARACTER_LENGTH` sind Synonyme.

### Syntax
<a name="s3-select-sql-reference-char-length-syntax"></a>

```
CHAR_LENGTH ( string )
```

### Parameters
<a name="s3-select-sql-reference-char-length-parameters"></a>

 *`string`*   
Die Zielzeichenfolge, die von der Funktion verwendet wird.

### Beispiele
<a name="s3-select-sql-reference-char-length-examples"></a>

```
CHAR_LENGTH('')          -- 0
CHAR_LENGTH('abcdefg')   -- 7
```

## LOWER
<a name="s3-select-sql-reference-lower"></a>

`LOWER` wandelt alle Großbuchstaben einer Zeichenfolge in Kleinbuchstaben um. Alle Zeichen, die keine Großbuchstaben sind, bleiben unverändert.

### Syntax
<a name="s3-select-sql-reference-lower-syntax"></a>

```
LOWER ( string )
```

### Parameters
<a name="s3-select-sql-reference-lower-parameters"></a>

 **`string`**   
Die Zielzeichenfolge, die von der Funktion verwendet wird.

### Beispiele
<a name="s3-select-sql-reference-lower-examples"></a>

```
LOWER('AbCdEfG!@#$') -- 'abcdefg!@#$'
```

## SUBSTRING
<a name="s3-select-sql-reference-substring"></a>

`SUBSTRING` gibt bei einer Zeichenfolge, einem Startindex und (optional) einer Länge die Teilzeichenfolge vom Startindex bis zum Ende der Zeichenfolge oder bis zur angegebenen Länge zurück.

**Anmerkung**  
Das erste Zeichen der Eingabezeichenfolge hat die Indexposition 1.  
 Wenn `start` < 1 ist und keine Länge angegeben wird, dann wird die Indexposition auf 1 festgelegt. 
 Wenn `start` < 1 ist und eine Länge angegeben wird, dann wird die Indexposition auf `start + length -1` festgelegt. 
 Wenn `start + length -1` < 0 ist, dann wird eine leere Zeichenfolge zurückgegeben. 
 Wenn `start + length -1` >= 0 ist, dann wird die Teilzeichenfolge beginnend bei Indexposition 1 mit der Länge `start + length - 1` zurückgegeben. 

### Syntax
<a name="s3-select-sql-reference-substring-syntax"></a>

```
SUBSTRING( string FROM start [ FOR length ] )
```

### Parameters
<a name="s3-select-sql-reference-substring-parameters"></a>

 **`string`**   
Die Zielzeichenfolge, die von der Funktion verwendet wird.

 **`start`**   
Die Startposition der Zeichenfolge.

 **`length`**   
Die Länge der zurückzugebenden Teilzeichenfolge. Falls nicht angegeben, wird bis zum Ende der Zeichenfolge fortgefahren.

### Beispiele
<a name="s3-select-sql-reference-substring-examples"></a>

```
SUBSTRING("123456789", 0)      -- "123456789"
SUBSTRING("123456789", 1)      -- "123456789"
SUBSTRING("123456789", 2)      -- "23456789"
SUBSTRING("123456789", -4)     -- "123456789"
SUBSTRING("123456789", 0, 999) -- "123456789" 
SUBSTRING("123456789", 1, 5)   -- "12345"
```

## TRIM
<a name="s3-select-sql-reference-trim"></a>

Kürzt vorangestellte oder nachgestellte Zeichen aus einer Zeichenfolge. Standardmäßig wird ein Leerzeichen (`' '`) entfernt.

### Syntax
<a name="s3-select-sql-reference-trim-syntax"></a>

```
TRIM ( [[LEADING | TRAILING | BOTH remove_chars] FROM] string )
```

### Parameters
<a name="s3-select-sql-reference-trim-parameters"></a>

 **`string`**   
Die Zielzeichenfolge, die von der Funktion verwendet wird.

 `LEADING` \$1 `TRAILING` \$1 `BOTH`   
Dieser Parameter gibt an, ob vorangestellte oder nachgestellte Zeichen oder vorangestellte und nachgestellte Zeichen gekürzt werden sollen.

 **`remove_chars`**   
Die zu entfernenden Zeichen. `remove_chars` kann eine Zeichenfolge mit einer Länge von > 1 sein. Diese Funktion gibt die Zeichenfolge mit einem beliebigen Zeichen von `remove_chars` zurück, der am Anfang oder am Ende der entfernten Zeichenfolge stand.

### Beispiele
<a name="s3-select-sql-reference-trim-examples"></a>

```
TRIM('       foobar         ')               -- 'foobar'
TRIM('      \tfoobar\t         ')            -- '\tfoobar\t'
TRIM(LEADING FROM '       foobar         ')  -- 'foobar         '
TRIM(TRAILING FROM '       foobar         ') -- '       foobar'
TRIM(BOTH FROM '       foobar         ')     -- 'foobar'
TRIM(BOTH '12' FROM '1112211foobar22211122') -- 'foobar'
```

## UPPER
<a name="s3-select-sql-reference-upper"></a>

`UPPER` wandelt alle Kleinbuchstaben einer Zeichenfolge in Großbuchstaben um. Alle Zeichen, die keine Kleinbuchstaben sind, bleiben unverändert.

### Syntax
<a name="s3-select-sql-reference-upper-syntax"></a>

```
UPPER ( string )
```

### Parameters
<a name="s3-select-sql-reference-upper-parameters"></a>

 **`string`**   
Die Zielzeichenfolge, die von der Funktion verwendet wird.

### Beispiele
<a name="s3-select-sql-reference-upper-examples"></a>

```
UPPER('AbCdEfG!@#$') -- 'ABCDEFG!@#$'
```