Dalam SQL, operator adalah karakter khusus atau kata kunci yang menentukan tindakan yang dilakukan pada satu atau lebih ekspresi.
Operator SQL merupakan bagian integral dari SQL, dan memungkinkan kita untuk menulis kueri yang mengembalikan hasil yang relevan.
Dalam artikel ini, saya menyajikan 12 operator SQL yang paling umum digunakan saat menulis kueri SQL.
Yang Sama (= ) Operator
Operator Setara (= ) mungkin adalah operator yang paling umum digunakan dalam SQL. Ini membandingkan kesetaraan dua ekspresi. Bahkan jika Anda tidak terlalu familiar dengan SQL, Anda mungkin tahu operator ini.
Bayangkan kita memiliki database untuk hotel hewan peliharaan, dan kita ingin mendapatkan informasi tentang semua hewan peliharaan bernama Fluffy.
Dalam hal ini, kita dapat melakukan ini:
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy';Hasil:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
Kueri kami menggunakan operator Equals (= ) untuk membandingkan kesetaraan nilai PetName kolom dan string Fluffy .
Dalam kasus kami, kami dapat melihat bahwa hotel hewan peliharaan saat ini memiliki dua hewan peliharaan bernama Fluffy.
Lebih Besar dari (> ) Operator
Operator Lebih Besar Dari (> ) membandingkan dua ekspresi dan mengembalikan TRUE jika operan kiri memiliki nilai lebih tinggi dari operan kanan; jika tidak, hasilnya adalah FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB > '2020-01-01';Hasil:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Dalam hal ini, membandingkan nilai DOB kolom dan tanggal 2020-01-01 untuk melihat apakah DOB kolom lebih besar.
Kurang Dari (< ) Operator
Operator Kurang Dari (< ) melakukan sebaliknya. Ini membandingkan dua ekspresi dan mengembalikan TRUE jika operan kiri memiliki nilai lebih rendah dari operan kanan; jika tidak, hasilnya adalah FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB < '2020-01-01';Hasil:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
Lebih Besar dari atau Sama Dengan (>= ) Operator
Operator Lebih Besar dari atau Sama Dengan (>= ) membandingkan dua ekspresi dan mengembalikan TRUE jika operan kiri memiliki nilai lebih besar atau sama dengan operan kanan; jika tidak, ia mengembalikan FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB >= '2020-09-17';Hasil:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Perhatikan bahwa itu mengembalikan 2020-09-17 dan semua tanggal yang lebih besar dari itu. Jika kita menggunakan operator Lebih Besar dari (> ), hanya dua baris pertama yang akan dikembalikan.
Kurang Dari atau Sama Dengan (<= ) Operator
Operator Kurang Dari atau Sama Dengan (<= ) membandingkan dua ekspresi dan mengembalikan TRUE jika operan kiri memiliki nilai lebih rendah dari atau sama dengan operan kanan; jika tidak, hasilnya adalah FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB <= '2020-09-17';Hasil:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | | Wag | 2020-03-15 | | Fluffy | 2020-09-17 | +-----------+------------+
Perhatikan bahwa itu mengembalikan 2020-09-17 dan semua tanggal kurang dari itu. Jika kita menggunakan operator Less Than (< ), hanya tiga baris pertama yang akan dikembalikan.
The AND Operator
AND operator menggabungkan dua ekspresi Boolean dan mengembalikan TRUE ketika kedua ekspresi TRUE .
Ini contohnya.
SELECT PetId, DOB
FROM Pets
WHERE PetName = 'Fluffy'
AND DOB > '2020-01-01';Hasil:
+---------+------------+ | PetId | DOB | |---------+------------| | 1 | 2020-11-20 | | 6 | 2020-09-17 | +---------+------------+
Dalam hal ini, kami hanya mendapatkan detail hewan peliharaan dengan nama Fluffy dan tanggal lahir mereka berada di antara dua tanggal tersebut.
OR Operator
OR operator menggabungkan dua ekspresi Boolean dan mengembalikan TRUE ketika salah satu dari kondisinya TRUE .
Ini contohnya.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy' OR PetName = 'Bark';Hasil:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Ini pada dasarnya kebalikan dari AND operator. Jika kita menggunakan AND , tidak akan ada baris yang dikembalikan, karena kita tidak dapat memiliki dua nilai yang berbeda dalam satu kolom secara bersamaan.
BETWEEN Operator
BETWEEN operator memungkinkan kita untuk menentukan rentang yang akan diuji. Misalnya, kita dapat menggunakannya untuk mengembalikan hewan peliharaan yang lahir di antara dua tanggal.
SELECT
PetName,
DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';Hasil:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
Yang NOT Operator
NOT operator meniadakan input Boolean (itu membalikkan nilai ekspresi Boolean apa pun). Karenanya mengembalikan TRUE ketika ekspresinya FALSE .
Inilah yang terjadi ketika kita menambahkan NOT operator ke contoh kita sebelumnya.
SELECT
PetName,
DOB
FROM Pets
WHERE DOB NOT BETWEEN '2018-01-01' AND '2020-01-01';Hasil:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Kali ini kami mendapatkan semua hewan peliharaan lainnya – hewan peliharaan yang bukan lahir di antara tanggal tersebut.
Di MariaDB, NOT terbatas untuk meniadakan IN , BETWEEN , dan EXISTS klausa. Sebagian besar DBMS lain mengizinkan NOT untuk meniadakan ekspresi apa pun.
The IN Operator
IN operator menentukan apakah nilai yang ditentukan cocok dengan nilai apa pun dalam subkueri atau daftar.
Ini contohnya.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');Hasil:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 4 | Wag | 2020-03-15 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Kami dapat mencapai hasil yang sama dengan menggunakan dua OR operator:
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy'
OR PetName = 'Bark'
OR PetName = 'Wag';
Namun, kode IN operator adalah cara yang lebih ringkas untuk melakukannya. IN operator sangat bermanfaat ketika Anda memiliki daftar nilai yang panjang untuk dibandingkan.
IN operator hampir selalu mengeksekusi lebih cepat daripada beberapa OR operator, terutama pada kumpulan data yang lebih besar.
Manfaat lain dari IN operator, apakah itu dapat berisi SELECT . yang lain daftar. Ini dikenal sebagai subkueri . Subquery adalah kueri yang bersarang di dalam kueri lain (atau bahkan subkueri lain).
Ini contohnya.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Hasil:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
Contoh ini menunjukkan kepada kita berapa banyak jenis hewan peliharaan di hotel hewan peliharaan kita.
Kita bisa menggunakan NOT operator untuk membalik ini dan melihat berapa banyak jenis hewan peliharaan yang bukan di hotel hewan peliharaan kami.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId NOT IN ( SELECT PetTypeId FROM Pets );Hasil:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 4 | Rabbit | +-------------+-----------+
Jadi database kami berisi jenis hewan peliharaan Rabbit , tetapi saat ini kami tidak memiliki kelinci sebagai hewan peliharaan.
+ dan || Operator Penggabungan String
+ dan || operator penggabungan string memungkinkan Anda menggabungkan string. Penggabungan string adalah operasi penggabungan string karakter secara end-to-end.
Alasan saya mencantumkan dua operator yang melakukan hal yang sama adalah karena, + operator didukung di SQL Server, dan || operator didukung di DB2, Oracle, PostgreSQL, SQLite.
Berikut ini contoh yang berfungsi di SQL Server.
SELECT
FirstName,
LastName,
FirstName + LastName
FROM Owners;Hasil:
+-------------+------------+--------------------+ | FirstName | LastName | (No column name) | |-------------+------------+--------------------| | Homer | Connery | HomerConnery | | Bart | Pitt | BartPitt | | Nancy | Simpson | NancySimpson | | Boris | Trump | BorisTrump | +-------------+------------+--------------------+
Dalam hal ini, pemilik memiliki nama depan dan nama belakang mereka disimpan di kolom yang berbeda. Dalam SELECT . kami list, pertama-tama kami mengambilnya satu per satu, tetapi kami juga mengambilnya lagi, menggunakan operator gabungan untuk menggabungkannya.
Ada beberapa masalah dengan hasil kami.
- Tidak ada spasi antara nama depan dan belakang.
- Tidak ada nama kolom.
Untungnya ini mudah diperbaiki.
Kita dapat menggunakan operasi penggabungan yang sama untuk memasukkan spasi antara nama depan dan nama belakang.
Dan kita dapat menggunakan alias kolom ke hasil gabungan untuk memberikan nama kolom di kumpulan hasil.
SELECT
FirstName,
LastName,
FirstName + ' ' + LastName AS FullName
FROM Owners;Hasil:
+-------------+------------+---------------+ | FirstName | LastName | FullName | |-------------+------------+---------------| | Homer | Connery | Homer Connery | | Bart | Pitt | Bart Pitt | | Nancy | Simpson | Nancy Simpson | | Boris | Trump | Boris Trump | +-------------+------------+---------------+
Jika Anda menggunakan DB2, Oracle, PostgreSQL, SQLite, tukar + untuk || dan itu akan berfungsi dengan baik.
Jika Anda menggunakan MySQL atau MariaDB, Anda harus menggunakan CONCAT() berfungsi untuk menggabungkan string.
The LIKE Operator
LIKE operator memungkinkan Anda untuk melakukan pencocokan pola. Ini menentukan apakah string karakter tertentu cocok dengan pola tertentu. Sebuah pola dapat menyertakan karakter reguler dan karakter wildcard.
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '%.com';Hasil:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
Dalam contoh ini, saya menggunakan LIKE operator bersama dengan % operator wildcard untuk mengembalikan pemilik yang alamat emailnya diakhiri dengan .com .
Operator Bonus! % Operator Wildcard
% operator wildcard cocok dengan string apa pun dari nol atau lebih karakter. Ini dapat digunakan sebagai awalan atau akhiran, dan juga dapat digunakan di tengah string.
Ini cenderung lebih umum digunakan sebagai sufiks, dan penggunaannya terbatas di tengah pola, meskipun ada beberapa kasus penggunaan yang valid untuk menggunakannya di tengah pola, seperti berikut:
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '[email protected]%.com';Hasil:
+-------------+------------+------------------+ | FirstName | LastName | Email | |-------------+------------+------------------| | Bart | Pitt | [email protected] | +-------------+------------+------------------+
Dalam hal ini, kami tidak tahu alamat email bart, tetapi kami tahu itu dimulai dengan [email protected] dan diakhiri dengan .com . Oleh karena itu, kami dapat menggunakan LIKE dalam hubungannya dengan % operator wildcard untuk mengisi sisanya.
Ingatlah bahwa teknik ini dapat mengembalikan banyak baris yang tidak relevan, bergantung pada data, dan cara Anda menyusun pernyataan SQL.
Perlu diketahui juga bahwa kueri yang berisi LIKE klausa dapat berjalan jauh lebih lambat daripada kueri lain, dan Anda mungkin harus menghindari penggunaan LIKE klausa kecuali Anda benar-benar membutuhkannya. Menggunakan % operator sebagai awalan bisa sangat lambat.
Itu tidak berarti Anda tidak boleh menggunakannya sama sekali. LIKE operator adalah bagian integral dari SQL, dan Anda akan menemukan banyak skenario di mana itu akan menjadi satu-satunya pilihan (atau setidaknya, pilihan terbaik).
Lebih Banyak Operator SQL
Lihat daftar lengkap Operator SQL saya untuk sejumlah besar operator lain yang tidak disertakan di sini.
