SQL COALESCE() Förklarat

De flesta större RDBMS:er stöder COALESCE() operator, som returnerar det första icke-nullvärdet från dess lista med argument.

COALESCE() är en SQL-standardfunktion (den ingår i ISO/IEC 9075-specifikationen).

Syntax

Syntaxen ser ut så här:

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

Så, minst ett argument krävs, men flera argument kan tillhandahållas (och vanligtvis tillhandahålls).

COALESCE() anses vara ett n -adic operatör. Med andra ord är det en operator som har ett variabelt antal operander (dvs. n operander).

Exempel

Här är ett enkelt exempel att visa:

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

Resultat:

Papaya

I det här fallet, Papaya var det första icke-nullvärdet, och så COALESCE() returnerade det värdet.

Salad var också ett icke-nullvärde, men det kom efter Papaya och därför returnerades den inte.

COALESCE() kontra CASE

COALESCE() anses vanligtvis vara en syntaktisk genväg för CASE uttryck.

Som sådan, följande uttalande:

COALESCE (V1, V2) 

motsvarar:

CASE WHEN V1 IS NOT NULL THEN V1 ELSE V2 END

Och följande uttalande:

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

(för n ≥ 3) Är ekvivalent med:

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

När alla värden är noll

Om alla värden är null , COALESCE() returnerar null :

SELECT COALESCE( null, null );

Resultat:

null

Beroende på din RDBMS kan den faktiska utdata för nollvärden vara annorlunda. Till exempel, när du använder psql (för PostgreSQL), matas den tomma strängen ut som standard när ett nullvärde returneras (även om detta kan ändras). Det är samma sak med SQLite (och detta kan också ändras).

I SQL Server, om alla argument är null , då måste minst ett av nullvärdena vara en typ null . Därför resulterar exemplet ovan faktiskt i ett fel (eftersom alla null-argument är null konstanter).

Uttryck

COALESCE() returnerar det aktuella värdet för det första uttrycket som initialt inte evalueras till null . Därför, om vi skickar ett uttryck som detta:

SELECT COALESCE( null, 3 * 5 );

Vi får det här:

15

Databasexempel

Anta att vi kör följande fråga:

SELECT
  name,
  salary
FROM employee;

Och vi får följande resultat:

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

Vi kan se att den sista raden har ett nollvärde i DOB kolumn.

Om vi ​​ville ersätta nollvärdet med ett annat värde kunde vi använda COALESCE() enligt följande:

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

Resultat:

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

I det här fallet ersatte vi alla null-värden med heltal 0 .

Skillnader mellan RDBMS

I allmänhet COALESCE() fungerar ungefär likadant över RDBMS:er.

Men det finns vissa skillnader.

Datatyper

Vi kan göra följande i MySQL, MariaDB och SQLite:

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

Resultat:

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

I det här fallet, när salary kolumnen innehåller ett nullvärde, utdata är None .

Men den frågan kan orsaka problem i SQL Server, PostgreSQL eller Oracle Database.

När jag kör den frågan i SQL Server, PostgreSQL och Oracle Database får jag ett felmeddelande på grund av att ersättningsvärdet är fel datatyp.

Det här är vad SQL Server returnerar när jag kör ovanstående fråga:

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

Det här är vad PostgreSQL returnerar:

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

Och här är vad Oracle Database returnerar:

ORA-00932: inconsistent datatypes: expected NUMBER got CHAR

Men om jag använder ett numeriskt värde får jag inte felet:

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

Resultat:

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

Så det här sista exemplet fungerar över alla sex av ovanstående RDBMS.

Nollargument

En annan skillnad mellan hur RDBMS bearbetar COALESCE() ligger i hur de hanterar nollargument.

Som nämnts, i SQL Server, om alla argument är null , då måste minst ett av nullvärdena vara en typ null . Med andra ord, om alla argument till COALESCE() är nollkonstanten får vi ett fel. Detta är inte fallet med andra RDBMS, där alla argument kan vara noll-konstanten, och utdata kommer att vara null istället för ett fel.