Anda di halaman 1dari 32

MySQL

MySQL adalah server basis data yang kompak dan kecil yang ideal untuk
banyak aplikasi basis data on-line. MySQL mendukung SQL standar (ANSI),
meskipun tidak selengkap subset yang menjadi standar seperti PostgreSQL.
MySQL dapat dijalankan di banyak platform dan memiliki kemampuan
multithreading pada server UNIX. Pada lingkungan bukan UNIX, MySQL dapat
dijalankan sebagai servis pada Windows NT dan sebagai proses normal pada mesin
Windows 95/98. MySQL adalah server DBMS relasional SQL yang mendukung
multithreading dan multi-user. MySQL mengimplementasikan client/server yang
terdiri dari sebuah daemon server (servis di server) dan banyak program dan pustaka
klien yang berbeda-beda.
MySQL dulunya dikembangkan tahun 1996 untuk menyediakan server SQL
yang dapat menangani transaksi dalam basis data yang sangat besar dengan kecepatan
tinggi.

Memulai Dengan MySQL


Program client yang biasanya digunakan untuk mengakses server MySQL di
Linux adalah program mysql. Program interaktif ini mengijinkan Anda mengakses
server MySQL, menjalankan query dan menyaksikan hasilnya.
Untuk connect ke server, biasanya dibutuhkan username MySQL ketika Anda
menjalankan mysql, dan biasanya juga password. Jika servernya berbeda dari
komputer tempat Anda login, Anda juga harus menuliskan hostname-nya. Contohnya
seperti berikut :
$ mysql h host u user p
Enter password: ********
Tanda ***** menunjukkan password
Enter

password:.

Anda, masukkanlah ketika mysql menampilkan

Jika Anda berhasil login, Anda akan melihat informasi

introduction yang diikuti oleh prompt mysql> :


shell> mysql -h host -u user -p
Enter password: ********
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 459 to server version: 3.22.20a-log
Type 'help' for help.
mysql>
1

Prompt ini menunjukkan bahwa mysql siap menerima perintah.


Beberapa instalasi MySQL memperbolehkan user untuk connect sebagai user
anonymous (tak bernama). Dalam hal ini, Anda dapat connect ke server tersebut
dengan mysql tanpa option apa-apa.
Setelah Anda berhasil terhubung, Anda dapat disconnect setiap saat dengan
menuliskan QUIT pada prompt mysql.

Memasukkan Query
Setelah Anda connect ke server MySQL Anda dapat mulai menuliskan query.
Contohnya :
mysql> SELECT VERSION(), CURRENT_DATE;
+--------------+--------------+
| version()
| CURRENT_DATE |
+--------------+--------------+
| 3.22.20a-log | 1999-03-19
|
+--------------+--------------+
1 row in set (0.01 sec)
mysql>

Query ini mengilustrasikan beberapa hal tentang mysql :

Sebuah perintah umumnya terdiri dari sebuah pernyataan SQL diakhiri dengan
tanda ; (titik koma).

Ketika Anda membuat perintah, mysql mengirimkannya ke server untuk


dieksekusi dan menampilkan hasilnya, kemudian menampilkan mysql> lain untuk
menunjukkan bahwa dia sudah siap untuk perintah lain.

mysql menampilkan output query sebagai tabel. Baris pertama berisi label untuk
kolom, dan baris-baris selanjutnya adalah hasil query-nya. Normalnya, label
kolom adalah nama dari kolom yang Anda ambil/fetch dari tabel database. Jika
Anda mengambil nilai dari ekspresi dan bukan kolom tabel (seperti contoh di
atas), mysql memberi label kolom menggunakan ekspresi itu sendiri.

mysql menunjukkan jumlah baris yang dikembalikan, dan berapa lama waktu
yang dibutuhkan untuk mengeksekusi, yang memberikan Anda gambaran kasar
dari performa server. Nilai ini tidak terlalu tepat karena mereka menunjukkan wall
clock time (bukan CPU time), dan karena mereka dipengaruhi oleh banyak faktor
seperti beban server dan kelambatan network.

Perintah/keyword juga dapat dituliskan baik huruf besar maupun huruf kecil. Jadi
query berikut ini hasilnya sama :
mysql> SELECT VERSION(), CURRENT_DATE;
mysql> select version(), current_date;
mysql> SeLeCt vErSiOn(), current_DATE;

Contoh berikut mendemonstrasikan bahwa Anda dapat menggunakan mysql sebagai


kalkulator sederhana :
mysql> SELECT SIN(PI()/4), (4+1)*5;
+-------------+---------+
| SIN(PI()/4) | (4+1)*5 |
+-------------+---------+
|
0.707107 |
25 |
+-------------+---------+

Perintah-perintah yang sudah dicontohkan di atas relatif pendek, hanya pernyataan


satu baris. Anda bahkan dapat memasukkan banyak pernyataan pada sebuah baris.
Cuma tinggal mengakhiri tiap pernyataan dengan tanda titik-koma :
mysql> SELECT VERSION(); SELECT NOW();
+--------------+
| version()
|
+--------------+
| 3.22.20a-log |
+--------------+
+---------------------+
| NOW()
|
+---------------------+
| 1999-03-19 00:15:33 |
+---------------------+

Sebuah perintah tidak harus diberikan pada sebuah baris, jadi perintah yang panjang
yang memerlukan beberapa baris bukan masalah. mysql menentukan apakah
pernyataan Anda berakhir dengan mencari titik-koma, tidak dengan mencari akhir
dari baris input. (Dengan kata lain, mysql menerima input berformat bebas, ia
mengumpulkan baris input tetapi tidak mengeksekusinya hingga menemukan titikkoma.)
Berikut ini contoh pernyataan banyak baris sederhana :
mysql> SELECT
-> USER()
-> ,
-> CURRENT_DATE;
+--------------------+--------------+
| USER()
| CURRENT_DATE |
+--------------------+--------------+
| joesmith@localhost | 1999-03-18
|
+--------------------+--------------+

Pada contoh ini, perhatikan bagaimana prompt berubah dari mysql> menjadi ->
setelah Anda memasukkan baris pertama dari query banyak baris. Inilah cara mysql
mengindikasikan bahwa ia tidak menemukan pernyataan yang lengkap dan ia
menunggu sisanya. Jika Anda memutuskan untuk tidak mengeksekusi perintah yang
sedang dalam proses pemasukannya, batalkanlah dengan mengetikkan \c :
mysql> SELECT
-> USER()
-> \c
mysql>

Tabel berikut ini menunjukkan tiap prompt yang mungkin Anda temukan dan artinya:
Prompt
mysql>
->
'>
">

Arti
Siap untuk perintah baru
Menunggu baris berikut dari perintah banyak baris
Menunggu baris berikut, memasukkan string yang dimulai oleh petik tunggal ( )
Menunggu baris berikut, memasukkan string yang dimulai oleh petik ganda ( )

Pernyataan banyak baris biasanya terjadi tidak sengaja ketika Anda bermaksud
untuk memberi perintah pada satu baris, tetapi lupa untuk mengakhirinya dengan titikkoma. Pada kasus ini, mysql menunggu input berikutnya :
mysql> SELECT USER()
->

Jika ini terjadi, kemungkinan besar mysql sedang menunggu titik-koma. Masukkan
sebuah titik-koma untuk mengakhiri pernyataan, dan mysql akan mengeksekusinya :
mysql> SELECT USER()
-> ;
+--------------------+
| USER()
|
+--------------------+
| erik@localhost
|
+--------------------+

Tanda prompt > dan > terjadi ketika pemasukan string. Pada MySQL, Anda dapat
menulis string yang diawali dan diakhiri oleh karakter atau (halo atau halo),
dan mysql memperbolehkan Anda memasukkan string pada banyak baris. Ketika
Anda melihat prompt atau , berarti Anda sudah memasukkan baris yang berisi
string yang dimulai dengan karakter atau , tetapi Anda belum memasukkan tanda
petik penutup yang sesuai.

Contoh Query Yang Umum


4

Berikut ini diberikan contoh tentang bagaimana memecahkan masalah yang umum
ditemukan pada MySQL.
Beberapa contoh menggunakan tabel shop unuk menyimpan harga dari tiap article
untuk penjual tertentu. Dianggap bahwa tiap penjual memiliki harga tetap untuk tiap
article, lalu (item,trader) adalah kunci primer untuk record-nya.
CREATE TABLE shop (
article INT(4) UNSIGNED ZEROFILL DEFAULT '0000' NOT NULL,
dealer CHAR(20)
DEFAULT ''
NOT NULL,
price
DOUBLE(16,2)
DEFAULT '0.00' NOT NULL,
PRIMARY KEY(article, dealer));
INSERT INTO shop VALUES
(1,'A',3.45),(1,'B',3.99),(2,'A',10.99),(3,'B',1.45),(3,'C',1.69),
(3,'D',1.25),(4,'D',19.95);

Kemudian, contoh datanya adalah :


SELECT * FROM shop
+---------+--------+-------+
| article | dealer | price |
+---------+--------+-------+
|
0001 | A
| 3.45 |
|
0001 | B
| 3.99 |
|
0002 | A
| 10.99 |
|
0003 | B
| 1.45 |
|
0003 | C
| 1.69 |
|
0003 | D
| 1.25 |
|
0004 | D
| 19.95 |
+---------+--------+-------+

Untuk melihat nomer article terbesar, Anda dapat menggunakan :


SELECT MAX(article) AS article FROM shop
+---------+
| article |
+---------+
|
4 |
+---------+

Untuk menemukan baris yang berisi nilai maximum untuk kolom tertentu, pada ANSI
SQL hal ini dapat mudah dilakukan dengan subquery :
SELECT article, dealer, price
FROM
shop
WHERE price=(SELECT MAX(price) FROM shop)

Pada MySQL (yang tidak memiliki subquery), lakukanlah dalam 2 langkah :


1. Ambil nilai harga (price) maximum dari tabel dengan pernyataan SELECT.
2. Menggunakan nilai ini, buatlah query sebenarnya :
5

SELECT article, dealer, price


FROM
shop
WHERE price=19.95

Cara lain adalah dengan mengurutkan semua baris secara descending (dari besar ke
kecil) dan hanya mengambil baris pertama menggunakan kalusa spesifik LIMIT :
SELECT article, dealer, price
FROM
shop
ORDER BY price DESC
LIMIT 1

Catatan: Bila terdapat beberapa baris dengan nilai price maximum yang sama, cuma
ditampilkan salah satu saja, yaitu yang pertama.
Untuk menunjukkan nilai maximum dari kolom per grup cuma nilainya, dapat
menggunakan :
``What's the highest price per article?''
SELECT article, MAX(price) AS price
FROM
shop
GROUP BY article
+---------+-------+
| article | price |
+---------+-------+
|
0001 | 3.99 |
|
0002 | 10.99 |
|
0003 | 1.69 |
|
0004 | 19.95 |
+---------+-------+

Untuk mencari dealer dengan price yang paling mahal untuk tiap article-nya, pada
ANSI SQL, dapat menggunakan :
SELECT article, dealer, price
FROM
shop s1
WHERE price=(SELECT MAX(s2.price)
FROM shop s2
WHERE s1.article = s2.article)

Pada MySQL, cara terbaik untuk melakukannya dengan langkah berikut :


1. Ambil daftar (article,maxprice).
2. Untuk tiap article ambil baris yang bersangkutan yang menyimpan price
maximum.
Hal ini paling mudah dilakukan dengan sebuah tabel temporary :
CREATE TEMPORARY TABLE tmp (
article INT(4) UNSIGNED ZEROFILL DEFAULT '0000' NOT NULL,
price
DOUBLE(16,2)
DEFAULT '0.00' NOT NULL);
LOCK TABLES article read;

INSERT INTO tmp SELECT article, MAX(price) FROM shop GROUP BY


article;
SELECT article, dealer, price FROM shop, tmp
WHERE shop.article=tmp.article AND shop.price=tmp.price;
UNLOCK TABLES;
DROP TABLE tmp;

Jika Anda tidak menggunakan tabel TEMPORARY, Anda juga harus mengunci
(LOCK) tabel tmp. Masalah ini juga dapat dilakukan dengan query tunggal, tetapi
dengan menggunakan trik yang tidak efisien :
SELECT article,
SUBSTRING( MAX( CONCAT(LPAD(price,6,'0'),dealer) ), 7) AS
dealer,
0.00+LEFT(
MAX( CONCAT(LPAD(price,6,'0'),dealer) ), 6) AS
price
FROM
shop
GROUP BY article;
+---------+--------+-------+
| article | dealer | price |
+---------+--------+-------+
|
0001 | B
| 3.99 |
|
0002 | A
| 10.99 |
|
0003 | C
| 1.69 |
|
0004 | D
| 19.95 |
+---------+--------+-------+

Pada MySQL Anda tidak memerlukan foreign key untuk menggabungkan (join) dua
tabel. Satu hal yang tidak dilakukan MySQL adalah mengecek untuk memastikan
bahwa key yang digunakan benar-benar ada pada tabel yang Anda referensi dan tidak
secara otomatis menghapus baris dari tabel yang berisi definisi foreign key.
CREATE TABLE persons (
id SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT,
name CHAR(60) NOT NULL,
PRIMARY KEY (id)
);
CREATE TABLE shirts (
id SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT,
style ENUM('t-shirt', 'polo', 'dress') NOT NULL,
color ENUM('red', 'blue', 'orange', 'white', 'black') NOT NULL,
owner SMALLINT UNSIGNED NOT NULL REFERENCES persons,
PRIMARY KEY (id)
);
INSERT INTO persons VALUES (NULL, 'Antonio Paz');
INSERT
(NULL,
(NULL,
(NULL,

INTO shirts VALUES


'polo', 'blue', LAST_INSERT_ID()),
'dress', 'white', LAST_INSERT_ID()),
't-shirt', 'blue', LAST_INSERT_ID());

INSERT INTO persons VALUES (NULL, 'Lilliana Angelovska');


INSERT
(NULL,
(NULL,
(NULL,
(NULL,

INTO shirts VALUES


'dress', 'orange', LAST_INSERT_ID()),
'polo', 'red', LAST_INSERT_ID()),
'dress', 'blue', LAST_INSERT_ID()),
't-shirt', 'white', LAST_INSERT_ID());

SELECT * FROM persons;


+----+---------------------+
| id | name
|
+----+---------------------+
| 1 | Antonio Paz
|
| 2 | Lilliana Angelovska |
+----+---------------------+
SELECT * FROM shirts;
+----+---------+--------+-------+
| id | style
| color | owner |
+----+---------+--------+-------+
| 1 | polo
| blue
|
1 |
| 2 | dress
| white |
1 |
| 3 | t-shirt | blue
|
1 |
| 4 | dress
| orange |
2 |
| 5 | polo
| red
|
2 |
| 6 | dress
| blue
|
2 |
| 7 | t-shirt | white |
2 |
+----+---------+--------+-------+
SELECT
WHERE
AND
AND

s.* FROM persons p, shirts s


p.name LIKE 'Lilliana%'
s.owner = p.id
s.color <> 'white';

+----+-------+--------+-------+
| id | style | color | owner |
+----+-------+--------+-------+
| 4 | dress | orange |
2 |
| 5 | polo | red
|
2 |
| 6 | dress | blue
|
2 |
+----+-------+--------+-------+

Pada pencarian dua key, MySQL belum mengoptimasikan pencarian Anda pada
kombinasi dua key yang berbeda dengan OR :
SELECT field1_index, field2_index FROM test_table WHERE field1_index
= '1' OR field2_index = '1'

Untuk saat ini Anda dapat memecahkan masalah ini dengan sangat efisien dengan
menggunakan tabel TEMPORARY, optimasi tipe ini juga sangat bagus jika Anda
menggunakan query yang sangat kompleks dimana server SQL melakukan optimasi
dengan cara yang salah.
CREATE TEMPORARY TABLE tmp
SELECT field1_index, field2_index FROM test_table WHERE field1_index
= '1';

INSERT INTO tmp


SELECT field1_index, field2_index FROM test_table WHERE field2_index
= '1';
SELECT * from tmp;
DROP TABLE tmp;

Membuat Dan Menggunakan Database


Sekarang setelah Anda mengetahui cara memasukkan perintah, inilah waktunya untuk
mengakses database.
Anggaplah bahwa Anda memiliki beberapa hewan peliharaan di rumah dan Anda
ingin menyimpan beberapa informasi mengenai mereka. Anda dapat melakukannya
dengan membuat tabel untuk menyimpan data Anda dan mengisinya dengan
informasi yang Anda inginkan. Kemudian Anda dapat menjawab banyak pertanyaan
tentang hewan Anda dengan mengambil data dari tabel tadi.
Gunakan pernyataan SHOW untuk menemukan database apa saja yang ada di server:
mysql> SHOW DATABASES;
+----------+
| Database |
+----------+
| mysql
|
| test
|
| tmp
|
+----------+

Daftar database ini mungkin berbeda untuk komputer Anda, tetapi database mysql dan
test kelihatannya selalu ada. Database mysql diperlukan karena ia menunjukkan hak
akses (privileges) untuk tiap user. Database test sering menyediakan tempat bagi user
untuk mencoba-coba.
Jika database test ada, cobalah untuk mengaksesnya:
mysql> USE test
Database changed

Ingat bahwa USE, seperti QUIT, tidak memerlukan titik-koma. (Anda dapat
mengakhiri pernyataan seperti ini dengan titik-koma jika ingin.) Pernyataan USE ini
juga spesial, yaitu harus diberikan pada baris tunggal.
Anda dapat menggunakan database test (jika Anda memiliki akses untuknya) untuk
contoh-contoh berikut, tetapi segala yang Anda buat pada database ini dapat dihapus
oleh orang lain yang juga dapat mengaksesnya. Karena itu, Anda mungkin dapat
meminta administrator MySQL Anda untuk ijin membuat database Anda sendiri.
Misalkan Anda ingin membuat database hewan. Administrator harus mengeksekusi
perintah seperti berikut :
mysql> GRANT ALL ON hewan.* TO your_mysql_name;
9

dimana your_mysqL_name adalah username MySQL Anda.


Jika administrator membuat database Anda ketika menset hak akses Anda, Anda
dapat mulai menggunakannya, tetapi bila tidak Anda harus membuatnya sendiri :
mysql> CREATE DATABASE hewan;

Pada UNIX, nama database-nya case sensitive (tidak seperti keyword SQL), jadi
Anda harus selalu menulis nama database Anda hewan, bukan Hewan, HEWAN, atau
variasi yang lain. Hal ini juga berlaku untuk nama tabel (Pada Windows, hal ini tidak
berlaku).
Membuat sebuah database tidak langsung dipilih untuk digunakan, Anda harus
melakukannya secara explisit. Untuk menggunakan database hewan, gunakan :
mysql> USE hewan
Database changed

Database Anda cuma perlu dibuat satu kali, tetapi Anda harus memilihnya untuk
digunakan tiap kali Anda memulai session mysql. Anda dapat melakukannya dengan
memasukkan perintah USE seperti di atas. Cara lainnya, Anda dapat memilih
database pada baris perintah ketika Anda menjalankan mysql. Hanya tinggal
menuliskan nama database ini setelah parameter koneksi yang Anda butuhkan.
Contohnya:
shell> mysql -h host -u user -p hewan
Enter password: ********

Ingat bahwa hewan bukan password Anda pada perintah di atas. Jika Anda ingin
memasukkan password Anda pada baris perintah setelah option p, Anda harus
melakukannya dengan tidak memberi spasi setelah p (-pmypassword, bukan p
mypassword). Namun, memasukkan password Anda pada baris perintah tidak
disarankan, karena password Anda akan dapat dilihat oleh user lain yang sedang login
ke komputer Anda.
Membuat database adalah bagian yang mudah, tetapi saat ini database tadi masih
kosong, sebagaimana pernyataan SHOW TABLE akan menunjukkannya :
mysql> SHOW TABLES;
Empty set (0.00 sec)

Bagian yang lebih sulit adalah memutuskan struktur dari database Anda yang
sebaiknya digunakan: tabel apa yang Anda butuhkan, dan kolom apa yang akan ada
pada tiap tabelnya.
Anda menginginkan sebuah tabel yang berisi record untuk tiap hewan peliharaan
Anda. Ini dapat dinamakan tabel pet, dan yang isi seharusnya, minimal adalah nama
10

tiap hewan. Karena nama saja tidak terlalu menarik, tabel ini seharusnya berisi
informasi lain. Sebagai contoh, jika lebih dari satu orang dalam keluarga Anda
menyimpan piaraan, Anda mungkin ingin membuat daftar pemilik tiap hewan. Anda
mungkin juga ingin informasi deskripsi untuk tiap spesies dan jenis kelamin.
Bagaimana tentang umur? Hal ini mungkin menarik, tetapi bukan ide yang bagus
untuk menyimpannya dalam database. Umur berubah seiring perubahan waktu, yang
berarti Anda harus sering mengupdatenya. Cara lain, adalah dengan menyimpan nilai
yang pasti, seperti tanggal lahir. Lalu, ketika dibutuhkan usia, Anda dapat
menghitungnya sebagai selisih antara tanggal sekarang dengan tanggal lahirnya.
MySQL menyediakan fungsi untuk melakukan aritmatika tanggal, jadi hal ini tidak
sulit. Menyimpan tanggal lahir dan bukannya umur juga memiliki keuntungan lain :

Anda dapat menggunakan database untuk tugas seperti membangkitkan pengingat


untuk ulang tahun hewan berikutnya.

Anda dapat menghitung umur yang berhubungan dengan tanggal dan bukannya
tanggal saat ini. Contohnya, jika Anda menyimpan tanggal kematian dalam
database, Anda dapat dengan mudah menghitung umur hewan saat kematiannya.

Tampaknya informasi untuk tabelnya sudah cukup, sekarang kita coba untuk
membuat tabelnya dengan menggunakan CREATE TABLE :
mysql> CREATE TABLE pet (name VARCHAR(20), owner VARCHAR(20),
-> species VARCHAR(20), sex CHAR(1), birth DATE, death DATE);

VARCHAR adalah pilihan yang bagus untuk kolom name, owner dan species karena
nilai kolom ini akan bervariasi panjangnya. Panjang dari tiap kolom tidak perlu sama,
dan tidak harus 20. Anda dapat memilih dari 1 sampai 255 yang tampaknya sesuai
bagi Anda (jika pilihan Anda salah dan ternyata kemudian dibutuhkan kolom yang
lebih panjang, MySQL menyediakan pernyataan ALTER TABLE).
Jenis kelamin hewan dapat ditunjukkan dengan bermacam cara, bisa m dan f, atau
mungkin male dan female. Cara termudahnya adalah menggunakan karakter
tunggal m dan f.
Penggunaan tipe data DATE untuk kolom birth dan death adalah pilihan yang bagus.
Sekarang Anda sudah membuat tabel, SHOW TABLES seharusnya menghasilkan
output :
mysql> SHOW TABLES;
+---------------------+
| Tables in hewan
|
+---------------------+
| pet
|
11

+---------------------+

Untuk memastikan bahwa tabel yang dibuat sesuai keinginan Anda, gunakan
pernyataan DESCRIBE atau DESC :
mysql> DESCRIBE pet;
+---------+-------------+------+-----+---------+-------+
| Field
| Type
| Null | Key | Default | Extra |
+---------+-------------+------+-----+---------+-------+
| name
| varchar(20) | YES |
| NULL
|
|
| owner
| varchar(20) | YES |
| NULL
|
|
| species | varchar(20) | YES |
| NULL
|
|
| sex
| char(1)
| YES |
| NULL
|
|
| birth
| date
| YES |
| NULL
|
|
| death
| date
| YES |
| NULL
|
|
+---------+-------------+------+-----+---------+-------+

Setelah membuat tabel, Anda butuh untuk memasukkan datanya. Pernyataan LOAD
DATA dan INSERT dapat digunakan untuk hal ini.
Anggaplah bahwa record hewan Anda dapat ditunjukkan sebagai berikut (perhatikan
bahwa MySQL mengharuskan tanggal dalam format YYYY-MM-DD).
name
Fluffy
Claws
Buffy
Fang
Bowser
Chirpy
Whistler
Slim

owner
Harold
Gwen
Harold
Benny
Diane
Gwen
Gwen
Benny

species
cat
cat
dog
dog
dog
bird
bird
snake

sex
f
m
f
m
m
f
m

birth
1993-02-04
1994-03-17
1989-05-13
1990-08-27
1998-08-31
1998-09-11
1997-12-09
1996-04-29

Death

1995-07-29

Karena Anda memulai dengan tabel kosong, cara terbaik untuk mengisinya adalah
dengan membuat file teks yang berisi sebuah baris untuk tiap hewan Anda, lalu
memasukkan isi file ini ke tabel dengan pernyataan tunggal.
Anda dapat membuat file teks pet.txt yang berisi satu record per baris, dengan nilai
yang dipisahkan dengan tab, dan kolomnya urut sesuai dengan daftar pada pernyataan
CREATE TABLE. Untuk nilai yang tidak ada dapat Anda isi dengan nilai NULL
(dengan menulis \N).
Untuk memasukkan file teks ini ke tabel pet, gunakan perintah ini :
mysql> LOAD DATA LOCAL INFILE "pet.txt" INTO TABLE pet;

Anda dapat menspesifikasi nilai pemisah kolom dan tanda akhir baris secara eksplisit
pada pernyataan LOAD DATA yang Anda inginkan, tetapi nilai defaultnya adalah tab
dan linefeed.

12

Jika Anda ingin menambahkan record baru suatu saat, pernyataan INSERT sangat
berguna. Pada bentuk yang paling sederhana, Anda menuliskan nilai untuk tiap
kolomnya, menurut urutan yang sama dengan waktu pembuatan tabel. Misalnya
Diane mendapatkan hamster baru bernama Puffball, Anda dapat menambahkan record
baru menggunakan pernyataan INSERT seperti berikut:
mysql> INSERT INTO pet
-> VALUES ('Puffball','Diane','hamster','f','1999-03-30',NULL);

Perhatikan bahwa nilai string dan tanggal ditulis dalam tanda petik. Juga dengan
INSERT, Anda dapat memasukkan NULL langsung untuk menggantikan nilai yang
tidak ada. Anda tidak menggunakan \N seperti dengan LOAD DATA.
Untuk mengambil informasi dari tabel, Anda dapat menggunakan pernyataan
SELECT. Bentuk umum dari pernyataan ini adalah:
SELECT what_to_select
FROM which_table
WHERE conditions_to_satisfy

What_to_select menunjukkan apa yang ingin Anda lihat. Ini dapat merupakan daftar
kolom, atau * untuk menunjukkan semua kolom. which_table menunjukkan tabel
yang mana yang ingin Anda ambil datanya. Klausa WHERE optional. Jika ada, maka
conditions_to_satisfy menunjukkan kondisi yang harus dipenuhi oleh baris agar ikut
ditampilkan.
Bentuk paling sederhana dari SELECT mengambil segalanya dari sebuah tabel :
mysql> SELECT * FROM pet;
+----------+--------+---------+------+------------+------------+
| name
| owner | species | sex | birth
| death
|
+----------+--------+---------+------+------------+------------+
| Fluffy
| Harold | cat
| f
| 1993-02-04 | NULL
|
| Claws
| Gwen
| cat
| m
| 1994-03-17 | NULL
|
| Buffy
| Harold | dog
| f
| 1989-05-13 | NULL
|
| Fang
| Benny | dog
| m
| 1990-08-27 | NULL
|
| Bowser
| Diane | dog
| m
| 1998-08-31 | 1995-07-29 |
| Chirpy
| Gwen
| bird
| f
| 1998-09-11 | NULL
|
| Whistler | Gwen
| bird
| NULL | 1997-12-09 | NULL
|
| Slim
| Benny | snake
| m
| 1996-04-29 | NULL
|
| Puffball | Diane | hamster | f
| 1999-03-30 | NULL
|
+----------+--------+---------+------+------------+------------+

Bentuk SELECT ini berguna jika Anda ingin melihat keseluruhan tabel. Misalnya,
setelah Anda selesai memasukkan himpunan data awal Anda. Tampak bahwa terdapat
kesalahan pada tabel di atas: Bowser lahir sesudah dia mati. Padahal data sebenarnya
untuk lahirnya adalah tahun 1989, bukan 1998.
Minimal ada dua cara untuk memperbaikinya :

13

Edit file pet.txt untuk memperbaiki kesalahan ini, lalu kosongkan tabel dan isi
ulang menggunakan DELETE dan LOAD DATA.
mysql> DELETE FROM pet;
mysql> LOAD DATA LOCAL INFILE "pet.txt" INTO TABLE pet;

Namun jika Anda melakukan ini, Anda juga harus memasukkan ulang record
untuk Puffball.

Perbaiki hanya record yang salah menggunakan pernyataan UPDATE:


mysql> UPDATE pet SET birth = "1989-08-31" WHERE name =
"Bowser";

Mudah untuk mengambil keseluruhan tabel, tetapi Anda sering tidak ingin
melakukannya, biasanya karena tabel menjadi sangat besar.
Anda dapat memilih hanya baris-baris tertentu saja dari tabel Anda. Contohnya, jika
Anda ingin memastikan perubahan yang dilakukan pada tanggal lahir Bowser, pilih
record Bowser seperti ini:
mysql> SELECT * FROM pet WHERE name = "Bowser";
+--------+-------+---------+------+------------+------------+
| name
| owner | species | sex | birth
| death
|
+--------+-------+---------+------+------------+------------+
| Bowser | Diane | dog
| m
| 1989-08-31 | 1995-07-29 |
+--------+-------+---------+------+------------+------------+

Outputnya menunjukkan bahwa tahun yang tersimpan sekarang sudah benar.


Pembandingan string normalnya case insensitive, Anda dapat menulis name
bowser, BOWSER, dll. Hasilnya akan sama.
Anda dapat menuliskan kondisi untuk sembarang kolom, bukan hanya name.
Contohnya, jika Anda ingin tahu hewan mana yang lahir setelah 1998, teslah kolom
birth:
mysql> SELECT * FROM pet WHERE birth >= "1998-1-1";
+----------+-------+---------+------+------------+-------+
| name
| owner | species | sex | birth
| death |
+----------+-------+---------+------+------------+-------+
| Chirpy
| Gwen | bird
| f
| 1998-09-11 | NULL |
| Puffball | Diane | hamster | f
| 1999-03-30 | NULL |
+----------+-------+---------+------+------------+-------+

Anda dapat menggabungkan kondisi, contohnya untuk melihat anjing betina:


mysql> SELECT * FROM pet WHERE species = "dog" AND sex = "f";
+-------+--------+---------+------+------------+-------+
| name | owner | species | sex | birth
| death |
+-------+--------+---------+------+------------+-------+
| Buffy | Harold | dog
| f
| 1989-05-13 | NULL |
+-------+--------+---------+------+------------+-------+

Query di atas menggunakan operator logika AND. Ada juga operator OR:
14

mysql> SELECT * FROM pet WHERE species = "snake" OR species = "bird";


+----------+-------+---------+------+------------+-------+
| name
| owner | species | sex | birth
| death |
+----------+-------+---------+------+------------+-------+
| Chirpy
| Gwen | bird
| f
| 1998-09-11 | NULL |
| Whistler | Gwen | bird
| NULL | 1997-12-09 | NULL |
| Slim
| Benny | snake
| m
| 1996-04-29 | NULL |
+----------+-------+---------+------+------------+-------+

AND dan OR dapat digabungkan. Jika Anda melakukannya, sebaiknya gunakan


kurung untuk menunjukkan kondisi yang harus disatukan:
mysql> SELECT * FROM pet WHERE (species = "cat" AND sex = "m")
-> OR (species = "dog" AND sex = "f");
+-------+--------+---------+------+------------+-------+
| name | owner | species | sex | birth
| death |
+-------+--------+---------+------+------------+-------+
| Claws | Gwen
| cat
| m
| 1994-03-17 | NULL |
| Buffy | Harold | dog
| f
| 1989-05-13 | NULL |
+-------+--------+---------+------+------------+-------+

Jika Anda tidak ingin melihat keseluruhan baris dari tabel Anda, Anda tinggal
menulis nama kolom yang Anda inginkan dengan dipisahkan oleh koma. Contohnya,
jika Anda ingin tahu kapan hewan Anda dilahirkan, pilihlah kolom name dan birth:
mysql> SELECT name, birth FROM pet;
+----------+------------+
| name
| birth
|
+----------+------------+
| Fluffy
| 1993-02-04 |
| Claws
| 1994-03-17 |
| Buffy
| 1989-05-13 |
| Fang
| 1990-08-27 |
| Bowser
| 1989-08-31 |
| Chirpy
| 1998-09-11 |
| Whistler | 1997-12-09 |
| Slim
| 1996-04-29 |
| Puffball | 1999-03-30 |
+----------+------------+

Untuk mencari siapa yang memiliki hewan piaraan, gunakan query ini:
mysql> SELECT owner FROM pet;
+--------+
| owner |
+--------+
| Harold |
| Gwen
|
| Harold |
| Benny |
| Diane |
| Gwen
|
| Gwen
|
| Benny |
| Diane |
+--------+

15

Namun, perhatikan bahwa query ini mengambil kolom owner dari tiap record, dan ada
beberapa yang tampil lebih dari sekali. Untuk meminimalkan outputnya, ambil record
output unik hanya sekali dengan menambahkan keyword DISTINCT:
mysql> SELECT DISTINCT owner FROM pet;
+--------+
| owner |
+--------+
| Benny |
| Diane |
| Gwen
|
| Harold |
+--------+

Anda dapat menggunakan klausa WHERE untuk menggabungkan pilihan baris


dengan pilihan kolom. Contohnya, untuk mengambil hanya tanggal lahir anjing dan
kucing, gunakan query ini:
mysql> SELECT name, species, birth FROM pet
-> WHERE species = "dog" OR species = "cat";
+--------+---------+------------+
| name
| species | birth
|
+--------+---------+------------+
| Fluffy | cat
| 1993-02-04 |
| Claws | cat
| 1994-03-17 |
| Buffy | dog
| 1989-05-13 |
| Fang
| dog
| 1990-08-27 |
| Bowser | dog
| 1989-08-31 |
+--------+---------+------------+

Anda mungkin memperhatikan bahwa contoh-contoh di atas menghasilkan baris yang


tidak sesuai dengan urutan tertentu. Tapi, kadang-kadang, lebih mudah untuk
memeriksa output query yang barisnya tersusun teratur menurut sesuatu. Untuk
mengurutkan hasilnya, gunakan klausa ORDER BY.
Berikut ini tanggal lahir hewan, diurutkan berdasarkan tanggal:
mysql> SELECT name, birth FROM pet ORDER BY birth;
+----------+------------+
| name
| birth
|
+----------+------------+
| Buffy
| 1989-05-13 |
| Bowser
| 1989-08-31 |
| Fang
| 1990-08-27 |
| Fluffy
| 1993-02-04 |
| Claws
| 1994-03-17 |
| Slim
| 1996-04-29 |
| Whistler | 1997-12-09 |
| Chirpy
| 1998-09-11 |
| Puffball | 1999-03-30 |
+----------+------------+

Untuk mengurutkannya secara terbalik, tambahkan keyword DESC (descending)


setelah nama kolom yang digunakan untuk mengurutkan:
16

mysql> SELECT name, birth FROM pet ORDER BY birth DESC;


+----------+------------+
| name
| birth
|
+----------+------------+
| Puffball | 1999-03-30 |
| Chirpy
| 1998-09-11 |
| Whistler | 1997-12-09 |
| Slim
| 1996-04-29 |
| Claws
| 1994-03-17 |
| Fluffy
| 1993-02-04 |
| Fang
| 1990-08-27 |
| Bowser
| 1989-08-31 |
| Buffy
| 1989-05-13 |
+----------+------------+

Anda dapat mengurutkan banyak kolom. contohnya, untuk mengurutkan berdasarkan


jenis hewan, lalu berdasarkan tanggal lahir yang muda lebih dulu, gunakan query
berikut:
mysql> SELECT name, species, birth FROM pet ORDER BY species, birth
DESC;
+----------+---------+------------+
| name
| species | birth
|
+----------+---------+------------+
| Chirpy
| bird
| 1998-09-11 |
| Whistler | bird
| 1997-12-09 |
| Claws
| cat
| 1994-03-17 |
| Fluffy
| cat
| 1993-02-04 |
| Fang
| dog
| 1990-08-27 |
| Bowser
| dog
| 1989-08-31 |
| Buffy
| dog
| 1989-05-13 |
| Puffball | hamster | 1999-03-30 |
| Slim
| snake
| 1996-04-29 |
+----------+---------+------------+

Perhatikan bahwa keyword DESC cuma berlaku untuk nama kolom yang mendahului
kata DESC.
MySQL menyediakan beberapa fungsi yang dapat Anda gunakan untuk melakukan
perhitungan berdasarkan tanggal, sebagai contoh, untuk menghitung umur atau seatu
jangka waktu.
Untuk menentukan umur tiap hewan piaraan Anda, hitung umur sebagai selisih antara
tanggal lahir dan tanggal saat ini. Lakukan ini dengan mengubah kedua tanggal
menjadi hari, hitung selisihnya, dan bagi dengan 365 (jumlah hari dalam satu tahun).
mysql> SELECT name, (TO_DAYS(NOW())-TO_DAYS(birth))/365 FROM pet;
+----------+-------------------------------------+
| name
| (TO_DAYS(NOW())-TO_DAYS(birth))/365 |
+----------+-------------------------------------+
| Fluffy
|
6.15 |
| Claws
|
5.04 |
| Buffy
|
9.88 |
| Fang
|
8.59 |
| Bowser
|
9.58 |
| Chirpy
|
0.55 |
17

| Whistler |
1.30 |
| Slim
|
2.92 |
| Puffball |
0.00 |
+----------+-------------------------------------+

Meskipun query ini bekerja, ada beberapa hal yang harus ditingkatkan. Pertama,
hasilnya dapat dilihat lebih mudah jika baris-barisnya diurutkan. Kedua, heading
untuk kolom age tidak terlalu berarti.
Masalah pertama dapat diatasi dengan menambahkan klausa ORDER BY untuk
mengurutkan berdasarkan name. Untuk mengatasi heading kolom, sediakan nama
untuk kolom ini sehingga label yang berbeda tampil pada outputnya (hal ini
dinamakan alias kolom):
mysql> SELECT name, (TO_DAYS(NOW())-TO_DAYS(birth))/365 AS age
-> FROM pet ORDER BY name;
+----------+------+
| name
| age |
+----------+------+
| Bowser
| 9.58 |
| Buffy
| 9.88 |
| Chirpy
| 0.55 |
| Claws
| 5.04 |
| Fang
| 8.59 |
| Fluffy
| 6.15 |
| Puffball | 0.00 |
| Slim
| 2.92 |
| Whistler | 1.30 |
+----------+------+

Untuk mengurutkan output berdasarkan umur, cuma tinggal menggunakan klausa


ORDER BY yang berbeda:
mysql> SELECT name, (TO_DAYS(NOW())-TO_DAYS(birth))/365 AS age
-> FROM pet ORDER BY age;
+----------+------+
| name
| age |
+----------+------+
| Puffball | 0.00 |
| Chirpy
| 0.55 |
| Whistler | 1.30 |
| Slim
| 2.92 |
| Claws
| 5.04 |
| Fluffy
| 6.15 |
| Fang
| 8.59 |
| Bowser
| 9.58 |
| Buffy
| 9.88 |
+----------+------+

Query yang mirip dapat digunakan untuk menentukan umur saat kematian hewan
yang sudah mati. Anda menentukan hewan yang mana dengan mengecek apakah nilai
death-nya NULL. Lalu, untuk yang nilainya tidak NULL, hitung selisih antara nilai
death dan birth:

18

mysql> SELECT name, birth, death, (TO_DAYS(death)TO_DAYS(birth))/365 AS age


-> FROM pet WHERE death IS NOT NULL ORDER BY age;
+--------+------------+------------+------+
| name
| birth
| death
| age |
+--------+------------+------------+------+
| Bowser | 1989-08-31 | 1995-07-29 | 5.91 |
+--------+------------+------------+------+

Query ini menggunakan death IS NOT NULL dan bukannya death != NULL karena
NULL adalah nilai khusus.
Bagaimana jika Anda ingin tahu hewan mana yang berulang tahun bulan depan?
Untuk perhitungan semacam ini, tahun dan tanggal tidak sesuai, Anda cuma ingin
mengambil bagian bulan dari kolom birth.. MySQL menyediakan beberapa fungsi
untuk

mengambil

bagian

dari

tanggal,

seperti

YEAR(),

MONTH()

dan

DAYOFMONTH().
MONTH adalah fungsi yang tepat untuk hal ini. Untuk melihat cara kerjanya,
jalankan query sederhana yang menampilkan nila untuk birth dan MONTH(birth):
mysql> SELECT name, birth, MONTH(birth) FROM pet;
+----------+------------+--------------+
| name
| birth
| MONTH(birth) |
+----------+------------+--------------+
| Fluffy
| 1993-02-04 |
2 |
| Claws
| 1994-03-17 |
3 |
| Buffy
| 1989-05-13 |
5 |
| Fang
| 1990-08-27 |
8 |
| Bowser
| 1989-08-31 |
8 |
| Chirpy
| 1998-09-11 |
9 |
| Whistler | 1997-12-09 |
12 |
| Slim
| 1996-04-29 |
4 |
| Puffball | 1999-03-30 |
3 |
+----------+------------+--------------+

Menemukan hewan yang berulang tahun bulan depan itu mudah juga. Anggaplah
bulan sekarang adalah April. Maka nilai month-nya 4 dan Anda cari hewan yang lahir
di bulan Mei (month=5) seperti ini:
mysql> SELECT name, birth FROM pet WHERE MONTH(birth) = 5;
+-------+------------+
| name | birth
|
+-------+------------+
| Buffy | 1989-05-13 |
+-------+------------+

Tetapi ada masalah jika bulan sekarang adalah Desember. Anda tidak bisa langsung
menambahkan satu ke nilai bulan (12) dan mencari hewan yang lahir di bulan 13,
karena tidak ada bulan 13. Namun, Anda mencari hewan yang lahir di bulan Januari
(month 1).

19

Anda bahkan dapat menulis query yang dapat bekerja dengan benar, tidak peduli
bulan apa sekarang ini. Dengan cara ini Anda tidak harus menggunakan nilai bulan
sekarang dalam query. DATE_ADD() membolehkan Anda untuk menambahkan
interval waktu untuk tanggal tertentu. Jika Anda menambahkan satu bulan ke nilai
dari NOW(), maka bagian month untuk MONTH() akan menghasilkan bulan yang
digunakan untuk mencari ulang tahun:
mysql> SELECT name, birth FROM pet
-> WHERE MONTH(birth) = MONTH(DATE_ADD(NOW(), INTERVAL 1 MONTH));

Cara lain untuk melakukannya adalah menambahkan 1 untuk mendapatkan bulan


selanjutnya setelah bulan ini :
mysql> SELECT name, birth FROM pet
-> WHERE MONTH(birth) = MOD(MONTH(NOW()), 12) + 1;

Ingat bahwa MONTH mengembalikan nilai antara 1 dan 12. Dan MOD(sesuatu,12)
mengembalikan nilai antara 0 dan 11. Jadi penambahan harus dilakukan setelah
MOD().

Nilai NULL
Secara konsep, NULL berarti nilai yang hilang atau nilai yang tidak diketahui dan
diperlakukan lain daripada nilai yang lain. Untuk mengetes nilai NULL, Anda tidak
dapat menggunakan operator perbandingan aritmatik seperti =, < atau !=. Untuk
mendemonstrasikannya sendiri, cobalah query berikut:
mysql> SELECT 1 = NULL, 1 != NULL, 1 < NULL, 1 > NULL;
+----------+-----------+----------+----------+
| 1 = NULL | 1 != NULL | 1 < NULL | 1 > NULL |
+----------+-----------+----------+----------+
|
NULL |
NULL |
NULL |
NULL |
+----------+-----------+----------+----------+

Anda mendapat hasil yang berarti dari perbandingan di atas. Gunakan operator IS
NULL dan IS NOT NULL sebagai gantinya:
mysql> SELECT 1 IS NULL, 1 IS NOT NULL;
+-----------+---------------+
| 1 IS NULL | 1 IS NOT NULL |
+-----------+---------------+
|
0 |
1 |
+-----------+---------------+

pada MySQL, 0 berarti false dan 1 berarti true.


Perlakuan yang khusus untuk NULL inilah sebabnya, pada bagian di atas, Anda harus
menggunakan death IS NOT NULL dan bukannya death != NULL.

20

Pengenalan Pola (Pattern Matching)


MySQL menyediakan pengenalan pola standar SQL juga pengenalan pola
berdasarkan ekspresi regular yang mirip dengan yang digunakan pada utiliti UNIX
seperti vi, grep dan sed.
Pengenalan pola memperbolehkan Anda untuk menggunakan _ untuk menggantikan
satu karakter, dan % untuk menggantikan sembarang jumlah karakter (termasuk nol
karakter). Pada MySQL, pola SQL defaultnya adalah case insensitive. Beberapa
contoh ditunjukkan di bawah. Perhatikan bahwa Anda tidak menggunakan = atau !=
ketika menggunakan pola SQL; gunakan perbandingan LIKE atau NOT LIKE sebagai
gantinya.
Untuk menemukan nama yang dimulai dengan b:
mysql> SELECT * FROM pet WHERE name LIKE "b%";
+--------+--------+---------+------+------------+------------+
| name
| owner | species | sex | birth
| death
|
+--------+--------+---------+------+------------+------------+
| Buffy | Harold | dog
| f
| 1989-05-13 | NULL
|
| Bowser | Diane | dog
| m
| 1989-08-31 | 1995-07-29 |
+--------+--------+---------+------+------------+------------+

Untuk menemukan nama yang diakhiri denga fy:


mysql> SELECT * FROM pet WHERE name LIKE "%fy";
+--------+--------+---------+------+------------+-------+
| name
| owner | species | sex | birth
| death |
+--------+--------+---------+------+------------+-------+
| Fluffy | Harold | cat
| f
| 1993-02-04 | NULL |
| Buffy | Harold | dog
| f
| 1989-05-13 | NULL |
+--------+--------+---------+------+------------+-------+

Untuk menemukan nama yang mengandung sebuah w:


mysql> SELECT * FROM pet WHERE name LIKE "%w%";
+----------+-------+---------+------+------------+------------+
| name
| owner | species | sex | birth
| death
|
+----------+-------+---------+------+------------+------------+
| Claws
| Gwen | cat
| m
| 1994-03-17 | NULL
|
| Bowser
| Diane | dog
| m
| 1989-08-31 | 1995-07-29 |
| Whistler | Gwen | bird
| NULL | 1997-12-09 | NULL
|
+----------+-------+---------+------+------------+------------+

Untuk menemukan nama yang berisi tepat lima karakter, gunakan karakter pola _ :
mysql> SELECT * FROM pet WHERE name LIKE "_____";
+-------+--------+---------+------+------------+-------+
| name | owner | species | sex | birth
| death |
+-------+--------+---------+------+------------+-------+
| Claws | Gwen
| cat
| m
| 1994-03-17 | NULL |
| Buffy | Harold | dog
| f
| 1989-05-13 | NULL |
+-------+--------+---------+------+------------+-------+

21

Jenis pengenalan pola lain yang disediakan oleh MySQL menggunakan ekspresi
regular (extended regular expressions). Jika Anda ingin mengetes untuk jenis pola
seperti ini, gunakan operator REGEXP dan NOT REGEXP (atau RLIKE dan NOT
RLIKE, yang sinonim).
Beberapa karakteristik dari ekspresi regular:

. menggantikan satu karakter.

Sebuah kelas karakter [] menggantikan sembarang karakter yang termasuk di


dalam tanda kurung siku. Contohnya, [abc] menggantikan a, b, atau c.
untuk menyebutkan jangkauan karakter, gunakan tanda -. [a-z] menggantikan
sembarang huruf kecil, dan [0-9] menggantikan sembarang digit.

* menggantikan nol atau lebih karakter yang didepannya. Contohnya, x*


menggantikan sembarang panjang dari karakter x, [0-9]* menggantikan
sembarang jumlah digit, dan .* menggantikan sembarang jumlah dari
sembarang.

Ekspresi regular ini case sensitive, tetapi Anda dapat menggunakan kelas karakter
untuk menggantikan kedua jenis huruf. Contohnya, [aA] menggantikan huruf
kecil dan huruf besar dari a dan [a-zA-Z] menggantikan sembarang huruf baik
huruf besar maupun kecil.

Pola ini cocok jika ditemukan dimanapun di dalam nilai yang sedang dites (pola
SQL cuma cocok jika sesuai untuk keseluruhan nilai).

Untuk memastikan bahwa pola harus sesuai untuk awal atau akhir nilai yang dites,
gunakan ^ pada awal atau $ pada akhir pola.

Untuk mendemokan cara kerja ekspresi regular, query LIKE yang ditunjukkan di atas
ditulis ulang menggunakan REGEXP:
Untuk menemukan nama

yang dimulai dengan b, gunakan

^ untuk

mencocokkannya dengan awal nama dan [bB] untuk mencocokkannya baik untuk
huruf b besar maupun kecil:
mysql> SELECT * FROM pet WHERE name REGEXP "^[bB]";
+--------+--------+---------+------+------------+------------+
| name
| owner | species | sex | birth
| death
|
+--------+--------+---------+------+------------+------------+
| Buffy | Harold | dog
| f
| 1989-05-13 | NULL
|
| Bowser | Diane | dog
| m
| 1989-08-31 | 1995-07-29 |
+--------+--------+---------+------+------------+------------+

Untuk menemukan nama yang diakhiri dengan fy, gunakan $ untuk


mencocokkannya dengan akhir dari nama:
22

mysql> SELECT * FROM pet WHERE name REGEXP "fy$";


+--------+--------+---------+------+------------+-------+
| name
| owner | species | sex | birth
| death |
+--------+--------+---------+------+------------+-------+
| Fluffy | Harold | cat
| f
| 1993-02-04 | NULL |
| Buffy | Harold | dog
| f
| 1989-05-13 | NULL |
+--------+--------+---------+------+------------+-------+

Untuk mencari nama yang mengandung sebuah w, gunakan [wW] untuk


mencocokkannya dengan huruf w kecil maupun besar:
mysql> SELECT * FROM pet WHERE name REGEXP "[wW]";
+----------+-------+---------+------+------------+------------+
| name
| owner | species | sex | birth
| death
|
+----------+-------+---------+------+------------+------------+
| Claws
| Gwen | cat
| m
| 1994-03-17 | NULL
|
| Bowser
| Diane | dog
| m
| 1989-08-31 | 1995-07-29 |
| Whistler | Gwen | bird
| NULL | 1997-12-09 | NULL
|
+----------+-------+---------+------+------------+------------+

karena pola ekspresi regular mencocokkan jika terjadi dimanapun dalam nilai, maka
pada query di atas tidak perlu memakai * pada sisi kiri maupun kanan dari pola
untuk mencocokkannya dengan keseluruhan nilai seperti jika Anda menggunakan
pola SQL.
Untuk menemukan nama yang tepat berisi lima huruf, gunakan ^ dan $ untuk
mencocokkan dengan awal dan akhir nama, dan lima . di antaranya:
mysql> SELECT * FROM pet WHERE name REGEXP "^.....$";
+-------+--------+---------+------+------------+-------+
| name | owner | species | sex | birth
| death |
+-------+--------+---------+------+------------+-------+
| Claws | Gwen
| cat
| m
| 1994-03-17 | NULL |
| Buffy | Harold | dog
| f
| 1989-05-13 | NULL |
+-------+--------+---------+------+------------+-------+

Anda juga dapat menuliskan query tadi menggunakan operator {n} (ulangi n-kali):
mysql> SELECT * FROM pet WHERE name REGEXP "^.{5}$";
+-------+--------+---------+------+------------+-------+
| name | owner | species | sex | birth
| death |
+-------+--------+---------+------+------------+-------+
| Claws | Gwen
| cat
| m
| 1994-03-17 | NULL |
| Buffy | Harold | dog
| f
| 1989-05-13 | NULL |
+-------+--------+---------+------+------------+-------+

Database juga sering digunakan untuk menjawab pertanyaan, Seberapa sering suatu
tipe data terdapat dalam suatu tabel?. Sebagai contoh, Anda mungkin ingin tahu
berapa banyak hewan yang Anda miliki, atau berapa hewan yang dimiliki tiap
pemiliknya, atau Anda mungkin ingin membuat sensus tertentu untuk hewan Anda.
Menghitung jumlah total hewan yang Anda miliki ini sama dengan pertanyaan
Berapa banyak baris yang ada dalam tabel pet?, karena terdapat satu record per
23

hewan. Fungsi COUNT() menghitung jumlah hasil yang bukan NULL, jadi query
untuk menghitung hewan Anda tampak seperti berikut:
mysql> SELECT COUNT(*) FROM pet;
+----------+
| COUNT(*) |
+----------+
|
9 |
+----------+

Pada query di atas, Anda mengambil nama orang yang memiliki hewan. Anda dapat
menggunakan COUNT() jika Anda ingin menemukan berapa banyak yang dimiliki
tiap pemilik:
mysql> SELECT owner, COUNT(*) FROM pet GROUP BY owner;
+--------+----------+
| owner | COUNT(*) |
+--------+----------+
| Benny |
2 |
| Diane |
2 |
| Gwen
|
3 |
| Harold |
2 |
+--------+----------+

Ingat bahwa penggunaan GROUP BY untuk menggabungkan semua record yang


sama owner-nya. Tanpa ini, Anda akan mendapatkan pesan error:
mysql> SELECT owner, COUNT(owner) FROM pet;
ERROR 1140 at line 1: Mixing of GROUP columns
(MIN(),MAX(),COUNT()...)
with no GROUP columns is illegal if there is no GROUP BY clause

COUNT() dan GROUP BY sangat berguna untuk mengkarakterisasi data Anda dalam
cara tertentu. Contoh berikut menunjukkan cara berbeda untuk melakukan operasi
konsensus hewan.
Jumlah hewan per spesies:
mysql> SELECT species, COUNT(*) FROM pet GROUP BY species;
+---------+----------+
| species | COUNT(*) |
+---------+----------+
| bird
|
2 |
| cat
|
2 |
| dog
|
3 |
| hamster |
1 |
| snake
|
1 |
+---------+----------+

jumlah hewan per jenis kelamin:


mysql> SELECT sex, COUNT(*) FROM pet GROUP BY sex;
+------+----------+
| sex | COUNT(*) |
+------+----------+
| NULL |
1 |
| f
|
4 |
24

| m
|
4 |
+------+----------+

(pada output ini, NULL menunjukkan jenis kelamin tidak diketahui)


Jumlah hewan per kombinasi dari spesies dan jenis kelamin:
mysql> SELECT species, sex, COUNT(*) FROM pet GROUP BY species, sex;
+---------+------+----------+
| species | sex | COUNT(*) |
+---------+------+----------+
| bird
| NULL |
1 |
| bird
| f
|
1 |
| cat
| f
|
1 |
| cat
| m
|
1 |
| dog
| f
|
1 |
| dog
| m
|
2 |
| hamster | f
|
1 |
| snake
| m
|
1 |
+---------+------+----------+

Anda tidak perlu mengambil keseluruhan tabel ketika menggunakan COUNT().


Contohnya, pada query sebelumnya, ketika digunakan hanya untuk anjing dan kucing,
tampak seperti ini:
mysql> SELECT species, sex, COUNT(*) FROM pet
-> WHERE species = "dog" OR species = "cat"
-> GROUP BY species, sex;
+---------+------+----------+
| species | sex | COUNT(*) |
+---------+------+----------+
| cat
| f
|
1 |
| cat
| m
|
1 |
| dog
| f
|
1 |
| dog
| m
|
2 |
+---------+------+----------+

Atau, jika Anda ingin jumlah hewan per jenis kelamin cuma untuk hewan yang
diketahui jenis kelaminnya:
mysql> SELECT species, sex, COUNT(*) FROM pet
-> WHERE sex IS NOT NULL
-> GROUP BY species, sex;
+---------+------+----------+
| species | sex | COUNT(*) |
+---------+------+----------+
| bird
| f
|
1 |
| cat
| f
|
1 |
| cat
| m
|
1 |
| dog
| f
|
1 |
| dog
| m
|
2 |
| hamster | f
|
1 |
| snake
| m
|
1 |
+---------+------+----------+

25

Menggunakan Lebih Dari Satu Tabel


Tabel pet menunjukkan hewan apa saja yang Anda miliki. Jika Anda ingin
menyimpan informasi lain mengenai mereka, seperti kejadian pada kehidupan
mereka, Anda membutuhkan tabel lain. Seperti apa tabel ini seharusnya?

Perlu berisi nama hewan jadi Anda tahu hewan mana yang mengalaminya.

Perlu tanggal jadi Anda tahu kapan hal ini terjadi.

Perlu field yang menggambarkan kejadian ini

Jika Anda ingin bisa mengkategorikan kejadian, akan sangat berguna untuk
memiliki field jenis kejadian.

Berdasarkan pertimbangan di atas, pernyataan CREATE TABLE untuk tabel event


mungkin tampak seperti berikut:
mysql> CREATE TABLE event (name VARCHAR(20), date DATE,
-> type VARCHAR(15), remark VARCHAR(255));

Seperti pada tabel pet, cara termudah untuk mulai mengisi record dengan membuat
file teks yang berisi informasi berikut:
Fluffy
Buffy
Buffy
Chirpy
Slim
Bowser
Fang
Fang
Claws
Whistler

1995-05-15
1993-06-23
1994-06-19
1999-03-21
1997-08-03
1991-10-12
1991-10-12
1998-08-28
1998-03-17
1998-12-09

Litter
Litter
litter
vet
vet
kennel
kennel
birthday
birthday
birthday

4 kittens, 3 female, 1 male


5 puppies, 2 female, 3 male
3 puppies, 3 female
needed beak straightened
broken rib

Gave him a new chew toy


Gave him a new flea collar
First birthday

Masukkan record ini dengan cara:


mysql> LOAD DATA LOCAL INFILE "event.txt" INTO TABLE event;

Berdasarkan apa yang Anda pelajari dari query yang Anda jalankan pada tabel pet,
Anda seharusnya sudah mampu untuk melakukan pengambilan record pada tabel
event, prinsipnya sama.
Anggaplah Anda ingin menemukan umur untuk tiap hewan ketika mereka melahirkan
(litter). Tabel event menunjukkan kapan ini terjadi, tetapi untuk menunjukkan umur
dari induknya, Anda butuh tanggal lahirnya. Karena ini disimpan dalam tabel pet,
Anda butuh kedua tabel untuk querynya:
mysql> SELECT pet.name, (TO_DAYS(date) - TO_DAYS(birth))/365 AS age,
remark
-> FROM pet, event
26

-> WHERE pet.name = event.name AND type = "litter";


+--------+------+-----------------------------+
| name
| age | remark
|
+--------+------+-----------------------------+
| Fluffy | 2.27 | 4 kittens, 3 female, 1 male |
| Buffy | 4.12 | 5 puppies, 2 female, 3 male |
| Buffy | 5.10 | 3 puppies, 3 female
|
+--------+------+-----------------------------+

Ada beberapa hal yang harus diperhatikan tentang query ini:

Pada klausa FROM terdapat dua tabel karena query ini butuh mengambil data dari
keduanya.

Ketika menggabungkan (join) informasi dari multiple tabel, Anda harus


menspesifikasi bagaimana record dalam satu tabel dapat cocok dengan record dari
tabel lain. Ini mudah karena mereka keduanya memiliki kolom name. Query ini
menggunakan klausa WHERE untuk mencocokkan record dari kedua tabel
berdasarkan value name.

Karena kolom name terdapat pada kedua tabel, Anda harus menspesifikasi dari
tabel mana kolom ini yang akan ditampilkan. Ini dilakukan dengan menambahkan
nama tabel sebelum nama kolom.

Anda tidak harus memiliki dua tabel yang berbeda untuk melakukan join. Kadangkadang ada gunanya untuk menggabungkan sebuah tabel ke dirinya sendiri, jika Anda
ingin membandingkan record dalam suatu tabel ke record lain dalam tabel yang sama.
Contohnya, untuk menemukan hewan yang merupakan pasangan diantara hewan
Anda, Anda dapat menggabungkan tabel pet dengan dirinya sendiri untuk
memadukan hewan jantan dan betina yang sejenis:
mysql> SELECT p1.name, p1.sex, p2.name, p2.sex, p1.species
-> FROM pet AS p1, pet AS p2
-> WHERE p1.species = p2.species AND p1.sex = "f" AND p2.sex =
"m";
+--------+------+--------+------+---------+
| name
| sex | name
| sex | species |
+--------+------+--------+------+---------+
| Fluffy | f
| Claws | m
| cat
|
| Buffy | f
| Fang
| m
| dog
|
| Buffy | f
| Bowser | m
| dog
|
+--------+------+--------+------+---------+

Pada query ini, kita menulis alias dari nama tabel agar bisa mereferensi kolom dan
menjelaskan asosiasi dari tiap kolom.

Mengambil Informasi Mengenai Database Dan Tabel

27

Bagaimana jika Anda lupa nama dari database atau tabel, atau struktur dari suatu
tabel? MySQL memecahkan masalah ini melalui beberapa pernyataan yang
menyediakan informasi mengenai database dan tabel yang didukungnya.
Anda sudah melihat SHOW DATABASES, yang menunjukkan daftar database yang
dikelola oleh server. Untuk menemukan database mana yang sedang digunakan,
gunakan fungsi DATABASE():
mysql> SELECT DATABASE();
+------------+
| DATABASE() |
+------------+
| hewan
|
+------------+

Jika Anda belum memilih database, hasilnya akan kosong.


Untuk melihat daftar tabel dari database yang sedang digunakan, gunakan perintah:
mysql> SHOW TABLES;
+---------------------+
| Tables in hewan
|
+---------------------+
| event
|
| pet
|
+---------------------+

Jika Anda ingin melihat struktur dari suatu tabel, perintah DESCRIBE sangat
berguna, perintah ini menampilkan informasi tentang tiap kolom tabel:
mysql> DESC pet;
+---------+-------------+------+-----+---------+-------+
| Field
| Type
| Null | Key | Default | Extra |
+---------+-------------+------+-----+---------+-------+
| name
| varchar(20) | YES |
| NULL
|
|
| owner
| varchar(20) | YES |
| NULL
|
|
| species | varchar(20) | YES |
| NULL
|
|
| sex
| char(1)
| YES |
| NULL
|
|
| birth
| date
| YES |
| NULL
|
|
| death
| date
| YES |
| NULL
|
|
+---------+-------------+------+-----+---------+-------+

Field menunjukkan nama kolom, Type adalah tipe data kolom, Null menunjukkan
apakah kolom yang bersangkutan dapat berisi nilai NULL, Key menunjukkan apakah
kolom diindex dan Default menunjukkan nilai default kolom.
Jika Anda memiliki index pada suatu tabel, SHOW INDEX FROM tbl_name akan
menghasilkan informasi mengenainya.

Index
Semua tipe kolom MySQL dapat diindex. Penggunaan index pada kolom yang
relevan adalah cara terbaik untuk meningkatkan performa operasi SELECT.
28

Sebuah tabel dapat memiliki max 16 index. Panjang maximum index adalah 256
bytes, meskipun hal ini dapat diubah ketika meng-compile MySQL.
Untuk kolom CHAR dan VARCHAR, Anda dapat mengindex sebagian dari kolom.
hal ini jauh lebih cepat dan memerlukan ruang harddisk yang lebih sedikit daripada
mengindex keseluruhan kolom. Sintaks yang digunakan dalam pernyataan CREATE
TABLE untuk mengindex sebagian awal kolom seperti berikut:
KEY index_name (col_name(length))

Contoh berikut membuat sebuah index untuk 10 karakter pertama dari kolom name:
mysql> CREATE TABLE test (
name CHAR(200) NOT NULL,
KEY index_name (name(10)));

MySQL dapat membuat index untuk banyak kolom. sebuah index dapat terdiri dari
max 15 kolom. index multiple kolom dapat dianggap sebagai array tersortir yang
berisi nilai yang dibuat dengan menggabungkan nilai dari kolom yang diindex.
MySQL menggunakan index multiple kolom sedemikian rupa sehingga query
menjadi cepat jika Anda menspesifikasi kuantiti yang diketahui untuk kolom pertama
dari index dalam klausa WHERE, bahkan jika Anda tidak menspesifikasi nilai untuk
kolom yang lain.
Anggap sebuah tabel dibuat menggunakan kriteria berikut:
mysql> CREATE TABLE test (
id INT NOT NULL,
last_name CHAR(30) NOT NULL,
first_name CHAR(30) NOT NULL,
PRIMARY KEY (id),
INDEX name (last_name,first_name));

Kemudian index name adalah index untuk last_name dan first_name. Index ini akan
digunakan untuk query yang menspesifikasi nilai untuk jangkauan yang diketahui dari
last_name atau last_name dan first_name. Maka, index name akan digunakan pada
query berikut:
mysql> SELECT * FROM test WHERE last_name="Widenius";
mysql> SELECT * FROM test WHERE last_name="Widenius"
AND first_name="Michael";
mysql> SELECT * FROM test WHERE last_name="Widenius"
AND (first_name="Michael" OR
first_name="Monty");
mysql> SELECT * FROM test WHERE last_name="Widenius"
AND first_name >="M" AND first_name < "N";

Namun, index name tidak akan digunakan untuk query berikut:


mysql> SELECT * FROM test WHERE first_name="Michael";
29

mysql> SELECT * FROM test WHERE last_name="Widenius"


OR first_name="Michael";

Program Yang Ada Dalam MySQL:


myisamchk

Program utilitas untuk menggambarkan,


memperbaiki tabel MySQL.

mengecek,

mengoptimasi

dan

make_binary_release

Membuat versi binary dari MySQL yang sudah di-compile.


msql2mysql

Sebuah skrip shell yang mengubah program mSQL ke MySQL. Ini tidak
menangani semua kasus, tetapi memberikan awal yang baik ketika pengubahan.
mysqlaccess

Skrip yang mengecek hak akses untuk kombinasi host, user, dan database.
mysqladmin

Utilitas untuk melakukan operasi administrative, seperti membuat atau menghapus


database, reload grant table, mem-flush taabel ke disk dan membuka ulang file
log. mysqladmin dapat juga digunakan untuk mengambil informasi versi, proses
dan status dari server.
mysqlbug

Skrip untuk melaporkan bug MySQL. Skrip ini seharusnya selalu digunakan
detika mengisi laporan bug ke list MySQL.
mysqld

Daemon SQL. Ini harus selalu berjalan.


mysqldump

Untuk men-dump database MySQL ke sebuah file sebagai pernyataan-pernyataan


SQL atau sebagai file teks yang dipisahkan oleh tab.
mysqlimport

Untuk mengimpor file teks ke tabel yang bersangkutan menggunakan LOAD


DATA INFILE.
mysqlshow

Menampilkan informasi mengenai database, tabel, kolom, dan index.


mysql_install_db

Membuat tabel grant MySQL dengan hak akses default. Ini biasanya dijalankan
cuma sekali, ketika pertama kali menginstall MySQL.

30

replace

Program utilitas yang digunakan oleh mysql2mysql, tetapi memiliki kegunaan


yang lainnya. replace mengubah string di dalam file atau pada input standar.
Dapat digunakan untuk menukar string. Contohnya, perintah ini menukar a dan b
dalam file yang bersangkutan:
shell> replace a b b a -- file1 file2 ...
safe_mysqld

Script yang menjalankan daemon mysqld dengan option yang aman, seperti merestart server ketika terjadi error dan mencatat informasi runtime ke file log.

Men-dump Struktur Dan Data Dari Database Dan Tabel MySQL


Utiliti untuk men-dump database atau koleksi dari database untuk backup atau untuk
mentransfer data ke server SQL lain. Dump ini akan berisi pernyataan SQL untuk
membuat tabel dan/atau mengisi tabel.
shell> mysqldump [OPTIONS] database [tables]
OR
mysqldump [OPTIONS] --databases [OPTIONS] DB1 [DB2 DB3...]
OR
mysqldump [OPTIONS] --all-databases [OPTIONS]

Jika Anda tidak memberikan tabel apapun atau menggunakan databases atau alldatabases, seluruh database akan di-dump.
Anda akan mendapatkan daftar option dari mysqldump yang didukung oleh versi
Anda dengan menjalankan perintah :
shell> mysqldump help

Penggunaan yang normal dari mysqldump mungkin adalah membuat backup dari
seluruh database.
mysqldump --opt database > backup-file.sql

Namun, juga sangat berguna untuk membuat server MySQL lain dengan informasi
dari suatu database:
mysqldump --opt database | mysql --host=remote-host -C database

Mungkin juga untuk men-dump beberapa database dengan satu perintah:


mysqldump --databases database1 [database2 database3...] >
my_databases.sql

Jika Anda ingin men-dump seluruh database, dapat menggunakan:


mysqldump --all-databases > all_databases.sql

Mengimpor Data Dari File Teks

31

mysqlimport menyediakan interface baris perintah untuk pernyataan SQL: LOAD


DATA INFILE. Sebagian besar option untuk mysqlimport berkaitan langsung dengan
option yang sama dari LOAD DATA INFILE.
mysqlimport dijalankan seperti berikut:
shell> mysqlimport [options] database textfile1 [textfile2....]

Untuk tiap file teks yang disebutkan di baris perintah, mysqlimport menghapus
ekstensi dari nama file dan menggunakan hasilnya untuk menentukan tabel mana
yang harus diisi hasil impor.

32