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.

# Bedingte Ausdrücke
<a name="sql-functions-conditional-expressions-spark"></a>

In SQL werden bedingte Ausdrücke verwendet, um Entscheidungen auf der Grundlage bestimmter Bedingungen zu treffen. Sie ermöglichen es Ihnen, den Fluss Ihrer SQL-Anweisungen zu steuern und verschiedene Werte zurückzugeben oder verschiedene Aktionen auszuführen, die auf der Auswertung einer oder mehrerer Bedingungen basieren.

AWS Clean Rooms unterstützt die folgenden bedingten Ausdrücke:

**Topics**
+ [Der bedingte Ausdruck CASE](CASE_function.md)
+ [COALESCEAusdruck](coalesce-function.md)
+ [GRÖSSTER und KLEINSTER Ausdruck](GREATEST_LEAST.md)
+ [IF-Ausdruck](IF.md)
+ [IS\$1NULL-Ausdruck](IS_NULL.md)
+ [IS\$1NOT\$1NULL-Ausdruck](IS_NOT_NULL.md)
+ [NVL- und COALESCE-Funktionen](NVL_function.md)
+ [NVL2 Funktion](NVL2.md)
+ [NULLIF-Funktion](NULLIF_function.md)

# Der bedingte Ausdruck CASE
<a name="CASE_function"></a>

Der CASE-Ausdruck ist ein bedingter Ausdruck, der if/then/else Aussagen in anderen Sprachen ähnelt. CASE wird verwendet, um ein Ergebnis anzugeben, wenn es mehrere Bedingungen gibt. Verwenden Sie CASE, wenn ein SQL-Ausdruck gilt, z. B. in einem SELECT-Befehl.

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 Ausdruck gefunden wird, wird die Aktion in der ELSE-Klausel zurückgegeben.

## Syntax
<a name="CASE_function-syntax"></a>

Einfache CASE-Anweisung, um übereinstimmende Bedingungen zu finden:

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

Gesuchte CASE-Anweisung, um jede Bedingung auszuwerten:

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

## Argumente
<a name="CASE_function-arguments"></a>

 *expression*   
Ein Spaltenname oder ein gültiger Ausdruck.

 *Wert*   
Wert, mit dem der Ausdruck verglichen wird, wie eine numerische Konstante oder eine Zeichenfolge.

 *Ergebnis*   
Der Zielwert oder -ausdruck, der zurückgegeben wird, wenn ein Ausdruck oder eine boolesche Bedingung ausgewertet werden. Die Datentypen aller Ergebnisausdrücke müssen in einen einzigen Ausgabetyp konvertierbar sein.

 *condition*   
Ein boolescher Ausdruck, der mit true oder false ausgewertet wird. Wenn die *Bedingung* mit true ausgewertet wird, ist der Wert des CASE-Ausdrucks das Ergebnis, das auf die Bedingung folgt, und der Rest des CASE-Ausdrucks wird nicht verarbeitet. Wenn die *Bedingung* mit false ausgewertet wird, werden alle nachfolgenden WHEN-Klauseln ausgewertet. Wenn keine Ergebnisse der WHEN-Bedingung mit true ausgewertet werden, ist der Wert des CASE-Ausdrucks das Ergebnis der ELSE-Klausel. Wenn die ELSE-Klausel ausgelassen wurde und keine Bedingung mit true ausgewertet wird, ist das Ergebnis null.

## Beispiele
<a name="CASE_function-examples"></a>

Verwenden Sie einen einfachen CASE-Ausdruck, um `New York City` durch `Big Apple` in einer für die Tabelle VENUE ausgeführten Abfrage zu ersetzen. Alle anderen Städtenamen werden durch ersetzt `other`.

```
select venuecity,
  case venuecity
    when 'New York City'
    then 'Big Apple' else 'other'
  end 
from venue
order by venueid desc;

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

Verwendet einen gesuchten CASE-Ausdruck, um Gruppennummern basierend auf dem PRICEPAID-Wert für einzelne Ticketverkäufe zuzuweisen:

```
select pricepaid,
  case when pricepaid <10000 then 'group 1'
    when pricepaid >10000 then 'group 2'
    else 'group 3'
  end 
from sales
order by 1 desc;

pricepaid |  case
----------+---------
12624     | group 2
10000     | group 3
10000     | group 3
9996      | group 1
9988      | group 1
...
```

# COALESCEAusdruck
<a name="coalesce-function"></a>

Ein COALESCE Ausdruck gibt den Wert des ersten Ausdrucks in der Liste zurück, der nicht Null ist. Wenn alle Ausdrücke null sind, ist das Ergebnis null. Wenn ein Nicht-Null-Wert gefunden wird, werden die verbleibenden Ausdrücke in der Liste nicht ausgewertet.

Diese Art von Ausdruck ist nützlich, wenn Sie einen Sicherungswert für etwas zurückgeben möchten, wenn der bevorzugte Wert fehlt oder null ist. Beispielsweise kann eine Abfrage eine von drei Telefonnummern zurückgeben (mobil, Festnetz oder beruflich; in dieser Reihenfolge), je nachdem, welche Telefonnummer in der Tabelle zuerst gefunden wird (nicht null).

## Syntax
<a name="coalesce-function-syntax"></a>

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

## Beispiele
<a name="coalesce-function-examples"></a>

Wendet den COALESCE Ausdruck auf zwei Spalten an.

```
select coalesce(start_date, end_date)
from datetable
order by 1;
```

Der Standardspaltenname für einen NVL-Ausdruck lautetCOALESCE. Die folgende Abfrage gibt dieselben Ergebnisse zurück.

```
select coalesce(start_date, end_date) from datetable order by 1;
```

# GRÖSSTER und KLEINSTER Ausdruck
<a name="GREATEST_LEAST"></a>

Gibt den größten oder kleinsten Wert aus einer Liste einer beliebigen Zahl von Ausdrücken zurück.

## Syntax
<a name="GREATEST_LEAST-synopsis"></a>

```
GREATEST (value [, ...])
LEAST (value [, ...])
```

## Parameter
<a name="GREATEST_LEAST-arguments"></a>

*expression\$1list*  
Eine durch Komma getrennte Liste von Ausdrücken, wie beispielsweise Spaltennamen. Die Ausdrücke müssen alle in einen gemeinsamen Datentyp konvertierbar sein. NULL-Werte in der Liste werden ignoriert. Wenn alle Ausdrücke zu NULL ausgewertet werden, ist das Ergebnis NULL.

## Rückgabewert
<a name="GREATEST_LEAST-returns"></a>

Gibt den größten Wert (bei GREATEST) oder den kleinsten Wert (bei LEAST) aus der angegebenen Liste von Ausdrücken zurück.

## Beispiel
<a name="GREATEST_LEAST-examples"></a>

Im folgenden Beispiel wird der höchste Wert alphabetisch für `firstname` oder `lastname` zurückgegeben.

```
select firstname, lastname, greatest(firstname,lastname) from users
where userid < 10
order by 3;

 firstname | lastname  | greatest
-----------+-----------+-----------
 Alejandro | Rosalez   | Ratliff
 Carlos    | Salazar   | Carlos
 Jane      | Doe       | Doe
 John      | Doe       | Doe
 John      | Stiles    | John
 Shirley   | Rodriguez | Rodriguez
 Terry     | Whitlock  | Terry
 Richard   | Roe       | Richard
 Xiulan    | Wang      | Wang
(9 rows)
```

# IF-Ausdruck
<a name="IF"></a>

Die Bedingungsfunktion IF gibt einen von zwei Werten zurück, die auf einer Bedingung basieren. 

Bei dieser Funktion handelt es sich um eine gängige Kontrollflussanweisung, die in SQL verwendet wird, um Entscheidungen zu treffen und auf der Grundlage der Auswertung einer Bedingung unterschiedliche Werte zurückzugeben. Sie ist nützlich, um einfache If-Else-Logik in einer Abfrage zu implementieren.

## Syntax
<a name="IF-syntax"></a>

```
if(expr1, expr2, expr3) 
```

## Argumente
<a name="IF-arguments"></a>

*expr1*  
Die Bedingung oder der Ausdruck, der ausgewertet wird. Ist dies der Fall`true`, gibt die Funktion den Wert von *expr2* zurück. *Wenn *expr1 gleich* ist`false`, gibt die Funktion den Wert von expr3 zurück.*

*Ausdruck2*  
Der Ausdruck, der ausgewertet und zurückgegeben wird, wenn *expr1* `true`

*Ausdruck3*  
Der Ausdruck, der ausgewertet und zurückgegeben wird, wenn *expr1* `false`

## Rückgabewert
<a name="IF-returns"></a>

Wenn als Ergebnis `expr1` ausgewertet wird`true`, kehrt es zurück`expr2`; andernfalls kehrt es zurück. `expr3`

## Beispiel
<a name="IF-example"></a>

Im folgenden Beispiel wird die `if()` Funktion verwendet, um basierend auf einer Bedingung einen von zwei Werten zurückzugeben. Die ausgewertete Bedingung ist`1 < 2`, was bedeutet`true`, dass der erste Wert zurückgegeben `'a'` wird.

```
SELECT if(1 < 2, 'a', 'b');
 a]
```

# IS\$1NULL-Ausdruck
<a name="IS_NULL"></a>

Der IS\$1NULL bedingte Ausdruck wird verwendet, um zu überprüfen, ob ein Wert Null ist.

Dieser Ausdruck ist ein Synonym für. IS NULL

## Syntax
<a name="IS_NULL-syntax"></a>

```
is_null(expr)
```

## Argumente
<a name="IS_NULL-arguments"></a>

*expr*  
Ein Ausdruck beliebigen Typs.

## Rückgabewert
<a name="IS_NULL-returns"></a>

Der IS\$1NULL bedingte Ausdruck gibt einen booleschen Wert zurück. Wenn NULL `expr1` ist, wird zurückgegeben`true`, andernfalls wird zurückgegeben. `false`

## Beispiele
<a name="IS_NULL-example"></a>

Das folgende Beispiel prüft, ob der Wert Null `1` ist, und gibt das boolesche Ergebnis zurück, `true` da 1 ein gültiger Wert ungleich Null ist.

```
SELECT is not null(1);
 true
```

Im folgenden Beispiel wird die `id` Spalte aus der `squirrels` Tabelle ausgewählt, jedoch nur für die Zeilen, in denen sich die Altersspalte befindet. `null`

```
SELECT id FROM squirrels WHERE is_null(age)
```

# IS\$1NOT\$1NULL-Ausdruck
<a name="IS_NOT_NULL"></a>

Der IS\$1NOT\$1NULL bedingte Ausdruck wird verwendet, um zu überprüfen, ob ein Wert nicht Null ist.

Dieser Ausdruck ist ein Synonym für. IS NOT NULL

## Syntax
<a name="IS_NOT_NULL-syntax"></a>

```
is_not_null(expr)
```

## Argumente
<a name="IS_NOT_NULL-arguments"></a>

*expr*  
Ein Ausdruck beliebigen Typs.

## Rückgabewert
<a name="IS_NOT_NULL-returns"></a>

Der IS\$1NOT\$1NULL bedingte Ausdruck gibt einen booleschen Wert zurück. Wenn nicht NULL `expr1` ist, wird zurückgegeben`true`, andernfalls zurückgegeben. `false`

## Beispiele
<a name="IS_NOT_NULL-example"></a>

Das folgende Beispiel prüft, ob der Wert nicht Null `1` ist, und gibt das boolesche Ergebnis zurück, `true` da 1 ein gültiger Wert ungleich Null ist.

```
SELECT is not null(1);
 true
```

Im folgenden Beispiel wird die `id` Spalte aus der `squirrels` Tabelle ausgewählt, jedoch nur für die Zeilen, in denen sich die Altersspalte nicht befindet. `null`

```
SELECT id FROM squirrels WHERE is_not_null(age)
```

# NVL- und COALESCE-Funktionen
<a name="NVL_function"></a>

Gibt den Wert des ersten Ausdrucks in einer Reihe von Ausdrücken zurück, der nicht null ist. Wenn ein Nicht-Null-Wert gefunden wird, werden die verbleibenden Ausdrücke in der Liste nicht ausgewertet. 

NVL ist identisch mit COALESCE. Es sind Synonyme. Unter diesem Thema finden Sie eine Erläuterung der Syntax sowie Beispiele für beide.

## Syntax
<a name="NVL_function-synopsis"></a>

```
NVL( expression, expression, ... )
```

Die Syntax für COALESCE ist identisch:

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

Wenn alle Ausdrücke null sind, ist das Ergebnis null.

Diese Funktionen sind hilfreich, wenn Sie einen Sekundärwert zurückgeben möchten, falls ein Primärwert fehlt oder null ist. Eine Abfrage könnte beispielsweise die erste von drei verfügbaren Telefonnummern zurückgeben: Mobiltelefonnummer, private oder geschäftliche Telefonnummer. Die Reihenfolge der Ausdrücke in der Funktion bestimmt die Reihenfolge der Auswertung.

## Argumente
<a name="NVL_function-arguments"></a>

 *expression*   
Ein Ausdruck (beispielsweise ein Spaltenname), der hinsichtlich des Null-Status ausgewertet werden soll.

## Rückgabetyp
<a name="NVL_function-returntype"></a>

AWS Clean Rooms bestimmt den Datentyp des zurückgegebenen Werts auf der Grundlage der Eingabeausdrücke. Wenn die Datentypen der Eingabeausdrücke keinen gemeinsamen Typ haben, wird ein Fehler zurückgegeben.

## Beispiele
<a name="NVL_function-examples"></a>

Wenn die Liste Ausdrücke mit Ganzzahlen enthält, gibt die Funktion eine Ganzzahl zurück. 

```
SELECT COALESCE(NULL, 12, NULL);

coalesce
--------------
12
```

Dieses Beispiel, das im Gegensatz zum vorherigen Beispiel NVL verwendet, gibt dasselbe Ergebnis zurück. 

```
SELECT NVL(NULL, 12, NULL);

coalesce
--------------
12
```

Im folgenden Beispiel wird einen Zeichenfolgetyp zurückgegeben.

```
SELECT COALESCE(NULL, 'AWS Clean Rooms', NULL);

coalesce
--------------
AWS Clean Rooms
```

Das folgende Beispiel führt zu einem Fehler, da die Datentypen in der Ausdrucksliste unterschiedlich sind. In diesem Fall enthält die Liste sowohl einen Zeichenfolgetyp als auch einen Zahlentyp.

```
SELECT COALESCE(NULL, 'AWS Clean Rooms', 12);
ERROR: invalid input syntax for integer: "AWS Clean Rooms"
```

# NVL2 Funktion
<a name="NVL2"></a>

Gibt einen von zwei Werten aus, je nachdem, ob ein angegebener Ausdruck zu NULL oder zu NOT NULL aufgelöst wird.

## Syntax
<a name="NVL2-synopsis"></a>

```
NVL2 ( expression, not_null_return_value, null_return_value )
```

## Argumente
<a name="NVL2-arguments"></a>

 *expression*   
Ein Ausdruck (beispielsweise ein Spaltenname), der hinsichtlich des Null-Status ausgewertet werden soll.

 *not\$1null\$1return\$1value*   
Der Wert, der zurückgegeben wird, wenn *expression* zu NOT NULL ausgewertet wird. Der Wert *not\$1null\$1return\$1value* muss entweder denselben Datentyp wie *expression* haben oder implizit in diesen Datentyp konvertiert werden können.

 *null\$1return\$1value*   
Der Wert, der zurückgegeben wird, wenn *expression* zu NULL ausgewertet wird. Der Wert *null\$1return\$1value* muss entweder denselben Datentyp wie *expression* haben oder implizit in diesen Datentyp konvertiert werden können.

## Rückgabetyp
<a name="NVL2-return-type"></a>

Der NVL2 Rückgabetyp wird wie folgt bestimmt:
+ Wenn *not\$1null\$1return\$1value* oder *null\$1return\$1value* null ist, wird der Datentyp des Nicht-Null-Ausdrucks zurückgegeben.

Wenn sowohl *not\$1null\$1return\$1value* als auch *null\$1return\$1value* nicht null sind:
+ Wenn *not\$1null\$1return\$1value* und *null\$1return\$1value* denselben Datentyp haben, wird dieser Datentyp zurückgegeben.
+ Wenn *not\$1null\$1return\$1value* und *null\$1return\$1value* unterschiedliche numerische Datentypen haben, wird der kleinste kompatible numerische Datentyp zurückgegeben.
+ Wenn *not\$1null\$1return\$1value* und *null\$1return\$1value* unterschiedliche Datum-/Uhrzeit-Datentypen haben, wird ein Zeitstempeldatentyp zurückgegeben.
+ Wenn *not\$1null\$1return\$1value* und *null\$1return\$1value* unterschiedliche Zeichendatentypen haben, wird der Datentyp von *not\$1null\$1return\$1value* zurückgegeben.
+ Wenn *not\$1null\$1return\$1value* und *null\$1return\$1value* gemischte numerische und nicht numerische Datentypen haben, wird der Datentyp von *not\$1null\$1return\$1value* zurückgegeben.

**Wichtig**  
In den letzten beiden Fällen, in denen der Datentyp von *not\$1null\$1return\$1value* zurückgegeben wird, wird *null\$1return\$1value* implizit in diesen Datentyp umgewandelt. Wenn die Datentypen nicht kompatibel sind, schlägt die Funktion fehl.

## Nutzungshinweise
<a name="nvl2-usage-notes"></a>

*Denn NVL2 die Rückgabe hat entweder den Wert des Parameters *not\$1null\$1return\$1value oder null\$1return\$1value, je nachdem, welcher Wert* von der Funktion ausgewählt wurde, hat aber den Datentyp *not\$1null\$1return\$1value*.*

Wenn beispielsweise column1 NULL ist, geben die folgenden Abfragen denselben Wert zurück. Der DECODE-Rückgabewert-Datentyp ist jedoch NVL2 INTEGER und der Rückgabewert-Datentyp VARCHAR.

```
select decode(column1, null, 1234, '2345');
select nvl2(column1, '2345', 1234);
```

## Beispiel
<a name="NVL2-examples"></a>

Im folgenden Beispiel werden einige Beispieldaten modifiziert und anschließend zwei Felder ausgewertet, um die richtigen Kontaktinformationen für Benutzer bereitzustellen: 

```
update users set email = null where firstname = 'Aphrodite' and lastname = 'Acevedo';

select (firstname + ' ' + lastname) as name, 
nvl2(email, email, phone) AS contact_info
from users 
where state = 'WA'
and lastname  like 'A%'
order by lastname, firstname;

name			     contact_info	
--------------------+-------------------------------------------
Aphrodite Acevedo	(555) 555-0100
Caldwell Acevedo 	Nunc.sollicitudin@example.ca
Quinn Adams		   vel@example.com
Kamal Aguilar		 quis@example.com
Samson Alexander	 hendrerit.neque@example.com
Hall Alford		   ac.mattis@example.com
Lane Allen		    et.netus@example.com
Xander Allison	   ac.facilisis.facilisis@example.com
Amaya Alvarado	   dui.nec.tempus@example.com
Vera Alvarez		  at.arcu.Vestibulum@example.com
Yetta Anthony		 enim.sit@example.com
Violet Arnold		 ad.litora@example.comm
August Ashley		 consectetuer.euismod@example.com
Karyn Austin		  ipsum.primis.in@example.com
Lucas Ayers		   at@example.com
```

# NULLIF-Funktion
<a name="NULLIF_function"></a>

Vergleicht zwei Argumente und gibt null zurück, wenn die Argumente gleich sind. Wenn sie nicht gleich sind, wird das erste Argument zurückgegeben.

## Syntax
<a name="NULLIF_function-synopsis"></a>

Der NULLIF-Ausdruck vergleicht zwei Argumente und gibt null zurück, wenn die Argumente gleich sind. Wenn sie nicht gleich sind, wird das erste Argument zurückgegeben. Dieser Ausdruck ist die Umkehrung des NVL- oder COALESCE-Ausdrucks.

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

## Argumente
<a name="NULLIF_function-arguments"></a>

 *expression1, expression2*   
Die Zielspalten oder -ausdrücke, die verglichen werden. Der Rückgabetyp ist mit dem Typ des ersten Ausdrucks identisch. 

## Beispiele
<a name="NULLIF_function-examples"></a>

Im folgenden Beispiel gibt die Abfrage die Zeichenfolge `first` zurück, da die Argumente nicht identisch sind.

```
SELECT NULLIF('first', 'second');

case
-------
first
```

Im folgenden Beispiel gibt die Abfrage `NULL` zurück, da die Argumente des Zeichenfolgeliterals identisch sind.

```
SELECT NULLIF('first', 'first');

case
-------
NULL
```

Im folgenden Beispiel gibt die Abfrage `1` zurück, da die Ganzzahlargumente nicht identisch sind.

```
SELECT NULLIF(1, 2);

case
-------
1
```

Im folgenden Beispiel gibt die Abfrage `NULL` zurück, da die Ganzzahlargumente identisch sind.

```
SELECT NULLIF(1, 1);

case
-------
NULL
```

Im folgenden Beispiel gibt die Abfrage null zurück, wenn die LISTID- und SALESID-Werte übereinstimmen:

```
select nullif(listid,salesid), salesid
from sales where salesid<10 order by 1, 2 desc;

listid  | salesid
--------+---------
     4  |       2
     5  |       4
     5  |       3
     6  |       5
     10 |       9
     10 |       8
     10 |       7
     10 |       6
        |       1
(9 rows)
```