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 Anda, masukkanlah ketika mysql menampilkan Enter password:. 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>
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 titik-koma.)
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
Arti
mysql> 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 titik-koma. 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
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 :
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 INTO shirts VALUES
(NULL, 'polo', 'blue', LAST_INSERT_ID()),
(NULL, 'dress', 'white', LAST_INSERT_ID()),
(NULL, 't-shirt', 'blue', LAST_INSERT_ID());

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

INSERT INTO shirts VALUES
(NULL, 'dress', 'orange', LAST_INSERT_ID()),
(NULL, 'polo', 'red', LAST_INSERT_ID()),
(NULL, 'dress', 'blue', LAST_INSERT_ID()),
(NULL, '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 s.* FROM persons p, shirts s
WHERE p.name LIKE 'Lilliana%'
AND s.owner = p.id
AND 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;
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 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 |
+---------------------+

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
owner species sex birth Death
Fluffy Harold cat f 1993-02-04
Claws Gwen cat m 1994-03-17
Buffy Harold dog f 1989-05-13
Fang Benny dog m 1990-08-27
Bowser Diane dog m 1998-08-31 1995-07-29
Chirpy Gwen bird f 1998-09-11
Whistler Gwen bird 1997-12-09
Slim Benny snake m 1996-04-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.
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 :
• 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:
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 |
+--------+
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:
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 |
| 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:
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).
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.

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 |
+-------+--------+---------+------+------------+-------+

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:
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 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 |
| 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 |
+---------+------+----------+

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
1995-05-15 Litter 4 kittens, 3 female, 1 male
Buffy 1993-06-23 Litter 5 puppies, 2 female, 3 male
Buffy 1994-06-19 litter 3 puppies, 3 female
Chirpy 1999-03-21 vet needed beak straightened
Slim 1997-08-03 vet broken rib
Bowser 1991-10-12 kennel
Fang 1991-10-12 kennel
Fang 1998-08-28 birthday Gave him a new chew toy
Claws 1998-03-17 birthday Gave him a new flea collar
Whistler 1998-12-09 birthday 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
-> 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. Kadang-kadang 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
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.
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";

mysql> SELECT * FROM test WHERE last_name="Widenius"
OR first_name="Michael";

Program Yang Ada Dalam MySQL:
myisamchk
Program utilitas untuk menggambarkan, mengecek, mengoptimasi dan memperbaiki tabel MySQL.
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.
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 me-restart 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 –all-databases, 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
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.