MySQL Database
Administration Fundamental
and Advanced
KATA PENGANTAR
MySQL merupakan software database open source yang paling populer di dunia,
dimana saat ini digunakan lebih dari 100 juta pengguna di seluruh dunia. Dengan
kehandalan, kecepatan dan kemudahan penggunaannya, MySQL menjadi pilihan utama
bagi banyak pengembang software dan aplikasi baik di platform web maupun desktop.
Pengguna MySQL tidak hanya sebatas pengguna perseorangan maupun perusahaan
kecil, namun perusahaan seperti Yahoo!, AlcatelLucent, Google, Nokia, Youtube,
Wordpress dan Facebook juga merupakan pengguna MySQL.
MySQL pertama kali dibuat dan dikembangkan di Swedia, yaitu oleh David Axmark,
Allan Larsson dan Michael "Monty" Widenius. Mereka mengembangkan MySQL sejak
tahun 1980an. Saat ini versi MySQL yang sudah stabil mencapai versi 5x, dan sedang
dikembangkan versi 6x. Untuk lebih lengkapnya dapat dilihat di situs resmi MySQL1.
Materi ini mencoba membahas MySQL secara praktis, disajikan secara terstruktur
dan disertai contohcontoh dan latihan untuk membantu pemahaman. Sehingga
diharapkan dapat membantu Student menguasai MySQL hingga mahir. Buku ini sangat
cocok bagi student yang baru mempelajari MySQL maupun bagi student yang ingin lebih
memperdalam MySQL sebagai salah satu software database terkemuka saat ini. Buku ini
terbagi menjadi 4 (empat) bagian. Bagian pertama merupakan bagian pendahuluan yang
membahas mengenai penjelasan singkat MySQL dan juga langkah instalasi MySQL serta
software pendukung lainnya. Bagian kedua adalah Dasardasar MySQL yang menjelaskan
mengenai perintahperintah dasar dari MySQL termasuk fungsifungsi di dalam MySQL.
Pada bagian ketiga dipaparkan mengenai perintahperintah MySQL yang lebih kompleks
seperti penggabungan antar tabel, trigger, views dan stored procedure. Selanjutnya pada
bagian yang terakhir akan dijelaskan mengenai penyajian laporan dan proses backup,
restore database MySQL.
Page 2
DAFTAR ISI
KATA PENGANTAR.............................................................................................................2
===================================================================
MySQL Administration Fundamental
===================================================================
PENDAHULUAN..................................................................................................................4
Bab 1. Sekilas Tentang MySQL
Bab 2. Instalasi MySQL dan Software Pendukung
DASAR-DASAR MySQL....................................................................................................24
Bab 3. Merancang Database
Bab 4. Dasardasar SQL
Bab 5. Fungsifungsi MySQL
PERINTAH MySQL LANJUTAN........................................................................................62
Bab 6. Perintah MySQL Lanjutan
Bab 7. Administrasi dan Keamanan di MySQL
Bab 8. Trigger dan Views
Bab 9. Function dan Stored Procedure
LAPORAN DAN BACKUP DI MySQL ..............................................................................96
Bab 10. Laporan di MySQL
Bab 11. Backup, Restore dan Import di MySQL
===================================================================
MySQL Administration Advanced
===================================================================
MySQL METADATA.........................................................................................................107
Bab 12. Memanfaatkan MySQL Metadata
STORAGE ENGINE .......................................................................................................120
Bab 13. MySQL Storage Engine
MEMAKSIMALKAN KINERJA.........................................................................................132
Bab 14. Memaksimalkan Kinerja MySQL
MYSQL CLUSTER..........................................................................................................149
Bab 15. Installasi MySQL Cluster
-= SEKIAN =-...................................................................................................................162
Page 3
Bagian 1
PENDAHULUAN
Page 4
Bab 1
Sekilas Tentang MySQL
Hierarki Database
Sejarah MySQL
Cerita tentang MySQL bermula pada tahun 1979, ketika Michael Widenius (a.k.a.
Monty), seorang programmer asal Swedia, mengembangkan sebuah sistem database
sederhana yang dinamakan UNIREG. UNIREG ini menggunakan koneksi low-level ISAM
database engine dengan indexing (baca : sistem database sederhana yang mendukung
index).
Monty bekerja pada perusahaan bernama TcX di Swedia. TcX pada tahun 1994
mulai mengembangkan aplikasi berbasis web, dan berencana menggunakan UNIREG
sebagai sistem databasenya. Namun malang bagi Monty, UNIREG dianggagap tidak
cocok untuk database yang dinamis seperti web.
TcX mencoba mencari alternatif sistem database lainnya, salah satunya adalah
mSQL (miniSQL), sebuah RDBMS yang tidak terlalu mahal dan hampir open source,
maksudnya jika anda membeli aplikasi ini, anda juga akan mendapatkan source code nya
juga. Namun mSQL versi 1 ini juga memiliki kekurangan, yaitu tidak mendukung indexing,
sehingga performanya tidak terlalu bagus.
Dengan hasutan petinggi-petinggi TcX, Monty mencoba menghubungi David
Hughes (programmer yang mengembangkan mSQL) untuk menanyakan apakah ia tertarik
mengembangkan sebuah konektor di mSQL yang dapat dihubungkan dengan UNIREG
ISAM sehingga mendukung indexing. Pada saat itu Hughes menolak, dengan alasan
sedang mengembangkan teknologi indexing yang independen untuk mSQL versi 2.
Dikarenakan penolakan David Hughes, TcX (dan juga Monty) akhirnya memutuskan
untuk merancang dan mengembangkan sendiri konsep sistem database baru. Sistem ini
merupakan gabungan dari UNIREG dan mSQL (source codenya dapat bebas digunakan).
Page 5
Sehingga pada May 1995, sebuah RDBMS baru, yang dinamakan MySQL dirilis.
David Axmark dari Detron HB, rekanan TcX mengusulkan agar MySQL di jual
dengan model bisnis baru. Ia mengusulkan agar MySQL dikembangkan dan dirilis dengan
gratis. Pendapatan perusahaan selanjutnya di dapat dari menjual jasa support untuk
perusahaan yang ingin mengimplementasikan MySQL. Konsep bisnis yang juga
diterapkan perusahaan-perusahaan Open Source lainnya.
Asal Nama MySQL
Asal penamaan MySQL sendiri agak unik. Monty berkata :
It is not perfectly clear where the name MySQL derives from. TcXs base directory
and a large amount of their libraries and tools have had the prefix My for well over ten
years. However, my daughter (some years younger) is also named My. So which of the
two gave its name to MySQL is still a mystery.
Berbagai sumber menyatakan, bahkan juga di situs MySQL sendiri bahwa My dari
MySQL berasal dari nama anak perempuan Monty. Namun seperti kutipan diatas, Monty
pun mengakui bahwa selama ia di TcX, library dan aplikasi yang dikembangkan
perusahaan itu juga banyak dimulai dengan awalan My.
Logo lumba-lumba dalam lambang MySQL di namai Sakila, yang berasal dari
sebuah kontest Name the Doplhin yang diadakan MySQL AB. Nama Sakila ini diajukan
oleh Ambrose Twebaze, seorang programmer open source dari Swaziland, Afrika. Sakila
memiliki akar dari bahasa Siswati, bahasa yang digunakan di Swaziland.
MySQL dan MySQL AB
Kembali ke kisah MySQL, Pada tahun 1995 itu juga, TcX berubah nama menjadi
MySQL AB, dengan Michael Widenius, David Axmark dan Allan Larsson sebagai
pendirinya. Titel AB dibelakang MySQL, adalah singkatan dari Aktiebolag, istilah PT
(Perseroan Terbatas) bagi perusahaan Swedia.
MySQL AB menjadi perusahaan di belakang MySQL, menyediakan jasa dan
bertanggung jawab dalam mengembangkan, memasarkan, dan menyediakan dukungan
untuk MySQL. MySQL sendiri dirilis dengan dual licencing, atau dua lisensi yakni versi
gratis dan versi berbayar.
Lisensi pertama di rilis dibawah GNU GPL (General Public License atau dikenal
juga dengan Gak Pakai Lisensi). Lisensi GPL ini membebaskan anda menggunakan
MySQL tanpa membayar loyalti kepada MySQL AB, dengan beberapa syarat tertentu.
Page 6
Misalnya, jika anda menggunakan MySQL dalam aplikasi yang anda buat, aplikasi
tersebut juga harus bersifat gratis dan berada di bawah lisensi GPL.
Lisensi kedua di peruntukkan bagi perusahaan-perusahaan komersil, maupun
pengembang software yang berniat menjual aplikasinya, dan menggunakan MySQL
sebagai databasenya. Untuk keperluan ini, anda diharuskan membeli lisensi komersial
dari MySQL AB. Lebih lanjut tentang permasalahan seputar lisensi MySQL, dapat
mengunjungi situs MySQL.
MySQL AB juga memegang hak copyright dari source code MySQL dan pemilik hak
merk dagang MySQL. Dengan kata lain, walaupun kita memiliki source code MySQL,
namun sistem database maupun aplikasi yang kita buat tidak boleh menggunakan merk
MySQL tanpa membayar loyalti kepada pihak MySQL AB. Hal ini pula yang menjelaskan
mengapa salah satu aplikasi administasi MySQL berbasis web PhpMyAdmin, tidak
menggunakan kata MySQL pada nama programnya.
MariaDB
MariaDB merupakan versi pengembangan terbuka dan mandiri dari MySQL. Sejak
diakuisisinya MySQL oleh Oracle pada September 2010, Monty Program sebagai penulis
awal kode sumber MySQL memisahkan diri dari pengembangan dan membuat versi yang
lebih mandiri yakni MariaDB.
Semua kemampuan MySQL dimiliki pula oleh MariaDB yakni:
1. Portabilitas. MariaDB dapat berjalan stabil pada berbagai sistem operasi seperti
Windows, Linux, FreeBSD, Mac Os X Server, Solaris, Amiga, dan masih banyak
lagi.
2. Perangkat lunak sumber terbuka. MariaDB didistribusikan sebagai perangkat lunak
sumber terbuka, dibawah lisensi GPL sehingga dapat digunakan secara gratis.
3. Multi-user. MariaDB dapat digunakan oleh beberapa pengguna dalam waktu yang
bersamaan tanpa mengalami masalah atau konflik.
4. 'Performance tuning', MariaDB memiliki kecepatan yang menakjubkan dalam
menangani query sederhana, dengan kata lain dapat memproses lebih banyak SQL
per satuan waktu.
5. Ragam tipe data. MariaDB memiliki ragam tipe data yang sangat kaya, seperti
signed / unsigned integer, float, double, char, text, date, timestamp, dan lain-lain.
6. Perintah dan Fungsi. MariaDB memiliki operator dan fungsi secara penuh yang
mendukung perintah Select dan Where dalam perintah (query).
Page 7
7. Keamanan.
MariaDB
memiliki
beberapa
lapisan
keamanan
seperti
level
subnetmask, nama host, dan izin akses user dengan sistem perizinan yang
mendetail serta sandi terenkripsi.
8. Skalabilitas dan Pembatasan. MariaDB mampu menangani basis data dalam skala
besar, dengan jumlah rekaman (records) lebih dari 50 juta dan 60 ribu tabel serta 5
miliar baris. Selain itu batas indeks yang dapat ditampung mencapai 32 indeks
pada tiap tabelnya.
9. Konektivitas. MariaDB dapat melakukan koneksi dengan klien menggunakan
protokol TCP/IP, Unix soket (UNIX), atau Named Pipes (NT).
10. Pelokalan Bahasa. MariaDB dapat mendeteksi pesan kesalahan pada klien dengan
menggunakan lebih dari dua puluh bahasa. Meski pun demikian, bahasa Indonesia
belum termasuk di dalamnya.
11. Antar Muka. MariaDB memiliki antar muka (interface) terhadap berbagai aplikasi
dan bahasa pemrograman dengan menggunakan fungsi API (Application
Programming Interface).
12. Klien dan Peralatan. MariaDB dilengkapi dengan berbagai peralatan (tool)yang
dapat digunakan untuk administrasi basis data, dan pada setiap peralatan yang ada
disertakan petunjuk online.
13. Struktur tabel. MariaDB memiliki struktur tabel yang lebih fleksibel dalam
menangani ALTER TABLE, dibandingkan basis data lainnya semacam PostgreSQL
ataupun Oracle.
untuk
memperoleh
informasi
dari
basis
data
tersebut
mengakses database secara praktis dan efisien. Dengan DBMS, user akan lebih mudah
Page 8
- http://www-306.ibm.com/software/data/db2/
- http://www.microsoft.com/sql/
Oracle
- http://www.oracle.com
Sybase
- http://www.sybase.com/
Interbase
- http://www.borland.com/interbase
Teradata
- http://www.teradata.com/
Firebird
- http://www.firebirdsql.org/
MySQL
- http://www.mysql.com
PostgreSQL
- http://www.postgresql.org/
has
the
best
overall
performance
and
that
MySQL
Page 9
Reliability
Biasanya sesuatu yang gratis susah diandalkan, bahkan banyak bug dan sering
hang. Tidak demikian dengan MySQL, karena sifatnya yang open source, setiap orang
dapat berkontribusi memeriksa bug dan melakukan test case untuk berbagai skenario
yang memerlukan sistem 24 jam online, multi-user dan data ratusan GB. Hasilnya, MySQL
merupakan RDBMS yang reliabel namun memiliki performa diatas rata-rata.
Skalability
MySQL dapat memproses data yang sangat besar dan kompleks, tanpa ada
penurunan performa yang berarti, juga mendukung sistem multi-prosesor. MySQL juga
dipakai oleh perusahaan-perusahaan besar di dunia, seperti Epson, New York Times,
Wikipedia, Google, Facebook, bahkan NASA.
User Friendly
Instalasi dan mempelajari MySQL cukup mudah dan tidak dipusingkan dengan
banyak settingan. Cukup download aplikasi MySQL dan install, kita dapat menggunakan
MySQL dalam waktu kurang dari 5 menit (dengan asumsi tidak mati lampu).
Portability and Standard Compliance
Database MySQL dapat dengan mudah berpindah dari satu sistem ke sistem
lainnya. Misalkan dari sistem Windows ke Linux. Aplikasi MySQL juga dapat berjalan di
sistem Linux (RedHat, SuSE, Mandrake, Debian), Embedded Linux (MontaVista,
LynuxWorks BlueCat),Unix (Solaris, HP-UX, AIX), BSD (Mac OS X, FreeBSD), Windows
(Windows 2000, Windows NT) dan RTOS (QNX).
Multiuser Support
Dengan menerapkan arsitektur client-server. Ribuan pengguna dapat mengakses
database MySQL dalam waktu yang bersamaan.
Internationalization
Atau dalam bahasa sederhananya, mendukung beragam bahasa. Dengan
dukungan penuh terhadap unicode, maka aksara non-latin seperti jepang, cina, dan korea
bisa digunakan di dalam MySQL.
Page 10
Page 11
SQL atau Structured Query Language merupakan suatu bahasa (language) yang
digunakan untuk mengakses database. SQL sering disebut juga sebagai query.
Hierarki Database
MySQL
MySQL adalah sebuah perangkat lunak sistem manajemen basis data SQL
(bahasa Inggris: database management system) atau DBMS yang multithread, multi-user,
dengan sekitar 6 juta instalasi di seluruh dunia. MySQL AB membuat MySQL tersedia
sebagai perangkat lunak gratis di bawah lisensi GNU General Public License (GPL), tetapi
mereka
juga
menjual
dibawah
lisensi
komersial
untuk
kasus-kasus
dimana
Page 12
Relational Database System. Seperti halnya software database lain yang ada di
pasaran, MySQL termasuk RDBMS.
Mendukung Sub Select. Mulai versi 4.1 MySQL telah mendukung select dalam
select (sub select).
Mendukung Triggers. MySQL mendukung trigger pada versi 5.0 namun masih
terbatas. Pengembang MySQL berjanji akan meningkatkan kemampuan trigger
pada versi 5.1.
Mendukung replication.
Mendukung transaksi.
Page 13
Bab 2
Instalasi MySQL dan Software Pendukung
3. Klik
Page 14
tombol Add untuk memilih component apa saja yang ingin di install
4. Pada contoh di bawah ini pilihan Component yang diinstall adalah MySQL Server
5.6.23 - x86
Page 15
TCP/IP: Jika kita menceklis bagian ini maka MySQL akan membuka Port
dan LISTENING di server tersebut, sehingga MySQL dapat diakses melalui
remote komputer atau Applikasi yang berbeda server.
Port Number: Pada bagian port number kita dapat merubah port defaultnya
(3306) ke port yang diinginkan dengan catatan applikasi yang akan
mengakses dapat melakukan konfigurasi nomer port MySQL server.
6. Jendela berikutnya kita harus men-setting MySQL Root Password yang akan
digunakan untuk memanage MySQL server tersebut, kita juga bisa menambahkan
user lain pada bagian MySQL User Accounts.
Page 16
7. Proses penambahan user baru bisa dilihat dibagian bawah ini, pada bagian Role
kita bisa menentukan Akses Control apa saja yang diberikan ke user tersebut
berdasarkan template Roles yang sudah disediakan.
Page 17
8. Langkah terakhir adalah menapply konfigurasi yang sudah kita terapkan di jendela
installasi sebelumnya seperti gambar di bawah ini
Page 18
2. MySQL Front
Merupakan front-end MySQL berbasis Windows yang cukup banyak digunakan.
MySQL-Front memiliki user interface yang cukup mudah digunakan, bahkan oleh user
pemula. Pada awalnya MySQL-Front merupakan software yang free, namun mulai versi
3.0 ke atas, software ini menjadi software yang bersifat shareware dengan masa
percobaan selama 30 hari. Jika ingin mencoba software ini, cobalah MySQL-Front versi
2.5 karena selain masih bebas untuk didownload, versi 2.5 cukup stabil dan sudah teruji.
Page 19
3. PHPMyAdmin
PHPMyAdmin merupakan front-end MySQL berbasis web. PHPMyAdmin dibuat
dengan menggunakan PHP. Saat ini, PHPMyAdmin banyak digunakan dalam hampir
semua penyedia hosting yang ada di internet. PHPMyAdmin mendukung berbagai fitu
administrasi MySQL termasuk manipulasi database, tabel, index dan juga dapat
mengeksport data ke dalam berbagai format data. PHPMyAdmin juga tersedia dalam 50
bahasa lebih, termasuk bahasa Indonesia. PHPMyAdmin dapat didownload secara gratis
di http://www.phpmyadmin.net
Page 20
Page 21
Page 22
Page 23
Bagian 2
DASAR-DASAR MySQL
Page 24
Bab 3
Merancang Database
Merancang database merupakan hal yang pertama kali harus dilakukan sebelum
membuat suatu aplikasi berbasis database. Rancangan database yang baik akan
menentukan seberapa baik sebuah aplikasi dibangun. Orang yang bertanggung jawab
dalam merancang database biasanya disebut sebagai seorang sistem analis.
Berikut ini contoh sederhana sebuah rancangan database dalam pada Sistem
Pemesanan Barang (ordering system). Rancangan database disajikan dalam bentuk class
diagram.
Page 25
Tipe tabel MyISAM merupakan tipe tabel yang sederhana, stabil dan mudah
digunakan. Jika kita akan menyimpan data sederhana yang tidak terlalu rumit, maka
gunakanlah tipe tabel ini. Kelebihan utama MyISAM adalah kecepatan dan kestabilannya.
Jika kita memilih tipe tabel MyISAM, maka MySQL secara otomatis akan menentukan
salah satu dari tiga jenis tabel MyISAM, yaitu :
a) MyISAM static. Jenis ini digunakan ketika semua kolom dalam tabel didefinisikan
dengan ukuran yang pasti (fixed). Dengan kata lain, tidak ada kolom yang memiliki
tipe seperti VARCHAR, TEXT dan BLOB. Karena sifatnya yang fixed, maka jenis ini
akan lebih cepat, aman dan stabil.
b) MyISAM dymanic. Jenis ini digunakan ketika terdapat kolom dengan tipe yang
dinamis, seperti tipe kolom VARCHAR. Keuntungan utama dari jenis ini adalah
ukuran yang dinamis. Jadi sifatnya lebih efektif karena ukuran data (file)
menyesuaikan isi dari masing-masing kolom (field).
c) MyISAM Compressed. Kedua jenis MyISAM, static dan dynamic dapat dikompresi
menjadi satu jenis yaitu MyISAM Compressed dengan perintah myisamchk.
Tentunya hasilnya lebih kecil dari segi ukuran. Tabel yang terkompresi tidak dapat
dikenakan operasi seperti INSERT, UPDATE dan DELETE.
InnoDB
Tipe tabel InnoDB merupakan tipe tabel MySQL yang mendukung proses transaksi. Tipe
ini memiliki beberapa keunggulan, antara lain:
a) Mendukung transaksi antar tabel.
b) Mendukung row-level-locking.
c) Mendukung Foreign-Key Constraints dan Crash recovery.
HEAP
Tabel dengan tipe HEAP tidak menyimpan datanya di hardisk, tetapi menyimpan di RAM
(memori). Tipe tabel ini biasanya digunakan sebagai tabel sementara (temporary). Tabel
secara otomatis akan dihapus (hilang) dari MySQL saat koneksi ke server diputus atau
server MySQL dimatikan.
Tipe Tabel yang Lain
Selain 3 (tiga) tipe tabel diatas, yaitu MyISAM, InnoDB dan HEAP, MySQL juga
mendukung tipe tabel yang lain, yaitu:
a) BDB. Tipe tabel ini mirip tipe tabel InnoDB, namun penggunaannya belum
maksimal.
Page 26
b) Archieve. Tipe ini tersedia sejak MySQL versi 4.1. Tipe ini digunakan untuk
menyimpan tabel yang terkompresi, dimana biasanya digunakan dalam proses
backup.
c) CSV. Tipe ini digunakan untuk menyimpan data dalam bentuk file text yang dibatasi
dengan koma (delimiter). Tipe ini tersedia sejak MySQL versi 4.1.
d) NDB Table (MySQL Cluster). Tersedia sejak MySQL versi 4.1.
e) Federated (External Tables). Tipe ini tersedia sejak MySQL versi 5.0.
Tipe Numeric
Tipe data numerik digunakan untuk menyimpan data numeric (angka). Ciri utama
data numeric adalah suatu data yang memungkinkan untuk dikenai operasi aritmatika
seperti pertambahan, pengurangan, perkalian dan pembagian. Berikut ini tipe field (kolom)
di MySQL yang termasuk ke dalam kelompok tipe numerik:
TINYINT
Penggunaan : digunakan untuk menyimpan data bilangan bulat positif dan negatif.
Jangkauan
Ukuran
: 1 byte (8 bit).
Page 27
SMALLINT
Penggunaan : digunakan untuk menyimpan data bilangan bulat positif dan negatif.
Jangkauan
Ukuran
MEDIUMINT
Penggunaan : digunakan untuk menyimpan data bilangan bulat positif dan negatif.
Jangkauan
Ukuran
INT
Penggunaan : digunakan untuk menyimpan data bilangan bulat positif dan negatif.
Jangkauan
Ukuran
BIGINT
Penggunaan : digunakan untuk menyimpan data bilangan bulat positif dan negatif.
Jangkauan
: 9,22 x 1018
Ukuran
FLOAT
Penggunaan : digunakan untuk menyimpan data bilangan pecahan positif dan
negatif presisi tunggal.
Jangkauan
Ukuran
DOUBLE
Penggunaan : digunakan untuk menyimpan data bilangan pecahan positif dan
negatif presisi ganda.
Jangkauan
Ukuran
Page 28
REAL
Merupakan sinonim dari DOUBLE.
DECIMAL
Penggunaan : digunakan untuk menyimpan data bilangan pecahan positif dan
negatif.
Jangkauan
Ukuran
NUMERIC
Merupakan sinonim dari DECIMAL.
Ukuran
: 3 byte.
TIME
Penggunaan : digunakan untuk menyimpan data waktu.
Jangkauan
Ukuran
: 3 byte.
DATETIME
Penggunaan : digunakan untuk menyimpan data tanggal dan waktu.
Jangkauan
Ukuran
: 8 byte.
YEAR
Page 29
Ukuran
: 1 byte.
VARCHAR
Penggunaan : digunakan untuk menyimpan data string ukuran dinamis.
Jangkauan
TINYTEXT
Penggunaan : digunakan untuk menyimpan data text.
Jangkauan
TEXT
Penggunaan : digunakan untuk menyimpan data text.
Jangkauan
MEDIUMTEXT
Penggunaan : digunakan untuk menyimpan data text.
Jangkauan
LONGTEXT
Penggunaan : digunakan untuk menyimpan data text.
Jangkauan
Page 30
: 64 digit biner
TINYBLOB
Penggunaan : digunakan untuk menyimpan data biner.
Jangkauan
: 255 byte
BLOB
Penggunaan : digunakan untuk menyimpan data biner.
Jangkauan
: 216 - 1 byte
MEDIUMBLOB
Penggunaan : digunakan untuk menyimpan data biner.
Jangkauan
: 224 - 1 byte
LONGBLOB
Penggunaan : digunakan untuk menyimpan data biner.
Jangkauan
: 232 - 1 byte
Page 31
SET
Penggunaan : combination (himpunan data).
Jangkauan
Page 32
Bab 4
Dasar-dasar SQL
Pendahuluan
Perintah DDL
Perintah DML
Pendahuluan
SQL merupakan singkatan dari Structured Query Language. SQL atau juga sering
disebut sebagai query merupakan suatu bahasa (language) yang digunakan untuk
mengakses database. SQL dikenalkan pertama kali dalam IBM pada tahun 1970 dan
sebuah standar ISO dan ANSII ditetapkan untuk SQL. Standar ini tidak tergantung pada
mesin yang digunakan (IBM, Microsoft atau Oracle). Hampir semua software database
mengenal atau mengerti SQL. Jadi, perintah SQL pada semua software database hampir
sama.
Terdapat 3 (tiga) jenis perintah SQL, yaitu :
1. DDL atau Data Definition Language
DDL merupakan perintah SQL yang berhubungan dengan pendefinisian suatu
struktur database, dalam hal ini database dan table. Beberapa perintah dasar yang
termasuk DDL ini antara lain :
CREATE
ALTER
RENAME
DROP
SELECT
INSERT
UPDATE
Page 33
DELETE
GRANT
REVOKE
Jika query di atas berhasil dieksekusi dan database berhasil dibuat, maka akan
ditampilkan pesan kurang lebih sebagai berikut :
Query OK, 1 row affected (0.02 sec)
Menampilkan Database
Untuk melihat database yang baru saja dibuat atau yang sudah ada, dapat
menggunakan perintah sebagai berikut :
SHOW DATABASES;
Hasil dari perintah di atas akan menampilkan semua database yang sudah ada di
Page 34
Membuka Database
Sebelum melakukan manipulasi tabel dan record yang berada di dalamnya, kita
harus membuka atau mengaktifkan databasenya terlebih dahulu. Untuk membuka
database penjualan, berikut ini querynya :
USE penjualan;
Jika perintah atau query di atas berhasil, maka akan ditampilkan pesan sebagai berikut :
Database changed
Menghapus Database
Untuk menghapus suatu database, sintaks umumnya adalah sbb :
DROP DATABASE [IF EXISTS] nama_database;
Bentuk
perintah
di
atas
akan
menghapus
database
dengan
nama
nama_database. Jika databasenya ada maka database dan juga seluruh tabel di
dalamnya akan dihapus. Jadi berhati-hatilah dengan perintah ini! Jika nama database
yang akan dihapus tidak ditemukan, maka akan ditampilkan pesan error. Aktifkan option
IF EXISTS untuk memastikan bahwa suatu database benar-benar ada.
Berikut ini contoh perintah untuk menghapus database dengan nama penjualan :
DROP DATABASE penjualan;
Page 35
Bentuk umum di atas merupakan bentuk umum pembuatan tabel yang sudah
disederhanakan. Penamaan tabel dan field memiliki aturan yang sama dengan penamaan
database.
Sebagai contoh, kita akan membuat tabel baru dengan struktur sebagai berikut :
Nama tabel : pelanggan
No
Nama Field
Tipe
Panjang
id_pelanggan *
Varchar
nm_pelanggan
Varchar
30
alamat
Text
telepon
Varchar
20
Varchar
50T
Untuk membuat tabel tersebut di atas, query atau perintah SQL-nya adalah sebagai
berikut :
CREATE TABLE pelanggan (
id_pelanggan varchar(5) NOT NULL,
nm_pelanggan varchar(30) NOT NULL,
alamat text,
telepon varchar (20),
email varchar (50),
PRIMARY KEY(id_pelanggan)
);
Jika query untuk membuat tabel di atas berhasil dijalankan, maka akan ditampilkan pesan
sebagai berikut :
Query OK, 0 rows affected (0.16 sec)
NOT NULL merupakan option untuk menyatakan bahwa suatu field tidak boleh
Page 36
kosong.
PRIMARY KEY merupakan perintah untuk menentukan field mana yang akan
dijadikan primary key pada tabel.
5, 10, 30 dan 50 di belakang tipe data merupakan panjang maksimal dari suatu
field.
Untuk tipe data date dan text (juga date dan blob) panjang karakter maksimalnya
tidak perlu ditentukan.
Selanjutnya untuk melihat tabel pelanggan sudah benar-benar sudah ada atau belum,
ketikkan perintah berikut ini :
SHOW TABLES;
Perintah di atas akan menampilkan seluruh tabel yang sudah ada dalam suatu database.
Contoh hasil dari perintah di atas adalah sebagai berikut :
+---------------------+
| Tables_in_penjualan |
+---------------------+
| pelanggan
|
+---------------------+
1 row in set (0.00 sec)
Untuk melihat struktur tabel pelanggan secara lebih detail, cobalah perintah atau query
sebagai berikut :
DESC pelanggan;
DESC merupakan singkatan dari DESCRIBE (dalam query bisa ditulis lengkap atau hanya
4 karakter pertama) dan pelanggan adalah nama tabel yang akan dilihat strukturnya. Dari
perintah di atas, akan ditampilkan struktur tabel pelanggan sebagai berikut :
+--------------+-------------+------+-----+---------+-------+
| Field
| Type
| Null | Key | Default | Extra |
+--------------+-------------+------+-----+---------+-------+
| id_pelanggan | varchar(5) | NO
| PRI | NULL
|
|
| nm_pelanggan | varchar(30) | NO
|
| NULL
|
|
| alamat
| text
| YES |
| NULL
|
|
| telepon
| varchar(20) | YES |
| NULL
|
|
| email
| varchar(50) | YES |
| NULL
|
|
+--------------+-------------+------+-----+---------+-------+
5 rows in set (0.00 sec)
Dari struktur tabel pelanggan yang ditampilkan di atas, dapat diketahui bahwa :
Page 37
Primary Key dari tabel pelanggan adalah id_pelanggan. Lihat kolom Key pada
field id_pelanggan.
Untuk field alamat, telepon dan email default-nya boleh kosong. Lihatlah kolom
Null dan Default pada field alamat dan telepon.
dimana :
ini
digunakan
untuk
menambahkan
field
baru
dengan
Page 38
Beberapa contoh variasi perintah ALTER untuk mengubah struktur suatu tabel
antara lain :
1. Menambahkan field tgllahir ke tabel pelanggan
ALTER TABLE pelanggan ADD tgllahir date NOT NULL;
Menghapus Tabel
Untuk menghapus sebuah tabel, bentuk umum dari perintah SQL adalah sebagai berikut :
DROP TABLE nama_tabel;
Contohnya kita akan menghapus tabel dengan nama pelanggan maka perintah SQL-nya
adalah :
DROP TABLE pelanggan;
Page 39
Sebagai contoh, kita akan menambahkan sebuah record ke dalam tabel pelanggan yang
telah kita buat sebelumnya. Berikut ini perintah SQL untuk menambahkan sebuah record
ke dalam tabel pelanggan :
INSERT INTO pelanggan VALUES ('P0001', 'Yusuf Hadiwinata','Jakarta Selatan',
'085692019009',
'yusuf.hadiwinata@gmail.com')
Jika perintah SQL di atas berhasil dieksekusi maka akan ditampilkan pesan sebagai
berikut :
Query OK, 1 row affected (0.00 sec)
Setelah perintah SQL di atas berhasil dieksekusi, maka record atau data dalam tabel
pelanggan akan bertambah. Jalankan perintah berikut ini untuk melihat isi tabel pelanggan
SELECT * FROM pelanggan;
Page 40
Perintah SET diikuti dengan field-field yang akan diubah yang mana diikuti juga
dengan perubahan isi dari masing-masing field. Untuk mengubah nilai dari
beberapa field sekaligus, gunakan koma (,) untuk memisahkan masing- masing
field.
Perintah WHERE diikuti oleh kondisi tertentu yang menentukan record mana yang
akan diedit (diubah). Perintah WHERE ini boleh ada boleh juga tidak. Jika WHERE
tidak ditambahkan pada perintah update maka semua record dalam tabel
bersangkutan akan berubah.
Perhatikan beberapa contoh perintah UPDATE tabel pelanggan berikut ini !
Dan jika query di atas berhasil dieksekusi maka akan ditampilkan hasil sebagai
berikut :
Query OK, 1 row affected (0.27 sec)
Rows matched: 1 Changed: 1 Warnings: 0
Page 41
DELETE FROM merupakan perintah dasar untuk menghapus suatu record dari
tabel.
Perintah WHERE diikuti oleh kondisi tertentu yang menentukan record mana yang
akan dihapus (didelete). Perintah WHERE ini boleh ada boleh juga tidak. Namun
demikian, jika WHERE tidak ditambahkan pada perintah delete maka semua record
dalam tabel bersangkutan akan terhapus. Jadi jangan lupa menambahkan WHERE
jika kita tidak bermaksud mengosongkan tabel
Perhatikan beberapa contoh perintah DELETE dari tabel pelanggan berikut ini !
1. Menghapus data pelanggan yang mempunyai id_pelanggan P0002
DELETE FROM pelanggan WHERE id_pelanggan='P0002';
Dan jika query di atas berhasil dieksekusi dan record yang akan dihapus ada, maka
akan ditampilkan hasil sebagai berikut :
Query OK, 1 row affected (0.11 sec)
Perhatikan beberapa contoh perintah SELECT dari tabel pelanggan berikut ini !
1. Menampilkan seluruh data atau record (*) dari tabel pelanggan
SELECT * FROM pelanggan;
Dan jika query di atas berhasil dieksekusi maka akan ditampilkan hasil sebagai
berikut :
+--------------+------------------+---------------+--------------+----------------------------+
| id_pelanggan | nm_pelanggan
| alamat
| telepon
| email
|
+--------------+------------------+---------------+--------------+----------------------------+
| P0001
| Yusuf Hadiwinata | Bekasi
| 085692019009 | yusuf.hadiwinata@gmail.com |
| P0002
| Yoga Rimaldo
| Bandung
| 08571239501 | yoga@computradetech.com
|
| P0003
| Winny
| Jakarta Barat | 0815829221
| winny@computradetech.com
|
| P0004
| Ninda Budianto
| Jakarta Timur | 08171231234 | ninda@computradetech.com
|
+--------------+------------------+---------------+--------------+----------------------------+
4 rows in set (0.00 sec)
Jika query di atas berhasil dieksekusi maka akan ditampilkan hasil sebagai berikut :
+--------------+------------------+
| id_pelanggan | nm_pelanggan
|
+--------------+------------------+
| P0001
| Yusuf Hadiwinata |
| P0002
| Yoga Rimaldo
|
| P0003
| Winny
|
| P0004
| Ninda Budianto
|
+--------------+------------------+
4 rows in set (0.00 sec)
3. Menampilkan id, nama dan alamat dari data pelanggan yang mempunyai id P0004
SELECT id_pelanggan, nm_pelanggan, alamat
FROM pelanggan WHERE id_pelanggan = 'P0004';
Page 43
+--------------+----------------+---------------+
| id_pelanggan | nm_pelanggan
| alamat
|
+--------------+----------------+---------------+
| P0004
| Ninda Budianto | Jakarta Timur |
+--------------+----------------+---------------+
1 row in set (0.00 sec)
4. Menampilkan id, nama dan email data semua pelanggan yang mempunyai email di
gmail
SELECT id_pelanggan, nm_pelanggan, email
FROM pelanggan WHERE email LIKE '%gmail%';
Operator != atau <>, akan bernilai TRUE jika nilai yang dibandingkan TIDAK SAMA
(berbeda).
Operator >, akan bernilai TRUE jika nilai yang pertama lebih besar dari nilai kedua.
Operator >=, akan bernilai TRUE jika nilai yang pertama lebih besar atau sama
dengan nilai kedua.
Operator <, akan bernilai TRUE jika nilai yang pertama lebih kecil dari nilai kedua.
Operator <=, akan bernilai TRUE jika nilai yang pertama lebih kecil atau sama
dengan nilai kedua.
Page 44
+--------------+--------------+---------------+---------------+
| P0005
| Rea
| Jakarta Timur | rea@gmail.com |
+--------------+--------------+---------------+---------------+
1 row in set (0.00 sec)
Operator && atau AND, akan menghubungkan dua kondisi dimana akan
bernilai TRUE jika kedua kondisi bernilai TRUE.
Page 45
Keterangan
Pada query di atas bentuk LIMIT digunakan untuk membatasi hasil tampilan. LIMIT
banyak digunakan untuk menampilkan data yang relatif banyak. Format fungsi LIMIT
adalah sebagai berikut :
LIMIT awal, jumlah_record
9. Menampilkan jumlah record yang ada di tabel pelanggan.
SELECT COUNT(*)FROM pelanggan;
Bab 5
Page 46
Fungsi-fungsi MySQL
Fungsi String
Fungsi Numerik
Fungsi Lainnya
Fungsi String
MySQL memiliki banyak sekali fungsi yang berhubungan dengan operasi String.
Berikut ini beberapa fungsi string yang disediakan MySQL.
Hasil keluarannya:
+------------------+----------------------------+
| nm_pelanggan
| CONCAT(alamat,' ',telepon) |
+------------------+----------------------------+
| Yusuf Hadiwinata | Bekasi 085692019009
|
| Yoga Rimaldo
| Bandung 08571239501
|
| Winny
| Jakarta Barat 0815829221
|
| Ninda Budianto
| Jakarta Timur 08171231234 |
| Rea
| Jakarta Timur 085512312345 |
+------------------+----------------------------+
5 rows in set (0.04 sec)
Hasil keluarannya:
Yusuf, Yoga, Rea
Page 47
Hasil keluarannya:
Budi
LENGTH (string)
OCTET_LENGTH (string)
CHAR_LENGTH (string)
CHARACTER_LENGTH (string)
Fungsi ini digunakan untuk menghitung panjang suatu string. Contoh:
SELECT LENGTH ('Budi Luhur');
Hasil keluarannya:
5
Hasil keluarannya:
Budi
Page 48
karakter. Contoh:
SELECT RIGHT ('Budi Luhur', 4);
Hasil keluarannya:
Uhur
LTRIM (string)
Fungsi ini digunakan untuk menghilangkan spasi di awal string (kiri).
Contoh:
SELECT LTRIM (' Budi Luhur');
Hasil keluarannya:
Budi Luhur
RTRIM (string)
Fungsi ini digunakan untuk menghilangkan spasi di akhir string (kanan).
Contoh:
SELECT RTRIM ('Budi Luhur ');
Hasil keluarannya:
Budi Luhur
TRIM (string)
Fungsi ini digunakan untuk menghilangkan spasi di awal dan akhir string (kiri dan
kanan). Contoh:
SELECT TRIM (' Budi Luhur ');
Hasil keluarannya:
Budi Luhur
Page 49
Contoh:
SELECT REPLACE ('www.mysql.com', 'w', 'x' );
Hasil keluarannya:
xxx.mysql.com
Hasil keluarannya:
MontMontMont
REVERSE (string)
Fungsi ini digunakan untuk membalik string. Contoh:
SELECT REVERSE ('mysql.com');
Hasil keluarannya:
moc.lqsym
LCASE (string)
LOWER (string)
Fungsi ini digunakan untuk mengubah string menjadi huruf kecil (lower- case).
Contoh:
SELECT LOWER ('MySQL');
Hasil keluarannya:
Mysql
UCASE (string)
UPPER (string)
Page 50
Fungsi ini digunakan untuk mengubah string menjadi huruf kapital (upper- case).
Contoh:
SELECT UPPER ('mysql');
Hasil keluarannya:
MYSQL
NOW ()
SYSDATE()
Fungsi ini digunakan untuk mendapatkan tanggal dan waktu sistem sekarang
Contoh:
SELECT NOW();
Hasil keluarannya:
2015-03-31 20:00:31
MONTH (tanggal)
Fungsi ini digunakan untuk mendapatkan urutan bulan (integer) dari suatu tanggal
yang diberikan dalam setahun, dimana 1=Januari, 2=Februari, dst. Contoh:
SELECT MONTH (1982-06-05);
Hasil keluarannya:
6
WEEK (tanggal)
Fungsi ini digunakan untuk mendapatkan urutan minggu (integer) dari suatu tanggal
Page 51
Hasil keluarannya:
22
YEAR (tanggal)
Fungsi ini digunakan untuk mendapatkan bilangan tahun dari suatu tanggal yang
diberikan. Contoh:
SELECT YEAR (now());
Hasil keluarannya:
2015
HOUR (waktu)
Fungsi ini digunakan untuk mendapatkan bilangan jam dari suatu parameter waktu
yang diberikan. Contoh:
SELECT HOUR (now());
Hasil keluarannya:
20
MINUTE (waktu)
Fungsi ini digunakan untuk mendapatkan bilangan menit dari suatu parameter
waktu yang diberikan. Contoh:
SELECT MINUTE (now());
Hasil keluarannya:
8
SECOND (waktu)
Fungsi ini digunakan untuk mendapatkan bilangan detik dari suatu waktu yang
Page 52
diberikan. Contoh:
SELECT SECOND (now());
Hasil keluarannya:
53
Hasil keluarannya:
2015-03-31 20:12:17
DATE_FORMAT(date, format)
Fungsi ini digunakan untuk mem-format tampilan tanggal.
TIME_FORMAT(time, format)
Fungsi ini digunakan untuk mem-format tampilan waktu.
Berikut ini format tampilan tanggal dan waktu, dan penggunaannya:
%M
%W
%D
%Y
: Tahun, 4 digit
%y
: Tahun, 2 digit
%a
%H
%i
: Menit, 00-59
%s
: Detik, 00-59
Hasil keluarannya:
Page 53
31-03-2015 20:12:17
Fungsi Numerik
MySQL memiliki fungsi-fungsi yang berhubungan dengan operasi numerik, berikut
ini contohnya:
OPERASI ARITMATIKA
Operasi aritmatika dalam MySQL terdiri dari:
+
: Pertambahan
: Pengurangan
: Perkalian
: Pembagian
Contoh penggunaan:
SELECT 10+20;
Hasil keluarannya:
30
SELECT 10/3;
Hasil keluarannya:
3.3333
ABS(x)
Fungsi digunakan untuk mengambil nilai absolut dari bilangan x. Contoh:
SELECT ABS(-20);
Hasil keluarannya:
20
Page 54
MOD(m, n)
Fungsi digunakan untuk mengoperasikan m modulus n. Contoh:
SELECT MOD(10,3);
Hasil keluarannya:
1
FLOOR(x)
Fungsi digunakan untuk mengambil nilai integer terbesar yang tidak lebih besar dari
x. Contoh:
SELECT FLOOR(10.3576);
Hasil keluarannya:
10
CEILING(x)
Fungsi digunakan untuk mengambil nilai integer terkecil yang tidak lebih kecil dari x.
Contoh:
SELECT CEILING(10.3576);
Hasil keluarannya:
11
ROUND(x)
ROUND(x, d)
Fungsi digunakan untuk melakukan pembulatan bilangan x sebanyak d tempat
presisi. Contoh:
SELECT ROUND(10.3576, 2);
Hasil keluarannya:
10.36
POW(x)
POWER(x, n)
Page 55
Hasil keluarannya:
1024
RAND()
RAND(x)
Fungsi digunakan untuk mengambil nilai random diantara 0 s/d 1.0. Contoh:
SELECT RAND();
Hasil keluarannya:
0.96589817662341
TRUNCATE(x, d)
Fungsi digunakan untuk memotong bilangan x sepanjang d tempat desimal.
Contoh:
SELECT TRUNCATE(10.28372, 1);
Hasil keluarannya:
10.2
Fungsi Lainnya
Selain fungsi yang berhubungan dengan string, date-and-time, dan numerik MySQL
juga memiliki fungsi-fungsi khusus, diantaranya :
Page 56
Hasil keluarannya:
7
COUNT(range)
Fungsi digunakan untuk mengambil jumlah baris dari suatu query. Contoh:
SELECT COUNT(*) FROM pelanggan;
Hasil keluarannya:
5
MAX(range)
Fungsi digunakan untuk mengambil nilai terbesar dari suatu ekspresi (query).
Contoh:
SELECT MAX(nilai) FROM nilai_ujian;
Hasil keluarannya:
93
MIN(range)
Fungsi digunakan untuk mengambil nilai terkecil dari suatu ekspresi (query).
Contoh:
SELECT MIN(nilai) FROM nilai_ujian;
Hasil keluarannya:
40
SUM(range)
Fungsi digunakan untuk menjumlahkan total nilai dari suatu ekspresi (query).
Contoh:
SELECT SUM(nilai) FROM nilai_ujian;
Hasil keluarannya:
450
Page 57
AVG(range)
Fungsi digunakan untuk menghitung rata-rata nilai dari suatu ekspresi (query).
Contoh:
SELECT AVG(nilai) FROM nilai_ujian;
Hasil keluarannya:
78
OPERASI BITWISE
Operasi bitwise dalam MySQL terdiri dari:
|
: Bitwise OR
&
: Bitwise AND
<<
: Shift Kiri
>>
: Shift Kanan
: Invert, negasi
Contoh penggunaan:
SELECT 4 | 2;
Hasil keluarannya:
6
DATABASE()
Fungsi digunakan untuk mengambil nama database yang sedang aktif (terbuka).
Contoh:
SELECT DATABASE();
Hasil keluarannya:
Penjualan
USER()
SYSTEM_USER()
Page 58
SESSION_USER()
Fungsi digunakan untuk mengambil user yang sedang digunakan (aktif).
Contoh:
SELECT USER();
Hasil keluarannya:
root@localhost
PASSWORD(str)
Fungsi digunakan untuk melakukan enkripsi suatu string. Sifat utama dari fungsi
password() ini adalah hasilnya selalu sama untuk setiap string yang sama. String
hasil dari fungsi password() tidak dapat di-decript (decode). Biasanya fungsi ini
digunakan untuk menyimpan password login.
Contoh:
SELECT PASSWORD('qwerty');
Hasil keluarannya:
*AA1420F182E88B9E5F874F6FBE7459291E8F4601
ENCODE(str, pass)
Fungsi digunakan untuk melakukan enkripsi suatu string str menggunakan
password atau key pass. Contoh:
SELECT ENCODE('qwerty', 'password');
Hasil keluarannya:
WkPH:
DECODE(encripted_str, pass)
Fungsi
digunakan
untuk
melakukan
dekripsi
suatu
string
encripted_str
menggunakan password atau key pass. Jika passwordnya benar, maka string
aslinya akan benar. Contoh:
SELECT DECODE('ce|', 'password');
Hasil keluarannya:
Page 59
Qwerty
Hasil keluarannya:
WkPH:
MD5(str)
Fungsi digunakan untuk melakukan enkripsi suatu string str menggunakan metode
md5. Fungsi ini juga tidak dapat didekripsi. Contoh:
SELECT MD5('qwerty');
Hasil keluarannya:
d8578edf8458ce06fbc5bb76a58c5ca4
LAST_INSERT_ID()
Fungsi digunakan untuk mengambil id terakhir dalam proses insert dimana tabelnya
mengandung field yang bersifat AUTO INCREMENT. Contoh:
SELECT LAST_INSERT_ID();
Hasil keluarannya:
231
VERSION()
Fungsi digunakan untuk mengambil versi MySQL yang digunakan. Contoh:
SELECT VERSION();
Hasil keluarannya:
5.0.45-community-nt
Page 60
Bagian 3
Bab 6
Perintah MySQL Lanjutan
Page 61
HAVING
SubSELECT
Transaksi
Pada bab ini akan dijelaskan beberapa perintah SQL lanjutan yang lebih kompleks
seperti join antar tabel, grouping, sub select, random search dan transaksi (commit-androolback). Untuk mempermudah penjelasan, maka semua contoh yang disajikan di bab ini
mengacu pada pemodelan data konseptual Sistem Pemesanan (Penjualan) Barang sbb:
Untuk membuat tabel-tabel dari rancangan di atas, kita akan menggunakan tipe tabel
InnoDB karena nantinya kita akan menggunakan transaksi di sistem tersebut. Dan berikut
ini spesifikasi basis data dari pemodelan data konseptual di atas:
DROP TABLE IF EXISTS detil_pesan;
CREATE TABLE detil_pesan (
id_pesan int(5) NOT NULL,
id_produk varchar(5) NOT NULL,
jumlah int(5) NOT NULL default '0',
harga decimal(10,0) NOT NULL default '0',
PRIMARY KEY (id_pesan,id_produk),
KEY FK_pesan (id_produk),
KEY id_pesan (id_pesan),
CONSTRAINT FK_pesan FOREIGN KEY (id_produk)
REFERENCES produk (id_produk),
Page 62
Page 63
Inner Join
Dengan inner join, tabel akan digabungkan dua arah, sehingga tidak ada data yang
NULL di satu sisi. Sebagai contoh, kita akan menggabungkan tabel pelanggan dan pesan
dimana kita akan menampilkan daftar pelanggan yang pernah melakukan pemesanan
(transaksi). Isi tabel pelanggan dan pesan adalah sebagai berikut :
Tabel pelanggan (hanya ditampilkan id, nama dan email).
+--------------+------------------+---------------+--------------+----------------------------+
| id_pelanggan | nm_pelanggan
| alamat
| telepon
| email
|
+--------------+------------------+---------------+--------------+----------------------------+
| P0001
| Yusuf Hadiwinata | Bekasi
| 085692019009 | yusuf.hadiwinata@gmail.com |
| P0002
| Yoga Rimaldo
| Bandung
| 08571239501 | yoga@computradetech.com
|
| P0003
| Winny
| Jakarta Barat | 0815829221
| winny@computradetech.com
|
| P0004
| Ninda Budianto
| Jakarta Timur | 08171231234 | ninda@computradetech.com
|
+--------------+------------------+---------------+--------------+----------------------------+
4 rows in set (0.00 sec)
Tabel pesan:
+----------+--------------+------------+
Page 64
Berikut ini perintah SQL untuk menggabungkan tabel pelanggan dan pesan:
SELECT pelanggan.id_pelanggan, pelanggan.nm_pelanggan,
pesan.id_pesan, pesan.tgl_pesan
FROM pelanggan, pesan
WHERE pelanggan.id_pelanggan=pesan.id_pelanggan;
Hasilnya :
+--------------+------------------+----------+------------+
| id_pelanggan | nm_pelanggan
| id_pesan | tgl_pesan |
+--------------+------------------+----------+------------+
| P0001
| Yusuf Hadiwinata |
1 | 2008-02-02 |
| P0002
| Yoga Rimaldo
|
2 | 2008-02-05 |
| P0002
| Yoga Rimaldo
|
3 | 2008-02-10 |
| P0004
| Ninda Budianto
|
4 | 2008-01-20 |
| P0004
| Ninda Budianto
|
5 | 2007-12-14 |
+--------------+------------------+----------+------------+
5 rows in set (0.01 sec)
Pada hasil perintah query di atas terlihat bahwa terdapat 5 (lima) transaksi yang dilakukan
oleh 3 (tiga) orang pelanggan. Jika kita lihat kembali isi tabel pelanggan di atas, maka
terdapat satu pelanggan yang tidak ditampilkan yaitu yang memiliki id pelanggan P0003.
Pelanggan tersebut tidak ditampilkan karena belum pernah melakukan transaksi.
Berikut ini perintah SQL untuk menggabungkan tabel pelanggan dan pesan:
Page 65
Hasilnya:
+--------------+------------------+----------+------------+
| id_pelanggan | nm_pelanggan
| id_pesan | tgl_pesan |
+--------------+------------------+----------+------------+
| P0001
| Yusuf Hadiwinata |
1 | 2008-02-02 |
| P0002
| Yoga Rimaldo
|
2 | 2008-02-05 |
| P0002
| Yoga Rimaldo
|
3 | 2008-02-10 |
| P0004
| Ninda Budianto
|
4 | 2008-01-20 |
| P0004
| Ninda Budianto
|
5 | 2007-12-14 |
+--------------+------------------+----------+------------+
5 rows in set (0.00 sec)
Outer Join
Dengan outer join, tabel akan digabungkan satu arah, sehingga memungkinkan ada
data yang NULL (kosong) di satu sisi. Sebagai contoh, kita akan menggabungkan tabel
pelanggan dan pesan dimana kita akan menampilkan daftar pelanggan yang pernah
melakukan pemesanan (transaksi).
Outer Join terbagi menjadi 2 (dua) yaitu LEFT JOIN dan RIGHT. Berikut ini bentuk
umum dan contohnya:
LEFT JOIN
Bentuk umum
SELECT tabel1.*, tabel2.*
FROM tabel1 LEFT JOIN tabel2
ON tabel1.PK=tabel2.FK;
Berikut ini perintah SQL untuk menggabungkan tabel pelanggan dan pesan:
SELECT pelanggan.id_pelanggan, pelanggan.nm_pelanggan,
pesan.id_pesan, pesan.tgl_pesan
FROM pelanggan LEFT JOIN pesan
ON pelanggan.id_pelanggan=pesan.id_pelanggan;
Hasilnya :
+--------------+------------------+----------+------------+
| id_pelanggan | nm_pelanggan
| id_pesan | tgl_pesan |
+--------------+------------------+----------+------------+
| P0001
| Yusuf Hadiwinata |
1 | 2008-02-02 |
| P0002
| Yoga Rimaldo
|
2 | 2008-02-05 |
| P0002
| Yoga Rimaldo
|
3 | 2008-02-10 |
| P0003
| Winny
|
NULL | NULL
|
Page 66
| P0004
| Ninda Budianto
|
4 | 2008-01-20 |
| P0004
| Ninda Budianto
|
5 | 2007-12-14 |
+--------------+------------------+----------+------------+
6 rows in set (0.00 sec)
Berbeda dengan hasil sebelumnya (inner join), penggunaan left join akan menampilkan
juga data pelanggan dengan id P0003, walaupun pelanggan tersebut belum pernah
bertransaksi. Dan pada kolom id_pesan dan tgl_pesan untuk pelanggan P0003 isinya
NULL, artinya di tabel kanan (pesan) pelanggan tersebut tidak ada.
RIGHT JOIN
Bentuk umum
SELECT tabel1.*, tabel2.*
FROM tabel1 RIGHT JOIN tabel2
ON tabel1.PK=tabel2.FK;
Berikut ini perintah SQL untuk menggabungkan tabel pelanggan dan pesan:
SELECT pelanggan.id_pelanggan, pelanggan.nm_pelanggan,
pesan.id_pesan, pesan.tgl_pesan
FROM pelanggan RIGHT JOIN pesan
ON pelanggan.id_pelanggan=pesan.id_pelanggan;
Hasilnya :
+--------------+------------------+----------+------------+
| id_pelanggan | nm_pelanggan
| id_pesan | tgl_pesan |
+--------------+------------------+----------+------------+
| P0001
| Yusuf Hadiwinata |
1 | 2008-02-02 |
| P0002
| Yoga Rimaldo
|
2 | 2008-02-05 |
| P0002
| Yoga Rimaldo
|
3 | 2008-02-10 |
| P0004
| Ninda Budianto
|
4 | 2008-01-20 |
| P0004
| Ninda Budianto
|
5 | 2007-12-14 |
+--------------+------------------+----------+------------+
5 rows in set (0.00 sec)
Dengan right join, tabel yang menjadi acuan adalah tabel sebelah kanan (tabel pesan),
jadi semua isi tabel pesan akan ditampilkan. Jika data pelanggan tidak ada di tabel
pelanggan, maka isi tabel pesan tetap ditampilkan.
Page 67
Hasilnya:
+----------+-----------+------------+-------+--------+
| id_pesan | id_produk | nm_produk | harga | jumlah |
+----------+-----------+------------+-------+--------+
|
1 | B0001
| Buku Tulis | 2700 |
2 |
|
1 | B0003
| Penggaris | 3000 |
3 |
|
1 | B0004
| Pensil
| 2000 |
1 |
+----------+-----------+------------+-------+--------+
3 rows in set (0.01 sec)
Hasilnya:
+----------+------------+--------+
| id_pesan | tgl_pesan | jumlah |
+----------+------------+--------+
|
1 | 2008-02-02 |
2 |
|
1 | 2008-02-02 |
3 |
|
1 | 2008-02-02 |
1 |
+----------+------------+--------+
3 rows in set (0.00 sec)
Jika kita perhatikan hasil perintah query di atas, kita akan mendapatkan jumlah
barang yang terjadi untuk setiap transaksi, namun hasil tampilannya masih per-barang.
Artinya jumlah yang ditampilkan masih berupa jumlah barang untuk masing-masing
barang.
Agar
menggunakan fungsi GROUP BY dan juga SUM untuk menjumlahkan jumlah barang.
Berikut ini perintah query dengan group by dan count.
Page 68
Hasilnya:
+----------+------------+--------+
| id_pesan | tgl_pesan | jumlah |
+----------+------------+--------+
|
1 | 2008-02-02 |
6 |
+----------+------------+--------+
1 row in set (0.05 sec)
Selain hasil di atas, kita juga dapat menggunakan tambahan WITH ROLLUP di belakang
group by untuk menampilkan jumlah total seluruh barang. Berikut ini perintah query dan
hasilnya:
SELECT pesan.id_pesan, pesan.tgl_pesan,
SUM(detil_pesan.jumlah) as jumlah
FROM pesan, detil_pesan
WHERE pesan.id_pesan=detil_pesan.id_pesan
GROUP BY id_pesan WITH ROLLUP;
Hasilnya:
+----------+------------+--------+
| id_pesan | tgl_pesan | jumlah |
+----------+------------+--------+
|
1 | 2008-02-02 |
6 |
|
NULL | 2008-02-02 |
6 |
+----------+------------+--------+
2 rows in set (0.03 sec)
HAVING
Perintah query berikut ini akan menampilkan jumlah item (jenis) barang untuk tiap
transaksi.
SELECT pesan.id_pesan, COUNT(detil_pesan.id_produk) as jumlah
FROM pesan, detil_pesan
WHERE pesan.id_pesan=detil_pesan.id_pesan
GROUP BY pesan.id_pesan ;
Hasilnya:
+----------+--------+
Page 69
| id_pesan | jumlah |
+----------+--------+
|
1 |
3 |
+----------+--------+
1 row in set (0.00 sec)
Dari hasil query di atas tampak bahwa ditampilkan jumlah item barang untuk semua
transaksi. Selanjutnya bagaimana jika kita ingin hanya menampilkan data yang jumlah
item barangnya lebih dari 2 (dua)? Mungkin kita langsung berfikir untuk menggunakan
WHERE seperti perintah query sebagai berikut:
SELECT pesan.id_pesan, COUNT(detil_pesan.id_produk) as jumlah
FROM pesan, detil_pesan
WHERE pesan.id_pesan=detil_pesan.id_pesan
AND jumlah > 2
GROUP BY pesan.id_pesan ;
Hasilnya ternyata tidak sesuai yang diinginkan. Lihat hasilnya sebagai berikut:
+----------+--------+
| id_pesan | jumlah |
+----------+--------+
|
1 |
1 |
+----------+--------+
1 row in set (0.00 sec)
Hal tersebut terjadi karena kondisi dalam WHERE tidak dapat diterapkan pada fungsi
agregrasi seperti COUNT, SUM, AVG dll. Untuk menyeleksi suatu fungsi agregasi, kita
tidak dapat menggunakan WHERE, namun kita dapat menggunakan HAVING. Berikut ini
perintah query yang menggunakan HAVING:
SELECT pesan.id_pesan, COUNT(detil_pesan.id_produk) as jumlah
FROM pesan, detil_pesan
WHERE pesan.id_pesan=detil_pesan.id_pesan
GROUP BY pesan.id_pesan
HAVING jumlah > 2 ;
Page 70
SubSELECT
Mulai versi 4.1, MySQL mendukung perintah query SubSELECT dimana
memungkinkan untuk melakukan query di dalam query. Misalnya kita akan menampilkan
data yang kondisinya merupakan hasil dari query lain.
Perintah SubSELECT memiliki banyak variasi. Berikut ini beberapa variasi bentuk
perintah SubSELECT.
SELECT
SELECT
SELECT
SELECT
SELECT
Dan berikut ini beberapa contoh perintah query yang menggunakan SubSELECT.
Hasilnya:
+----------+--------+
| id_pesan | jumlah |
+----------+--------+
|
1 |
3 |
+----------+--------+
1 row in set (0.00 sec)
Page 71
Transaksi
MySQL merupakan software database berbasis client-server. Hal ini berarti bahwa
beberapa client dapat melakukan koneksi ke server MySQL secara bersamaan. Masingmasing client dapat melakukan select, insert, update, maupun delete data di server
MySQL. Hal ini tentunya dapat menjadi masalah jika terjadi bentrok antar-client.
Sebagai contoh dalam proses transaksi pemesanan barang. Jika terdapat 2 (dua)
pelanggan melakukan transaksi pada waktu yang sama, misalnya melakukan pemesanan
barang. Keduanya akan menambahkan data di tabel yang sama dan mungkin saja data
yang dimasukkan tertukar atau tidak valid. Hal ini tidak akan terjadi jika pada saat satu
pelanggan melakukan transaksi, pelanggan yang lain harus menunggu sampai proses
transaksi selesai.
Untuk mengatur proses query yang terjadi dalam suatu sistem yang memiliki user
banyak (multi-user-system), kita dapat memanfaatkan dua hal di MySQL. Pertama kita
dapat mengunci tabel (table-locking). Cara ini dapat dilakukan jika tipe tabel yang
digunakan adalah MyISAM. Kedua, dapat menggunakan perintah BEGIN, COMMIT dan
Page 72
ROLLBACK. Cara ini dapat dilakukan jika tipe tabel adalah tabel transaksi, yaitu InnoDB.
Terdapat 4 (empat) prinsip dasar transaksi yang biasa disingkat sebagai ACID,
yaitu:
Atomicity.
Atom merupakan komponen terkecil dari materi, atau sesuatu yang tidak dapat
dibagi-bagi lagi. Prinsip ini berlaku pada proses transaksi. Semua proses (perintah)
yang ada di dalam satu paket transaksi harus selesai semua atau tidak selesai
sama sekali. Dengan kata lain, dalam satu transaksi tidak boleh ada proses
(perintah) yang gagal dieksekusi.
Consistency.
Bahwa kegagalan satu proses dalam transaksi tidak akan mempengaruhi transaksi
lainnya.
Isolation.
Secara sederhana, bahwa data yang sedang digunakan dalam satu transaksi, tidak
dapat digunakan oleh transaksi lainnya sebelum seluruh proses transaksi yang
pertama selesai.
Durability.
Jika sebuah transaksi selesai dieksekusi, hasilnya tetap tercatat dengan baik.
Mengunci Tabel
Mengunci tabel (table-locking) dapat dilakukan untuk membatasi akses terhadap
suatu tabel jika ada user yang sedang aktif mengakses tabel. Suatu tabel yang sedang
terkunci (locked), tidak dapat diakses dengan bebas oleh user lain. Untuk mengunci tabel
di MySQL dapat menggunakan kata kunci LOCK.
Bentuk umum perintah LOCK :
LOCK TABLE table1 locktype, table2 locktype, ...;
Page 73
tidak dapat diubah oleh siapapun, termasuk user yang mengeksekusi perintah
LOCK. Dengan kata lain, tabel bersifat read-only.
READ LOCAL.
Sama seperti READ, tetapi perintah INSERT dapat dilakukan selama tidak merubah
record (data) yang ada.
WRITE.
User yang aktif diperbolehkan untuk membaca dan mengubah tabel (read-andwrite). User yang lain tidak dapat mengubah isi tabel, hanya dapat membaca tabel
(read-only).
LOW PRIORITY WRITE.
Seperti halnya WRITE, hanya saja user lain dapat melakukan READ LOCK.
Untuk membuka tabel yang terkunci, gunakan perintah UNLOCK TABLES;
Contoh table-locking:
LOCK TABLES trans READ, customer WRITE;
SELECT sum(value) FROM trans WHERE customer_id= some_id;
UPDATE customer SET total_value=total
WHERE customer_id=some_id;
UNLOCK TABLES;
Page 74
Contoh :
SET AUTOCOMMIT=0;
BEGIN;
INSERT INTO pesan VALUES(NULL,'P0001',now());
SET @id := LAST_INSERT_ID();
INSERT INTO detil_pesan VALUES (@id,'B0001','2','2500');
COMMIT;
Page 75
Bab 7
Administrasi dan Keamanan di MySQL
Keamanan di MySQL
Keamanan di MySQL
Masalah keamanan (security) di MySQL merupakan hal yang tidak boleh dianggap
sepele apalagi dikesampingkan. MySQL merupakan software database yang bersifat
client-server, yang memungkinkan beberapa user dapat mengakses server MySQL dari
mana pun. Untuk itu, server MySQL harus benar-benar aman dari akses (serangan)
orang-orang yang tidak berhak.
Berikut ini beberapa hal yang harus diperhatikan dalam mengamankan server
MySQL:
1. JANGAN PERNAH MEMBERI AKSES KE SEMUA USER (KECUALI USER root)
untuk dapat mengakses database mysql. Jika seseorang dapat mengakses
database ini, maka dia dapat melihat informasi user (termasuk user, password dan
host) MySQL dan (mungkin) dapat menambah atau mengubah informasi tersebut.
2. Pelajari mengenai hak akses di MySQL. Perintah GRANT dan REVOKE digunakan
untuk mengatur hak akses di MySQL. Sebisa mungkin jangan memberikan hak
akses ke MySQL pada semua host (%). Dan cobalah untuk mengecek dengan:
a) Cobalah login dengan perintah mysql -u root. Jika berhasil login ke server, maka
hal ini bisa menjadi masalah besar, karena password root masih kosong
sehingga semua user dapat mengakses server MySQL.
b) Gunakan perintah SHOW GRANTS untuk melihat semua hak akses user.
3. Jangan pernah menyimpan password dalam bentuk teks biasa di MySQL! Gunakan
fungsi enkripsi searah seperti fungsi PASSWORD() dan MD5() untuk mengenkripsi
isi password. Kita tidak dapat menjamin 100% bahwa server kita aman dari
Page 76
penyusup (intruder).
4. Hati-hati dalam memilih password. Pilihlah password yang mudah diingat tapi sulit
ditebak oleh orang lain. Dan juga jangan gunakan kata-kata yang ada di kamus,
gunakanlah kombinasi angka dan huruf.
5. Pasang firewall di server untuk mencegah penyusup. Hal ini dapat mencegah
setidaknya 50% dari program penyusup yang ada.
6. Jangan percaya sepenuhnya terhadap data yang dimasukkan oleh user. Akan lebih
baik jika kita menganggap bahwa semua user adalah jahat. Lakukan validasi data
sebelum dimasukkan ke database. Hal ini biasanya dapat dilakukan di dalam
bahasa pemrograman yang digunakan.
7. Hati-hati dalam mengirim atau mentransfer data lewat internet, karena mungkin ada
orang lain yang dapat membajak data tersebut.
Dalam hal pengamanan server MySQL, setidaknya ada beberapa faktor yang
mempengaruhi. Kita belum cukup jika mengamankan satu sisi (faktor) saja, tetapi harus
menyeluruh. Berikut ini beberapa faktor tersebut:
1. Server atau komputer tempat MySQL berada. Server tempat MySQL diinstall
tentunya menjadi gerbang utama bagi penyusup (intruder). Untuk ini kita harus
benar-benar memperhatikan faktor keamanan server. Kita dapat
memasang
Page 77
Page 78
procedure.
proc.
Tabel ini digunakan untuk menyimpan informasi mengenai daftar procedure dalam
MySQL.
func.
Tabel ini digunakan untuk menyimpan informasi mengenai function yang
didefinisikan di MySQL.
Berikut ini pilihan untuk priv_type dalam bentuk umum perintah GRANT dan REVOKE di
atas:
ALL PRIVILEGES
ALTER
CREATE
DELETE
DROP
FILE
INDEX
INSERT
PROCESS
REFERENCES
RELOAD
SELECT
SHUTDOWN
UPDATE
USAGE
Perintah GRANT dan REVOKE dapat digunakan untuk membuat user baru
maupun
mengatur hak akses user yang sudah ada dengan hak akses (privileges ) tertentu.
Tingkatan hak akses user dapat terbagi menjadi tingkatan global (tersimpan di tabel
mysql.user), database (tersimpan di tabel mysql.host dan mysql.db), tabel (tersimpan di
tabel mysql.tables_priv) dan kolom (tersimpan di tabel mysql.columns_priv).
Setiap perubahan hak akses di MySQL, termasuk menambahkan user baru, tidak
akan berlaku sebelum diakhiri dengan perintah FLUSH PRIVILEGES.
Page 79
Menambahkan user baru dengan nama user monty yang dapat mengakses
semua database dari komputer localhost dengan password qwerty. User ini juga
berhak menjalankan perintah GRANT untuk user lain.
Menambahkan user baru dengan nama user adinda, tidak dapat mengakses
database (*.*), hanya dapat mengakses dari komputer dengan IP 192.168.1.5 dan
password qwerty.
Menambahkan user baru dengan nama user admin, hanya dapat mengakses
database mysql, hanya dapat mengakses dari komputer localhost dan dengan
password qwerty.
Berikut ini beberapa contoh mengatur hak akses user yang sudah ada di MySQL:
Mengubah hak akses user adinda agar dapat mengakses database penjualan.
Mengubah hak akses user admin agar dapat CREATE di database penjualan.
Page 80
diekripsi
Page 81
Bab 8
Trigger dan Views
Triggers
Views
Trigger
Trigger digunakan untuk memanggil satu atau beberapa perintah SQL secara
otomatis sebelum atau sesudah terjadi proses INSERT, UPDATE atau DELETE dari suatu
tabel. Sebagai contoh misalnya kita ingin menyimpan id pelanggan secara otomatis ke
tabel log sebelum menghapus data di tabel pelanggan.
Triggers mulai dikenal di versi MySQL 5.0, dan di versi saat ini fungsionalitasnya
sudah bertambah. Pada versi selanjutnya (5.1) pihak pengembang MySQL berjanji akan
lebih menguatkan (menambah) fitur trigger ini.
Trigger sering digunakan, antara lain untuk:
Melakukan update data otomatis jika terjadi perubahan. Contohnya adalah dalam
sistem penjualan, jika dientri barang baru maka stock akan bertambah secara
otomatis.
Trigger dapat digunakan untuk melakukan validasi dan verifikasi data sebelum data
tersebut disimpan
dimana
BEFORE | AFTER digunakan untuk menentukan kapan proses secara otomatis akan
Page 82
Menghapus Trigger
Untuk menghapus trigger, dapat menggunakan perintah DROP TRIGGER dengan
diikuti dengan nama tabel dan nama triggernya. Berikut ini bentuk umum dan contoh
perintah untuk menghapus trigger.
DROP TRIGGER tablename.triggername;
Contoh :
DROP TRIGGER penjualan.before_insert;
Page 83
View
Views di MySQL mulai disediakan pada versi 5.0. Views merupakan suatu tampilan
tabel virtual. Views berisi perintah SELECT ke tabel dalam database. Views dapat
digunakan untuk mempermudah kita dalam pembuatan laporan atau tampilan database
yang diinginkan dengan cepat. Dengan kata lain, views merupakan perintah SELECT
yang disimpan, sehingga setiap saat kita membutuhkannya, kita dapat langsung
memanggilnya tanpa perlu mengetikkan perintah SELECT kembali.
Membuat dan Mendefinisikan Views
View dibuat atau didefinisikan dengan menggunakan perintah CREATE VIEW.
Bentuk umum perintah untuk membuat (mendefinisikan) view, sebagai berikut:
CREATE
[OR REPLACE]
[ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}]
[DEFINER = { user | CURRENT_USER }]
[SQL SECURITY { DEFINER | INVOKER }]
VIEW view_name [(column_list)]
AS select_statement
[WITH [CASCADED | LOCAL] CHECK OPTION]
Berikut ini contoh view untuk menampilkan data id, nama dan telepon pelanggan
dari tabel pelanggan yang diurutkan berdasarkan nama pelanggan.
CREATE VIEW `data_plg` AS (select id_pelanggan, nm_pelanggan, telepon from
`pelanggan` order by `nm_pelanggan`) ;
Dan untuk mengeksekusi perintah di atas, kita dapat memanggil dengan perintah SELECT
seperti halnya menampilkan data dari suatu tabel. Berikut ini contoh cara pemanggilan
view beserta hasil querynya.
SELECT * FROM data_plg;
+--------------+------------------+--------------+
| id_pelanggan | nm_pelanggan
| telepon
|
+--------------+------------------+--------------+
| P0004
| Ninda Budianto
| 08171231234 |
| P0003
| Winny
| 0815829221
|
| P0002
| Yoga Rimaldo
| 08571239501 |
| P0001
| Yusuf Hadiwinata | 085692019009 |
+--------------+------------------+--------------+
4 rows in set (0.01 sec)
Page 84
Contoh lain misalnya jika kita ingin membuat view untuk menampilkan laporan
jumlah barang dari setiap transaksi pemesanan yang dilakukan oleh pelanggan.
CREATE VIEW lap_jumlah_brg_transaksi AS
(SELECT pesan.id_pesan, pesan.tgl_pesan, pelanggan.id_pelanggan,
pelanggan.nm_pelanggan, detil_pesan.jumlah
FROM pesan, detil_pesan, pelanggan
WHERE pesan.id_pesan=detil_pesan.id_pesan AND
pelanggan.id_pelanggan=pesan.id_pelanggan
GROUP BY pesan.id_pesan) ;
+----------+------------+--------------+------------------+--------+
| id_pesan | tgl_pesan | id_pelanggan | nm_pelanggan
| jumlah |
+----------+------------+--------------+------------------+--------+
|
1 | 2008-02-02 | P0001
| Yusuf Hadiwinata |
2 |
+----------+------------+--------------+------------------+--------+
1 row in set (0.09 sec)
Mengubah View
View yang sudah dibuat, dapat diubah dengan perintah ALTER. Bentuk umum
perintah untuk mengubah view yang sudah ada, sebagai berikut:
ALTER
[ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}]
[DEFINER = { user | CURRENT_USER }]
[SQL SECURITY { DEFINER | INVOKER }]
VIEW view_name [(column_list)]
AS select_statement
[WITH [CASCADED | LOCAL] CHECK OPTION]
+--------------+------------------+-----------------+--------------+----------------------------+
| id_pelanggan | nm_pelanggan
| alamat
| telepon
| email
|
+--------------+------------------+-----------------+--------------+----------------------------+
| P0002
| Yoga Rimaldo
| Bandung
| 08571239501 | yoga@computradetech.com
|
| P0003
| Winny
| Jakarta Barat
| 0815829221
| winny@computradetech.com
|
| P0001
| Yusuf Hadiwinata | Jakarta Selatan | 085692019009 | yusuf.hadiwinata@gmail.com |
| P0004
| Ninda Budianto
| Jakarta Timur
| 08171231234 | ninda@computradetech.com
|
+--------------+------------------+-----------------+--------------+----------------------------+
4 rows in set (0.00 sec)
Page 85
Menghapus View
View yang sudah dibuat, dapat dihapus dengan perintah DROP. Berikut ini bentuk
umum dan contoh perintah untuk menghapus view.
DROP VIEW view_name;
Contoh :
DROP VIEW data_plg;
SELECT * FROM data_plg;
ERROR 1146 (42S02): Table 'penjualan.data_plg' doesn't exist
Page 86
Bab 9
Function dan Stored Procedure
Hello World!
Trigger
Function dan Stored Procedure merupakan fitur utama yang paling penting di
MySQL 5. Function dan Stored Procedure merupakan suatu kumpulan perintah atau
statement yang disimpan dan dieksekusi di server database MySQL. Dengan SP (Stored
Procedure), kita dapat menyusun program sederhana berbasis sintaks SQL untuk
menjalankan fungsi tertentu. Hal ini menjadikan aplikasi yang kita buat lebih efektif dan
efisien.
Berikut ini beberapa keuntungan menggunakan Stored Procedure:
Lebih cepat. Hal ini karena kumpulan perintah query dijalankan langsung di server.
Berbeda dengan jika dijalankan secara sekuensial di bahasa pemrograman, akan
lebih lambat karena harus bolak-balik antara client dan server.
Page 87
Selanjutnya, Stored Procedure dari segi bentuk dan sifatnya terbagi menjadi 2
(dua), yaitu FUNCTION dan PROCEDURE. Perbedaan utama antara function dan
procedure adalah terletak pada nilai yang dikembalikannya (di-return). Function memiliki
suatu nilai yang dikembalikan (di-return), sedangkan procedure tidak.
Umumnya suatu procedure hanya berisi suatu kumpulan proses yang tidak
menghasilnya value, biasanya hanya menampilkan saja.
Note: terdapat istilah SP (Stored Procedure) maka yang dimaksud adalah Function dan
Procedure.
Hello World!
Sebagai contoh sederhana, kita akan membuat suatu SP yang akan menampilkan
string Hello World! di layar hasil. Berikut ini perintah query untuk membuat SP tersebut:
DELIMITER $$
CREATE PROCEDURE hello()
BEGIN
SELECT "Hello World!";
END$$
DELIMITER ;
Untuk memanggil procedure tersebut, gunakanlah CALL. Berikut ini contoh pemanggilan
procedure dan hasil tampilannya:
CALL hello();
Page 88
Cara
pemanggilan
dari
procedure
diatas
adalah
dengan
menggunakan
CALL
Pada bentuk procedure yang kedua di atas (jumlahPelanggan2), kita menyimpan hasil
dari procedure ke dalam satu variabel bernama hasil yang bertipe INT. Perbedaan dari
kedua bentuk di atas adalah, pada bentuk kedua, kita dapat memanggil procedure dengan
SELECT, sedangkan pada yang pertama tidak bisa. Berikut ini contoh pemanggilan untuk
procedure yang kedua:
Page 89
Contoh 2. Procedure untuk menghitung jumlah item barang yang pernah dibeli oleh satu
pelanggan.
DELIMITER $$
CREATE PROCEDURE jumlahItemBarang (pelanggan VARCHAR(5))
BEGIN
SELECT SUM(detil_pesan.jumlah)
FROM pesan, detil_pesan
WHERE pesan.id_pesan=detil_pesan.id_pesan
AND pesan.id_pelanggan=pelanggan;
END$$
DELIMITER ;
Contoh 3. Function untuk menghitung jumlah produk yang tersedia (stock) untuk satu
produk tertentu.
DELIMITER $$
CREATE FUNCTION jumlahStockBarang(produk VARCHAR(5))
RETURNS INT
BEGIN
DECLARE jumlah INT;
SELECT COUNT(*) INTO jumlah FROM produk
WHERE id_produk=produk;
RETURN jumlah;
END$$
DELIMITER ;
Untuk memanggil suatu function, kita tidak menggunakan CALL, tetapi langsung
dapat memanggil dengan SELECT. Berikut ini contoh pemanggilan untuk fungsi di atas.
SELECT jumlahStockBarang('B0001');
Mengubah SP
Untuk mengubah SP yang sudah ada, berikut ini bentuk umumnya:
ALTER {PROCEDURE | FUNCTION} sp_name [characteristic ...]
Page 90
Menghapus SP
Untuk menghapus SP yang sudah ada, berikut ini bentuk umumnya:
DROP {PROCEDURE | FUNCTION} [IF EXISTS] sp_name
Atau
DROP PROCEDURE `penjualan`.`jumlahPelanggan`;
DROP PROCEDURE `penjualan`.`jumlahStockBarang`;
Variabel
Variabel digunakan untuk menyimpan suatu nilai secara temporer (sementara) di
memory. Variabel akan hilang saat sudah tidak digunakan lagi. Variabel dalam MySQL
sebelum dapat digunakan, pertama kali harus dideklarasikan terlebih dahulu. Berikut ini
bentuk umum pendeklarasian suatu variabel di MySQL:
DECLARE variable_name DATATYPE [DEFAULT value];
Contohnya:
DECLARE jumlah INT;
DECLARE kode VARCHAR(5);
DECLARE tgl_lahir DATE DEFAULT 1987-06-14;
Setelah dideklarasikan, suatu variabel dapat diisi dengan suatu nilai sesuai dengan tipe
data yang didefinisikan saat pendeklarasian. Untuk mengisikan nilai ke dalam suatu
variabel, digunakan perintah SET. Format umumnya sebagai berikut:
SET variable_name = expression|value;
Contohnya:
SET jumlah = 10;
Page 91
Berikut ini contoh function hitungUmur() untuk menghitung umur seseorang saat ini
berdasarkan tahun kelahiran yang diberikan.
DELIMITER $$
CREATE FUNCTION hitungUmur (lahir DATE)
RETURNS INT
BEGIN
DECLARE thn_sekarang, thn_lahir INT;
SET thn_sekarang = YEAR(now());
SET thn_lahir = YEAR (lahir);
RETURN thn_sekarang - thn_lahir;
END$$
DELIMITER ;
Penyeleksian Kondisi
Dengan adanya fasilitas penyeleksian kondisi, kita dapat mengatur alur proses
yang terjadi dalam database kita. Di MySQL, penyeleksian kondisi terdiri dari IF, IF...ELSE
dan CASE. Berikut ini bentuk umum ketiga perintah tersebut:
IF kondisi THEN
perintah-jika-benar;
END IF;
IF kondisi THEN
perintah-jika-benar;
ELSE
perintah-jika-salah;
END IF;
CASE expression
WHEN value THEN
statements
[WHEN value THEN
statements ...]
[ELSE
statements]
END CASE;
WHERE id_pelanggan=pelanggan;
Page 92
Dan berikut ini contoh penggunaan perintah CASE dalam fungsi getDiskon()
dimana fungsi ini menentukan diskon berdasarkan jumlah pesanan yang dilakukan.
DELIMITER $$
CREATE FUNCTION getDiskon(jumlah INT) RETURNS int(11)
BEGIN
DECLARE diskon INT;
CASE
WHEN (jumlah >= 100) THEN
SET diskon = 10;
WHEN (jumlah >= 50 AND jumlah < 100) THEN
SET diskon = 5;
WHEN (jumlah >= 20 AND jumlah < 50) THEN
SET diskon = 3;
ELSE SET diskon = 0;
END CASE;
RETURN diskon;
END$$
DELIMITER ;
Perulangan
Selain penyeleksian kondisi, MySQL juga mendukung adanya perulangan dalam
querynya. Perulangan biasanya digunakan untuk mengulang proses atau perintah yang
sama. Dengan perulangan, perintah akan lebih efisien dan singkat. Berikut ini bentukbentuk perintah perulangan:
[label:] LOOP
statements
END LOOP [label];
[label:] REPEAT
statements
UNTIL expression
END REPEAT [label]
[label:] WHILE expression DO
statements
END WHILE [label]
Page 93
Page 94
Bagian 4
Page 95
Bab 10
Laporan di MySQL
Format Laporan
Page 96
2. Pilih format laporan dan tempat menyimpan hasil laporan dan tentukan nama file
3. Masukan properties dari proses export dan klik Run
Page 97
Format Laporan
Format file laporan yang dapat di-generate secara langsung dengan MySQL Front
diantaranya file CSV, HTML, XML, Excel XML, dan SQL.
CSV
CSV merupakan singkatan dari Comma Separated Version. CSV merupakan suatu
format data dimana setiap record dipisahkan dengan koma (,) atau titik koma (;). Selain
sederhana, format ini dapat dibuka dengan berbagai text-editor seperti Notepad, Word,
bahkan MS Excel. Berikut ini pilihan untuk membuat report dalam CSV.
Page 98
Bab 11
Backup, Restore dan Import di MySQL
Backup
Restore
Import
Backup
Proses backup data merupakan hal yang sangat penting dilakukan. Hal ini
diperlukan untuk mengantisipasi hal-hal yang tidak diinginkan di database kita, misalnya
hilangnya data, rusaknya database dsb. Sebaiknya proses backup dilakukan secara rutin
dan terus-menerus.
Backup di MySQL sebenarnya ada 2 jenis, yaitu secara otomatis dan manual.
Secara otomatis kita dapat menggunakan konsep replication , dimana server database
kita secara real-time di-backup dengan server lain. Jika terdapat perubahan di server
utama kita, maka secara otomatis perubahannya akan di- replikasi ke server kedua. Selain
itu, kita juga dapat melakukan backup otomatis dengan bantuan software tertentu.
Biasanya kita dapat membuat schedule- backup. Backup akan dijalankan oleh software
secara otomatis setiap periode waktu tertentu.
Jenis kedua, kita dapat melakukan backup secara manual. Backup manual
dilakukan oleh database administrator dengan menjalankan perintah-perintah tertentu.
Backup manual ada dua bentuk, yaitu backup dalam bentuk file database dan backup
dalam bentuk perintah database.
Backup Bentuk File
Backup dalam bentuk file disini maksudnya adalah melakukan backup MySQL
dengan meng-copy folder tempat database MySQL disimpan. Jika kita menggunakan
sistem operasi Windows dan MySQL 5.x, secara default database MySQL tersimpan
didalam folder C:\Program Files\MySQL\MySQL Server 5.0\data. Kita hanya tinggal mengcopy database yang akan kita backup dari folder tersebut ke tempat lain.
Keuntungan dari cara backup seperti ini adalah kemudahannya terutama bagi yang
awam dengan database, karena tinggal copy dan paste. Namun cara seperti ini terkadang
bermasalah saat melakukan restore jika menggunakan sistem operasi yang berbeda.
Page 99
Contoh misalnya kita akan melakukan backup semua database, sintaksnya sebagai
berikut:
shell > mysqldump --all-databases > backup-semua-db.sql
Jika ingin membakup salah satu database saja bisa menggunakan perintah seperti
dibawah ini:
shell > mysqldump penjualan > backup-penjualan-db.sql
Selain dengan cara perintah manual, kita juga dapat memanfaatkan software lain
seperti MySQL Front. Berikut ini prosedur atau cara backup dengan memanfaatkan
MySQL Front.
1. Silahkan jalankan MySQL Front dari shorcut atau Startmenu, lalu pilih database
server yang akan di backup seperti gambar dibawah ini:
Page 100
2. Pilih database yang akan di backup dan klik kanan pada database tersebut, pilih
export sebagai SQL File lalu Run
3. Hasil dari file backup database dapat di edit menggunakan text editor seperti
notepad atau wordpad jika diperlukan.
Page 101
Restore
Restore merupakan prosedur yang dilaksanakan untuk mengembalikan file yang
dibackup ke database MySQL. Proses restore juga dapat dilakukan melalui perintah SQL
dengan memanfaatkan mysql dan juga bisa menggunakan software bantuan.
Jika menggunakan sintaks SQL, berikut ini contoh perintahnya:
shell > mysql u user p < backup-semua-db.sql
Untuk merestore single database backup bisa menggunakan format dibawah ini:
shell > mysql -u user p penjualan < backup-penjualan-db.sql
Sedangkan jika menggunakan MySQL Front, berikut ini prosedur restore databasenya:
1. Pilih nama database yang akan di restore/replace isinya, lalu klik kanan pada
database tersebut dan pilih import, lanjutkan dengan mengklik Import from SQL File
seperti gambar dibawah ini:
Page 102
Import
Adakalanya kita mempunyai data mentah dalam jumlah besar. Data dapat dalam
bentuk Excel, CVS, SQL, atau yang lainnya. Dan jika kita ingin meng-import data tersebut,
kita harus menyesuaikan format data tersebut ke format yang dikenal oleh MySQL
Jika data dalam format .SQL maka prosedur untuk import dapat mengikuti prosedur
restore diatas. Berikut ini contoh prosedur import untuk format data CVS. Untuk format
data yang lain, harus disesuaikan dengan format CVS.
1. Jika sebelumnya kita mempunya data mentah yang berbentuk CSV ingin kita
tambahkan pada database server, prosedur import dapat digunakan untuk
kebutuhan seperti itu, berikut adalah contoh data yang akan di import
Berikut contoh isi dari table pelanggan dari database penjualan:
Page 103
2. Dan berikut contoh dari File CSV yang akan kita import ke dalam database
penjualan table pelanggan
3. Proses Import CSV file menggunakan PhpMyAdmin adalah dengan cara mengklik
nama database dan dilanjutkan dengan megklik nama table pada menu kiri
PhpMyAdmin, setelah isi table yang ingin di import terlihat dapat melanjutkan
dengna megnklik Tab Import seperti gambar dibawah ini:
4. Klik Browser lalu arahkan ke file yang akan di import seperti gambar di bawah ini,
selanjutnya klik tombol Go yang berlokasi di pojok kanan bawah
Page 104
5. Hasil dari Import data CSV dapat kita lihat pada table pelanggan
Page 105
Bagian 5
MySQL METADATA
Page 106
Bab 12
Memanfaatkan MySQL Metadata
MySQL Metadata
Pada aplikasi MySQL terdapat tiga macam data atau informasi yang dapat
di
versi
database dll.
Untuk mendapatkan informasi diatas menggunakan MySQL prompt ataupun
menggunakan MySQL Front sangatlah mudah, untuk kali kita akan menggunakan PERL
dan PHP Script untuk mengeluarkan informasi diatas.
Page 107
Ada dua buah jenis koneksi dari script PHP ke MySQL yaitu menggunakan MySQLi
dan PDO. Kedua jenis koneksi tersebut mempunyai keuntungan tersendiri dimana PDO
dapat bekerja pada 12 macam database systems dan MySQLi hanya bekerja untuk
MySQL databases sehingga PDO akan memudahkan kita berpindah progam database.
Jika pada bagian username dan password kita salah memasukan informasinya, maka
pada saat php script tersebut di jalankan akan menghasilkan seperti gambar di bawah ini:
Page 108
<?php
$servername = "localhost";
$username = "username";
$password = "password";
// Membuat koneksi
$conn = mysqli_connect($servername, $username, $password);
// Mengecheck koneksi
if (!$conn) {
die("Connection failed: " . mysqli_connect_error());
}
echo "Connected successfully";
?>
Note: pada contoh php script model object-oriented diatas: fungsi $connect_error sudah
ditiadakan sampai dengan versi PHP 5.2.9 and 5.3.0. PHP memutuskan untuk membuat
mysql extension berstatus deprecated. Yang artinya pengaksesan database MySQL
menggunakan fungsi mysql extension sudah tidak disarankan lagi. Programmer PHP
diharapkan pindah ke mysqli extension atau PDO yang berbasis objek. sebagai gantinya
Page 109
Koneksi ke database MySQL akan otomatis terputus pada akhir dari script PHP. Untuk
memutus koneksi sebelum berakhirnya script bisa menggunakan fungsi dibawah ini
$conn->close();
Page 110
MySQL ini, saya akan mencoba menampilkan tabel mahasiswa_ilkom dengan tampilan
akhir seperti gambar berikut:
Tampilan diatas di dapat dengan mengkombinasikan PHP, MySQL, HTML dan CSS. Dan
berikut adalah kode program yang digunakan:
<?php
//buat koneksi dengan MySQL
$link=mysql_connect('localhost','root','password');
//jika koneksi gagal, langsung keluar dari PHP
if (!$link)
{
die("Koneksi dengan MySQL gagal");
}
//gunakan database penjualan
$result=mysql_query('USE penjualan');
if (!$result)
{
die("Database penjualan gagal digunakan");
}
//tampilkan tabel pelanggan
$result=mysql_query('SELECT * FROM pelanggan');
?>
<!DOCTYPE html>
<head>
<meta charset="UTF-8">
<title>Belajar PHP MySQL</title>
<style>
h3{
text-align:center; }
table {
border-collapse:collapse;
border-spacing:0;
font-family:Arial, sans-serif;
font-size:16px;
padding-left:300px;
margin:auto; }
table th {
font-weight:bold;
padding:10px;
color:#fff;
background-color:#2A72BA;
border-top:1px black solid;
border-bottom:1px black solid;}
table td {
padding:10px;
border-top:1px black solid;
border-bottom:1px black solid;
text-align:center; }
tr:nth-child(even) {
background-color: #DFEBF8; }
Page 111
</style>
</head>
<body>
<h3>Penyajian Data MySQL dalam bentuk tabel HTML dengan CSS</h3>
<table>
<tr>
<th>ID</th>
<th>Nama</th>
<th>Alamat</th>
<th>Telepon</th>
<th>Email</th>
</tr>
<?php
while ($row=mysql_fetch_array($result))
{
echo "<tr>";
echo "<td>".$row['id_pelanggan']."</td>";
echo "<td>".$row['nm_pelanggan']."</td>";
echo "<td>".$row['alamat']."</td>";
echo "<td>".$row['telepon']."</td>";
echo "<td>".$row['email']."</td>";
echo "</tr>";
}
?>
</table>
</body>
</html>
Page 112
data
tabel
while($lihat=mysql_fetch_array($query)){
//mengeluarkan isi data
dengan mysql_fetch_array dengan perulangan
?>
<tr>
<td><?php echo $no++; ?></td> <!--menampilkan nomor dari variabel no-->
<td><?php echo $lihat['id_pelanggan'] ?></td>
<!-- menampilkan data ID Pelanggan dari tabel pelanggan-->
<td><?php echo $lihat['nm_pelanggan'] ?></td>
<!--menampilkan data nama dari tabel pelanggan-->
<td><?php echo $lihat['alamat'] ?></td>
<!-- menampilkan data jurusan dari tabel pelanggan-->
<td><?php echo $lihat['telepon'] ?></td>
<!--menampilkan data alamat dari tabel pelanggan-->
<td><?php echo $lihat['email'] ?></td>
<!--menampilkan data jenis kelamin dari tabel pelanggan-->
<td><a href="edit_mhs.php?id_pelanggan=<?php echo $lihat['id_pelanggan'] ?>">Edit</a> ||
<!--membuat link ke file dan hapus.php-->
<a href="hapus_mhs.php?id_pelanggan=<?php echo $lihat['id_pelanggan'] ?>">Hapus</a></td>
<!--membuat link ke file dan hapus.php-->
</tr>
<?php
}
?>
</table>
<br/>
<a href="tambah_mhs.php">Tambah Pelanggan</a>
<!--membuat link untuk di hubungakan ke file tambah pelanggan-->
</body>
</html>
Page 113
</head>
<body>
<h1>Data Pelanggan</h1>
<table border="1">
<tr>
<th>No</th>
<th>ID</th>
<th>Nama</th>
<th>Alamat</th>
<th>Telepon</th>
<th>Email</th>
<th>opsi</th>
</tr>
<?php
$query=mysql_query("select * from pelanggan");
//mengambil data tabel pelanggan dan memasukkan nya ke variabel query
$no=1;
//membuat nomor pada tabel
while($lihat=mysql_fetch_array($query)){
//mengeluarkan isi data dengan mysql_fetch_array dengan perulangan
?>
<tr>
<td><?php echo $no++; ?></td>
<!--menampilkan nomor dari variabel no-->
<td><?php echo $lihat['id_pelanggan'] ?></td>
<!-- menampilkan data ID Pelanggan dari tabel pelanggan-->
<td><?php echo $lihat['nm_pelanggan'] ?></td>
<!--menampilkan data nama dari tabel pelanggan-->
<td><?php echo $lihat['alamat'] ?></td>
<!-- menampilkan data jurusan dari tabel pelanggan-->
<td><?php echo $lihat['telepon'] ?></td>
<!--menampilkan data alamat dari tabel pelanggan-->
<td><?php echo $lihat['email'] ?></td>
<!--menampilkan data jenis kelamin dari tabel pelanggan-->
<td><a href="edit_mhs.php?id_pelanggan=<?php echo $lihat['id_pelanggan'] ?>">Edit</a> ||
<!--membuat link ke file dan hapus.php-->
<a href="hapus_mhs.php?id_pelanggan=<?php echo $lihat['id_pelanggan'] ?>">Hapus</a></td>
<!--membuat link ke file dan hapus.php-->
</tr>
<?php
}
?>
</table>
<br/>
<a href="tambah_mhs.php">Tambah Pelanggan</a>
<!--membuat link untuk di hubungakan ke file tambah pelanggan-->
</body>
</html>
<?php
include 'config.php';
$id_pelanggan = $_POST['id_pelanggan'];
$nama = $_POST['nama'];
$alamat = $_POST['alamat'];
$telepon = $_POST['telepon'];
$email = $_POST['email'];
$input = mysql_query("insert into pelanggan values
('$id_pelanggan','$nama','$alamat','$telepon','$email')");
if ($input) {
header("location:lihat_mhs.php");
} else {
echo "gagal";
}
?>
Page 114
Sejauh ini sudah bisa melist (SELECT) dan menambahkan pelanggan baru (INSERT),
selanjutnya dilanjutkan dengan membuat script PHP untuk edit (UPDATE) dan hapus
pelanggang (DELETE).
Berikut adalah isi dari file yang digunakan untuk merubah informasi dari suatu pelanggan
Berikut isi dari file edit_mhs.php dan update.php
<h1>Edit data pelanggan</h1>
<?php
include './config.php';
$id_pelanggan = $_GET['id_pelanggan'];
$query = mysql_query("select * from pelanggan where id_pelanggan='$id_pelanggan'");
while ($q = mysql_fetch_array($query)) {
?>
<table>
<form action="update.php?id_pelanggan=<?php echo $q['id_pelanggan'];?>" method="post">
<tr>
<td>Nama</td>
<td><input type="text" value="<?php echo $q['nm_pelanggan'] ?>" name="nama"></td>
</tr>
<tr>
<td>Alamat</td>
<td><input type="text" name="alamat" value="<?php echo $q['alamat'] ?>"></td>
</tr>
<tr>
<td>Telepon</td>
<td><input type="text" name="telepon" value="<?php echo $q['telepon'] ?>"></td>
</tr>
<tr>
<td>Email</td>
<td><input type="text" name="email" value="<?php echo $q['email'] ?>"></td>
</tr>
<tr>
<tr>
<td></td><td><input type="submit" value="update"></td> </br>
</tr>
<?php echo $q['id_pelanggan'];?>
}
?>
</form>
</table>
<?php
Page 115
update.php
<?php
include './config.php';
$id = $_GET['id_pelanggan'];
$nama = $_POST['nama'];
$alamat = $_POST['alamat'];
$telepon = $_POST['telepon'];
$email = $_POST['email'];
$update = mysql_query("update pelanggan set nm_pelanggan='$nama', alamat='$alamat',
telepon='$telepon', email='$email' where id_pelanggan like '$id'");
if ($update) {
header("location:lihat_mhs.php");
} else {
echo "gagal mengupdate data";
}
?>
pada form kita memilih file update.php untuk melakukan aksi atau pengolahan dari form
edit ini. oleh karena itu kita harus membuat file update.php dulu, agar data yang di edit
dapat di olah pada database update.php.
Bagian terakhir adalah membuat fungsi delete menggunakan PHP, silahkan buat file
hapus_mhs.php dengan isi seperti di bawah ini:
<?php
include 'config.php';
$id = $_GET['id_pelanggan'];
$hps = mysql_query("delete from pelanggan where id_pelanggan='$id'");
if ($hps) {
header("location:lihat_mhs.php");
} else {
echo "gagal menghapus";
}
?>
Page 116
antarmuka
pembebanan
dinamis
database
driver,
standar.
pengecekan
DBI
error
juga
bertanggung
jawab
atas
dan
penanganan,
memberikan
implementasi untuk metode default, dan banyak tugas-tugas khusus non-database lain.
Sebelum kita dapat menggunakan DBI, untuk mengetahui Driver apa saja yang
terinstall dapat menggunakan perl script seperti ini:
#!/usr/bin/perl
use strict;
use DBI;
my @ary = DBI->available_drivers();
print join("\n", @ary), "\n";
Contoh outputnya:
DBM
ExampleP
File
Gofer
Proxy
Sponge
mysql
Page 117
agar dapat menggunakan interpreter DBI, kita harus meninstall DBI Per module, perintah
yang dapat digunakan untuk menginstall Perl DBI module adalah:
# perl -MCPAN -e shell
cpan[]> install DBI
Page 118
Bagian 6
STORAGE ENGINE
Page 119
Bab 13
MySQL Storage Engine
Page 120
menyimpan data dalam bentuk file text dan menggunakan pembatas koma untuk
memisahkan format nilai. Student dapat menggunakannya untuk bertukar data
antar perangkat lunak yang mendukung format CSV.
5. Merge : merupakan storage engine yang memudahkan Administrator Database
MySQL untuk mengelompokkan secara logis serangkaian tabel MyISAM yang
identik dan mengacunya sebagai satu obyek.
6. Archive : mulai ditambahkan di MySQL versi 4.1.3, merupakan storage engine
yang digunakan untuk menyimpan atau memperoleh informasi dalam jumlah cukup
besar dari tabel-tabel yang tidak terindeks.
7. Blackhole : merupakan storage engine yang menerima tetapi tidak menyimpan
data dan proses pengambilan data selalu tidak menghasilkan apapun (an empty
set), digunakan dalam desain database terdistribusi dimana data otomatis
direplikasi tetapi tidak disimpan.
8. Federated : mulai ditambahkan di MySQL versi 5.0, merupakan storage engine
yang menawarkan kemampuan untuk menghubungkan server MySQL yang
terpisah untuk membuat satu database logis dari banyak server fisik.
9. Example : merupakan storage engine yang berfungsi sebagai rintisan yang tidak
melakukan apapun dan berfungsi sebagai contoh dalam kode sumber MySQL.
Student dapat membuat tabel menggunakan storage engine ini, tetapi tidak dapat
digunakan untuk menyimpan ataupun mengambil data.
Komparasi antar Storage Engine:
Feature
MyISAM
Memory
InnoDB
Archive
NDB
Storage limits
Transactions
Locking granularity
MVCC
Geospatial data type support
Geospatial indexing support
B-tree indexes
T-tree indexes
Hash indexes
Full-text search indexes
Clustered indexes
Data caches
Index caches
Compressed data
Encrypted data
Cluster database support
Replication support
Foreign key support
Backup / point-in-time recovery
Query cache support
Update statistics for data dictionary
256TB
No
Table
No
Yes
Yes
Yes
No
No
Yes
No
No
Yes
Yes
Yes
No
Yes
No
Yes
Yes
Yes
RAM
No
Table
No
No
No
Yes
No
Yes
No
No
N/A
N/A
No
Yes
No
Yes
No
Yes
Yes
Yes
64TB
Yes
Row
Yes
Yes
Yes
Yes
No
No
Yes
Yes
Yes
Yes
Yes
Yes
No
Yes
Yes
Yes
Yes
Yes
None
No
Table
No
Yes
No
No
No
No
No
No
No
No
Yes
Yes
No
Yes
No
Yes
Yes
Yes
384EB
Yes
Row
No
Yes
No
No
Yes
Yes
No
No
Yes
Yes
No
Yes
Yes
Yes
No
Yes
Yes
Yes
Page 121
SHOW ENGINES; .
menampilkan status dan keterangan dari Storage engine MySQL yang terinstall.
Berikut keluaran dari perintah tersebut
*************************** 1. row ***************************
Engine: MyISAM
Support: YES
Comment: MyISAM storage engine
Transactions: NO
XA: NO
Savepoints: NO
*************************** 2. row ***************************
Engine: CSV
Support: YES
Comment: CSV storage engine
Transactions: NO
XA: NO
Savepoints: NO
*************************** 3. row ***************************
Engine: MRG_MYISAM
Support: YES
Comment: Collection of identical MyISAM tables
Transactions: NO
XA: NO
Savepoints: NO
*************************** 4. row ***************************
Engine: BLACKHOLE
Support: YES
Comment: /dev/null storage engine (anything you write to it disappears)
Transactions: NO
XA: NO
Savepoints: NO
*************************** 5. row ***************************
Engine: MEMORY
Support: YES
Comment: Hash based, stored in memory, useful for temporary tables
Transactions: NO
XA: NO
Savepoints: NO
*************************** 6. row ***************************
Engine: FEDERATED
Support: NO
Comment: Federated MySQL storage engine
Transactions: NULL
XA: NULL
Savepoints: NULL
*************************** 7. row ***************************
Engine: ARCHIVE
Support: YES
Comment: Archive storage engine
Transactions: NO
XA: NO
Savepoints: NO
Page 122
Student dapat juga melakuan pengaturan default pada session saat ini yang berguna
sebagai nilai default pada saat membuat table dengan menggunakan perintah:
SET default_storage_engine=ARCHIVE;
Jika ingin merubah mode dari storage engine pada sutatu tabel bisa menggunakan
perintah seperti dibawah ini:
ALTER TABLE foo ENGINE = InnoDB;
Untuk melihat Storage engine yang digunakan pada table dapat menggunakan perintah
seperti di bawah ini:
SHOW TABLE STATUS FROM test WHERE Name='foo'
SHOW TABLE STATUS LIKE 'foo';
SELECT * FROM information_schema.tables WHERE table_schema = DATABASE();
Hasilnya:
mysql> SHOW TABLE STATUS LIKE 'foo' \G
*************************** 1. row ***************************
Name: foo
Engine: InnoDB
Version: 10
Row_format: Compact
Rows: 2
Page 123
Avg_row_length: 8192
Data_length: 16384
Max_data_length: 0
Index_length: 0
Data_free: 8388608
Auto_increment: NULL
Create_time: 2015-04-06 17:07:12
Update_time: NULL
Check_time: NULL
Collation: latin1_swedish_ci
Checksum: NULL
Create_options:
Comment:
1 row in set (0.00 sec)
InnoDB mempunyai performa yang baik dalam memproses data volumes yang
besar.
Merupakan DML operations (add, update and delete data) dan kompatibel dengan
model ACID (atomic, consistent, isolated and durable), serta mempunyai kemapuan
transactions featuring commit, rollback, and crash-recovery untuk menjaga
konsistensi user data.
Row-level locking (locks ditempatkan dalam single records (rows) system sehingga
dapat meningkatkan perfomance dari system concurrency multi-user. Semua lock
process dari InnoDB dipegang oleh transaksi yang dilepaskan pada saat transaksi
sudah di commit atau dibatalkan.
InnoDB tables menggunakan sistem Primary key sehingga proses query menjadi
lebih optimal dan menurunkan beban kerja disk.
integritas data. Olehkarena itu setiap ada perintah insert, update, dan delete akan
diperiksa untuk memastikan tidak terjadinya inkonsistensi data antar pada table
yang berbeda.
Keutungan lainya adalah dapat me Mix table dengan format InnoDB dengan format
storage
engine
MySQL
lainya.
Sebagai
Page 124
contoh,
memungkinkan
untuk
(col1));
DESC table4;
+-------+----------+------+-----+---------+-------+
| Field | Type
+-------+----------+------+-----+---------+-------+
| col1
| int(11)
| NO
| col2
| char(30) | YES
| PRI | 0
| NULL
+-------+----------+------+-----+---------+-------+
2 rows in set (0.00 sec)
Page 125
Secara default, index key dari single-column bisa sampai 767 byte. Batas panjang
yang sama berlaku untuk setiap index key.
InnoDB panjang dari internal maximum key adalah 3500 bytes, Namun dari MySQL
hanya mengijinkan sampai dengan 3072 bytes (kombinasi antara index key dalam
multi-column index).
Panjang dari maximum row adalah 8000 bytes untuk setinggan default page
Page 126
Secara internal, InnoDB supports row sizes lebih besar dari 65,535 bytes, tapi
MySQL sendiri membebankan batas row sizes sampai dengan 65.535 untuk ukuran
gabungan dari semua kolom.
Maximum dari table space size adalah empat miliar dari database pages (64TB)
dan ukuran minimum table space lebih besar sedikit dari 10MB.
clause ENGINE dikarenakan default dari Storage enginenya adalah InnoDB. Berikut
contoh membuat table dengan Storage engine MyISAM.
CREATE TABLE table7 (col1 INT, col2 CHAR(30)) ENGINE = MYISAM;
SHOW TABLE STATUS FROM test WHERE Name='table7' \G
*************************** 1. row ***************************
Name: table7
Engine: MyISAM
Version: 10
Row_format: Fixed
Rows: 0
Avg_row_length: 0
Data_length: 0
Max_data_length: 9851624184872959
Index_length: 1024
Data_free: 0
Auto_increment: NULL
Create_time: 2015-04-07 14:57:23
Page 127
Panjang file sampai dengan 63-bit, dengan catatan System operasi mendukung
Large File pada file systemnya
Maksimum 64 jumlah indeks dan 16 jumlah kolom per indeks yang diperbolehkan.
Dapat menempatkan file data dan file indeks dalam direktori yang berbeda serta
pada hardisk yang berbeda sehingga mendapatkan speed dan perfoma yang lebih
baik. Agar dapat mengaktifkan fasilitas tersebut dengan cara menambahkan clause
DATA DIREKTORI dan table INDEKS DIREKTORI pada saat CREATE TABLE.
Mengijinkan Nilai NULL dalam kolom yang terindex. Besaran ukuran yang
dibutuhkan adalah 0-1 byte per key.
Setiap kolom karakter dapat memiliki satu set karakter yang berbeda.
Tabel dengan kolom type VARCHAR dapat mempunya panjang yang sudah di
tetapkan atau yang dinamis.
Jumlah panjang dari VARCHAR dan kolom CHAR dalam sebuah tabel bisa sampai
64KB.
Process mysqld (MySQL Server) mati secara seketika pada saat sedang menulis.
Page 128
ditambahkan
clause
ENGINE.
Untuk
MySQL versi
5.6
keatas
harus
Page 129
MEMORY storage engine mendukung HASH dan BTREE tipe index. Untuk dapat
mengaktifkanya kita dapat menambahkan clause tersebut pada saat membuat table tipe
MEMORY. Berikut contohnya:
CREATE TABLE table9 (id INT, INDEX USING HASH (id)) ENGINE = MEMORY;
CREATE TABLE table10 (id INT, INDEX USING BTREE (id)) ENGINE = MEMORY;
Operasi yang melibatkan hal sementara, data yang tidak critical seperti manajemen
sesi atau caching.
Media penyimpanan In-memory untuk dapat akses yang cepat and latency yang
rendah. Volume data yang dapat ditampung seluruhnya dalam memori tampa
menggunakan swap atau virtual memory pages pada operating system.
Sebuah index key untuk single-column index yang besaranya bisa mencapai to 767
bytes. Batas panjang yang sama berlaku untuk setiap ndex key prefixi.
Page 130
Bagian 7
MEMAKSIMALKAN KINERJA
Page 131
Bab 14
Memaksimalkan Kinerja MySQL
Database Tunning
Database Tuning adalah sejumlah aktifitas yang dilakukan untuk memperbaiki atau
meningkatkan kinerja atau performance sebuah database. Aktifitas tuning ini meliputi
banyak aspek dari software hingga hardware, antara lain I/O Tuning, DBMS Tuning, Query
Tuning, dan Database Maintenance. Masing-masing memiliki tekniknya sendiri-sendiri,
dan membutuhkan skill yang mumpuni.
Beberapa point dalam optimasi database MySQL adalah sebagai berikut:
1. Optimasi Query dengan bantuan Database Index
2. Optimasi MySQL variable di file my.ini (my.cnf).
3. Optimasi Struktur Table.
4. Optimasi SQL Query.
Page 132
TABLE big_table AS
@baris := @baris+1 as baris
select @baris := 0 ) x
select 1 kolom from information_schema.tables ) a
select 1 kolom from information_schema.tables ) b
select 1 kolom from information_schema.tables ) c ;
Duplicates: 0
Warnings: 0
Salah satu teknik yang banyak digunakan dalam aplikasi database adalah
pagination, dimana teknik ini mengharuskan kita mengetahui total rows yang ada dalam
sebuah table untuk menentukan jumlah page yang ada. Coba kita lakukan query
count(*) untuk mengetahui total rows dalam table tersebut, dan lihat waktu yang
diperlukan untuk mendapatkan hasilnya.
SELECT count(*) FROM big_table ;
+----------+
| count(*) |
+----------+
| 1191016 |
+----------+
1 row in set (0.33 sec)
Rupanya perlu waktu 18 detik untuk mendapatkan hasilnya. Untuk user yang
penyabar, mungkin hal ini tidak menjadi masalah besar. Sekarang kita coba lihat
execution plan yang dipilih oleh mysql saat mengeksekusi perintah count(*) yang kita
berikan, maka terlihat seperti di bawah ini, bahwa mysql melakukan full table scan,
ditandai dengan type=ALL pada execution plan yang muncul. Full table scan artinya,
mysql meload seluruh table ke memory dan menghitung row yang ada di dalamnya satu
persatu.
EXPLAIN SELECT count(*) FROM big_table;
+----+-------------+-----------+------+---------------+------+---------+------+---------+-------+
| id | select_type | table
| type | possible_keys | key | key_len | ref | rows
| Extra |
+----+-------------+-----------+------+---------------+------+---------+------+---------+-------+
| 1 | SIMPLE
| big_table | ALL | NULL
| NULL | NULL
| NULL | 1191651 |
|
+----+-------------+-----------+------+---------------+------+---------+------+---------+-------+
1 row in set (0.00 sec)
Sekarang kita coba lagi dengan model query lain yang sangat umum, yaitu query
searching dengan menggunakan WHERE clause. Kita coba mencari sebuah row tertentu
yang kira-kira lokasinya ada di tengah-tengah table. Pada contoh di bawah ini bisa terlihat
Page 133
bahwa mysql tetap melakukan full table scan ke seluruh rows, padahal row yang kita
inginkan sudah ditemukan di tengah-tengah table. Dan rupanya perlu waktu lebih lama,
yaitu 19 detik, dibandingkan dengan proses count(*) yang hanya 18 detik.
SELECT * FROM big_table WHERE baris = 5346781;
Empty set (19 sec)
Execution plan mengkonfirmasikan bahwa mysql melakukan full table scan dari row
pertama sampai row terakhir, padahal kita hanya menginginkan satu row saja.
EXPLAIN SELECT * FROM big_table WHERE baris = 5346781 \G
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: big_table
type: ALL
possible_keys: NULL
key: NULL
key_len: NULL
ref: NULL
rows: 1191651
Extra: Using where
1 row in set (0.00 sec)
Index selesai dibuat, dan kita coba lakukan proses penghitungan jumlah rows
menggunakan query yang sama seperti sebelumnya. dan hasilnya muncul dalam 10 detik,
sebuah peningkatan yang luar biasa dari 18 detik menjadi 10 detik saja (y)
SELECT count(*) FROM big_table ;
+----------+
| count(*) |
+----------+
|
1191016 |
+----------+
1 row in set (10 sec)
Jika kita lihat execution plan, maka mysql tidak lagi menggunakan full table scan,
namun sekarang menggunakan index scan. walaupun masih melakukan scan ke seluruh
rows sebanyak 9 juta, namun index scan jauh leih cepat dibandingkan full table scan.
Page 134
Sekarang test menggunakan query searching, dan hasilnya muncul sangat cepat, hanya
0.05 detik.
SELECT * FROM big_table
+---------+
|
baris
+---------+
|
. . . . . .
| 1191016 |
+---------+
1191016 rows in set (0.05 sec)
baris = 5346781 ;
Jika kita lihat execution plan, maka mysql tidak lagi melakukan scan ke seluruh rows,
namun langsung menuju satu row yang kita inginkan. Peningkatan kinerja pencarian dari
19 detik menjadi 0.05 detik adalah peningkatan sangat baik.
Perlu diperhatikan bahwa INDEX yang di buat berdasarkan FIELD yang terlibat
dalam WHERE clause, sehingga Query Optimizer di MySQL otomatis akan mengenali
index tersebut dan menggunakannya untuk proses pencarian.
Page 135
Page 136
2. query_cache_size
Apabila MySQL server sibuk dan selalu mengulang-ulang query yang sama, maka
settting query_cache_size perlu diperhatikan. query_cache_size akan menyimpan query
yang berulang, sehingga akan mempercepat kerja MySQL untuk query yang sama.
Karena query yang sebelumnya disimpan dalam memory cache. Nilai defaultnya adalah 0
(mariadb)
SHOW VARIABLES WHERE Variable_name = 'query_cache_size' ;
+------------------+-------+
| Variable_name
| Value |
+------------------+-------+
| query_cache_size | 0
|
+------------------+-------+
3. key_buffer_size
Data base menggunakan key index. Karena itu apabila index ini tersimpan dalam
satu memori secara utuh, maka sudah tentu proses MySQL server akan semakin cepat
untuk mendapatkan hasil dari query yang diinginkan. Secara ideal semua index akan
bagus tersimpan dalam memory ini, akan tetapi perlu juga melihat kemampuan kapasitas
memory server.
Untuk kebutuhan table yang menggunakan engine MyISAM. Max 25% dari total
memory (RAM) Hardware dalam satuan MB, misal memory server 3GB (3002 MB * 25%=
Page 137
750,5 MB) maka bisa di edit menjadi 750M. apabila tidak ada table MyISAM sebaiknya
disetting menjadi 16-32M. Nilai defaultnya adalah 128MB (mariadb)
SHOW VARIABLES WHERE Variable_name = 'key_buffer_size' ;
+-----------------+-----------+
| Variable_name
| Value
|
+-----------------+-----------+
| key_buffer_size | 134217728 |
+-----------------+-----------+
5. sort_buffer_size
Apakah MySQL server memiliki query atau operasi myisamchk atau sort ? Maka
option ini sangat penting untuk di perhatikan. Dengan memasang buffer yang besar
tentunya akan melakukan sorting secara besar juga. Memperbesar pada nilai ini akan
mempercepat sorting. Nilai defaultnya adalah 2MB (mariadb)
SHOW VARIABLES WHERE Variable_name = 'sort_buffer_size' ;
+------------------+---------+
| Variable_name
| Value
|
+------------------+---------+
| sort_buffer_size | 2097152 |
+------------------+---------+
Page 138
+----------------+
SELECT count(*)
+----------+
| count(*) |
+----------+
|
100000 |
+----------+
Setelah
100k
test
-e
"insert
into
sorttest
value
FROM sorttest;
row
terbuat,
dilanjutkan
dengan
melakukan
pengetesan
dengan
Page 139
sort_buffer_size=32*1024*100
sort_buffer_size=1024*1024*100
sort_buffer_size=4096*1024*100
6. read_rnd_buffer_size
read_rnd_buffer_size digunakan setelah client melakukan sorting. Yaitu untuk
memproses row dari query sorting yang telah kita lakukan. Apabila query server sering
memakai ORDER BY, maka option ini perlu diperhatikan. Cara menghitung besar buffer ini
dengan logika 1 MB adalah 1KB, jadi apabila memory server adalah 1GB, maka dapat
merubahnya menjadi sebesar 1MB. Nilai defaultnya adalah 256KB (mariadb)
SHOW VARIABLES WHERE Variable_name = 'read_rnd_buffer_size' ;
+----------------------+--------+
| Variable_name
| Value |
+----------------------+--------+
| read_rnd_buffer_size | 262144 |
+----------------------+--------+
Page 140
cepat,
maka
thread_cache/thread_cache_size
adalah
option
yang
perlu
perhatikan. Karena jika semakin besar nilai ini, akan semakin tinggi juga load CPU server.
SHOW VARIABLES WHERE Variable_name = 'thread_cache_size' ;
+-------------------+-------+
| Variable_name
| Value |
+-------------------+-------+
| thread_cache_size | 0
|
+-------------------+-------+
8. tmp_table_size
tmp_table_size akan memberikan kesempatan kepada MySQL untuk menyimpan
table ke dalam harddisk yang dianggap sebagai memory. Sudah tentu tmp_table_size
akan memperlambat kecepatan MySQL. Apabila server mempunyai memory yang minim
dan kecepatan MySQL tidak begitu diperhitungkan, barangkali ini adalah option yang
dapat digunakan. Nilai defaultnya adalah 16MB (mariadb)
SHOW VARIABLES WHERE Variable_name = 'tmp_table_size' ;
+----------------+----------+
| Variable_name | Value
|
+----------------+----------+
| tmp_table_size | 16777216 |
+----------------+----------+
Bagaimana cara menghitung memory yang diperlukan oleh MySQL Server dengan
mudah ? Gunakan rumus sederhana berikut ini.
memory=key_buffer+(sort_buffer_size+read_buffer_size)*max_connections
9. innodb_buffer_pool_size
Untuk kebutuhan table yang menggunakan engine InnoDB. Cara menghitung
maximalnya adalah 70% dari total memory (RAM) Hardware dalam satuan MB, semisal
memory adalah 3GB (3002 MB * 25%= 2101,4 MB) maka kita dapat merubah nilainya
menjadi 2101M. Nilai defaultnya adalah 128MB (mariadb)
SHOW VARIABLES WHERE Variable_name = 'innodb_buffer_pool_size' ;
+-------------------------+-----------+
| Variable_name
| Value
|
+-------------------------+-----------+
| innodb_buffer_pool_size | 134217728 |
+-------------------------+-----------+
Page 141
10. read_buffer_size
Cara menghitungnya adalah dengan membagi 2 nilai dari sort_buffer_size, adapun nilai
defaultnya adalah 128KB (mariadb)
SHOW VARIABLES WHERE Variable_name = 'read_buffer_size' ;
+------------------+--------+
| Variable_name
| Value |
+------------------+--------+
| read_buffer_size | 131072 |
+------------------+--------+
11. innodb_flush_log_at_trx_commit
Konfigurasi pada valui ini hanya opsional, apabila edit menjadi 0 (nol) bisa menjadi
sedikit lebih cepat, namun kekurangannya adalah memungkinkan untuk kehilangan data
yang sedang ditransaksikan apabila server crash.
SHOW VARIABLES WHERE Variable_name = 'innodb_flush_log_at_trx_commit' ;
+--------------------------------+-------+
| Variable_name
| Value |
+--------------------------------+-------+
| innodb_flush_log_at_trx_commit | 1
|
+--------------------------------+-------+
Page 142
Pada bagian Variable to adjust kita sudah mendapatkan parameter mana saja yang dapat
digunakan untuk memaksimalkan kinerja MySQL.
Page 143
Page 144
WORKER THREADS
Current thread_cache_size = 64
Current threads_cached = 63
Current threads_per_sec = 0
Historic threads_per_sec = 0
Your thread_cache_size is fine
MAX CONNECTIONS
Current max_connections = 512
Current threads_connected = 1
Historic max_used_connections = 259
The number of used connections is 50% of the configured maximum.
Your max_connections variable seems to be fine.
INNODB STATUS
Current InnoDB index space = 1.04 G
Current InnoDB data space = 6.16 G
Current InnoDB buffer pool free = 0 %
Current innodb_buffer_pool_size = 6.00 G
Depending on how much space your innodb indexes take up it may be safe
to increase this value to up to 2 / 3 of total system memory
MEMORY USAGE
Max Memory Ever Allocated : 7.13 G
Configured Max Per-thread Buffers : 1.46 G
Configured Max Global Buffers : 6.39 G
Configured Max Memory Limit : 7.85 G
Physical Memory : 15.35 G
Max memory limit seem to be within acceptable norms
KEY BUFFER
Current MyISAM index space = 1 M
Current key_buffer_size = 256 M
Key cache miss rate is 1 : 31
Key buffer free ratio = 81 %
Your key_buffer_size seems to be fine
QUERY CACHE
Query cache is enabled
Current query_cache_size = 128 M
Current query_cache_used = 116 M
Current query_cache_limit = 8 M
Current Query cache Memory fill ratio = 90.99 %
Current query_cache_min_res_unit = 4 K
However, 5758316 queries have been removed from the query cache due to lack
of memory
Perhaps you should raise query_cache_size
MySQL won't cache query results that are larger than query_cache_limit in
size
SORT OPERATIONS
Current sort_buffer_size = 2 M
Current read_rnd_buffer_size = 256 K
Sort buffer seems to be fine
JOINS
./tuning-primer.sh: line 402: export: `2097152': not a valid identifier
Current join_buffer_size = 260.00 K
You have had 62647 queries where a join could not use an index properly
You have had 588 joins without keys that check for key usage after each row
Page 145
mysql_secure_installation
merupakan tools tambahan yang menjadi bawaan dari MySQL, tool ini dapat
digunakan untuk meningkatkan keamanan server MySQL
# mysql_secure_installation
/usr/bin/mysql_secure_installation: line 379: find_mysql_client: command not
found
NOTE: RUNNING ALL PARTS OF THIS SCRIPT IS RECOMMENDED FOR ALL MariaDB
SERVERS IN PRODUCTION USE! PLEASE READ EACH STEP CAREFULLY!
In order to log into MariaDB to secure it, we'll need the current
password for the root user. If you've just installed MariaDB, and
you haven't set the root password yet, the password will be blank,
so you should just press enter here.
Enter current password for root (enter for none):
OK, successfully used password, moving on...
Page 146
Setting the root password ensures that nobody can log into the MariaDB
root user without the proper authorisation.
Set root password? [Y/n] y
New password:
Re-enter new password:
Password updated successfully!
Reloading privilege tables..
... Success!
By default, a MariaDB installation has an anonymous user, allowing anyone
to log into MariaDB without having to have a user account created for
them. This is intended only for testing, and to make the installation
go a bit smoother. You should remove them before moving into a
production environment.
Remove anonymous users? [Y/n] y
... Success!
Normally, root should only be allowed to connect from 'localhost'. This
ensures that someone cannot guess at the root password from the network.
Disallow root login remotely? [Y/n] y
... Success!
By default, MariaDB comes with a database named 'test' that anyone can
access. This is also intended only for testing, and should be removed
before moving into a production environment.
Remove test database and access to it? [Y/n] y
- Dropping test database...
... Success!
- Removing privileges on test database...
... Success!
Reloading the privilege tables will ensure that all changes made so far
will take effect immediately.
Reload privilege tables now? [Y/n] y
... Success!
Cleaning up...
All done! If you've completed all of the above steps, your MariaDB
installation should now be secure.
Thanks for using MariaDB!
Page 147
Bagian 8
MYSQL CLUSTER
Page 148
Bab 15
MariaDB High-Aavability Cluster
Synchronous replication
Untuk percobaan pembuatan cluster akan menggunakan 2 buah database server yaitu
Server 1, IP Address 10.11.12.1 Name: db1
Server 2, IP Address 10.11.12.2 Name: db2
Operating System Centos 6.5 dengan Desktop Minimum install
Page 149
iburst
iburst
iburst
iburst
Page 150
>>
>>
>>
>>
/etc/ntp.conf
/etc/ntp.conf
/etc/ntp.conf
/etc/ntp.conf
[
[
OK
OK
]
]
/etc/selinux/config
Jika firewall ingin tetap di aktifkan, port 3306, 4444, 4567, dan 4568 harus dimasukan
kedalam pengaturan firewall
Jalankan di kedua node
sudo lokkit
sudo lokkit
sudo lokkit
sudo lokkit
iptables -A
iptables -A
iptables -A
iptables -A
--port 3306:tcp
--port 4444:tcp
--port 4567:tcp
--port 4568:tcp
INPUT -p tcp dport
INPUT -p tcp dport
INPUT -p tcp dport
INPUT -p tcp dport
3306
4444
4567
4568
-j
-j
-j
-j
ACCEPT
ACCEPT
ACCEPT
ACCEPT
MariaDB membutuhkan paket socat yang terdapat pada repository EPEL (Extra Package
for Enterprise Linux), silahkan tambahakn repository EPEL dengan mengetikan perintah di
bawah:
Page 151
Page 152
11/13
12/13
13/13
1/13
2/13
3/13
4/13
5/13
6/13
7/13
8/13
9/13
10/13
11/13
12/13
13/13
proses
installasi
selesai,
lanjutkan
dengan
jalankan
script
/usr/bin/mysql_secure_installation.
Jalankan di kedua node
/usr/bin/mysql_secure_installation
pada
file
/etc/my.cnf.d/server.cnf,
konfigurasi
ini
digunakan
untuk
CATATAN PENTING: ketika menjalankan perintah ini pada db2/node2 jangan lupa untuk
menyesuaikan wsrep_node_address dan wsrep_node_name variable.
Page 153
Periksa status dengan menjalankan perintah berikut pada node hanya db1:
[root@mariadb-cluster-node1
'wsrep%'"
~]#
mysql
-uroot
-predhat
-e"show
status
like
+------------------------------+------------------------------------------------+
| Variable_name
| Value
|
+------------------------------+------------------------------------------------+
| wsrep_local_state_uuid
| dc916334-de60-11e4-9afd-37c163596afd
|
| wsrep_protocol_version
| 7
|
| wsrep_last_committed
| 0
|
| wsrep_replicated
| 0
|
>>>>>>>>>>>>>>>> DIPERSINGKAT <<<<<<<<<<<<<<<<<<<<<<
| wsrep_provider_name
| Galera
|
| wsrep_provider_vendor
| Codership Oy <info@codership.com>
|
| wsrep_provider_version
| 25.3.9(r3385)
|
| wsrep_ready
| ON
|
| wsrep_thread_count
| 2
|
+------------------------------+------------------------------------------------+
Penjelasan status:
wsrep_local_state_comment: Synced (cluster berjalan dan bersiap mensinkronisasi)
wsrep_incoming_addresses: 10.11.12.1:3306 (IP Address Cluseter node ini)
wsrep_cluster_size: 1 (Anggota cluster saat ini berjumlah 1 Node)
wsrep_ready: ON (Cluster telah siap)
Step 9: Menginisialisasi node cluster kedua
Jika tidak ada kesalah dalam konfigurasi sebelumnya, untuk mengabungkan node
lainya adalah dengan menyalakan service dari MariaDB, ketik perintah berikut pada db2
[root@mariadb-cluster-node2 ~]# service mysql start
Starting MySQL..SST in progress, setting sleep higher..
OK
setelah berhasil menjalankan service MariaDB pada db2, untuk melihat statusnya dapat
menggunakan perintah berikut:
Page 154
Terlihat dari output perintah di atas saat ini jumlah dari Cluster Node yang bergabung
berjumlah 2 buah, dan pad incoming address sudah bertambah dengan ip address dari
db2, hal tersebut mengidikasikan proses installasi cluster sudah berhasil.
Step 10: Menguji Cluster MariaDB
Sekarang cluster sudah berjalan. Mari kita menguji apakah cluster bekerja dengan
baik atau tidak. Pada db1 buat database 'testcluster' dengan menjalankan perintah berikut:
[root@mariadb-cluster-node1 ~]# mysql -u root -predhat -e 'CREATE DATABASE
clustertest;'
dan pada db2 jalankan perintah di bawah ini untuk menguji kinerja cluster
[root@mariadb-cluster-node2 ~]# mysql -u root -predhat -e 'SHOW DATABASES;'
+--------------------+
| Database
|
+--------------------+
| clustertest
|
| information_schema |
| mysql
|
| performance_schema |
+--------------------+
Jika database clustertest yang dibuat dari db1 muncul juga di db2 hal tersebut
mengindikasikan proses dari konfigurasi cluster sudah berjalan. Untuk lebih memastikan
lagi, kita dapat membuat Table pada database Cluster dan mengisinya dengan informasi.
Untuk memastikan cluster berjalan dengan mode master-master, untuk pembuatan Table
bisa di uji coba pada dari node db2 dan di cek dari node db1 seperti berikut:
[root@mariadb-cluster-node2 ~]# mysql -u root -predhat -e 'CREATE TABLE
clustertest.mycluster ( id INT NOT NULL AUTO_INCREMENT, name VARCHAR(50),
ipaddress VARCHAR(20), PRIMARY KEY(id));'
[root@mariadb-cluster-node1 ~]# mysql -u root -predhat -e 'USE clustertest;
SHOW TABLES;'
Page 155
+-----------------------+
| Tables_in_clustertest |
+-----------------------+
| mycluster
|
+-----------------------+
Jika node db1 bisa menampilkan table yang baru dibuat hal tersebut mengindikasikan
Cluster model Master-Master telah berhasil di konfigurasi. Testing berikutnya yaitu menguji
penambahan record data.
[root@mariadb-cluster-node1 ~]# mysql -u root -predhat -e 'INSERT INTO
clustertest.mycluster (name, ipaddress) VALUES ("db1", "10.11.12.1");'
[root@mariadb-cluster-node2 ~]# mysql -u root -predhat -e 'USE clustertest;
SELECT * FROM mycluster'
+----+------+------------+
| id | name | ipaddress |
+----+------+------------+
| 2 | db1 | 10.11.12.1 |
+----+------+------------+
TABLES
{explicit
table
list}
WITH
READ
LOCK,
(GET_LOCK(),
Page 156
Untuk memantau perubahan dalam keanggotaan cluster dan status node, Anda dapat
menggunakan perintah Notification.
Pada saat salah satu anggota cluster menerima dan mereplikasi write-sets dari node
lainya atau sebaliknya, berarti cluster anda pada status yang baik. Untuk mengecek
Integritas cluster, untuk setiap node jalankan langkah-langkah berikut:
Page 157
Tiap node yang tergabung kedalam cluster akan memberikan Value yang sama. Jika anda
mendapatkan salah satu node mengeluarkan Value yang berbeda, hal tersebut
mengindikasikan bahwa node tersebut tidak ter-join ke cluster.
Memeriksa node milik komponen cluster yang sama:
[root@mariadb-cluster-node1 ~]# mysql -uroot -predhat -e"SHOW GLOBAL STATUS
LIKE 'wsrep_cluster_conf_id'"
+-----------------------+-------+
| Variable_name
| Value |
+-----------------------+-------+
| wsrep_cluster_conf_id | 4
|
+-----------------------+-------+
[root@mariadb-cluster-node2 ~]# mysql -uroot -predhat -e"SHOW GLOBAL STATUS
LIKE 'wsrep_cluster_conf_id'"
+-----------------------+-------+
| Variable_name
| Value |
+-----------------------+-------+
| wsrep_cluster_conf_id | 4
|
+-----------------------+-------+
Tiap node yang tergabung kedalam cluster akan memberikan Value yang sama. Jika anda
mendapatkan salah satu node mengeluarkan Value yang berbeda, hal tersebut
mengidikasikan cluster tersebut dalam kondisi terbagi-bagi (partioned). Biasanya
permasalahnya ada pada koneksi antar Node cluster, jika koneksi sudah diperbaiki,
nilainya akan kembali sama secara otomatis.
Pada node pertama, check jumlah node yang tergabung kedalam cluster dengan
menggunaka perintah berikut:
[root@mariadb-cluster-node1 ~]# mysql -uroot -predhat -e"SHOW GLOBAL STATUS
Page 158
LIKE 'wsrep_cluster_size';"
+--------------------+-------+
| Variable_name
| Value |
+--------------------+-------+
| wsrep_cluster_size | 2
|
+--------------------+-------+
[root@mariadb-cluster-node2 ~]# mysql -uroot -predhat -e"SHOW GLOBAL STATUS
LIKE 'wsrep_cluster_size';"
+--------------------+-------+
| Variable_name
| Value |
+--------------------+-------+
| wsrep_cluster_size | 2
|
+--------------------+-------+
Jika Value yang dihasilkan sama, mengindikasikan semua node sudah dengan baik
tergabung kedalam cluster.
Periksa primary status dari komponen cluster
[root@mariadb-cluster-node1 ~]# mysql -uroot -predhat -e"SHOW GLOBAL STATUS
LIKE 'wsrep_cluster_status';"
+----------------------+---------+
| Variable_name
| Value
|
+----------------------+---------+
| wsrep_cluster_status | Primary |
+----------------------+---------+
[root@mariadb-cluster-node2 ~]# mysql -uroot -predhat -e"SHOW GLOBAL STATUS
LIKE 'wsrep_cluster_status';"
+----------------------+---------+
| Variable_name
| Value
|
+----------------------+---------+
| wsrep_cluster_status | Primary |
+----------------------+---------+
Page 159
Hal Ini memberikan nilai rata-rata berapa banyak transaksi yang dapat diterapkan secara
bersamaan dalam satu waktu.
Memeriksa Perfoma Jaringan Yang Lambat
Jika Anda memiliki jaringan yang lambat atau jaringan sedang terdapat gangguan,
periksa nilai variabel di bawah ini:
wsrep_local_send_queue_avg
wsrep_local_send_queue_max
wsrep_local_send_queue_min
Untuk menentukan apakah Anda memiliki permasalahan jaringan, jalankan query berikut:
[root@mariadb-cluster-node2 ~]# mysql -uroot
'wsrep_local_send_queue_avg';"
+----------------------------+----------+
| Variable_name
| Value
|
+----------------------------+----------+
| wsrep_local_send_queue_avg | 0.000000 |
Page 160
-predhat
-e"SHOW
STATUS
LIKE
+----------------------------+----------+
Nilai tinggi dapat menunjukkan gangguan pada link jaringan. Jika hal ini terjadi,
penyebabnya bisa berada di setiap lapisan, dari komponen fisik untuk konfigurasi sistem
operasi.
Page 161
-= SEKIAN =-
Page 162