Kamis, 30 Desember 2010

Tips Cepet Lulus Kuliah

Buwat temen2 ku yang masih molor molor kuliah. Smangadh Bro masak kalian kalah ma si kecil mungil ini...


BTW, Anyway, Busway Dipikir-pikir kuliah itu pekerjaan yang gampang-gampang susah. Dibilang gampang karena secara teoritik dan praktik kuliah itu perkara yang sepele, paling mudah di dunia dan akhirat pada zaman ini, siapapun pasti bisa. Dibilang susah karena toh masih ada saja mahasiswa yang gagal atau terlambat menyelesaikan studinya, karena telat memahami bahwa kuliah itu perkara yang mudah.

Karena masih ada saja yang belum memahami hakikat kuliah maka saya tergugah untuk membagi-bagikan informasi berikut. Sebelumnya, tolong di catat baik-baik pernyataan berikut: “Keledai juga bisa lulus kuliah, kok!” Ini jock menarik yang saya peroleh dari dosen. Tak perlulah saudara ketahui siapa beliau yang pasti orang baik dan cerdas. Dalam konteks ini anda dan saya hanya berkepentingan dengan statement beliau sebagai asumsi untuk membangun kerangka argumentasi yang menerut Rene Descartes “Clear and Disting.” Dan saya orang yang bertanggung jawab mutlak atas penafsiran dan improvisasi selanjutnya demi keberhasilan anda. Jadi, yang paling penting bagi anda mulai detik ini, tanamkan dalam imaginasi anda: Keledai

Tidak peduli siapa anda, jurusan apa, dan kuliah dimana, tips ini akan berlaku secara universal karena berlandaskan riset panjang dan akurat. Anda akan merasa tercengang karena tips ini lebih canggih dari program akselerasi manapun, apalagi sekedar Quantum Learning.

Berikut ini tips cepat lulus kuliah ala Keledai

1. Keledai juga bisa lulus kalau mampu membayar uang bangunan dan SPP.

2. Keledaijuga bisa lulus kalau rajin masuk kelas dan mengisi absensi minimal 80%.

3. Keledai juga bisa lulus kalau rajin mengerjakan tugas kuliah biarpun nyontek.

4. Keledai juga bisa lulus kalau ikut paraktikum lapangan.

5. Keledai juga bisa lulus kalau ikut mengisi UTS dan UAS apapun jawabannya.

6. Keledai juga bisa lulus kalau rajin bimbingan skripsi.

7. Keledai juga bisa lulus karena malas kritis karena takut masuk UGD.

8. Keledai juga bisa lulus karena fokus kuliah dan tidak ikut-ikutan ormawa.
Jika tips di atas konsisten di laksanakan niscaya mimpi anda menjadi sarjana segera terkabul. Karena berdasarkan pengandaian, Keledai juga akan berhasil lulus dengan IPK Cum Laude dan berhasil meraih cita-cita mengenakan pakaian ala badut saat wisuda. Tidak apa-apa yang penting ibu domba dan ibu anda akan sama-sama senang melihat anaknya menjadi sarjana. Semoga bermanfaat bagi anda. Ayo semangat, malu dong sama Keledai....

Uhm… bagi yang bukan merasa keledai ayo smangadh. Dulu Saya targetin kerjain TA (Berhubung saya DIII kemudian ekstensi ke S1) dari tahun ke 2 (tepatnya semester awal semester 5), tetapi kenyataan molor karena saya cari sampingan kerja teknisi komputer di sebuah distributor sperpart komputer di jogjakarta.. tapi alhamdulillah akhirnya lulus juga dan bisa lanjutin S1 saya. Poin-poinnya:

1. Keluar dari kerja.. fokus kuliah.. Modifikasi dari model yang lama yaitu tinggalkan kuliah sambil kerja

2. Carilah literatur penunjang yang banyak! Punya saya daftar pustaka sampai 45 biji.

3. Manfaatin internet!

4. Nginep di perpus juga boleh, kan ada tuh namanya studi pustaka? katanya nginep di perpus. Haha..

5. Buat dateline kapan mau dikelarin!

6. de el el (boleh ditambahin)

bonus: punya affairs! dengan dosen!

Smoga ada Manfaat nya....

Sumber : http://iwankurniawan04.blogspot.com/2010/02/tips-cepet-lulus-kuliah.html

Dial-Up Aha di Linux Slackware


http://andika26.wordpress.com/2010/10/23/dial-up-aha-di-linux-slackware/

Mount Otomatis NTFS File system pada Slackware

Memang bagi seorang awam atau newbie terhadap slackware seperti saya ini, mungkin akan berkata slackware itu sangat sulit. Tapi saya akan menepisnya pendapat seperti itu. Karena hal mustahil kalau kita mengatakan SULIT tetapi kita belum mencobanya. Itu pasti jawaban orang yang tidak ingin maju dan tidak suka tantangan. Waktu Pertama kali menginstal linux slackware saya menemukan beberapa masalah seperti hal yang satu ini harddisk NTFS tidak dapat me-mounting secara otomatis. Tapi saya mendapatkan kembali solusinya dari Google :D .

Pertama Jika anda ingin me-mount Harddisk yang tipe File Systemnya (NTFS) pada Slackware, pastikan dulu sebelumnya paket ntfs-3g telah terinstall.
Cek letak Harddsik yang ingin di mount

root@ozan:~# fdisk -l

Disana akan muncul.

Disk /dev/sda: 640.1 GB, 640133946880 bytes
255 heads, 63 sectors/track, 77825 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Disk identifier: 0xe1bfe1bf

Device Boot Start End Blocks Id System
/dev/sda1 1 5227 41985846 7 HPFS/NTFS
/dev/sda2 5228 77824 583135402+ f W95 Ext’d (LBA)
/dev/sda3 * 68969 70184 9767520 83 Linux
/dev/sda4 70185 70306 979965 82 Linux swap
/dev/sda5 5228 43472 307202931 7 HPFS/NTFS
/dev/sda6 43473 68968 204796588+ 7 HPFS/NTFS

Langkah selanjutnya Untuk menggunakan ntfs-3g di Slackware kita perlu menginstal sekering pertama, untuk melakukan download versi terbaru dari fuse.sourceforge.net

1. mendapatkan versi terbaru dari sekering dari fuse.sourceforge.net
2. membongkar itu
$ tar-zxf fuse-2.7.0.tar.gz
3. masukkan direktori
$ cd fuse-2,7
4. mengkompilasi dan menginstalnya
$. /configure
$ make
$ sudo make install

dan sekarang instalasi ntfs-3g

1. mendapatkan versi terbaru dari ntfs-3g dari ntfs-3g.org
2. membongkar itu
$ tar-zxf ntfs-3g-1.616.tgz
3. masukkan direktori
$ cd ntfs-3g-1,616
4. mengkompilasi dan menginstalnya
$. /configure
$ make
$ sudo make install
5. Nah, setelah itu penulis buatlah folder dulu di /mnt sebagai contoh saya membuat 3 folder yaitu hda1, hda5, dan hda6. Fungsinya untuk mendirect hardi disk yang ada di sda1 ke hda1. Selanjutnya adalah mengubah dan menambahkan /etc/fstab untuk menunjukkan apa yang partisi Anda ingin memuat dengan ntfs-3g
$ sudo nano /etc/fstab
Disini penulis menambahkan file sda1 seperti contoh dibawah ini.
/dev/sda1 /mnt/hda1 ntfs-3g defaults 1 0
/dev/sda5 /mnt/hda5 ntfs-3g defaults 1 0
/dev/sda6 /mnt/hda6 ntfs-3g defaults 1 0
Setelah itu simpan fstab-nya kemudian restart komputer anda. Dan harddisk anda akan mount secara otomatis.

Sumber :

http://mfauzan.info/tag/mount-otomatis-ntfs-file-system-pada-slackware/

Selasa, 28 Desember 2010

Buktikan Anda hebat, bukalah source code Anda -> " I'M Not SUPERMAN "

By Yohanes Nugroho on March 8, 2010 9:57 AM | 1 Comment | No TrackBacks

Saya banyak mendengar orang yang merasa dirinya hebat dalam bidang programming, tapi tidak bisa membuktikan klaimnya. Jika ada yang bilang bahwa dirinya adalah penyanyi yang hebat, saya tinggal meminta dia menyanyi, jika dia adalah pelukis yang hebat, saya akan meminta dia melukis. Jika seseorang hanya memperlihatkan lukisan lalu bilang "saya melukis ini", maka saya belum tentu percaya bahwa itu adalah benar lukisannya.

Dalam hal programming, kadang-kadang ada orang yang memperlihatkan program yang sudah jadi sebagai "bukti" mereka jago memprogram. Tapi sebuah program tidak cukup bercerita (apalagi hanya dari screenshotnya). Kita tidak bisa melihat apa isi dalamnya, yang mungkin penuh dengan komponen buatan orang lain. Mungkin ada yang bangga bisa membuat "MP3 Player", tapi ternyata yang dibuat hanyalah user interface untuk komponen yang sudah ada. Tampilan bukanlah segalanya. Jika dibandingkan dengan seseorang yang membuat program command line yang memutar MP3 dengan membuat decodernya sendiri, saya akan menyatakan bahwa orang yang membuat decoder MP3 player tersebut jauh lebih hebat dibandingkan orang yang hanya membuat user interface saja.

Dengan tidak melihat source codenya, saya juga tidak yakin apakah gaya penulisan kode Anda bagus atau tidak. Bahkan ada kemungkinan ternyata source code Anda adalah hasil copy paste dari banyak tempat (yang bisa dicari dengan google code search). Saya sudah sering melihat banyak aplikasi yang seolah-olah hebat, tapi ternyata tidak sama sekali. Dengan sedikit reverse engineering, saya sudah melihat ada banyak aplikasi yang ternyata hanya memakai komponen yang sudah jadi (bahkan sebagian memakai komponen komersial dan tidak membayar, tapi diakali menggunakan crack).

Sebagian orang akan beralasan: wah saya tidak bisa memperlihatkan program saya atau source code saya, karena itu rahasia perusahaan. Jika Anda adalah programmer yang hebat, Anda tentunya akan membuat banyak program dalam hidup Anda (kecuali Anda sangat sibuk seperti Linus Torvalds yang hanya berkonsentrasi di Kernel Linux dan sedikit di Git). Program tersebut tidak perlu besar ataupun rumit. Banyak produk yang dibuat oleh programmer yang terdiri dari beberapa puluh, beberapa ratus, atau 1000-2000 baris kode saja dan sangat berguna bagi orang lain.

Kebanyakan plugin wordpress atau skrip GreaseMonkey hanya berkisar beberapa puluh sampai beberapa ratus baris kode. Bahkan Anda bisa membuat aplikasi serius tanpa harus menulis banyak kode. Jika Anda memang hebat. Misalnya salah satu produk web dari 37signals hanya terdiri atas 579 baris kode. Sebuah Window Manager untuk X11 dapat dibuat dalam 1000-2000 baris kode saja (contohnya xmonad dan dwm). Bahkan kernel sistem operasi Minix hanya sekitar 4000 baris kode saja (driver dsb dibuat di userspace, dan tidak termasuk dalam kode kernel).

Saya menggunakan metrik Lines of Code, karena ini yang paling mudah (meski tidak akurat), dan dengan aneka framework dan library yang ada saat ini Anda bisa menulis aplikasi lengkap dengan sangat cepat. Jadi saya tidak menantang Anda membuat program sangat kecil seperti dalam demoscene menggunakan assembly, tapi menantang Anda merilis program yang berguna, walaupun sederhana. Programnya juga sebaiknya memperlihatkan sesuatu yang baru atau menarik, bukan sekedar membuat another MP3 player dengan komponen buatan orang lain.

Saya belum merasa diri saya sudah hebat, tapi jika ada yang bertanya aplikasi apa saja yang sudah saya buat, saya bisa memperlihatkan halaman ini: http://yohan.es/applications/. Kalau ada orang lain yang mengaku hebat, tapi tidak bisa membuktikan kehebatannya, jangan-jangan dia hanya seperti djoko blue energy.



~_^



SUMBER

Minggu, 26 Desember 2010

Modul Java

1. Site
2. download

3. download

4. download

5. download

6. download

Modul Basis Data

1. Download

2. Download

Yeaah So Good Man :)

MySQL Tuning

Kadang dalam suatu aplikasi kita melakukan query select data pada
tabel yang sama dan dilakukan berulang-ulang, hal ini akan sangat
membebani MYSQL. Dalam MYSQL terdapat fitur yang bagus untuk
mempercepat query mysql dengan mengaktifkan query cache. Apabila fitur ini diaktifkan setiap query akan di cache di memory dan ini akan meningkatkan query performance.

Untuk mengaktifkan query cache, kita perlu menambahkan beberapa baris options di mysql configuration file (my.cnf) :

1 set query_cache_type = 1. (ada beberapa nilai yang mungkin : 0 (disable / off), 1 (enable / on) and 2 (on demand).

query-cache-type = 1

2 set query_cache_size = sesuai kemampuan RAM, yang direkomendasikan 20MB.

query-cache-size = 20M

Jika kita memeilih query-cache-type = 2 ( on demand ), anda perlu mengedit perintah query agar support cache, misal :

SELECT SQL_CACHE field1, field2 FROM table1 WHERE field3 = ‘yes’

Untuk mengecek apakah query cache sudah aktif, jalan lakukan perintah berikut :

SHOW VARIABLES LIKE ‘%query_cache%’;

Hasil nya :

+——————-+———+

| Variable_name | Value |

+——————-+———+

| have_query_cache | YES |

| query_cache_limit | 1048576 |

| query_cache_size | 20971520 |

| query_cache_type | ON |

+——————-+———+

4 rows in set (0.06 sec)

Untuk mengecek apakah query cache bisa berjalan dengan baik, caranya
lakukan 2 kali query yang sama dan cek variable berikut di MYSQL :

SHOW STATUS LIKE ‘%qcache%’;

+————————-+———-+

| Variable_name | Value |

+————————-+———-+

| Qcache_queries_in_cache | 1 |

| Qcache_inserts | 3 |

| Qcache_hits | 0 |

| Qcache_lowmem_prunes | 0 |

| Qcache_not_cached | 2 |

| Qcache_free_memory | 20947592 |

| Qcache_free_blocks | 1 |

| Qcache_total_blocks | 4 |

+————————-+———-+

Sumber :

1. Klik
2.Klik

Join MySQL 3

Link Ajah ||^__||||

CHECK LINK BROTHA...!!

Join MySQL 2

Pada modul ini, Anda akan mempelajari apa itu join, mengapa digunakan dan bagaimana statemen SELECT menggunakannya.
1 Memahami Join

Salah
satu fitur SQL yang paling berguna adalah kemampuan untuk menggabungkan
tabel dengan query-query yang mendapatkan kembali data. Join adalah
salah satu dari beberapa operasi paling penting yang dapat Anda lakukan
dengan menggunakan statemen SELECT. Dan sebagai bagian penting dalam mempelajari SQL, Anda perlu memahami dengan baik join dan sintaks join.


2 Mengapa Menggunakan Join

Pemisahan
data ke dalam banyak tabel memungkinkan proses pemyimpanan menjadi
lebih efesien, manipulasi lebih mudah dan skalabilitas yang lebih
besar. Tetapi manfaat tersebut ada tuntutan.

Jika data disimpan dalam banyak tabel, bagaimana Anda dapat mendapatkan kembali data dengan sebuah statemen SELECT tunggal ?

Jawabannya
adalah dengan menggunakan join. Join adalah mekanisme yang digunakan
untuk menghubungkan beberapa tabel dengan statemen SELECT
(dan karena itu disebut join). Dengan menggunakan sintaks khusus,
beberapa tabel dapat digabungkan sehingga dapat dihasilkan sekumpulan
output tunggal, dan join menghubungkan record-record yang benar
disetiap tabel.


3 Membuat Join

Membuat
join sangat sederhana. Anda harus menentukan semua tabel yang akan
dimasukkan dan bagaimana tabel itu dihubungkan satu dengan yang
lainnya. Lihat contoh berikut ini :

INPUT

SELECT Supplier.Nama, Barang.Nama, Barang.Harga

FROM Supplier, Barang

WHERE Supplier.KodeSup = Barang.KodeSup



OUTPUT

Nama Nama Harga

------------ ---------- -----

Bears R Us 8 inch teddy bear 5.99

Bears R Us 12 inch teddy bear 8.99

Bears R Us 18 inch teddy bear 11.99

Doll House Inc. Fish bean bag toy 3.49

Doll House Inc. Bird bean bag toy 3.49

Doll House Inc. Rabbit bean bag toy 3.49

Doll House Inc. Raggedy Ann 4.99

ANALYSIS

Statemen SELECT
memulai dengan cara yang sama seperti semua statemen yang Anda ketahui
sejauh ini, dengan menetapkan field yang didapatkan kembali. Perbedaan
besar disini adalah dua dari field yang ditentukan (Barang.Nama dan Barang.Harga) ada pada satu tabel, sedangkan yang lainnya (Supplier.Nama) pada tabel lainnya.

Sekerang perhatikan klausa FROM. Tidak seperti semua statemen SELECT sebelumnya, statemen ini mempunyai dua tabel pada klausa FROM, yaitu Supplier dan Barang. Keduanya adalah nama dua tabel yang akan digabungkan dalam statemen SELECT. Tabel-tabel digabung dengan benar dengan klausa WHERE yang memerintahkan DBMS untuk mencocokkan KodeSup pada tabel Supplier dengan KodeSup pada tabel Barang.

Anda juga mencatat bahwa field tersebut ditetapkan sebagai Supplier.KodeSup dan Barang.KodeSup. Disini diperlukan nama field yang terkualifikasi sepenuhnya, karena jika Anda hanya menentukan KodeSup, DBMS tidak dapat memberi tahu field KodeSup mana yang akan Anda hubungi (Ada dua KodeSup, satu pada setiap tabel). Seperti dapat Anda lihat pada outputnya, statemen SELECT tunggal mengembalikan data dari dua tabel yang berbeda.


4 Pentingnya Klausa WHERE

Mungkin terlihat aneh jika menggunakan klausa WHERE untuk mengatur hubungan join, tetapi sebenarnya, ada sebuah alasa yang sangat bagus untuk ini. Ingat, jika tabel-tabel digabungkan dalam statemen SELECT, maka hubungan itu disusun on-the-fly.
Tidak ada sesuatu dalam definisi tabel database yang dapat
memerintahkan DBMS bagaimana menggabungkan tabel. Anda harus
melakukannya sendiri.

Ketika
Anda menggabungkan dua tabel, yang sebenarnya Anda lakukan adalah
memasangkan setiap record pada tabel pertama dengan setiap record pada
tabel kedua. Klausa WHERE (seperti semua klausa WHERE)
bertindak sebagai penyaring untuk hanya memasukkan record yang memenuhi
kondisi penyaringan yang telah ditentukan – disini kondisi join.

Untuk memahami hal tersebut, lihat statemen SELECT dan output berikut ini :

INPUT

SELECT Supplier.Nama, Barang.Nama, Barang.Harga

FROM Supplier, Barang

OUTPUT

Nama Nama Harga

------------ ---------- -----

Bears R Us 8 inch teddy bear 5.99

Bear Emporium 8 inch teddy bear 5.99

Doll House Inc. 8 inch teddy bear 5.99

Furball Inc. 8 inch teddy bear 5.99

Bears R Us 12 inch teddy bear 8.99

Bear Emporium 12 inch teddy bear 8.99

Doll House Inc. 12 inch teddy bear 8.99

Furball Inc. 12 inch teddy bear 8.99

Bears R Us 18 inch teddy bear 11.99

Bear Emporium 18 inch teddy bear 11.99

Doll House Inc. 18 inch teddy bear 11.99

Furball Inc. 18 inch teddy bear 11.99

Bears R Us Fish bean bag toy 3.49

Bear Emporium Fish bean bag toy 3.49

Doll House Inc. Fish bean bag toy 3.49

Furball Inc. Fish bean bag toy 3.49

Bears R Us Bird bean bag toy 3.49

Bear Emporium Bird bean bag toy 3.49

Doll House Inc. Bird bean bag toy 3.49

Furball Inc. Bird bean bag toy 3.49

Bears R Us Rabbit bean bag toy 3.49

Bear Emporium Rabbit bean bag toy 3.49

Doll House Inc. Rabbit bean bag toy 3.49

Furball Inc. Rabbit bean bag toy 3.49

Bears R Us Raggedy Ann 4.99

Bear Emporium Raggedy Ann 4.99

Doll House Inc. Raggedy Ann 4.99

Furball Inc. Raggedy Ann 4.99

ANALYSIS

Seperti Anda lihat pada output terdahulu, Cartesian Product jarang Anda inginkan. Data yang dikembalikan disini mencocokkan setiap barang dengan

setiap supplier, termasuk barang-barang dengan supplier yang salah.



Catatan Penting

Jangan Lupakan Klausa WHERE. Pastikan semua join Anda mempunyai klausa WHERE, atau DBMS akan mengembalikan lebih banyak data daripada yang Anda inginkan. Pastikan juga klausa WHERE Anda benar. Kondisi penyaringan yang tidak benar akan menyebabkan DBMS mengembalikan data yang tidak benar.


5 Inner Join

Join yang Anda gunakan selama ini disebut EQUIJOIN – join berdasarkan pengujian persamaan tabel antara dua tabel. Jeni join ini juga disebut INNER JOIN.
Pada dasarnya, beberapa DBMS menggunakan sintaks yang sedikit berbeda
karena join tersebut menetapkan tipe join yang jelas berbeda. Statemen SELECT berikut ini mengembalikan data yang tepat sama seperti contoh terdahulu.

INPUT

SELECT Supplier.Nama, Barang.Nama, Barang.Harga

FROM Supplier INNER JOIN Barang

ON Supplier.KodeSup = Barang.KodeSup

ANALYSIS

SELECT pada statemen ini sama seperti statemen SELECT sebelumnya, tetapi klausa FROM berbeda. Hubungan antara dua tabel adalah bagian dari klausa FROM yang ditentukan sebagai INNER JOIN. Ketika menggunakan sintaks ini, kondisi join ditetapkan dengan menggunakan klausa ON khusus sebagai pengganti klausa WHERE. Kondisi sebenarnya yang dilewatkan pada ON sama seperti yang dilewatkan pada WHERE.


6 Menggabungkan Banyak Tabel

SQL tidak menentukan batasan untuk jumlah tabel yang mungkin digabungkan dalam statemen SELECT.
Peraturan dasar untuk membuat join tetap sama. Pertama, daftarkan semua
tabel dan kemudian tentaukan hubungan di antara setiap tabel. Contohnya
sebagai berikut :

INPUT

SELECT Supplier.Nama, Barang.Nama, Barang.Harga, BarangJual.Jumlah

FROM BarangJual, Barang, Supplier

WHERE Barang.KodeSup = Supplier.KodeSup

AND BarangJual.KodeBrg = Barang.KodeBrg

AND NoFaktur = '20007';

OUTPUT

Nama Nama Harga Jumlah

---- ---- ----- ------

Bears R Us 18 inch teddy bear 11.99 50

Doll House Inc. Rabbit bean bag toy 3.49 100

Doll House Inc. Bird bean bag toy 3.49 100

Doll House Inc. Rabbit bean bag toy 3.49 100

Doll House Inc. Raggedy Ann 4.99 50

ANALYSIS

Contoh tersebut menampilkan item pada pesanan NoFaktur 20007. Item pesanan disimpan pada tabel BarangJual. Setiap barang disimpan berdasarkan kode barang itu, yang merujuk kepada barang dalam tabel barang. Barang dihubungkan ke supplier yang tepat pada tabel supplier berdasarkan kode supplier, yang disimpan dengan setiap catatan barang. Klausa FROM disini mendaftar tiga tabel, dan klausa WHERE menetapkan kondisi join. Kondisi WHERE tambahan kemudian digunakan untuk menyaring hanya item-item untuk pesanan 20007.



Contoh kasus lain untuk INNER JOIN :

INPUT

SELECT Nama, Kontak

FROM Customer, Penjualan, BarangJual

WHERE Customer.KodeCus = Penjualan.KodeCus

AND BarangJual.NoFaktur = Penjualan.NoFaktur

AND KodeBrg = 'RGAN01'

OUTPUT

Nama Kontak

---- ------

Fun4All Denise L. Stephens

ANALYSIS

Ada tiga kondisi klausa WHERE disini dua kondisi pertama menghubungkan tabel dalam join, dan yang terakhir menyaring data untuk barang RGAN01.
7 Tipe-Tipe Join

Sejauh ini Anda hanya menggunakan join sederhana yang dikenal sebagai INNER JOIN EQUIJOIN. Sekarang perhatikan tiga tipe join tambahan : SELF-JOIN, NATURAL JOIN dan OUTER JOIN.


1 Membuat Self-Join

Salah satu alasan utama menggunakan alias tabel adalah untuk merujuk kepada tabel yang sama lebih dari satu kali pada statemen SELECT tunggal. Ada contoh untuk menunjukkan hal ini.

Misalkan Anda ingin mengirim sebuah surat ke semua kontak pelanggan yang bekerja untuk perusahaan yang sama dimana Jim Jones bekerja. Query ini mengharuskan Anda pertama-tama mencari perusahaan tempat Jim Jones bekerja,
dan selanjutnya pelanggan mana yang bekerja untuk perusahaan tersebut.
Berikut ini satu cara untuk menyelesaikan masalah tersebut :

INPUT

SELECT c1.KodeCus, c1.Nama, c1.Kontak

FROM Customer c1, Customer c2

WHERE c1.Nama = c2.Nama

AND c2.Kontak='Jim Jones'

OUTPUT

KodeCus Nama Kontak

------- ---- ------

1000000003 Fun4All Jim Jones

1000000004 Fun4All Denise L. Stephens

ANALYSIS

Dua tabel yang dibutuhkan pada query ini sebenarnya adalah tabel yang sama, dan karena itu tabel Customer muncul dua kali pada klausa FROM. Meskipun ini sah sama sekali, tetapi semua referensi ke tabel Customer akan ambigous karena DBMS tidak mengetahui tabel Customer yang Anda rujuk.

Untuk memecahkan masalah ini, digunakan alias-alias tabel. Kejadian pertama pada Customer punya alias c1, dan kejadian kedua mempunyai alias c2. Sekarang alias-alias itu dapat digunakan sebagai nama tabel. Statemen SELECT, misalnya, menggunakan prefiks c1 untuk
menyatakan eksplisit nama lengkap dari field yang diinginkan. Jika ini
tidak dilakukan, DBMS akan menghasilkan sebuah error karena ada dua
field bernama KodeSup, Nama dan Kontak. DBMS tidak dapat mengetahui yang mana yang Anda inginkan (bahkan sekalipun field itu hanya satu dan sama). Klausa WHERE pertama-tama menghubungkan tabel, dan kemudian menyaring data dengan Kontak pada tabel kedua untuk mengembalikan hanya data yang diinginkan.


2 Natural Join

Kapanpun
tabel digabungkan, sedikitnya ada satu field yang akan muncul pada
lebih dari satu tabel (field yang digabungkan). Penggabungan standar (INNER JOIN yang Anda pelajari diatas) mengembalikan semua data, bahkan banyak kejadian pada field yang sama. NATURAL JOIN hanya mengurangi kejadian tersebut sehingga hanya satu pada setiap field yang dikembalikan.

Sebenarnya bukan NATURAL JOIN yang melakukan hal tersebut, melainkan Anda yang melakukan. NATURAL JOIN adalah join dimana dilakukan dengan menggunakan wildcard (SELECT *) untuk satu tabel dan sub-kumpulan eksplisit dari field untuk semua tabel lainnya. Berikut ini contohnya :

INPUT

SELECT C.*, P.NoFaktur, P.Tanggal, BJ.KodeBrg, BJ.Jumlah, BJ.Harga

FROM Customer C, Penjualan P, BarangJual BJ

WHERE C.KodeCus = P.KodeCus

AND BJ.NoFaktur = P.NoFaktur

AND KodeBrg = 'RGAN01'

ANALYSIS

Pada
Contoh tersebut, wildcard digunakan hanya untuk tabel yang pertama.
Seluruh field lainnya dengan jelas di daftar sehingga tidak ada field
duplikat yang di dapat kembali.

Sebenarnya, setiap INNER JOIN yang Anda buah sejauh ini adalah NATURAL JOIN, dan Anda tidak pernah membutuhkan INNER JOIN yang bukan NATURAL JOIN.


3 Outer Join

Kebanyakan
join menghubungkan record-record dalam satu tabel dengan record-record
tabel lainnya. Tetapi kadang-kadang Anda perlu memasukkan record yang
tidak mempunyai record-record yang berhubungan. Sebagai contoh, Anda
mungkin menggunakan join untuk menyelesaikan tugas berikut :

· Menghitung berapa banyak pesanan yang dibuat oleh setiap pelanggan, termasuk pelanggan yang sudah melakukan pesanan.

· Mendaftar semua barang dengan banyaknya pesanan, termasuk barang yang tidak dipesan oleh siapapun.

· Menjumlah rata-rata ukuran penjualan, mencakup rekening pelanggan yang belum melakukan pesanan.

Pada
setiap contoh tersebut, join memasukkan record-record tabel yang tidak
mempunyai record berkaitan dalam tabel terkait. Tipe join ini disebut OUTER JOIN.

Statemen SELECT berikut adalah INNER JOIN. Statemen ini mendapatkan kembali daftar semua pelanggan dan pesanan mereka :

INPUT

SELECT Customer.KodeCus, Penjualan.NoFaktur

FROM Customer INNER JOIN Penjualan

ON Customer.KodeCus = Penjualan.KodeCus



Untuk
mendapatkan kembali daftar semua pelanggan, termasuk pelanggan yang
tidak membuat pesanan, Anda dapat melakukan hal berikut :

INPUT

SELECT Customer.KodeCus, Penjualan.NoFaktur

FROM Customer LEFT OUTER JOIN Penjualan

ON Customer.KodeCus = Penjualan.KodeCus

OUTPUT

KodeCus NoFaktur

------- --------

1000000001 20005

1000000001 20009

1000000002 NULL

1000000003 20006

1000000004 20007

1000000005 20008

ANALYSIS

Seperti INNER JOIN, statemen SELECT ini menggunakan keyword OUTER JOIN untuk menentukan tipe join. Tetapi tidak seperti INNER JOIN, yang menghubungkan record pada kedua tabel, OUTER JOIN juga memasukkan record dengan yang tidak berhubungan. Dan seperti terlihat pada contoh sebelumnya, ketika membuat OUTER JOIN, Anda harus menentukan tabel dari mana Anda memasukkan semua record. Jika Anda menggunakan sintaks OUTER JOIN, Anda harus menggunakan keyword RIGHT atau LEFT. Contoh diatas menggunakan LEFT OUTER JOIN untuk memilih semua record dari tabel pada bagian kiri klausa FROM (tabel Customer). Untuk memilih semua record dari tabel pada bagian kanan, Anda dapat menggunakan RIGHT OUTER JOIN seperti terlihat pada contoh berikut :

INPUT

SELECT Customer.KodeCus, Penjualan.NoFaktur

FROM Customer RIGHT OUTER JOIN Penjualan

ON Customer.KodeCus = Penjualan.KodeCus

OUTPUT

KodeCus NoFaktur

------- --------

1000000001 20005

1000000003 20006

1000000004 20007

1000000005 20008

1000000001 20009

Tanpa memperhatikan bentuk OUTER JOIN yang digunakan, selalu ada dua bentuk dasar pada OUTER JOIN, yaitu LEFT OUTER JOIN dan RIGHT OUTER JOIN. Perbedaan di antara keduanya hanya urutan tabel yang akan dihubungkan. Dengan demikian, dua tipe OUTER JOIN dapat digunakan secara bergantian, dan keputusan tentang mana yang digunakan semata-mata tergantung pada kenyamanan.

*Menggabungkan Tabel ditulis oleh Muhammad Idris

Sumber :

Join MySQL 1

pada suatu kasus, terdapat tabel sederhana pengguna dengan struktur dan data sebagai berikut
tabel pengguna

CREATE TABLE `pengguna` (
`id_pengguna` int(11) NOT NULL auto_increment,
`nama` varchar(20) NOT NULL,
PRIMARY KEY (`id_pengguna`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

tabel pengguna_lengkap

CREATE TABLE `pengguna_lengkap` (
`id_pengguna` int(11) NOT NULL,
`alamat` varchar(50) NOT NULL,
`telepon` varchar(15) NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

data:

INSERT INTO `pengguna` (`id_pengguna`, `nama`) VALUES
(1, 'khalifavi'),
(2, 'silvershade'),
(3, 'kaelina');

INSERT INTO `pengguna_lengkap` (`id_pengguna`, `alamat`, `telepon`) VALUES
(1, 'cigiringsing', '081910435544'),
(2, 'cijambe', '022 7815913'),
(4, 'tubagus ismail', '022 91724325');

dari data tersebut, dapat kita lihat bahwa pada tabel pengguna, tidak terdapat record dengan id 4, dan begitu pula pada tabel pengguna_lengkap tidak terdapat record dengan id 3.
apabila dilakukan join biasa maka beberapa record tidak akan tampil seperti yang kita mau

SELECT * FROM pengguna p, pengguna_lengkap pk
WHERE p.id_pengguna = pk.id_pengguna;

lalu dimana yang memiliki id_pengguna 3 dan 4?, untuk itulah ada beberapa join khusus…

untuk menampilkan semua yang terdapat di tabel pengguna namun tidak terdapat di tabel pengguna_lengkap kita bisa menggunakan LEFT JOIN

SELECT *
FROM pengguna p LEFT JOIN pengguna_lengkap pk
ON p.id_pengguna = pk.id_pengguna;

Selengkapnya

View MySQL

View bisa dikatakan summary dari tabel atau beberapa tabel, dengan view, kita bisa gabungkan beberapa tabel sekaligus dan view ini tersimpan di sisi server, sehingga nanti penggunaannya tinggal panggil saja, berikut contohnya, :D:\its me\xampp\mysql\bin>mysql -u root
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 4
Server version: 5.0.41-community-nt MySQL Community Edition (GPL)

Type ‘help;’ or ‘\h’ for help. Type ‘\c’ to clear the buffer.

mysql> create database forum;
Query OK, 1 row affected (0.00 sec)

mysql> use forum;
Database changed
mysql> create table barang(kode_barang char(3) not null primary key default’0′,n
ama_barang char(30),harga_barang int);
Query OK, 0 rows affected (0.09 sec)

mysql> insert into barang values(’001′,’mobil’,50000000);
Query OK, 1 row affected (0.05 sec)

mysql> create table jual(tgl date,kode char(3),jml_jual int);
Query OK, 0 rows affected (0.09 sec)

mysql> insert into jual values(’2007-01-01′,’001′,3);
Query OK, 1 row affected (0.00 sec)

mysql> create view jualan_view as select DATE_FORMAT(b.tgl,’%d %M %Y’) as tgl,b.kode,a.nama_barang, a.harga_barang,b.jml_jual,(a.harga_barang*b.jml_jual) as total from jual b, barang a where
b.kode=a.kode_barang;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from jualan_view;
==========================================
| tgl | kode | nama_barang | harga_barang | jml_jual | total |
===========================================
| 01 January 2007 | 001 | mobil | 50000000 | 3 | 150000000 |
+———————–+——+————-+————–+———-+
1 row in set (0.00 sec)

Sumber :

Membuat Database MySQL 2

mysql> create database JMB;

mysql> use JMB;
Database changed


//Membuat Tabel User sebagai Login

PRIMARY KEY CREATE TABLE user (
-> username VARCHAR(15) NOT NULL,
-> password VARCHAR(10) NOT NULL,
-> PRIMARY KEY(username), UNIQUE(username));
Query OK, 0 rows affected (0.14 sec)

mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| jmb |
| mysql |
| test |
+--------------------+
4 rows in set (0.03 sec)

mysql> describe user;
+----------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+-------+
| username | varchar(15) | NO | PRI | NULL | |
| password | varchar(10) | NO | | NULL | |
+----------+-------------+------+-----+---------+-------+
2 rows in set (0.03 sec)


//Tabel tbBuku


mysql> CREATE TABLE tbBuku (
-> B_ISBN VARCHAR(15),
-> B_Title VARCHAR(50),
-> B_Authors VARCHAR(50),
-> B_Publisher VARCHAR(50),
-> B_Price Float(50),
-> PRIMARY KEY(B_ISBN), UNIQUE(B_ISBN));
Query OK, 0 rows affected (0.09 sec)


mysql> describe tbBuku;
+-------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------------+-------------+------+-----+---------+-------+
| B_ISBN | varchar(15) | NO | PRI | | |
| B_Title | varchar(50) | YES | | NULL | |
| B_Authors | varchar(50) | YES | | NULL | |
| B_Publisher | varchar(50) | YES | | NULL | |
| B_Price | double | YES | | NULL | |
+-------------+-------------+------+-----+---------+-------+
5 rows in set (0.00 sec)


//Describe tabel and Insert Table

mysql> use jmb;
Database changed
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| jmb |
| mysql |
| test |
+--------------------+
4 rows in set (0.00 sec)

mysql> select * from user;
+------------+----------+
| username | password |
+------------+----------+
| Ninku Reka | Namco |
+------------+----------+
1 row in set (0.00 sec)

mysql> insert into user(username, password) values ('Mbah Kaum', 'iramaya');
Query OK, 1 row affected (0.03 sec)

mysql> select * from user;
+------------+----------+
| username | password |
+------------+----------+
| Mbah Kaum | iramaya |
| Ninku Reka | Namco |
+------------+----------+
2 rows in set (0.00 sec)

mysql> DELETE FROM tbBiodata WHERE id = 10

Query OK, 1 row affected (0.08 sec)

Membuat Database MySQL

Berikut ini contoh-contoh perintah SQL di MySQL. Contoh kasusnya untuk
membuat database penggajian sederhana dimana:
Gaji Bersih = Gaji Pokok + Tunjangan Transport + Bonus – Potongam
Tunjangan Transport = Jumlah Hari masuk * 20.000
A. MEMBUAT DATABASE “PAYROLLDB”
mysqladmin create payrolldb
*****************************************
B. MEMBUAT TABEL-TABEL YANG DIPERLUKAN
Membuat table “t_pegawai”
CREATE TABLE t_pegawai ( nip varchar (10), nama varchar (30), gapok int
(8),PRIMARY KEY (nip) )
Membuat table “t_gajian”
CREATE TABLE t_gajian2 ( id int(11) AUTO_INCREMENT, nip varchar(10),
periode varchar(6), masuk int(2), bonus float, potongan float, PRIMARY KEY
(id))
*****************************************
C. MENAMBAHKAN DATA KE TABEL
Menambah data pada table “t_pegawai”
INSERT INTO `t_pegawai` VALUES (’090022001′,’Puji Hartono’,1500000);
INSERT INTO `t_pegawai` VALUES (’090022002′,’Mahaputra’,1750000);
INSERT INTO `t_pegawai` VALUES (’090022003′,’Tarmizi’,1900000);
INSERT INTO `t_pegawai` VALUES (’090022004′,’Iwan’,1500000);
INSERT INTO `t_pegawai` VALUES (’090022005′,’Agus’,2000000);
INSERT INTO `t_pegawai` VALUES (’090022006′,’Budi’,1100000);
INSERT INTO `t_pegawai` VALUES (’090022007′,’Amin’,1200000);
INSERT INTO `t_pegawai` VALUES (’090022008′,’Galih’,1400000);
INSERT INTO `t_pegawai` VALUES (’090022009′,’Irwan’,1700000);
INSERT INTO `t_pegawai` VALUES (’090022010′,’Miki’,1600000);
Menambah data pada table “t_pegawai”
INSERT INTO `t_gajian` VALUES (0,’090022061′,’200801′,20,300000,0);
INSERT INTO `t_gajian` VALUES (1,’090022062′,’200801′,19,0,0);
INSERT INTO `t_gajian` VALUES (2,’090022063′,’200801′,18,500000,300000);
INSERT INTO `t_gajian` VALUES (3,’090022064′,’200801′,20,0,0);
INSERT INTO `t_gajian` VALUES (4,’090022065′,’200801′,20,300000,500000);
INSERT INTO `t_gajian` VALUES (5,’090022066′,’200801′,18,0,0);
INSERT INTO `t_gajian` VALUES (6,’090022067′,’200801′,17,0,200000);
INSERT INTO `t_gajian` VALUES (7,’090022068′,’200801′,20,300000,300000);
INSERT INTO `t_gajian` VALUES (8,’090022069′,’200801′,20,250000,0);
INSERT INTO `t_gajian` VALUES (9,’090022070′,’200801′,18,600000,200000);
*****************************************
D. MELIHAT DATA
Menampilkan data dalam tabel t_pegawai
mysql> select * from t_pegawai;
+———–+————–+———+
| nip | nama | gapok |
+———–+————–+———+
| 090022001 | Puji Hartono | 1500000 |
| 090022002 | Mahaputra | 1750000 |
| 090022003 | Tarmizi | 1900000 |
| 090022004 | Iwan | 1500000 |
| 090022005 | Agus | 2000000 |
| 090022006 | Budi | 1100000 |
| 090022007 | Amin | 1200000 |
| 090022008 | Galih | 1400000 |
| 090022009 | Irwan | 1700000 |
| 090022010 | Miki | 1600000 |
+———–+————–+———+
10 rows in set (0.00 sec)
Menampilkan data dalam tabel t_gajian
mysql> select * from t_gajian;
+—-+———–+———+——-+——–+———-+
| id | nip | periode | masuk | bonus | potongan |
+—-+———–+———+——-+——–+———-+
| 0 | 090022061 | 200801 | 20 | 300000 | 0 |
| 1 | 090022062 | 200801 | 19 | 0 | 0 |
| 2 | 090022063 | 200801 | 18 | 500000 | 300000 |
| 3 | 090022064 | 200801 | 20 | 0 | 0 |
| 4 | 090022065 | 200801 | 20 | 300000 | 500000 |
| 5 | 090022066 | 200801 | 18 | 0 | 0 |
| 6 | 090022067 | 200801 | 17 | 0 | 200000 |
| 7 | 090022068 | 200801 | 20 | 300000 | 300000 |
| 8 | 090022069 | 200801 | 20 | 250000 | 0 |
| 9 | 090022070 | 200801 | 18 | 600000 | 200000 |
+—-+———–+———+——-+——–+———-+
Mengurutkan data berdasar gaji pokok
mysql> select * from t_pegawai order by gapok;
+———–+————–+———+
| nip | nama | gapok |
+———–+————–+———+
| 090022006 | Budi | 1100000 |
| 090022007 | Amin | 1200000 |
| 090022008 | Galih | 1400000 |
| 090022001 | Puji Hartono | 1500000 |
| 090022004 | Iwan | 1500000 |
| 090022010 | Miki | 1600000 |
| 090022009 | Irwan | 1700000 |
| 090022002 | Mahaputra | 1750000 |
| 090022003 | Tarmizi | 1900000 |
| 090022005 | Agus | 2000000 |
+———–+————–+———+
10 rows in set (0.07 sec)
Mencari data pegawai
mysql> select * from t_pegawai where nama like ‘%agus%’;
+———–+——+———+
| nip | nama | gapok |
+———–+——+———+
| 090022005 | Agus | 2000000 |
+———–+——+———+
1 row in set (0.02 sec)
Membatasi output Query dengan limit
mysql> select * from t_pegawai limit 0,5;
+———–+————–+———+
| nip | nama | gapok |
+———–+————–+———+
| 090022001 | Puji Hartono | 1500000 |
| 090022002 | Mahaputra | 1750000 |
| 090022003 | Tarmizi | 1900000 |
| 090022004 | Iwan | 1500000 |
| 090022005 | Agus | 2000000 |
+———–+————–+———+
5 rows in set (0.00 sec)
Menjumlah sebuah field
mysql> select sum(gapok) AS Total_Gaji from t_pegawai;
+————+
| Total_Gaji |
+————+
| 15650000 |
+————+
1 row in set (0.01 sec)
Mencari nilai field tertinggi
mysql> select max(gapok) AS Gaji_Tertinggi from t_pegawai;
+—————-+
| Gaji_Tertinggi |
+—————-+
| 2000000 |
+—————-+
1 row in set (0.02 sec)
Mencari nilai field terendah
mysql> select min(gapok) AS Gaji_Terendah from t_pegawai;
+—————+
| Gaji_Terendah |
+—————+
| 1100000 |
+—————+
1 row in set (0.01 sec)
Mencari nilai rata-rata dari sebuah field
mysql> select avg(gapok) AS Gaji_Rata_Rata from t_pegawai;
+—————-+
| Gaji_Rata_Rata |
+—————-+
| 1565000.0000 |
+—————-+
1 row in set (0.02 sec)
Menghitung jumlah record
mysql> select count(nama) as Total from t_pegawai;
+——-+
| Total |
+——-+
| 10 |
+——-+
1 row in set (0.00 sec)
*****************************************
E. MENGUBAH DATA
mysql> update t_pegawai set nama=’Iwan S’ where nip=’090022004′;
Query OK, 0 rows affected (0.00 sec)
Rows matched: 1 Changed: 0 Warnings: 0
mysql> select * from t_pegawai;
+———–+————–+———+
| nip | nama | gapok |
+———–+————–+———+
| 090022001 | Puji Hartono | 1500000 |
| 090022002 | Mahaputra | 1750000 |
| 090022003 | Tarmizi | 1900000 |
| 090022004 | Iwan S | 1500000 | <<= Data yang telah diubah | 090022005 | Agus | 2000000 | | 090022006 | Budi | 1100000 | | 090022007 | Amin | 1200000 | | 090022008 | Galih | 1400000 | | 090022009 | Irwan | 1700000 | | 090022010 | Miki | 1600000 | +———–+————–+———+ 10 rows in set (0.01 sec) ***************************************** F. MENGHAPUS DATA
mysql> delete from t_pegawai where nip=’090022001′;
Query OK, 1 row affected (0.02 sec)mysql> select * from t_pegawai;
+———–+———–+———+
| nip | nama | gapok |
+———–+———–+———+
| 090022002 | Mahaputra | 1750000 |
| 090022003 | Tarmizi | 1900000 |
| 090022004 | Iwan S | 1500000 |
| 090022005 | Agus | 2000000 |
| 090022006 | Budi | 1100000 |
| 090022007 | Amin | 1200000 |
| 090022008 | Galih | 1400000 |
| 090022009 | Irwan | 1700000 |
| 090022010 | Miki | 1600000 |
+———–+———–+———+
9 rows in set (0.00 sec)
*****************************************
G. QUERY BEBERAPA TABEL
Terakhir, kita akan membuat penghitungan gaji berdasarkan:
- Jumlah hari masuk
- Bonus
- Potongan
Gaji Bersih = Gaji Pokok + (Jumlah Hari Masuk * 20.000) + Bonus – Potongan
mysql> select t_gajian.periode, t_pegawai.nip, t_pegawai.nama, gapok+
(masuk*20000) + bonus-potongan as ‘Gaji Bersih’ from t_pegawai,t_gajian
where t_pegawai.nip=t_gajian.nip;
+———+———–+————–+————-+
| periode | nip | nama | Gaji Bersih |
+———+———–+————–+————-+
| 200801 | 090022001 | Puji Hartono | 2200000 |
| 200801 | 090022002 | Mahaputra | 2130000 |
| 200801 | 090022003 | Tarmizi | 2460000 |
| 200801 | 090022004 | Iwan S | 1900000 |
| 200801 | 090022005 | Agus | 2200000 |
| 200801 | 090022006 | Budi | 1460000 |
| 200801 | 090022007 | Amin | 1340000 |
| 200801 | 090022008 | Galih | 1800000 |
| 200801 | 090022009 | Irwan | 2350000 |
| 200801 | 090022010 | Miki | 2360000 |
+———+———–+————–+————-+
10 rows in set (0.00 sec)
*****************************************
H. MEMBACKUP/MERESTOR DATA

mysqldump –u root –p payrooldb > backup.sql
Merestore
Mysql –u root –p payrooldb < backup.sql

Trigger MySQL

Untuk membuat trigger di MySQL and harus mengaktifkan INODB pada MySQL. Setelah aktif barulah kita bisa menggunkan fasilitas trigger pada MySQL. Ok langsung pada tujuan mari kita mulai proyek kita, pertama – tama kita akan membuat 2 buah tabel untuk percobaan kita

Code :

CREATE TABLE `tbl_pertama` (
`kode` char(2) NOT NULL,
`nama` varchar(20) default NULL,
PRIMARY KEY (`kode`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `tbl_kedua` (
`kode_kedua` char(2) NOT NULL,
`nama_kedua` varchar(20) default NULL,
PRIMARY KEY (`kode_kedua`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Trigger berada pada sebuah table tertentu jadi trigger akan bekerja jika sebuah table mengalami seuatu kejadian, jadi trigger akan bekerja secara otomatis jika sebuah table mengalami proses.

Trigger dapat bekerja BEFORE atau AFTER sebuah tabel mengalami tiga kejadian [Insert, Edit, delete]. Saya harap semua telah mengerti sampai di sini. Trigger dapat berjalan pada saat table mengalami tiga kejadian tersebut [Insert, Edit, delete]. Trigger bukannya bisa melakukan dua proses malah bisa lebih dari satu atau dua proses.

Mari kita buat trigger pada tabel percobaan kita. Pada contoh kasus ini jika kita melakukan pengisian pada tabel pertama makan otomatis tabel kedua akan terisi, begitu juga saat kita melakakukan update dan delete.

Code :
Untuk proses insert :

CREATE TRIGGER `tr_insert` AFTER INSERT ON `tbl_pertama`
FOR EACH ROW
BEGIN
INSERT INTO tbl_kedua values(new.kode, new.nama);
END;

Untuk proses update :

CREATE TRIGGER `tr_update` AFTER UPDATE ON `tbl_pertama`
FOR EACH ROW
BEGIN
update tbl_kedua set kode_kedua=new.kode, nama_kedua=new.nama
where kode_kedua=OLD.kode;
END;

Untuk proses delete :

CREATE TRIGGER `tr_delete` AFTER DELETE ON `tbl_pertama`
FOR EACH ROW
BEGIN
delete from tbl_kedua where kode_kedua=OLD.kode;
END;

Sampai di sini selesai sudah trigger yang kita buat silakan coba dan explorasi.
Selengkapnya.........

Tips Mengubah File Database Access ke MySQL

File database Microsoft Access dapat dimanipulasi dengan mudah. Namun, untuk menghubungkan banyak file, terutama file yang besar, tidaklah mudah. Dengan tool berikut ini, Anda dapat mengubah file Acess ke file database MySQL. MySQL adalah sebuah website open source yang menyediakan secara online akses yang aman ke file database dan tidak bergantung pada ukuran file-nya.

1. Sign up untuk account MySQL, dan Anda dapat mendownload program MySQL ke ke computer Anda.
2. Backup semua file Access Anda. Anda harus mem-backup semua file yang ada sebelum menginstal dan meng-convert-nya.
3. Download driver ODBC dan mengisntall-nya ke computer Anda. Driver ODBC dapat Anda temukan di website MySQL.
4. Click “Start/Programs/Administrative Tools/Data Sources (ODBC)”
5. Click "Add" di bawah tab "User DSN".
6. Pilih "MySQL ODBC Driver," lalu click "Finish." , click "Test Data Source," click "OK," dan click "OK" lagi.
7. Jika Anda mendapat pesan error, seperti "Unable to Connect," maka untuk sementara Anda disable terlebih dulu firewall yang mungkin sedang berjalan.
8. Coba converter gratis, contohnya DBTools, atau converter online lainnya. Setiap converter memiliki arah yang berbeda, namun tool converter DBTools yang akan digunakan dalam kali ini.
9. Pertama, nyalakan DAO, buka DBTools. Anda akan mendapat pesan bahwa belum ada profile server-nya. Pilih "Options/Preferences/DAO 3.6". Kemudian keluar dari DBTools lalu me-restart program tersebut.
10. Koneksikan ke MySQL. Sekali terkoneksi, maka Anda dapat menggunakan wizard "Import Data" agar dapat terkoneksi dengan database Access yang akan Anda convert.
11. Pilih "Access97", sesuai dengan versi Microsoft Access yang ada di computer. Click "OK" dan wizard tersebut kemudian akan meng-import dan mengkoversi file database Access ke MySQL.

(h_n)

Sumber : http://www.beritanet.com/Literature/Tutorial/Tips-Mengubah-File-Database-Access-MySQL.html