SQL COALESCE() Forklaret

De fleste større RDBMS'er understøtter COALESCE() operator, som returnerer den første ikke-nul værdi fra sin liste over argumenter.

COALESCE() er en SQL-standardfunktion (den er inkluderet i ISO/IEC 9075-specifikationen).

Syntaks

Syntaksen ser sådan ud:

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

Så der kræves mindst ét ​​argument, men flere argumenter kan (og er normalt) angives.

COALESCE() betragtes som et n -adic operatør. Med andre ord er det en operator, der har et variabelt antal operander (dvs. n operander).

Eksempel

Her er et simpelt eksempel til at demonstrere:

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

Resultat:

Papaya

I dette tilfælde Papaya var den første ikke-nul værdi, og derfor COALESCE() returnerede den værdi.

Salad var også en ikke-nul værdi, men den kom efter Papaya og så det blev ikke returneret.

COALESCE() vs CASE

COALESCE() betragtes typisk som en syntaktisk genvej til CASE udtryk.

Som sådan er følgende erklæring:

COALESCE (V1, V2) 

svarer til:

CASE WHEN V1 IS NOT NULL THEN V1 ELSE V2 END

Og følgende udsagn:

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

(for n ≥ 3) Er ækvivalent med:

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

Når alle værdier er nul

Hvis alle værdier er null , COALESCE() returnerer null :

SELECT COALESCE( null, null );

Resultat:

null

Afhængigt af dit RDBMS kan det faktiske output for nulværdier være anderledes. For eksempel, når du bruger psql (til PostgreSQL), udlæses den tomme streng som standard, når en null-værdi returneres (selvom dette kan ændres). Det er det samme med SQLite (og dette kan også ændres).

I SQL Server, hvis alle argumenter er null , så skal mindst én af null-værdierne være en indtastet null . Derfor resulterer ovenstående eksempel faktisk i en fejl (fordi alle null-argumenter er null konstanter).

Udtryk

COALESCE() returnerer den aktuelle værdi af det første udtryk, der oprindeligt ikke evalueres til null . Derfor, hvis vi sender et udtryk som dette:

SELECT COALESCE( null, 3 * 5 );

Vi får dette:

15

Databaseeksempel

Antag, at vi kører følgende forespørgsel:

SELECT
  name,
  salary
FROM employee;

Og vi får følgende resultat:

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

Vi kan se, at den sidste række har en nulværdi i DOB kolonne.

Hvis vi ville erstatte null-værdien med en anden værdi, kunne vi bruge COALESCE() som følger:

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

Resultat:

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

I dette tilfælde erstattede vi alle null-værdier med hele tallet 0 .

Forskelle mellem RDBMS'er

Generelt COALESCE() fungerer stort set det samme på tværs af RDBMS'er.

Men der er nogle forskelle.

Datatyper

Vi kan gøre følgende i MySQL, MariaDB og SQLite:

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

Resultat:

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

I dette tilfælde, når salary kolonnen indeholder en nulværdi, outputtet er None .

Men den forespørgsel kan forårsage problemer i SQL Server, PostgreSQL eller Oracle Database.

Når jeg kører den forespørgsel i SQL Server, PostgreSQL og Oracle Database, får jeg en fejl, fordi erstatningsværdien er den forkerte datatype.

Her er, hvad SQL Server returnerer, når jeg kører ovenstående forespørgsel:

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

Her er, hvad PostgreSQL returnerer:

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

Og her er, hvad Oracle Database returnerer:

ORA-00932: inconsistent datatypes: expected NUMBER got CHAR

Men hvis jeg bruger en numerisk værdi, får jeg ikke fejlen:

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

Resultat:

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

Så dette sidste eksempel fungerer på tværs af alle seks af ovenstående RDBMS'er.

Nul-argumenter

En anden forskel mellem, hvordan RDBMS'er behandler COALESCE() er i, hvordan de håndterer nulargumenter.

Som nævnt, i SQL Server, hvis alle argumenter er null , så skal mindst én af null-værdierne være en indtastet null . Med andre ord, hvis alle argumenter til COALESCE() er nulkonstanten, så får vi en fejl. Dette er ikke tilfældet med andre RDBMS'er, hvor alle argumenter kan være nul-konstanten, og outputtet vil være null i stedet for en fejl.