Struktur Perintah SQL

Sebelum mengetik perintah pertama, kita perlu peta jalannya: anatomi perintah SQL. SQL adalah bahasa yang berbentuk kumpulan statement — satu unit perintah lengkap yang dikirim ke server MySQL untuk dieksekusi. Memahami bagian-bagian sebuah statement membuat kita bisa membaca dokumentasi resmi, membedakan pesan galat, dan menulis query yang mudah dipelihara. Pada Chapter ini kita akan membongkar anatomi statement, mengenali empat kategori besar perintah SQL, lalu mempelajari aturan huruf besar-kecil dan penulisan multi-baris.

Anatomi Statement SQL #

Setiap statement SQL tersusun dari komponen yang bisa kita bedah satu per satu: keyword (kata kunci perintah), identifier (nama objek seperti tabel dan kolom), ekspresi, clause (klausa), dan terminator berupa titik koma. Pernyataan paling sederhana yang bisa kita jalankan bahkan tidak butuh tabel sama sekali:

SELECT 2 + 3 AS hasil;

Output yang Dihasilkan:

+-------+
| hasil |
+-------+
|     5 |
+-------+
1 row in set (0.00 sec)

Mari kita telaah komponen pada statement di atas:

1. SELECT (keyword): Kata kunci yang memberi tahu server bahwa kita ingin membaca nilai. Keyword selalu ditulis di awal statement dan menentukan “kata kerja” dari perintah.
2. 2 + 3 (ekspresi): Perhitungan yang dievaluasi server sebelum hasilnya dikembalikan ke klien.
3. AS hasil (alias): Label untuk kolom hasil. Bagian ini identifier buatan kita sendiri sehingga bebas dinamai, misalnya hasil atau total.
4. ; (terminator): Tanda titik koma menutup statement. Klien mysql menunggu tanda ini sebelum mengirim perintah ke server, sehingga titik koma wajib ada di akhir setiap statement.

Mempersiapkan Tabel Latihan #

Anatomi yang paling berguna dipelajari pada statement yang menyentuh data nyata. Karena itu kita siapkan dulu satu database dan satu tabel kecil berisi tiga produk. Perintah CREATE DATABASE, CREATE TABLE, dan INSERT akan dibahas tuntas pada chapter dan section berikutnya — untuk sekarang cukup jalankan blok berikut sebagai bahan latihan:

CREATE DATABASE belajar_sql;
USE belajar_sql;
CREATE TABLE produk (
  id INT,
  nama VARCHAR(100),
  harga INT
);
INSERT INTO produk (id, nama, harga) VALUES
  (1, 'Buku Tulis', 4000),
  (2, 'Pulpen Hitam', 15000),
  (3, 'Tip Ex', 8000);

Output yang Dihasilkan:

Query OK, 1 row affected (0.00 sec)

Database changed
Query OK, 0 rows affected (0.00 sec)

Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

Blok di atas dijalankan berurutan dalam satu sesi: database belajar_sql dibuat, dijadikan database aktif, tabel produk didefinisikan dengan tiga kolom, lalu tiga baris data produk dimasukkan. Mulai sekarang kita bisa memakai tabel ini untuk setiap contoh pada chapter berikutnya.

Klausa: Menyusun Statement Bertingkat #

Statement yang membaca tabel tersusun dari klausa-klausa yang saling melengkapi. Klausa adalah potongan statement yang diawali keyword tertentu dan memfilter satu aspek dari hasil. Bentuk dasarnya seperti ini:

SELECT nama, harga FROM produk;

Output yang Dihasilkan:

+--------------+-------+
| nama         | harga |
+--------------+-------+
| Buku Tulis   |  4000 |
| Pulpen Hitam | 15000 |
| Tip Ex       |  8000 |
+--------------+-------+
3 rows in set (0.00 sec)

Bedah komponennya:

1. SELECT nama, harga: Klausa daftar kolom. Kita menyebut dua identifier kolom yang ingin dibaca, dipisah tanda koma.
2. FROM produk: Klausa sumber data. Identifier produk menunjuk tabel tempat kolom-kolom tersebut tinggal.
3. ;: Terminator yang menutup statement.

Klausa bisa ditambah bertingkat untuk mempersempit dan mengurutkan hasil sekaligus:

SELECT nama, harga
FROM produk
WHERE harga >= 8000
ORDER BY harga DESC;

Output yang Dihasilkan:

+--------------+-------+
| nama         | harga |
+--------------+-------+
| Pulpen Hitam | 15000 |
| Tip Ex       |  8000 |
+--------------+-------+
2 rows in set (0.00 sec)

Klausa WHERE harga >= 8000 menyaring baris sehingga hanya produk dengan harga minimal 8000 yang lolos, sementara ORDER BY harga DESC mengurutkan hasil dari nilai terbesar. Urutan penulisan klausa tidak bebas: SELECT harus di depan, FROM mengikuti, lalu WHERE, dan ORDER BY berada di akhir. Menulis WHERE setelah ORDER BY akan memicu galat sintaks.

Penulisan Multi-Baris #

MySQL tidak peduli pemisah baris: server hanya mencari terminator ; sebelum sebuah statement dianggap selesai. Karena itu statement panjang boleh — dan sebaiknya — dipecah menjadi beberapa baris dengan indentasi, seperti contoh WHERE dan ORDER BY di atas. Setiap baris baru tidak mengubah makna statement sedikit pun; yang penting kata kunci, identifier, dan tanda bacanya tetap utuh.

Klien mysql membantu kebiasaan ini dengan prompt lanjutan ->: ketika kita menekan Enter di tengah statement yang belum berakhir, klien menampilkan -> sebagai tanda bahwa ia masih menunggu sisa statement. Baris-baris indentasi dua atau empat spasi pada daftar kolom adalah konvensi gaya penulisan, bukan aturan sintaks — tim yang sama sebaiknya sepakat satu gaya agar query mudah dibaca bersama.

Kategori Perintah SQL: DDL, DML, DCL, dan TCL #

Perintah SQL dikelompokkan menjadi empat kategori besar berdasarkan fungsinya. Pengelompokan ini membantu kita mengetahui perintah mana yang mengubah struktur, mana yang mengubah isi data, dan mana yang mengatur hak akses:

Perintah CREATE DATABASE dan CREATE TABLE yang kita pakai sejauh ini termasuk DDL, sedangkan SELECT termasuk DML. Sebagian literatur menempatkan SELECT pada kelompok tersendiri bernama DQL (Data Query Language), namun dokumentasi MySQL memperlakukan pembacaan data sebagai bagian dari DML. Kategori DCL dan TCL baru akan terasa manfaatnya ketika kita mulai mengatur pengguna dan transaksi pada section lanjutan.

Huruf Besar-Kecil: Keyword vs Identifier #

Keyword SQL tidak case-sensitive: select, Select, dan SELECT sama-sama diterima server. Identifier kolom juga tidak case-sensitive, sehingga SELECT NAMA FROM produk tetap sah. Identifier tabel berlaku aturan berbeda yang bergantung sistem operasi — hal ini sering mengejutkan pemula:

select nama, harga from produk;

Output yang Dihasilkan:

+--------------+-------+
| nama         | harga |
+--------------+-------+
| Buku Tulis   |  4000 |
| Pulpen Hitam | 15000 |
| Tip Ex       |  8000 |
+--------------+-------+
3 rows in set (0.00 sec)

Statement di atas memakai keyword huruf kecil semua dan tetap menghasilkan output identik dengan versi huruf besarnya. Untuk tabel, MySQL menyimpan nama file tabel di sistem operasi, sehingga perilakunya dipengaruhi variabel server lower_case_table_names:

SELECT @@lower_case_table_names;

Output yang Dihasilkan:

+--------------------------+
| @@lower_case_table_names |
+--------------------------+
|                        0 |
+--------------------------+
1 row in set (0.00 sec)

Nilai 0 berarti perbandingan nama tabel dilakukan apa adanya (case-sensitive) — nilai inilah yang dipakai server kita yang berjalan di Linux. Akibatnya, menulis nama tabel dengan huruf yang berbeda dari aslinya memicu galat:

-- @error
SELECT * FROM PRODUK;

Output yang Dihasilkan:

Query OK, 0 rows affected (0.00 sec)

ERROR 1146 (42S02): Table 'belajar_sql.PRODUK' doesn't exist
Bye

Server mencari tabel bernama PRODUK huruf besar dan tidak menemukannya, padahal tabel kita bernama produk huruf kecil. Di Windows dan macOS, lower_case_table_names secara bawaan bukan nol sehingga nama tabel diperlakukan case-insensitive.

Referensi #

• SQL Statements — MySQL 8.4 Reference Manual
• Keywords and Reserved Words — MySQL 8.4 Reference Manual
• Identifier Case Sensitivity — MySQL 8.4 Reference Manual
• SELECT Statement — MySQL 8.4 Reference Manual

Kita kini bisa membaca anatomi statement SQL seperti membaca kalimat: keyword menentukan aksi, identifier menunjuk objek, klausa menyaring makna, dan titik koma menutupnya. Pemahaman ini akan langsung terpakai pada chapter berikutnya, di mana kita membuat database pertama dan mengatur character set yang tepat untuk data berbahasa Indonesia.