pengenalan mysql - imstmiklombok.files.wordpress.com€¦ · web viewmysql. mysql adalah server...

[PENGENALAN MYSQL] STMIK LOMBOK

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 –pEnter 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 -pEnter 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() -> \cmysql>

Tabel berikut ini menunjukkan tiap prompt yang mungkin Anda temukan dan artinya:

Prompt Artimysql> 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, priceFROM shopWHERE 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, priceFROM shopWHERE 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, priceFROM shopORDER BY price DESCLIMIT 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 priceFROM shopGROUP 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, priceFROM shop s1WHERE 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, tmpWHERE 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 priceFROM shopGROUP 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 tmpSELECT field1_index, field2_index FROM test_table WHERE field1_index = '1';


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

Membuat Dan Menggunakan DatabaseSekarang 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 testDatabase 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 hewanDatabase 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 hewanEnter 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_selectFROM which_tableWHERE 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.

pengenalan mysql - imstmiklombok.files.wordpress.com€¦ · web viewmysql. mysql adalah server...

Documents