SQL COALESCE() Dijelaskan

Sebagian besar RDBMS utama mendukung COALESCE() operator, yang mengembalikan nilai non-null pertama dari daftar argumennya.

COALESCE() adalah fitur standar SQL (termasuk dalam spesifikasi ISO/IEC 9075).

Sintaks

Sintaksnya seperti ini:

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

Jadi, setidaknya satu argumen diperlukan, tetapi beberapa argumen dapat (dan biasanya) disediakan.

COALESCE() dianggap sebagai n -operator adik. Dengan kata lain, ini adalah operator yang memiliki sejumlah variabel operan (yaitu n operand).

Contoh

Berikut adalah contoh sederhana untuk ditunjukkan:

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

Hasil:

Papaya

Dalam hal ini, Papaya adalah nilai non-null pertama, jadi COALESCE() mengembalikan nilai tersebut.

Salad juga merupakan nilai bukan nol, tetapi muncul setelah Papaya dan tidak dikembalikan.

COALESCE() vs CASE

COALESCE() biasanya dianggap sebagai pintasan sintaksis untuk CASE ekspresi.

Dengan demikian, pernyataan berikut:

COALESCE (V1, V2) 

setara dengan:

CASE WHEN V1 IS NOT NULL THEN V1 ELSE V2 END

Dan pernyataan berikut:

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

(untuk n 3) Setara dengan:

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

Ketika Semua Nilai Null

Jika semua nilai adalah null , COALESCE() mengembalikan null :

SELECT COALESCE( null, null );

Hasil:

null

Bergantung pada RDBMS Anda, keluaran aktual untuk nilai nol mungkin berbeda. Misalnya, saat menggunakan psql (untuk PostgreSQL), string kosong akan dikeluarkan secara default setiap kali nilai null dikembalikan (walaupun ini dapat diubah). Sama halnya dengan SQLite (dan ini juga dapat diubah).

Di SQL Server, jika semua argumen null , maka setidaknya satu dari nilai nol harus diketik null . Oleh karena itu, contoh di atas sebenarnya menghasilkan kesalahan (karena semua argumen null adalah null konstanta).

Ekspresi

COALESCE() mengembalikan nilai saat ini dari ekspresi pertama yang awalnya tidak mengevaluasi ke null . Oleh karena itu, jika kita memberikan ekspresi seperti ini:

SELECT COALESCE( null, 3 * 5 );

Kami mendapatkan ini:

15

Contoh Basis Data

Misalkan kita menjalankan kueri berikut:

SELECT
  name,
  salary
FROM employee;

Dan kita mendapatkan hasil sebagai berikut:

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

Kita dapat melihat bahwa baris terakhir memiliki nilai null di DOB kolom.

Jika kita ingin mengganti nilai null dengan nilai lain, kita bisa menggunakan COALESCE() sebagai berikut:

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

Hasil:

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

Dalam hal ini kami mengganti semua nilai null dengan integer 0 .

Perbedaan Antara RDBMS

Secara umum, COALESCE() bekerja hampir sama di seluruh RDBMS.

Tapi ada beberapa perbedaan.

Tipe Data

Kita dapat melakukan hal berikut di MySQL, MariaDB, dan SQLite:

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

Hasil:

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

Dalam hal ini, setiap kali salary kolom berisi nilai nol, outputnya adalah None .

Tetapi kueri itu dapat menyebabkan masalah di SQL Server, PostgreSQL, atau Oracle Database.

Ketika saya menjalankan kueri itu di SQL Server, PostgreSQL, dan Oracle Database, saya mendapatkan kesalahan karena nilai penggantinya adalah tipe data yang salah.

Inilah yang dikembalikan SQL Server ketika saya menjalankan kueri di atas:

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

Inilah yang dikembalikan PostgreSQL:

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

Dan inilah yang Oracle Database kembalikan:

ORA-00932: inconsistent datatypes: expected NUMBER got CHAR

Tetapi jika saya menggunakan nilai numerik, saya tidak mendapatkan kesalahan:

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

Hasil:

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

Jadi contoh terakhir ini berfungsi di keenam RDBMS di atas.

Argumen Null

Perbedaan lain antara bagaimana RDBMS memproses COALESCE() adalah bagaimana mereka menangani argumen nol.

Seperti yang disebutkan, di SQL Server, jika semua argumen null , maka setidaknya satu dari nilai nol harus diketik null . Dengan kata lain, jika semua argumen ke COALESCE() adalah konstanta nol, maka kita mendapatkan kesalahan. Ini tidak terjadi dengan RDBMS lain, di mana semua argumen dapat berupa konstanta nol, dan outputnya akan menjadi null bukannya error.