Spiegazione di SQL COALESCE()

La maggior parte dei principali RDBMS supporta COALESCE() operatore, che restituisce il primo valore non null dall'elenco di argomenti.

COALESCE() è una funzionalità standard SQL (è inclusa nella specifica ISO/IEC 9075).

Sintassi

La sintassi è questa:

COALESCE (V1, V2, ..., Vn)

Quindi, è richiesto almeno un argomento, ma possono essere (e di solito sono) forniti più argomenti.

COALESCE() è considerato un n -operatore adico. In altre parole, è un operatore che ha un numero variabile di operandi (cioè n operandi).

Esempio

Ecco un semplice esempio da dimostrare:

SELECT COALESCE(null, 'Papaya', 'Salad');

Risultato:

Papaya

In questo caso, Papaya era il primo valore non nullo, quindi COALESCE() restituito quel valore.

Salad era anche un valore non nullo, ma veniva dopo Papaya e quindi non è stato restituito.

COALESCE() rispetto a CASE

COALESCE() è generalmente considerata una scorciatoia sintattica per il CASE espressione.

In quanto tale, la seguente affermazione:

COALESCE (V1, V2) 

equivale a:

CASE WHEN V1 IS NOT NULL THEN V1 ELSE V2 END

E la seguente affermazione:

COALESCE (V1, V2, ..., Vn)

(per n ≥ 3) È equivalente a:

CASE WHEN V1 IS NOT NULL THEN V1 ELSE COALESCE (V2, ..., Vn) END

Quando tutti i valori sono nulli

Se tutti i valori sono null , COALESCE() restituisce null :

SELECT COALESCE( null, null );

Risultato:

null

A seconda del tuo RDBMS, l'output effettivo per i valori Null potrebbe essere diverso. Ad esempio, quando si utilizza psql (per PostgreSQL), la stringa vuota viene emessa per impostazione predefinita ogni volta che viene restituito un valore null (sebbene questo possa essere modificato). È lo stesso con SQLite (e anche questo può essere modificato).

In SQL Server, se tutti gli argomenti sono null , allora almeno uno dei valori null deve essere un null digitato . Pertanto, l'esempio precedente genera effettivamente un errore (perché tutti gli argomenti null sono null costanti).

Espressioni

COALESCE() restituisce il valore corrente della prima espressione che inizialmente non restituisce null . Pertanto, se passiamo un'espressione come questa:

SELECT COALESCE( null, 3 * 5 );

Otteniamo questo:

15

Esempio di database

Supponiamo di eseguire la seguente query:

SELECT
  name,
  salary
FROM employee;

E otteniamo il seguente risultato:

 name  | salary 
-------+--------
 Elise | 100000
 Rohit |  50000
 Homer |   null

Possiamo vedere che l'ultima riga ha un valore nullo nel DOB colonna.

Se volessimo sostituire il valore nullo con un altro valore, potremmo usare COALESCE() come segue:

SELECT
  name,
  COALESCE(salary, 0) AS salary
FROM employee;

Risultato:

 name  | salary 
-------+--------
 Elise | 100000
 Rohit |  50000
 Homer |      0

In questo caso abbiamo sostituito tutti i valori nulli con l'intero 0 .

Differenze tra RDBMS

In generale, COALESCE() funziona più o meno allo stesso modo su tutti gli RDBMS.

Ma ci sono alcune differenze.

Tipi di dati

Possiamo fare quanto segue in MySQL, MariaDB e SQLite:

SELECT
  name,
  COALESCE(salary, 'None') AS salary
FROM employee;

Risultato:

name	salary
-----   ------
Elise	100000
Rohit	50000
Homer	None

In questo caso, ogni volta che lo salary colonna contiene un valore null, l'output è None .

Ma quella query può causare problemi in SQL Server, PostgreSQL o Oracle Database.

Quando eseguo quella query in SQL Server, PostgreSQL e Oracle Database, viene visualizzato un errore dovuto al fatto che il valore sostitutivo è il tipo di dati errato.

Ecco cosa restituisce SQL Server quando eseguo la query precedente:

Msg 245, Level 16, State 1, Line 15
Conversion failed when converting the varchar value 'None' to data type int.

Ecco cosa restituisce PostgreSQL:

ERROR:  invalid input syntax for type integer: "None"
LINE 3:   COALESCE(salary, 'None') AS salary
                           ^

Ed ecco cosa restituisce Oracle Database:

ORA-00932: inconsistent datatypes: expected NUMBER got CHAR

Ma se utilizzo un valore numerico, non ottengo l'errore:

SELECT
  name,
  COALESCE(salary, 0) AS salary
FROM employee;

Risultato:

 name  | salary 
-------+--------
 Elise | 100000
 Rohit |  50000
 Homer |      0

Quindi questo esempio finale funziona su tutti e sei gli RDBMS di cui sopra.

Argomenti nulli

Un'altra differenza tra il modo in cui gli RDBMS elaborano COALESCE() è nel modo in cui trattano argomenti nulli.

Come accennato, in SQL Server, se tutti gli argomenti sono null , allora almeno uno dei valori null deve essere un null digitato . In altre parole, se tutti gli argomenti su COALESCE() sono la costante nulla, quindi otteniamo un errore. Questo non è il caso di altri RDBMS, dove tutti gli argomenti possono essere la costante nulla e l'output sarà null invece di un errore.