Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Espressioni condizionali
<a name="sql-functions-conditional-expressions-spark"></a>

In SQL, le espressioni condizionali vengono utilizzate per prendere decisioni in base a determinate condizioni. Consentono di controllare il flusso delle istruzioni SQL e restituire valori diversi o eseguire azioni diverse in base alla valutazione di una o più condizioni.

AWS Clean Rooms supporta le seguenti espressioni condizionali:

**Topics**
+ [Espressione condizionale CASE](CASE_function.md)
+ [COALESCEespressione](coalesce-function.md)
+ [espressione MASSIMA e MINIMA](GREATEST_LEAST.md)
+ [Espressione IF](IF.md)
+ [espressione IS\$1NULL](IS_NULL.md)
+ [espressione IS\$1NOT\$1NULL](IS_NOT_NULL.md)
+ [Funzioni NVL e COALESCE](NVL_function.md)
+ [NVL2 funzione](NVL2.md)
+ [Funzione NULLIF](NULLIF_function.md)

# Espressione condizionale CASE
<a name="CASE_function"></a>

L'espressione CASE è un'espressione condizionale, simile alle if/then/else istruzioni presenti in altre lingue. CASE è utilizzata per specificare un risultato quando ci sono condizioni multiple. Usa CASE quando un'espressione SQL è valida, ad esempio in un comando SELECT.

Esistono due tipi di espressioni CASE: semplici e ricercate.
+ Nelle espressioni CASE semplici, un'espressione viene confrontata con un valore. Quando viene trovata una corrispondenza, viene applicata l'azione specificata nella clausola THEN. Se non viene trovata una corrispondenza, viene applicata l'azione nella clausola ELSE.
+ Nelle espressioni CASE cercate, ogni CASE viene valutata in base a un'espressione booleana e l'istruzione CASE restituisce la prima CASE corrispondente. Se non vengono trovate corrispondenze tra le clausole WHEN, viene restituita l'operazione nella clausola ELSE.

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

Semplice istruzione CASE usata per abbinare le condizioni:

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

Istruzione CASE ricercata usata per valutare ogni condizione:

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

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

 *espressione*   
Un nome di colonna o qualsiasi espressione valida.

 *value*   
Valore con cui viene confrontata l'espressione, ad esempio una costante numerica o una stringa di caratteri.

 *result*   
Il valore o espressione di destinazione che viene restituito quando viene valutata un'espressione o una condizione booleana. I tipi di dati di tutte le espressioni dei risultati devono essere convertibili in un singolo tipo di output.

 *condizione*   
Un'espressione booleana che restituisce true o false. Se la *condizione* è true, il valore dell'espressione CASE è il risultato che segue la condizione e il resto dell'espressione CASE non viene elaborato. Se la *condizione* è false, vengono valutate tutte le clausole WHEN successive. Se nessun risultato della condizione WHEN è true, il valore dell'espressione CASE è il risultato della clausola ELSE. Se la clausola ELSE viene omessa e nessuna condizione è true, il risultato è null.

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

Utilizzare una semplice espressione CASE per sostituire `New York City` con `Big Apple` in una query sulla tabella VENUE. Sostituire tutti gli altri nomi di città con `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
...
```

Utilizzare un'espressione CASE ricercata per assegnare numeri di gruppo in base al valore PRICEPAID per le vendite di biglietti singoli:

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

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

Un'COALESCEespressione restituisce il valore della prima espressione dell'elenco che non è nulla. Se tutte le espressioni sono null, il risultato è null. Quando viene trovato un valore non null, le espressioni rimanenti nell'elenco non vengono valutate.

Questo tipo di espressione è utile quando si desidera restituire un valore di backup per qualcosa quando il valore preferito è mancante o null. Ad esempio, una query può restituire uno dei tre numeri di telefono (cellulare, casa o lavoro, in tale ordine), a seconda di quale si trova prima nella tabella (non null).

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

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

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

Applica COALESCE l'espressione a due colonne.

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

Il nome di colonna predefinito per un'espressione NVL è. COALESCE La seguente query restituisce gli stessi risultati.

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

# espressione MASSIMA e MINIMA
<a name="GREATEST_LEAST"></a>

Restituisce il valore più grande o più piccolo da un elenco numeri di espressioni.

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

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

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

*expression\$1list*  
Un elenco di espressioni separate da virgole, come ad esempio i nomi di colonne. Le espressioni devono essere tutte convertibili in un tipo di dati comune. I valori NULL nell'elenco vengono ignorati. Se tutte le espressioni vengono valutate su NULL, il risultato è NULL.

## Valori restituiti
<a name="GREATEST_LEAST-returns"></a>

Restituisce il valore massimo (per GREATEST) o minimo (per LEAST) dell'elenco di espressioni fornito.

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

Nell'esempio seguente viene restituito il valore più alto in ordine alfabetico per `firstname` oppure `lastname`.

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

# Espressione IF
<a name="IF"></a>

La funzione condizionale IF restituisce uno dei due valori in base a una condizione. 

Questa funzione è un'istruzione di flusso di controllo comune utilizzata in SQL per prendere decisioni e restituire valori diversi in base alla valutazione di una condizione. È utile per implementare una semplice logica if-else all'interno di una query.

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

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

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

*espr (1)*  
La condizione o l'espressione che viene valutata. In caso affermativo`true`, la funzione restituirà il valore di *expr2*. *Se *expr1* è`false`, la funzione restituirà il valore di expr3.*

*espr (2)*  
*L'espressione che viene valutata e restituita se expr1 è.* `true`

*expr 3*  
*L'espressione che viene valutata e restituita se expr1 è.* `false`

## Valori restituiti
<a name="IF-returns"></a>

Se `expr1` restituisce a`true`, restituisce; in caso contrario restituisce`expr2`. `expr3`

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

L'esempio seguente utilizza la `if()` funzione per restituire uno dei due valori in base a una condizione. La condizione da valutare è`1 < 2`, ovvero`true`, quindi `'a'` viene restituito il primo valore.

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

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

L'espressione IS\$1NULL condizionale viene utilizzata per verificare se un valore è nullo.

Questa espressione è sinonimo di. IS NULL

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

```
is_null(expr)
```

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

*expr*  
Un'espressione di qualsiasi tipo.

## Valori restituiti
<a name="IS_NULL-returns"></a>

L'espressione IS\$1NULL condizionale restituisce un valore booleano. Se `expr1` è NULL, restituisce, altrimenti restituisce`true`. `false`

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

L'esempio seguente verifica se il valore `1` è null e restituisce il risultato booleano `true` perché 1 è un valore valido e non nullo.

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

L'esempio seguente seleziona la `id` colonna dalla `squirrels` tabella, ma solo per le righe in cui si trova la colonna dell'età. `null`

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

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

L'espressione IS\$1NOT\$1NULL condizionale viene utilizzata per verificare se un valore non è nullo.

Questa espressione è sinonimo di. IS NOT NULL

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

```
is_not_null(expr)
```

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

*expr*  
Un'espressione di qualsiasi tipo.

## Valori restituiti
<a name="IS_NOT_NULL-returns"></a>

L'espressione IS\$1NOT\$1NULL condizionale restituisce un valore booleano. Se non `expr1` è NULL, restituisce, altrimenti restituisce`true`. `false`

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

L'esempio seguente verifica se il valore non `1` è nullo e restituisce il risultato booleano `true` perché 1 è un valore valido e non nullo.

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

L'esempio seguente seleziona la `id` colonna dalla `squirrels` tabella, ma solo per le righe in cui non è presente la colonna dell'età. `null`

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

# Funzioni NVL e COALESCE
<a name="NVL_function"></a>

Restituisce il valore della prima espressione che non è null in una serie di espressioni. Quando viene trovato un valore non null, le restanti espressioni nell'elenco non vengono valutate. 

NVL è identica a COALESCE. Sono sinonimi. Questo argomento illustra la sintassi e contiene esempi per entrambe.

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

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

La sintassi di COALESCE è la stessa:

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

Se tutte le espressioni sono null, il risultato è null.

Queste funzioni sono utili quando si desidera restituire un valore secondario quando manca un valore primario o è null. Ad esempio, una query potrebbe restituire il primo dei tre numeri di telefono disponibili: cellulare, casa o ufficio. L'ordine delle espressioni nella funzione determina l'ordine di valutazione.

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

 *espressione*   
Un'espressione, come ad esempio un nome di colonna, da valutare per lo stato null.

## Tipo restituito
<a name="NVL_function-returntype"></a>

AWS Clean Rooms determina il tipo di dati del valore restituito in base alle espressioni di input. Se i tipi di dati delle espressioni di input non hanno un tipo comune, viene restituito un errore.

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

Se l'elenco contiene espressioni intere, la funzione restituisce un numero intero. 

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

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

Questo esempio, che è uguale all'esempio precedente tranne per il fatto che utilizza NVL, restituisce lo stesso risultato. 

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

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

Nell'esempio seguente viene restituito un tipo di stringa.

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

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

L'esempio seguente genera un errore perché i tipi di dati variano nell'elenco delle espressioni. In questo caso, nell'elenco sono presenti sia un tipo di stringa che un tipo numerico.

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

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

Restituisce uno dei due valori in base al fatto che un'espressione specificata valuti in NULL o NOT NULL.

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

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

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

 *espressione*   
Un'espressione, come ad esempio un nome di colonna, da valutare per lo stato null.

 *not\$1null\$1return\$1value*   
Il valore restituito se l' *espressione* valuta in NOT NULL. Il valore *not\$1null\$1return\$1value* deve avere lo stesso tipo di dati dell' *espressione* o essere implicitamente convertibile in quel tipo di dati.

 *null\$1return\$1value*   
Il valore restituito se l' *espressione* valuta in NULL. Il valore *null\$1return\$1value* deve avere lo stesso tipo di dati dell' *espressione* o essere implicitamente convertibile in quel tipo di dati.

## Tipo restituito
<a name="NVL2-return-type"></a>

Il tipo di NVL2 restituzione è determinato come segue:
+ Se *not\$1null\$1return\$1value* o *null\$1return\$1value* è null, viene restituito il tipo di dati dell'espressione not null.

Se sia *not\$1null\$1return\$1value* sia *null\$1return\$1value* sono non null:
+ Se sia *not\$1null\$1return\$1value* sia *null\$1return\$1value* hanno lo stesso tipo di dati, viene restituito quel tipo di dati.
+ Se *not\$1null\$1return\$1value* e *null\$1return\$1value* hanno tipi di dati numerici diversi, viene restituito il tipo di dati numerico compatibile più piccolo.
+ Se *not\$1null\$1return\$1value* e *null\$1return\$1value* hanno tipi di dati di datetime diversi, viene restituito un tipo di dati numerici di timestamp.
+ Se *not\$1null\$1return\$1value* e *null\$1return\$1value* hanno diversi tipi di dati di carattere, viene restituito il tipo di dati di *not\$1null\$1return\$1value*.
+ Se *not\$1null\$1return\$1value* e *null\$1return\$1value* hanno tipi di dati numerici e non numerici misti viene restituito il tipo di dati di *not\$1null\$1return\$1value*.

**Importante**  
Negli ultimi due casi in cui viene restituito il tipo di dati di *not\$1null\$1return\$1value*, *null\$1return\$1value* viene assegnato implicitamente a quel tipo di dati. Se i tipi di dati non sono compatibili, la funzione ha esito negativo.

## Note per l'utilizzo
<a name="nvl2-usage-notes"></a>

*Infatti NVL2, il valore restituito avrà il valore del parametro *not\$1null\$1return\$1value o null\$1return\$1value*, a seconda di quale sia selezionato dalla funzione, ma avrà il tipo di dati *not\$1null\$1return\$1value*.*

Ad esempio, supponendo che la colonna 1 sia NULL, le seguenti query restituiranno lo stesso valore. Tuttavia, il tipo di dati del valore restituito NVL2 DECODE sarà INTEGER e il tipo di dati del valore restituito sarà VARCHAR.

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

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

L'esempio seguente modifica alcuni dati di esempio, quindi valuta due campi per fornire informazioni di contatto appropriate per gli utenti: 

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

# Funzione NULLIF
<a name="NULLIF_function"></a>

Confronta due argomenti e restituisce null se gli argomenti sono uguali. Se non sono uguali, viene restituito il primo argomento.

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

L'espressione NULLIF confronta due argomenti e restituisce null se gli argomenti sono uguali. Se non sono uguali, viene restituito il primo argomento. Questa espressione è l'inverso dell'espressione NVL o COALESCE.

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

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

 *expression1, expression2*   
Le colonne o le espressioni di destinazione che vengono confrontate. Il tipo di restituzione è uguale al tipo della prima espressione. 

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

Nell'esempio seguente, la query restituisce la stringa `first` perché gli argomenti non sono uguali.

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

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

Nell'esempio seguente, la query restituisce `NULL` perché gli argomenti della stringa letterale non sono uguali.

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

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

Nell'esempio seguente, la query restituisce `1` perché gli argomenti del numero intero non sono uguali.

```
SELECT NULLIF(1, 2);

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

Nell'esempio seguente, la query restituisce `NULL` perché gli argomenti del numero intero sono uguali.

```
SELECT NULLIF(1, 1);

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

Nell'esempio seguente, la query restituisce null quando i valori LISTID e SALESID corrispondono:

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