Mengenal SQL
SQL atau Structure Query Language merupakan salah satu bahasa untuk mengolah database. Bahasa ini begitu umum dan didukung oleh banyak database server terkenal seperti MySQL, Postgres, Interbase, Informix, Sybase, DB2, dan juga Oracle. Dengan demikian penguasaan bahasa ini menjadi begitu penting. Lagi pula aplikasi yang dibangun dengan porsi penggunaan SQL yang cukup besar akan menjadi lebih menghemat waktu pemrograman manakala kita akan menggunakan database yang sama. Anda akan tahu sisi penghematan waktunya setelah membaca artikel ini.
Database Server
Database Server merupakan program utama pengolah database. Program ini biasanya idle (menetap) di memeory server dan menanti request (permintaan) dari program program client.
Database
Database merupakan kumpulan dari seluruh objek database seperti tabel, view, trigger atau fungsi. Setiap produk database server punya cara masing-masing dalam menyimpan sebuah database dalam filesystem. Ada yang dalam bentuk direktori, ada juga dalam bentuk sebuah file.
Login
Apapun database server yang Anda gunakan, proses login tetap diperlukan untuk menjalankan perintah SQL. Suatuproses login membutuhkan informasi, sbb: - Username
- Password
- Nama database
Sesaat setelah database server diinstall, sebuah username sudah tercipta, yaitu username dengan otoritas superuser. User inilah yang nantinya digunakan untuk pertama kalinya dalam login.
Program Client
Program client adalah suatu program yang dibutuhkan untuk proses login. Setiap database server biasanya memiliki program client standard. Berikut ini 3 contoh program client pada 3 database server, Postgres, MySQL dan Interbase.
Postgres
Postgres menyertakan program client bernama psql. Postgres memiliki superuser postgres dan database sistem template1. Anda bisa menggunakan keduanya untuk uji konektivitas secara lokal. Password secara default (sesaat setelah postgres di-install) diabaikan. Artinya Anda boleh mengosongkan password ketika ditanya dengan menekan [ENTER].
$ psql -u template1
Username: postgres
Password:
template1=>
Kini perintah SQL siap diketikkan, yaitu pembuatan database.
template1=> CREATE DATABASE saya;
template1=> \c saya
saya=>
\c bukanlah perintah SQL melainkan perintah psql untuk berpindah ke database lain. Karena ini perintah sql, maka tidak dibutuhkan tanda ; (titik koma) di akhir perintah. Anda bisa melihat seluruh perintah psql dengan /?. Untuk keluar dari prompt ini tekan CTRL-D.
MySQL
MySQL memiliki mysql untuk program clientnya. Perintah pembuatan database juga sama seperti Postgres.
$ mysql
mysql> CREATE DATABASE saya;
mysql> CONNECT saya;
Connection id: 14
Current database: saya
mysql>
Interbase
isql merupakan program client yang menyertai Interbase. Superusernya bernama sysdba dengan password masterkey. Perintah pembuatan databasenya sedikit berbeda dengan dua database sebelumnya, yaitu dengan memberikan tanda kutip.
$ isql -u sysdba -p masterkey
SQL> CREATE DATABASE 'saya.gdb';
SQL>
Dari prompt ini database saya.gdb adalah database yang sedang aktif, sehingga Anda siap mengetikkan perintah SQL lainnya dalam database ini.
Struktur Tabel
Setelah Anda berhasil login ke suatu database, kini saatnya untuk membuat tabel. Pembuatan tabel terkait erat dengan sistem dari aplikasi yang akan dibuat. Jadi misalnya kita akan membuat sistem kepegawaian di sebuah perusahaan, maka struktur tabelnya setidaknya memiliki dua field berikut:- ID Pegawai
- Nama Pegawai
Dalam perintah SQL, pembuatan tabelnya seperti ini
CREATE TABLE pegawai (
id INTEGER,
nama VARCHAR(30)
);
Dalam standar SQL, penulisan perintah tidak mempedulikan huruf besar atau pun kecil. Namun dalam tulisan ini penulis akan menggunakan huruf besar untuk perintah SQL dan huruf kecil untuk nama objek database yang dibuat. Titik koma diakhir perintah diperlukan untuk memberitahukan program client bahwa perintah berakhir dan siap dijalankan (execute).
Field dan Tipe Data
pegawai merupakan nama tabel, id dan nama nama field. Field (kolom) berada dalam tabel. tabel pasti memiliki field. INTEGER dan VARCHAR merupakan tipe data yang menyertai field id dan nama. Tipe data ini disesuaikan dengan sistem yang dibangun. Kalau memang kita akan memastikan bahwa ID pegawai itu hanya terdiri dari angka, maka gunakan INTEGER. Kalau kita punya definisi lain, misalnya kombinasi huruf dan angka, maka VARCHAR perlu dipakai. Angka 30 dalam VARCHAR menunjukkan jumlah karakter maksimum yang diperbolehkan. Dengan demikian struktur diatas mengatakan:- ID pegawai harus angka
- Nama pegawai maksimum 30 karakter
Ada banyak tipe data lainnya yang bisa menyertai suatu field, antara lain:- DATETIME: berisi tanggal dan jam
- FLOAT: angka pecahan
- TEXT: sama dengan VARCHAR dengan jumlah tak terbatas.
Selain tipe data, sebenarnya suatu field bisa disertakan dengan aturan tertentu.
Mengisi Tabel
Kini struktur tabel siap diisi
dengan data. Kita akan membuat pegawai baru yang memiliki ID 1919 dengan nama Sugiana.
INSERT INTO pegawai (id,
nama)
VALUES (1919, 'Sugiana');
Record
Selamat, sebuah record sudah dimasukkan ke dalam tabel. Record bisa juga disebut baris data & field merupakan kolomnya.
Melihat Isi Tabel
Untuk melihat isi tabel, gunakan perintah SELECT:
SELECT * FROM pegawai;
id | nama
-----+----
1919 | Sugiana
Mengubah record
Field nama yang berisi 'Sugiana' akan diubah menjadi 'Owo Sugiana'. Untuk itu gunakan perintah UPDATE. Untuk mengubahnya:
UPDATE pegawai
SET nama = 'Owo Sugiana';
Anda harus hati-hati dengan perintah ini, karena bila jumlah recordnya lebih dari satu maka perintah di atas akan berdampak ke seluruh record. Oleh karena itu gunakan perintah WHERE dimana hanya record yang memenuhi kriteria tertentu saja yang diubah. Misalkan isi tabel pegawai sekarang menjadi seperti ini:
id | nama
-----+------
1919 | Owo Sugiana
1920 | Pribadi Endro
Maka perintah UPDATE di atas menjadi seperti ini:
UPDATE pegawai
SET nama = 'Owo Sugiana'
WHERE id = 1919;
Menghapus Record
Sekarang record pertama (dengan field ID bernilai 1919) akan dihapus. Kita dapat menggunakan perintah DELETE untuk melakukannya:
DELETE FROM pegawai
WHERE ID = 1919;
Menghapus Tabel
Perintah penghapusan tabel berbeda dengan perintah penghapusan record. Menghapus tabel dapat menggunakan perintah DROP TABLE:
DROP TABLE pegawai;
DDL & DML
Dalam SQL perintah seperti CREATE TABLE dan DROP TABLE disebut sebagai Data Definition Language (DDL), sedangkan perintah SELECT, INSERT, UPDATE & DELETE disebut Data Manipulation Language (DML). DDL berkaitan dengan masalah struktur, sedangkan DML berkaitan dengan data (record).
Sort
Perintah SELECT ynag sudah diperkenalkan sebelumnya dapat diberikan perintah tambahan ORDER BY ynag berfungsi untuk mengurutkan (sortir) hasil query (kata query biasa digunakan untuk proses yang dilakukan dari perintah SELECT). Kita telah memiliki tabel pegawai dan kini akan ditampilkan dan hasilnya akan diurutkan berdasarkan nama.
SELECT * FROM pegawai ORDER BY nama;
id | nama
----+----
1919 | Owo Sugiana
1920 | Pribadi Endro
Penggunaan ORDER BY diatas secara default nilai field nama diurutkan dari alphabet teratas ke bawah (ascending). Perintah berikut menghasilkan hasil query yang sama:
SELECT * FROM pegawai ORDER BY nama ASC;
Sedangkan DESC dapat menyertai ORDER BY yang digunakan untuk mengurutkan dari bawah ke atas (descending).
SELECT * FROM pegawai ORDER BY nama DESC;
Record Tertentu
Suatu query juga bisa diberi kondisi, artinya hanya record tertentu saja yang memenuhi kriteria yang akan ditampilkan. Misalkan tabel pegawai sekarang berisi data seperti ini:
SELECT * FROM pegawai;
id | nama
----+-----
1919 | Owo Sugiana
1920 | Pribadi Endro
1921 | Eko Pranoto
1922 | Agus
dan akan ditampilkan record pegawai yang ber-ID 1919 saja.
SELECT * FROM pegawai WHERE id = 1919;
id | nama
----+----
1919 | Owo Sugiana
Untuk menampilkan negasinya (yang bukan ber-ID 1919):
SELECT * FROM pegawai WHERE id <> 1919;
Atau beberapa id tertentu
SELECT * FROM pegawai WHERE id = 1919 OR ID = 1921;
id | nama
-----+-----
1919 | Owo sugiana
1921 | Eko Pranoto
Perintah diatas bisa juga ditulis seperti ini:
SELECT * FROM pegawai WHERE id IN (1919,1921);
Atau negasinya
SELECT * FROM pegawai WHERE id NOT IN (1919,1921);
Ulasan berikut akan mengolah field nama untuk berbagai kondisi dalam query. Misalnya pegawai yang namanya diawali huruf P:
SELECT * FROM pegawai WHERE
nama LIKE 'P%';
id | nama
-------+-----
1920 | Pribadi Endro
Sertakan juga % sebelum dan sesudah kata yang akan dicari untuk menampilkan nama pegawai yang mengandung kata atau huruf tertentu, misalnya huruf a:
SELECT * FROM pegawai WHERE
nama LIKE '%a%';
id | nama
------+----
1919 | Owo Sugiana
1920 | Pribadi Endro
1921 | Eko Pranoto
Bisa jadi yang kita maksudkan adalah semua nama pegawai yang mengandung huruf 'a' maupun 'A' yang berarti tidak memperdulikan huruf kecil maupun besar (incase sensitive). Dengan demikian seharusnya nama pegawai Agus tampil di hasil query. ada beberapa cara untuk melakukan hal ini. Yang pertama, berikan kondisi tambahan dengan memanfaatkan operator OR:
SELECT * FROM pegawai WHERE
nama LIKE '%a%' OR nama LIKE '%A%';
Yang kedua kapitalkan seluruh huruf di field nama (dengan fungsi UPPER) dan kapitalkan juga yang dicari:
SELECT * FROM pegawai WHERE
UPPER(nama) LIKE '%A%';
Fungsi
Ibarat matematika, fungsi merupakan suatu rumus yang menghitung suatu atau sejumlah nilai. Dalam SQL ada dua jenis fungsi:- Non Agregate Function
- Agregate Function
Yang pertama merupakan fungsi dimana pengaruhnya record per record. Contoh: hasil query dimana seluruh nama pegawai ditampilkan dalam huruf besar.
SELECT UPPER(nama) FROM pegawai;
upper
----------
OWO SUGIANA
PRIBADI ENDRO
Sedangkan fungsi jenis kedua pengaruhnya ke seluruh record secara "akumulatif". Misalkan akan di-query jumlah record yang dimiliki tabel pegawai:
SELECT COUNT(*) FROM pegawai;
count
------
2
Nilai ID terkecil:
SELECT MIN(id) FROM pegawai;
Nilai id terbesar:
SELECT MAX(id) FROM pegawai;
Atau mungkin Anda ingin menjumlahkan nilai-nilai seluruh field ID:
SELECT SUM(id) FROM pegawai;
Aturan Dalam Field
Sebenarnya ini adalah bagian yang sangat mendasar karena merupakan "pondasi" dari sistem database yang akan dibagun. Penulis sering menggunakan istilah "struktur bicara", yang bermakna untuk mengetahui bagaimana aturan suatu sistem aplikasi, bisa dilihat dari struktur databasenya dulu.
Suatu field dapat dikenal dengan suatu aturan tertentu. Aturan ini dimaksudkan untuk menjaga konsistensi data. Tipe data (seperti INTEGER atau VARCHAR) yang menyertai suatu field merupakan "aturan awal" untuk menjaga konsistensi ini.
Aturan lainnya yang sering dipakai antara lain:- NOT NULL, suatu field harus berisi nilai
- PRIMARY KEY, sebuah atau beberapa field menjadi key (kunci) untuk suatu tabel
Mari kita lihat lagi tabel pegawai. Dalam tulisan sebelumnya, tabel ini memiliki struktur sebagai berikut:
CREATE TABLE pegawai (
id INTEGER NOT NULL,
nama VARCHAR(30) NOT NULL);
Dari sini Anda tidak diperkenankan menuliskan perintah berikut:
INSERT INTO pegawai (id)
VALUES (1921);
atau:
INSERT INTO pegawai (nama)
VALUES ('Andre Grananda');
Meski struktur di atas sudah lebih baik dari struktur sbelumnya, namun juga masih mengandung kelemahan, yaitu nilai id boleh sama di dua record atau lebih. Padahal id merupakan identitas unik bagi setiap pegawai. Nama boleh sama, tapi ID tidak. Contoh berikut seharusnya tidak boleh terjadi:
SELECT * FROM pegawai;
id | nama
-------+------
1919 | Owo Sugiana
1920 | Pribadi Endro
1921 | Andre Grananda
1921 | Inou Gautama
Yaitu terdapat dua nilai id yang sama di dua record.
Penggunaan PRIMARY KEY untuk field id dapat memastikan bahwa nilai dalam field id pasti unik:
CREATE TABLE pegawai (
id INTEGER NOT NULL PRIMARY KEY,
nama VARCHAR(30) NOT NULL);
Sampai disini tentu kita mendapat beberapa manfaat penerapan aturan pada field:- Data tetap konsisten
- Mempermudah debugging.Pada saat pembuatan aplikasi ada kemungkinan terjadi bug yang menyebabkan duplicate key pada primary key. Pencegahan dari sisi database server mempermudah proses penelusuran kesalahan dalam algoritma program.
- Sistem menjadi lebih mudah dianalisa. Meski sudah terdapat dokumentasi teknis, penerapan struktur database yang benar akan mempermudah penelusuran suatu sistem yang berguna untuk proses pengembangan.
Tanggal
Secara default penanggalan di SQL menggunakan format YYYY/MM/DD (tahun - bulan - tanggal) dengan tipe data DATE.
CREATE TABLE kalender (
tgl DATE NOT NULL);
INSERT INTO kalender VALUES ('2001/7/21');
Isikan beberapa record sehingga menjadi seperti ini:
SELECT * FROM kalender;
tgl
--------
2001-07-21
2001-07-01
2001-03-19
Ekspresi tanggal dinyatakan dalam string sebagaimana contoh di atas, begitu juga bila kita ingin menyatakannya dalam perintah SELECT, misalnya:
SELECT * FROM kalender WHERE tgl = '2001/7/1';
Untuk kondisi interval, gunakan operator BETWEEN:
SELECT * FROM kalender
WHERE tgl BETWEEN '2001/7/1' AND '2001/7/31';
tgl
--------
2001-07-21
2001-07-01
atau bisa juga dengan operator >= dan <= untuk hasil yang sama:
SELECT * FROM kalender WHERE tgl >= '2001/7/01' AND tgl <= '2001/7/31';
Relasi
Merancang suatu struktur data dalam suatu database memerlukan perencanaan yang matang. Sebab bila tidak, struktur tersebut bisa menyebabkan data yang tersimpan tidak efisien (redundant) yang juga akan berakibat pada sulitnya dalam pengolahan dan perawatan (maintenance) data tersebut. Di awal-awal artikel ini kita sudah memiliki tabel pegawai, dimana database yang sama akan dilengkapi dengan data anak pegawai bersangkutan. Jika dikaitkan dengan sistem kepegawaian (human resource) di suatu perusahaan maka data anak ini diperlukan untuk tunjangan keluarga. dalam "format
spreadsheet" struktur tabelnya bisa saja seperti ini:
CREATE TABLE pegawai (
id INTEGER NOT NULL PRIMARY KEY,
nama VARCHAR (30) NOT NULL,
nama_anak1 VARCHAR(30)
nama_anak2 VARCHAR(30),
nama_anak3 VARCHAR(30)
);
Struktur diatas mungkin sudah mencukupi kebutuhan karena ketentuan ketenagakerjaan mengenai tunjangan keluarga adalah untuk jumlah anak maksimum tiga. Meski struktur tersbeut memudahkan programmer (karena untuk mendapatkan data anak cukup query dari suatu tabel), namun struktur ini masih mengandung kelemahan:
- Tidak semua pegawai punya anak, sehingga penyiapan tiga kolom (field) merupakan pemborosan (terlepas dari metode yang digunakan database server dalam menyimpan data)
- Dalam sebuah keluarga tidak mungkin nama anak sama. Struktur diatas memungkinkan seorang pegawai punya dua anak dengan nama sama.
- Ketentuan maksimum tiga anak adalah sebuah ketentuan yang bisa saja berubah, Untuk mengantisipasi kebutuhan ke depan, jelas struktur tersebut kurang fleksible.
Untuk mengantisipasi tiga hal tersebut maka struktur tabel pegawai sebaiknya dipecah menjadi dua: tabel pegawai dan tabel anak dimana keduanya memiliki field penghubung.
CREATE TABLE pegawai (
id INTEGER NOT NULL PRIMARY KEY,
nama VARCHAR(30) NOT NULL);
CREATE TABLE anak(
id_pegawai INTEGER NOT NULL,
nama VARCHAR(30) NOT NULL,
PRIMARY KEY (id_pegawai,nama));
Field penghubung yang dipilih adalah ID pegawai dan bukan nama pegawai. Mengapa? Jawabannya sangat mudah: karena ID pegawai bersifat
unik di tabel pegawai (tidak mungkin ID pegawai sama dalam suatu perusahaan). Jika nama pegawai yang digunakan sebagai penghubung maka bisa menimbulkan kerancuan dalam proses query nanti (query yang menggabungkan tabel pegawai dan tabel anak) karena dalam struktur tabel pegawai memungkinkan dua orang pegawai memiliki nama yang sama. Hal "baru" dalam struktur tabel anak adalah adanya PRIMARY KEY yang terdiri dari dua field. Hal ini untuk menjawab permasalahan nomor dua, yaitu untuk memastikan bahwa nama anak tidak ada yang sama dalam sebuah ID pegawai.
SELECT Antar Tabel
Cobalah untuk mengisi tabel pegawai dan tabel anak:
INSERT INTO pegawai (id,nama) VALUES (1923,'Riki');
INSERT INTO anak (id_pegawai,nama) VALUES (1923,'Mahmud');
dan kini anda diminta untuk menampilkan hasil query dimana terdapat nama pegawai beserta nama anaknya:
SELECT pegawai.id,pegawai.nama,anak.nama FROM pegawai, anak WHERE pegawai.id=anak.id_pegawai;
id | nama | nama |
----+----+----
1923 | Riki | Mahmud
Anda bingung ada dua nama kolom yang sama? Agar lebih informatif, gunakan alias untuk kolom tersebut:
SELECT pegawai.id,pegawai.nama AS nama_pegawai,anak.nama AS nama_anak FROM pegawai, anak WHERE pegawai.id=anak.id_pegawai;
id | nama_pegawai | nama_anak
----+--------+--------
1923 | Riki | Mahmud
Penulisan nama tabel juga bisa dipersingkat dengan menggunakan alias:
SELECT p.id, p.nama AS nama_pegawai,a.nama AS
nama_anak FROM pegawai p, anak a WHERE p.id = a.id_pegawai;
Agregate Function
Pada bab-bab terdahulu, kita sudah diperkenalkan dengan agregate function , yaitu fungsi yang sifatnya akumulatif. Salah satunya akan digunakan untuk menampilkan hasil query dimana akan diperoleh jumlah anak yang dimiliki oleh setiap pegawai, yaitu fungsi COUNT:
SELECT p.id,
p.nama AS nama_pegawai,
a.nama AS nama_anak FROM pegawai p, anak a WHERE p.id = a.id_pegawai;
id | nama_pegawai | nama_anak
---+--------+--------
1922 | Agus | Heni
1923 | Riki | Mahmud
1923 | Riki | Wati
SELECT p.nama, COUNT(*) AS jml_anak FROM pegawai p, anak a WHERE p.id = a.id_pegawai GROUP BY p.nama;
| nama | jml_anak
----+-------
Agus | 1
Riki | 2
Sintaks lainnya yang baru dalam perintah SQL kali ini adalah penggunaan GROUP BY yaitu untuk memberitahu database server bahwa proses akumulatif jumlah anak dikelompokkan berdasarkan nama pegawai. Tanpa GROUP BY, anda akan mendapatkan pesan error. GROUP BY memang dibuat untuk menyertai agregate function. Kini hasil query tersebut akan diberi kondisi hanya pegawai dengan jumlah anak satu saja yang akan ditampilkan. Kita telah mempelajari perintah WHERE untuk menyatakan kondisi, namun karena COUNT adalah agregate function maka perintah ini tidak bisa
digunakan. Sebagai gantinya digunakan HAVING:
SELECT p.nama, COUNT(*) AS jml_anak FROM pegawai p, anak a WHERE p.id = a.id_pegawai GROUP BY p.nama HAVING COUNT(*) = 1;
nama | jml_anak
----+-----
Agus | 1
Sub-SELECT
Query sebelumnya hanya membahas tentang mendapatkan pegawai yang memiliki anak. Namun bagaimana memperoleh hasil query untuk pegawai yang belum memiliki anak? Jelas kita tidak dapat menggunakan query terakhir yang memanfaatkan COUNT, karena - sekali lagi - query tersebut hanya untuk pegawai yang memiliki anak. Logika dari query yang akan kita buat kali ini adalah: tampilkan seluruh pegawai dimana ID pegawai tidak ditemui di tabel anak. Pertama-tama tampilkan seluruh pegawai:
SELECT * FROM pegawai;
id | nama
---+-----
1919 | Owo Sugiana
1920 | Pribadi Endro
1921 | Eko Pranoto
1922 | Agus
1923 | Riki
Kemudian "saring" kembali hasil query diatas dengan memanfaatkan operator NOT IN:
SELECT * FROM pegawai WHERE id NOT IN (SELECT id_pegawai FROM anak);
id | nama
---+-----
1919 | Owo Sugiana
1920 | Pribadi Endro
1921 | Eko Pranoto
SELECT dalam SELECT inilah yang disebut dengan
sub-SELECT. Hasil query yang sama juga bisa diperoleh dengan menggunakan operator NOT EXIST:
SELECT * FROM pegawai p WHERE NOT EXIST (SELECT * FROM anak a WHERE a.id_pegawai = p.id);
Perlu diketahui bahwa MySQL versi 3.22 belum mendukung sub-SELECT. Sebagai gantinya kita dapat melakukan "penyaringan" hasil query di tingkat aplikasi. View, view merupakan query yang tersimpan dalam database dan dapat diberlakukan sebagaimana sebuah tabel yang dapat di SELECT.
CREATE VIEW v_anak_pegawai AS SELECT p.id,
p.nama AS nama_pegawai,
a.nama AS nama_anak FROM pegawai p, anak a WHERE p.id = a.id_pegawai;
v_anak_pegawai merupakan nama VIEW dan sudah dapat digunakan dalam SELECT sebagaimana sebuah tabel:
SELECT * FROM v_anak_pegawai;
Dengan demikian penggunaan view semakin memudahkan penulisan query berulang yang biasanya terdapat di berbagai source aplikasi yang dibangun. Untuk menghapusnya gunakan perintah DROP VIEW:
DROP VIEW v_anak_pegawai;
Referential Integrity
Kita kembali ke masalah struktur. Struktur tabel anak dalam pembahasan di atas sudah memiliki aturan yang baik.
Namun masih memiliki kelemahan dari aspek yang disebut dengan referential integrity. Perhatikan contoh berikut:
SELECT * FROM pegawai;
id | nama
---+------
1919 | Owo Sugiana
1920 | Prabadi Endro
1921 | Eko Pranoto
1922 | Agus
1923 | Riki
SELECT * FROM anak;
id_pegawai | nama
-----+------
1923 | Mahmud
1923 | Wati
1922 | Heni
Sekarang tambahkan di tabel anak ID pegawai yang tidak terdapat di tabel pegawai:
INSERT INTO anak (id_pegawai,nama) VALUES (2000,'Budi');
Seperti yang kita lihat di tabel pegawai bahwa ID 2000 tidak ada. Meski hal tersebut dapat dilakukan di tingkat database namun secara sistem ketenagakerjaan hal tersebut tidak diperbolehkan, karena data tersbeut seharusnya memang tidak ada. Untuk memastikan bahwa data yang tidak benar itu tidak akan terisi, maka kita bisa melakukan pencegahan berikut:- Memberikan aturan dalam struktur field id_pegawai
- Aplikasi melakukan pemeriksaan terlebih dahulu (dengan query) apakah ID pegawai tersebut ada. Kalau tidak ada tampilkan pesan error.
Yang pertama merupakan solusi yang sangat mendasar, artinya integritas data sudah terjaga, baik data yang dimasukkan lewat aplikasi (dengan user interface yang sudah dibuat sedemikian rupa) atau user menuliskan SQL secara langsung (seperti INSERT diatas). Di tingkat aplikasi, pencegahan pertama ini memiliki kelemahan dalam menampilkan pesan kesalahan dimana pesan tersebut berasal dari database server yang sifatnya sangat teknis sekali. Oleh karena itu solusi pertama perlu dilengkapi dengan kedua, dimana kita bisa menampilkan pesan kesalahan sesuai dengan bahasa yang dikehendaki. Pemberian referential integrity untuk field id_pegawai adalah, sbb:
CREATE TABLE anak (
id_pegawai INTEGER NOT NULL references PEGAWAI, nama VARCHAR(30) NOT NULL,
PRIMARY KEY(id_pegawai, nama));
Atau bisa juga dengan menggunakan FOREIGN KEY:
CREATE TABLE anak (
id_pegawai INTEGER NOT NULL,
nama VARCHAR(30) NOT NULL
PRIMARY KEY(id_pegawai,nama),
FOREIGN KEY(id_pegawai) REFERENCES pegawai);
Kembali ke MySQL, database server ini belum menerapkan referential integrity. Para pembuatnya memberikan alasan mengapa hal itu (yang sudah menjadi standar SQL). Anda bisa melihat dalam dokumentasinya.
SQL yang Universal
Penguasaan SQL menjadi sangat penting dalam dunia pemrograman, karena bahasa ini banyak didukung oleh berbagai produk database dan sudah menjadi standar umum. Seperti contoh-contoh dalam tulisan ini yang sudah diujicoba di tiga database open-source: PostgreSQL, MySQL, Interbase. Dengan mengoptimalkan penggunaan perintah SQL dalam algoritma program dapat memudahkan para programmer untuk lintas platform. Ilustrasi berikut bisa memperjelas makna lintas palform ini: "Dengan database yang sama kita bisa menggunakan bahasa pemrograman yang bermacam-macam dimana pengolahan data dilakukan oleh SQL, dan bahasa pemrograman yang mengatur tampilannya. "Dengan perintah SQL yang sama kita bisa menggunakan produk database yang beragam. Hasil akhirnya adalah penghematan waktu penyelesaian program karena penggunaan source yang serupa.
Sumber :
majalah bulanan INFOLINUX
Homepage: http://www.infolinux.web.id
Copyright (a) 2001 Pelik
Design by globalnet