MySQL

                                   

MySQL  adalah  server  basis  data  yang  kompak  dan  kecil  yang  ideal  untuk  banyak  aplikasi  basis  data  on-line.  MySQL  mendukung  SQL  standar  (ANSI), meskipun tidak selengkap subset yang menjadi standar seperti PostgreSQL.

MySQL  dapat  dijalankan  di  banyak  platform  dan  memiliki  kemampuan  multithreading  pada  server  UNIX.  Pada  lingkungan  bukan  UNIX,  MySQL  dapat dijalankan  sebagai  servis  pada  Windows  NT  dan  sebagai  proses  normal  pada  mesin Windows  95/98.  MySQL  adalah  server  DBMS  relasional  SQL  yang  mendukung multithreading  dan  multi-user.  MySQL  mengimplementasikan  client/server  yang terdiri dari sebuah daemon server (servis di server) dan banyak program dan pustaka  klien yang berbeda-beda.

MySQL  dulunya  dikembangkan  tahun  1996  untuk  menyediakan  server  SQL  yang dapat menangani transaksi dalam basis data yang sangat besar dengan kecepatan tinggi.

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

$ mysql –h host –u user –p
Enter password: ********
Tanda ***** menunjukkan password Anda, masukkanlah ketika mysql menampilkan
Enter  password:. 

Jika  Anda  berhasil  login,  Anda  akan  melihat  informasi  introduction yang diikuti oleh prompt mysql> :

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

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

 Memasukkan Query
 Setelah  Anda  connect  ke  server  MySQL  Anda  dapat  mulai  menuliskan  query.
 Contohnya :

  mysql> SELECT VERSION(), CURRENT_DATE; 
 +------------------+--------------------+  
  | version()         | CURRENT_DATE  | 
 +------------------+--------------------+ 
  | 3.22.20a-log    | 1999-03-19         | 
 +------------------+--------------------+ 
  1 row in set (0.01 sec) 
  mysql>
  Query ini mengilustrasikan beberapa hal tentang mysql :

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

  - Ketika  Anda  membuat  perintah,  mysql  mengirimkannya  ke  server  untuk
    dieksekusi dan menampilkan hasilnya, kemudian menampilkan mysql> lain untuk
    menunjukkan bahwa dia sudah siap untuk perintah lain. 

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

    mysql memberi label kolom menggunakan ekspresi itu sendiri.

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

      Perintah/keyword  juga  dapat  dituliskan  baik  huruf  besar  maupun  huruf  kecil.  Jadi
     query berikut ini hasilnya sama :

      mysql> SELECT VERSION(), CURRENT_DATE;
      mysql> select version(), current_date;
      mysql> SeLeCt vErSiOn(), current_DATE;
 
Contoh  berikut mendemonstrasikan bahwa  Anda dapat menggunakan mysql  sebagai    kalkulator sederhana :

  mysql> SELECT SIN(PI()/4), (4+1)*5;
 +---------------+-----------+
  | SIN(PI()/4)  | (4+1)*5  |
 +-------------+-------------+
  |    0.707107  |      25      |
  +---------------+----------+
 
  Perintah-perintah  yang  sudah  dicontohkan  di atas  relatif  pendek,  hanya  pernyataan
  satu  baris.  Anda  bahkan  dapat  memasukkan  banyak  pernyataan  pada  sebuah  baris.
  Cuma tinggal mengakhiri tiap pernyataan dengan tanda titik-koma :

  mysql> SELECT VERSION(); SELECT NOW();
   +---------------+
   | version()       |
   +---------------+
   | 3.22.20a-log |
  +----------------+
  +-------------------------+
  | NOW()                      |
 +--------------------------+
  | 1999-03-19 00:15:33 |
 +--------------------------+
 
Sebuah perintah tidak harus diberikan pada sebuah baris, jadi perintah yang panjang  yang  memerlukan  beberapa  baris  bukan  masalah.  mysql  menentukan  apakah pernyataan  Anda  berakhir  dengan  mencari  titik-koma,  tidak  dengan  mencari  akhir dari  baris  input.  (Dengan  kata  lain,  mysql  menerima  input  berformat  bebas,  ia mengumpulkan  baris  input  tetapi  tidak  mengeksekusinya  hingga  menemukan  titik- koma.) Berikut ini contoh pernyataan banyak baris sederhana :

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

  mysql> SELECT
      -> USER()
      -> \c
  mysql>
 
  Tabel berikut ini menunjukkan tiap prompt yang mungkin Anda temukan dan artinya:
  Prompt  Arti
  mysql>  Siap untuk perintah baru
  ->  Menunggu baris berikut dari perintah banyak baris
  '>  Menunggu baris berikut, memasukkan string yang dimulai oleh petik tunggal ( „ ) 
  ">  Menunggu baris berikut, memasukkan string yang dimulai oleh petik ganda ( “ ) 

Pernyataan  banyak  baris  biasanya  terjadi  „tidak  sengaja‟  ketika  Anda  bermaksud  untuk memberi perintah pada satu baris, tetapi lupa untuk mengakhirinya dengan titik- koma. Pada kasus ini, mysql menunggu input berikutnya :

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

  mysql> SELECT USER()
      -> ;
    +--------------------+
  | USER()             |
    +--------------------+
  | erik@localhost     |
    +--------------------+
 
Tanda prompt ‘> dan “> terjadi ketika pemasukan string. Pada MySQL, Anda dapat menulis  string  yang  diawali  dan  diakhiri  oleh  karakter  „  atau  “  („halo‟  atau  “halo”),  dan  mysql  memperbolehkan  Anda  memasukkan  string  pada  banyak  baris.  Ketika Anda  melihat  prompt  „  atau  “,  berarti  Anda  sudah  memasukkan  baris  yang  berisi string  yang dimulai dengan karakter „ atau “, tetapi  Anda belum memasukkan tanda  petik penutup yang sesuai.

Contoh Query Yang Umum
Berikut  ini  diberikan  contoh  tentang  bagaimana  memecahkan  masalah  yang  umum
ditemukan pada MySQL.
Beberapa  contoh  menggunakan  tabel  shop  unuk  menyimpan  harga  dari  tiap  article untuk penjual tertentu. Dianggap bahwa tiap penjual memiliki harga tetap untuk tiap article, lalu (item,trader) adalah kunci primer untuk record-nya.

  CREATE TABLE shop (
   article INT(4) UNSIGNED ZEROFILL DEFAULT '0000' NOT NULL,
   dealer  CHAR(20)                 DEFAULT ''     NOT NULL,
   price   DOUBLE(16,2)             DEFAULT '0.00' NOT NULL,
   PRIMARY KEY(article, dealer));
 
  INSERT INTO shop VALUES
              (1,'A',3.45),(1,'B',3.99),(2,'A',10.99),(3,'B',1.45),(3,'C',1.69),
      (3,'D',1.25),(4,'D',19.95); 
 Kemudian, contoh datanya adalah :
  SELECT * FROM shop
 
      +---------+--------+-------+
  | article | dealer | price |
      +---------+--------+-------+
  |    0001 | A      |  3.45 |
  |    0001 | B      |  3.99 |
  |    0002 | A      | 10.99 |
  |    0003 | B      |  1.45 |
  |    0003 | C      |  1.69 |
  |    0003 | D      |  1.25 |
  |    0004 | D      | 19.95 |
      +---------+--------+-------+
  Untuk melihat nomer article terbesar, Anda dapat menggunakan :
  SELECT MAX(article) AS article FROM shop
  +---------+
  | article |
  +---------+
  |       4 |
  +---------+

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

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

SELECT article, dealer, price
        FROM   shop
          WHERE  price=19.95
  Cara  lain  adalah  dengan  mengurutkan  semua  baris  secara  descending  (dari  besar  ke
  kecil) dan hanya mengambil baris pertama menggunakan kalusa spesifik LIMIT :
  SELECT article, dealer, price
  FROM   shop
  ORDER BY price DESC
  LIMIT 1
 
Catatan: Bila terdapat beberapa baris dengan nilai price maximum yang sama, cuma ditampilkan salah satu saja, yaitu yang pertama. Untuk  menunjukkan  nilai  maximum  dari  kolom  per  grup  cuma  nilainya,  dapat menggunakan :
  ``What's the highest price per article?''  
  SELECT article, MAX(price) AS price
  FROM   shop
  GROUP BY article
 
    +---------+-------+
  | article | price |
    +---------+-------+
  |    0001 |  3.99 |
  |    0002 | 10.99 |
  |    0003 |  1.69 |
  |    0004 | 19.95 |
    +---------+-------+
Untuk  mencari  dealer  dengan  price  yang  paling  mahal  untuk  tiap  article-nya,  pada ANSI SQL, dapat menggunakan :
  SELECT article, dealer, price
  FROM   shop s1
  WHERE  price=(SELECT MAX(s2.price)
                FROM shop s2
                WHERE s1.article = s2.article)
 
  Pada MySQL, cara terbaik untuk melakukannya dengan langkah berikut :

  1. Ambil daftar (article,maxprice).
  2. Untuk  tiap  article  ambil  baris  yang  bersangkutan  yang  menyimpan  price maximum.
      Hal ini paling mudah dilakukan dengan sebuah tabel temporary :

  CREATE TEMPORARY TABLE tmp (
          article INT(4) UNSIGNED ZEROFILL DEFAULT '0000' NOT NULL,
          price   DOUBLE(16,2)             DEFAULT '0.00' NOT NULL);
 
  LOCK TABLES article read;
   INSERT INTO tmp SELECT article, MAX(price) FROM shop GROUP BY
  article;
  SELECT article, dealer, price FROM shop, tmp
  WHERE shop.article=tmp.article AND shop.price=tmp.price;
 
  UNLOCK TABLES;
  DROP TABLE tmp;
  Jika  Anda  tidak  menggunakan  tabel  TEMPORARY,  Anda  juga  harus  mengunci
  (LOCK)  tabel  tmp.  Masalah  ini  juga  dapat  dilakukan  dengan  query  tunggal,  tetapi dengan menggunakan trik yang tidak efisien :
  SELECT article,
   SUBSTRING( MAX( CONCAT(LPAD(price,6,'0'),dealer) ), 7) AS
  dealer,
    0.00+LEFT(      MAX( CONCAT(LPAD(price,6,'0'),dealer) ), 6) AS
  price
  FROM   shop
  GROUP BY article;
 
      +---------+--------+-------+
  | article | dealer | price |
      +---------+--------+-------+
  |    0001 | B      |  3.99 |
  |    0002 | A      | 10.99 |
  |    0003 | C      |  1.69 |
  |    0004 | D      | 19.95 |
      +---------+--------+-------+
Pada MySQL Anda tidak memerlukan foreign key untuk menggabungkan (join) dua  tabel.  Satu  hal  yang  tidak  dilakukan  MySQL  adalah  mengecek  untuk  memastikan  bahwa key yang digunakan benar-benar ada pada tabel yang Anda referensi dan tidak  secara otomatis menghapus baris dari tabel yang berisi definisi foreign key.

  CREATE TABLE persons (
      id SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT, 
      name CHAR(60) NOT NULL,
      PRIMARY KEY (id)
  );
  CREATE TABLE shirts (
      id SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT,
      style ENUM('t-shirt', 'polo', 'dress') NOT NULL,
      color ENUM('red', 'blue', 'orange', 'white', 'black') NOT NULL,
      owner SMALLINT UNSIGNED NOT NULL REFERENCES persons,
      PRIMARY KEY (id)
  );
  INSERT INTO persons VALUES (NULL, 'Antonio Paz');
  INSERT INTO shirts VALUES
  (NULL, 'polo', 'blue', LAST_INSERT_ID()),
  (NULL, 'dress', 'white', LAST_INSERT_ID()),
  (NULL, 't-shirt', 'blue', LAST_INSERT_ID());
  INSERT INTO persons VALUES (NULL, 'Lilliana Angelovska');
  INSERT INTO shirts VALUES
  (NULL, 'dress', 'orange', LAST_INSERT_ID()),
  (NULL, 'polo', 'red', LAST_INSERT_ID()),
  (NULL, 'dress', 'blue', LAST_INSERT_ID()),
  (NULL, 't-shirt', 'white', LAST_INSERT_ID());
  SELECT * FROM persons;
      +----+---------------------+
  | id | name                |
      +----+---------------------+
  |  1 | Antonio Paz         |
  |  2 | Lilliana Angelovska |
      +----+---------------------+
 
  SELECT * FROM shirts;
      +----+---------+--------+-------+
  | id | style   | color  | owner |
      +----+---------+--------+-------+
  |  1 | polo    | blue   |     1 |
  |  2 | dress   | white  |     1 |
  |  3 | t-shirt | blue   |     1 |
  |  4 | dress   | orange |     2 |
  |  5 | polo    | red    |     2 |
  |  6 | dress   | blue   |     2 |
  |  7 | t-shirt | white  |     2 |
      +----+---------+--------+-------+
 
  SELECT s.* FROM persons p, shirts s
  WHERE p.name LIKE 'Lilliana%'
     AND s.owner = p.id
     AND s.color <> 'white';
 
      +----+-------+--------+-------+
  | id | style | color  | owner |
      +----+-------+--------+-------+
  |  4 | dress | orange |     2 |
  |  5 | polo  | red    |     2 |
  |  6 | dress | blue   |     2 |
      +----+-------+--------+-------+
Pada  pencarian  dua  key,  MySQL  belum  mengoptimasikan  pencarian  Anda  pada  kombinasi dua key yang berbeda dengan OR :

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

  INSERT INTO tmp
  SELECT field1_index, field2_index FROM test_table WHERE field2_index  = '1';
  SELECT * from tmp;
  DROP TABLE tmp;
 Membuat Dan Menggunakan Database
Sekarang setelah Anda mengetahui cara memasukkan perintah, inilah waktunya untuk  mengakses database.  Anggaplah  bahwa  Anda  memiliki  beberapa  hewan  peliharaan  di  rumah  dan  Anda ingin  menyimpan  beberapa  informasi  mengenai  mereka.  Anda  dapat  melakukannya dengan  membuat  tabel  untuk  menyimpan  data  Anda  dan  mengisinya  dengan  informasi yang Anda inginkan. Kemudian Anda dapat menjawab banyak pertanyaan tentang hewan Anda dengan mengambil data dari tabel tadi. 
Gunakan pernyataan SHOW untuk menemukan database apa saja yang ada di server:

  mysql> SHOW DATABASES;
    +----------+
  | Database |
    +----------+
  | mysql    |
  | test     |
  | tmp      |
    +----------+

Daftar database ini mungkin berbeda untuk komputer Anda, tetapi database mysql dan test kelihatannya selalu  ada. Database mysql  diperlukan karena ia menunjukkan hak akses (privileges) untuk tiap user. Database test sering menyediakan tempat bagi user untuk mencoba-coba. Jika database test ada, cobalah untuk mengaksesnya:
  mysql> USE test
 Database changed
 
Ingat  bahwa  USE,  seperti  QUIT,  tidak  memerlukan  titik-koma.  (Anda  dapat mengakhiri pernyataan seperti ini dengan titik-koma jika ingin.) Pernyataan USE ini
juga spesial, yaitu harus diberikan pada baris tunggal.
Anda  dapat  menggunakan  database  test  (jika  Anda  memiliki  akses  untuknya)  untuk contoh-contoh berikut, tetapi segala yang Anda buat pada database ini dapat dihapus oleh  orang  lain  yang  juga  dapat  mengaksesnya.  Karena  itu,  Anda  mungkin  dapat meminta  administrator  MySQL  Anda  untuk  ijin  membuat  database  Anda  sendiri.
Misalkan  Anda  ingin  membuat  database  hewan.  Administrator  harus  mengeksekusi perintah seperti berikut :

  mysql> GRANT ALL ON hewan.* TO your_mysql_name;
 dimana your_mysqL_name adalah username MySQL Anda. Jika  administrator  membuat  database  Anda  ketika  menset  hak  akses  Anda,  Anda dapat mulai menggunakannya, tetapi bila tidak Anda harus membuatnya sendiri :

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

 mysql> USE hewan
 Database changed
 
Database  Anda  cuma  perlu  dibuat  satu  kali,  tetapi  Anda  harus  memilihnya  untuk  digunakan tiap kali Anda memulai session mysql. Anda dapat melakukannya dengan memasukkan  perintah  USE  seperti  di  atas.  Cara  lainnya,  Anda  dapat  memilih database  pada  baris  perintah  ketika  Anda  menjalankan  mysql.  Hanya  tinggal  menuliskan  nama  database  ini  setelah  parameter  koneksi  yang  Anda  butuhkan.

  Contohnya:
  shell> mysql -h host -u user -p hewan
  Enter password: ********
 
Ingat  bahwa  hewan  bukan  password  Anda  pada  perintah  di  atas.  Jika  Anda  ingin memasukkan  password  Anda  pada  baris  perintah  setelah  option –p,  Anda  harus melakukannya  dengan  tidak  memberi  spasi  setelah –p  (-pmypassword,  bukan –p mypassword).  Namun,  memasukkan  password  Anda  pada  baris  perintah tidak disarankan, karena password Anda akan dapat dilihat oleh user lain yang sedang login ke komputer Anda.

Membuat  database  adalah  bagian  yang  mudah,  tetapi  saat  ini  database  tadi  masih kosong, sebagaimana pernyataan SHOW TABLE akan menunjukkannya :
  mysql> SHOW TABLES;
  Empty set (0.00 sec)
 

Bagian  yang  lebih  sulit  adalah  memutuskan  struktur  dari  database  Anda  yang sebaiknya digunakan:  tabel  apa  yang Anda butuhkan, dan kolom apa  yang akan ada pada tiap tabelnya.
Anda  menginginkan  sebuah  tabel  yang  berisi  record  untuk  tiap  hewan  peliharaan Anda. Ini dapat dinamakan tabel pet, dan yang isi seharusnya, minimal adalah nama  tiap  hewan.  Karena  nama  saja  tidak  terlalu  menarik,  tabel  ini  seharusnya  berisi  informasi  lain.  Sebagai  contoh,  jika  lebih  dari  satu  orang  dalam  keluarga  Anda  menyimpan piaraan, Anda mungkin ingin membuat daftar pemilik tiap hewan. Anda mungkin juga ingin informasi deskripsi untuk tiap spesies dan jenis kelamin.

Bagaimana  tentang  umur?  Hal  ini  mungkin  menarik,  tetapi  bukan  ide  yang  bagus untuk menyimpannya dalam database. Umur berubah seiring perubahan waktu, yang berarti Anda harus sering mengupdatenya. Cara lain, adalah dengan menyimpan nilai  yang  pasti,  seperti  tanggal  lahir.  Lalu,  ketika  dibutuhkan  usia,  Anda  dapat menghitungnya  sebagai  selisih  antara  tanggal  sekarang  dengan  tanggal  lahirnya.

MySQL  menyediakan  fungsi  untuk  melakukan  aritmatika  tanggal,  jadi  hal  ini  tidak sulit. Menyimpan tanggal lahir dan bukannya umur juga memiliki keuntungan lain :

  - Anda dapat menggunakan database untuk tugas seperti membangkitkan pengingat
    untuk ulang tahun hewan berikutnya.

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

Tampaknya  informasi  untuk  tabelnya  sudah  cukup,  sekarang  kita  coba  untuk membuat tabelnya dengan menggunakan CREATE TABLE :

  mysql> CREATE TABLE pet (name VARCHAR(20), owner VARCHAR(20),
      -> species VARCHAR(20), sex CHAR(1), birth DATE, death DATE);
 
VARCHAR adalah pilihan yang bagus untuk kolom name, owner dan species karena nilai kolom ini akan bervariasi panjangnya. Panjang dari tiap kolom tidak perlu sama, dan  tidak  harus  20.  Anda  dapat  memilih  dari  1  sampai  255  yang  tampaknya  sesuai bagi  Anda  (jika  pilihan  Anda  salah  dan  ternyata  kemudian  dibutuhkan  kolom  yang lebih panjang, MySQL menyediakan pernyataan ALTER TABLE).

Jenis kelamin hewan dapat ditunjukkan dengan bermacam cara, bisa “m” dan “f”, atau mungkin  “male”  dan  “female”.  Cara  termudahnya  adalah  menggunakan  karakter tunggal “m” dan “f”.

Penggunaan tipe data DATE untuk kolom birth dan death adalah pilihan yang bagus. Sekarang  Anda  sudah  membuat  tabel,  SHOW  TABLES  seharusnya  menghasilkan
  output :
  mysql> SHOW TABLES;
      +---------------------+
  | Tables in hewan     |
      +---------------------+
  | pet                 |
     +---------------------+
Untuk  memastikan  bahwa  tabel  yang  dibuat  sesuai  keinginan  Anda,  gunakan  pernyataan DESCRIBE atau DESC :

  mysql> DESCRIBE pet;
          +---------+-------------+------+-----+---------+-------+
  | Field   | Type        | Null | Key | Default | Extra |
          +---------+-------------+------+-----+---------+-------+
  | name    | varchar(20) | YES  |     | NULL    |       |
  | owner   | varchar(20) | YES  |     | NULL    |       |
  | species | varchar(20) | YES  |     | NULL    |       |
  | sex     | char(1)     | YES  |     | NULL    |       |
  | birth   | date        | YES  |     | NULL    |       |
  | death   | date        | YES  |     | NULL    |       |
          +---------+-------------+------+-----+---------+-------+
 
Setelah membuat  tabel,  Anda butuh  untuk  memasukkan datanya. Pernyataan  LOAD DATA dan INSERT dapat digunakan untuk hal ini. Anggaplah bahwa record hewan Anda dapat ditunjukkan sebagai berikut (perhatikan bahwa MySQL mengharuskan tanggal dalam format YYYY-MM-DD).

  name  owner  species  sex  birth  Death 
  Fluffy  Harold  cat  f  1993-02-04  
  Claws  Gwen  cat  m  1994-03-17   
  Buffy  Harold  dog  f  1989-05-13  
  Fang  Benny  dog  m  1990-08-27  
  Bowser  Diane  dog  m  1998-08-31  1995-07-29 
  Chirpy  Gwen  bird  f  1998-09-11  
  Whistler  Gwen  bird   1997-12-09  
  Slim  Benny  snake  m  1996-04-29  

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

Anda dapat menspesifikasi nilai pemisah kolom dan tanda akhir baris secara eksplisit  pada pernyataan LOAD DATA yang Anda inginkan, tetapi nilai defaultnya adalah tab dan linefeed.
                                                                          
Jika  Anda  ingin  menambahkan  record  baru  suatu  saat,  pernyataan  INSERT  sangat berguna.  Pada  bentuk  yang  paling  sederhana,  Anda  menuliskan  nilai  untuk  tiap kolomnya,  menurut  urutan  yang  sama  dengan  waktu  pembuatan  tabel.  Misalnya
Diane mendapatkan hamster baru bernama Puffball, Anda dapat menambahkan record baru menggunakan pernyataan INSERT seperti berikut:
  mysql> INSERT INTO pet
      -> VALUES ('Puffball','Diane','hamster','f','1999-03-30',NULL);
Perhatikan  bahwa  nilai  string  dan  tanggal  ditulis  dalam  tanda  petik.  Juga  dengan INSERT,  Anda  dapat  memasukkan  NULL  langsung  untuk  menggantikan nilai  yang tidak ada. Anda tidak menggunakan \N seperti dengan LOAD DATA.
Untuk  mengambil  informasi  dari  tabel,  Anda  dapat  menggunakan  pernyataan SELECT. Bentuk umum dari pernyataan ini adalah:
  SELECT what_to_select
  FROM which_table
  WHERE conditions_to_satisfy
What_to_select menunjukkan apa yang ingin Anda lihat. Ini dapat merupakan daftar kolom,  atau  *  untuk  menunjukkan  semua  kolom.  which_table  menunjukkan  tabel yang mana yang ingin Anda ambil datanya. Klausa WHERE optional. Jika ada, maka conditions_to_satisfy menunjukkan kondisi  yang  harus dipenuhi oleh baris agar ikut ditampilkan.

Bentuk paling sederhana dari SELECT mengambil segalanya dari sebuah tabel :
  mysql> SELECT * FROM pet;
              +----------+--------+---------+------+------------+------------+
  | name     | owner  | species | sex  | birth      | death      |
              +----------+--------+---------+------+------------+------------+
  | Fluffy   | Harold | cat     | f    | 1993-02-04 | NULL       |
  | Claws    | Gwen   | cat     | m    | 1994-03-17 | NULL       |
  | Buffy    | Harold | dog     | f    | 1989-05-13 | NULL       |
  | Fang     | Benny  | dog     | m    | 1990-08-27 | NULL       |
  | Bowser   | Diane  | dog     | m    | 1998-08-31 | 1995-07-29 |
  | Chirpy   | Gwen   | bird    | f    | 1998-09-11 | NULL       |
  | Whistler | Gwen   | bird    | NULL | 1997-12-09 | NULL       |
  | Slim     | Benny  | snake   | m    | 1996-04-29 | NULL       |
  | Puffball | Diane  | hamster | f    | 1999-03-30 | NULL       |
              +----------+--------+---------+------+------------+------------+
Bentuk  SELECT  ini  berguna  jika  Anda  ingin  melihat  keseluruhan  tabel.  Misalnya, setelah Anda selesai memasukkan himpunan data awal Anda. Tampak bahwa terdapat  kesalahan pada tabel di atas: Bowser lahir sesudah dia mati. Padahal data sebenarnya  untuk lahirnya adalah tahun 1989, bukan 1998 Minimal ada dua cara untuk memperbaikinya :
                                                                                 
 - Edit  file  pet.txt  untuk  memperbaiki  kesalahan  ini,  lalu  kosongkan  tabel  dan  isi
   ulang menggunakan DELETE dan LOAD DATA.

          mysql> DELETE FROM pet;
         mysql> LOAD DATA LOCAL INFILE "pet.txt" INTO TABLE pet;
 
   Namun  jika  Anda  melakukan  ini,  Anda  juga  harus  memasukkan  ulang  record  untuk Puffball.
  -Perbaiki hanya record yang salah menggunakan pernyataan UPDATE:

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

Outputnya menunjukkan bahwa tahun yang tersimpan sekarang sudah benar. Pembandingan  string  normalnya  case  insensitive,  Anda  dapat  menulis  name  “bowser”, “BOWSER”, dll. Hasilnya akan sama.
Anda  dapat  menuliskan  kondisi  untuk  sembarang  kolom,  bukan  hanya  name.
Contohnya, jika Anda ingin tahu hewan mana  yang lahir setelah 1998, teslah kolom birth:
  mysql> SELECT * FROM pet WHERE birth >= "1998-1-1";
          +----------+-------+---------+------+------------+-------+
  | name     | owner | species | sex  | birth      | death |
          +----------+-------+---------+------+------------+-------+
  | Chirpy   | Gwen  | bird    | f    | 1998-09-11 | NULL  |
  | Puffball | Diane | hamster | f    | 1999-03-30 | NULL  |
          +----------+-------+---------+------+------------+-------+
  Anda dapat menggabungkan kondisi, contohnya untuk melihat anjing betina:
  mysql> SELECT * FROM pet WHERE species = "dog" AND sex = "f";
          +-------+--------+---------+------+------------+-------+
  | name  | owner  | species | sex  | birth      | death |
          +-------+--------+---------+------+------------+-------+
  | Buffy | Harold | dog     | f    | 1989-05-13 | NULL  |
          +-------+--------+---------+------+------------+-------+
  Query di atas menggunakan operator logika AND. Ada juga operator OR:
  mysql> SELECT * FROM pet WHERE species = "snake" OR species = "bird";
          +----------+-------+---------+------+------------+-------+
  | name     | owner | species | sex  | birth      | death |
          +----------+-------+---------+------+------------+-------+
  | Chirpy   | Gwen  | bird    | f    | 1998-09-11 | NULL  |
  | Whistler | Gwen  | bird    | NULL | 1997-12-09 | NULL  |
  | Slim     | Benny | snake   | m    | 1996-04-29 | NULL  |
          +----------+-------+---------+------+------------+-------+
 
AND  dan  OR  dapat  digabungkan.  Jika  Anda  melakukannya,  sebaiknya  gunakan  kurung untuk menunjukkan kondisi yang harus disatukan:
  mysql> SELECT * FROM pet WHERE (species = "cat" AND sex = "m")
      -> OR (species = "dog" AND sex = "f");
          +-------+--------+---------+------+------------+-------+
  | name  | owner  | species | sex  | birth      | death |
          +-------+--------+---------+------+------------+-------+
  | Claws | Gwen   | cat     | m    | 1994-03-17 | NULL  |
  | Buffy | Harold | dog     | f    | 1989-05-13 | NULL  |
          +-------+--------+---------+------+------------+-------+

Jika  Anda  tidak  ingin  melihat  keseluruhan  baris  dari  tabel  Anda,  Anda  tinggal menulis nama kolom yang Anda inginkan dengan dipisahkan oleh koma. Contohnya, jika Anda ingin tahu kapan hewan Anda dilahirkan, pilihlah kolom name dan birth:
  mysql> SELECT name, birth FROM pet;
      +----------+------------+
  | name     | birth      |
      +----------+------------+
  | Fluffy   | 1993-02-04 |
  | Claws    | 1994-03-17 |
  | Buffy    | 1989-05-13 |
  | Fang     | 1990-08-27 |
  | Bowser   | 1989-08-31 |
  | Chirpy   | 1998-09-11 |
  | Whistler | 1997-12-09 |
  | Slim     | 1996-04-29 |
  | Puffball | 1999-03-30 |
      +----------+------------+
  Untuk mencari siapa yang memiliki hewan piaraan, gunakan query ini:
  mysql> SELECT owner FROM pet;
    +--------+
  | owner  |
    +--------+
  | Harold |
  | Gwen   |
  | Harold |
  | Benny  |
  | Diane  |
  | Gwen   |
  | Gwen   |
  | Benny  |
  | Diane  |
    +--------+                                                                       
Namun, perhatikan bahwa query ini mengambil kolom owner dari tiap record, dan ada beberapa yang tampil lebih dari sekali. Untuk meminimalkan outputnya, ambil record output unik hanya sekali dengan menambahkan keyword DISTINCT:
mysql> SELECT DISTINCT owner FROM pet;
    +--------+
  | owner  |
    +--------+
  | Benny  |
  | Diane  |
  | Gwen   |
  | Harold |
    +--------+
Anda  dapat  menggunakan  klausa  WHERE  untuk  menggabungkan  pilihan  baris dengan  pilihan  kolom.  Contohnya,  untuk  mengambil  hanya  tanggal  lahir  anjing  dan kucing, gunakan query ini:
  mysql> SELECT name, species, birth FROM pet
      -> WHERE species = "dog" OR species = "cat";
      +--------+---------+------------+
  | name   | species | birth      |
      +--------+---------+------------+
  | Fluffy | cat     | 1993-02-04 |
  | Claws  | cat     | 1994-03-17 |
  | Buffy  | dog     | 1989-05-13 |
  | Fang   | dog     | 1990-08-27 |
  | Bowser | dog     | 1989-08-31 |
      +--------+---------+------------+
Anda mungkin memperhatikan bahwa contoh-contoh di atas menghasilkan baris yang tidak  sesuai  dengan  urutan tertentu.  Tapi,  kadang-kadang,  lebih  mudah  untuk memeriksa  output  query  yang  barisnya  tersusun  teratur  menurut  sesuatu.  Untuk mengurutkan hasilnya, gunakan klausa ORDER BY. Berikut ini tanggal lahir hewan, diurutkan berdasarkan tanggal:
  mysql> SELECT name, birth FROM pet ORDER BY birth;
      +----------+------------+
  | name     | birth      |
      +----------+------------+
  | Buffy    | 1989-05-13 |
  | Bowser   | 1989-08-31 |
  | Fang     | 1990-08-27 |
  | Fluffy   | 1993-02-04 |
  | Claws    | 1994-03-17 |
  | Slim     | 1996-04-29 |
  | Whistler | 1997-12-09 |
  | Chirpy   | 1998-09-11 |
  | Puffball | 1999-03-30 |
      +----------+------------+
Untuk  mengurutkannya  secara  terbalik,  tambahkan  keyword  DESC  (descending) setelah  nama kolom yang digunakan untuk mengurutkan:

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

      +----------+------------+
  | name     | birth      |
      +----------+------------+
  | Puffball | 1999-03-30 |
  | Chirpy   | 1998-09-11 |
  | Whistler | 1997-12-09 |
  | Slim     | 1996-04-29 |
  | Claws    | 1994-03-17 |
  | Fluffy   | 1993-02-04 |
  | Fang     | 1990-08-27 |
  | Bowser   | 1989-08-31 |
  | Buffy    | 1989-05-13 |
      +----------+------------+
Anda dapat mengurutkan banyak kolom. contohnya, untuk mengurutkan berdasarkan  jenis  hewan,  lalu  berdasarkan  tanggal  lahir  yang  muda lebih  dulu,  gunakan  query berikut:
  mysql> SELECT name, species, birth FROM pet ORDER BY species, birth
  DESC;
        +----------+---------+------------+
  | name     | species | birth      |
        +----------+---------+------------+
  | Chirpy   | bird    | 1998-09-11 |
  | Whistler | bird    | 1997-12-09 |
  | Claws    | cat     | 1994-03-17 |
  | Fluffy   | cat     | 1993-02-04 |
  | Fang     | dog     | 1990-08-27 |
  | Bowser   | dog     | 1989-08-31 |
  | Buffy    | dog     | 1989-05-13 |
  | Puffball | hamster | 1999-03-30 |
  | Slim     | snake   | 1996-04-29 |
        +----------+---------+------------+
Perhatikan bahwa keyword DESC cuma berlaku untuk nama kolom yang mendahului kata DESC.
MySQL  menyediakan  beberapa  fungsi  yang  dapat  Anda  gunakan  untuk  melakukan perhitungan berdasarkan tanggal, sebagai contoh, untuk menghitung umur atau seatu jangka waktu. Untuk menentukan umur tiap hewan piaraan Anda, hitung umur sebagai selisih antara  tanggal  lahir  dan  tanggal  saat  ini.  Lakukan  ini  dengan  mengubah  kedua  tanggal menjadi hari, hitung selisihnya, dan bagi dengan 365 (jumlah hari dalam satu tahun).

  mysql> SELECT name, (TO_DAYS(NOW())-TO_DAYS(birth))/365 FROM pet;
            +----------+-------------------------------------+
  | name     | (TO_DAYS(NOW())-TO_DAYS(birth))/365 |
            +----------+-------------------------------------+
  | Fluffy   |                                6.15 |
  | Claws    |                                5.04 |
  | Buffy    |                                9.88 |
  | Fang     |                                8.59 |
  | Bowser   |                                9.58 |
  | Chirpy   |                                0.55 |
  | Whistler |                                1.30 |
  | Slim     |                                2.92 |
  | Puffball |                                0.00 |
            +----------+-------------------------------------+
Meskipun  query  ini  bekerja,  ada  beberapa  hal  yang  harus  ditingkatkan.  Pertama, hasilnya  dapat  dilihat  lebih  mudah  jika  baris-barisnya  diurutkan.  Kedua,  heading untuk kolom age tidak terlalu berarti.
Masalah  pertama  dapat  diatasi  dengan  menambahkan  klausa  ORDER  BY  untuk mengurutkan  berdasarkan  name.  Untuk  mengatasi  heading  kolom,  sediakan  nama untuk  kolom  ini  sehingga  label  yang  berbeda  tampil  pada  outputnya  (hal  ini dinamakan alias kolom):
  mysql> SELECT name, (TO_DAYS(NOW())-TO_DAYS(birth))/365 AS age
      -> FROM pet ORDER BY name;
    +----------+------+
  | name     | age  |
    +----------+------+
  | Bowser   | 9.58 |
  | Buffy    | 9.88 |
  | Chirpy   | 0.55 |
  | Claws    | 5.04 |
  | Fang     | 8.59 |
  | Fluffy   | 6.15 |
  | Puffball | 0.00 |
  | Slim     | 2.92 |
  | Whistler | 1.30 |
    +----------+------+
Untuk  mengurutkan  output  berdasarkan  umur,  cuma  tinggal  menggunakan  klausa  ORDER BY yang berbeda:
  mysql>  SELECT name, (TO_DAYS(NOW())-TO_DAYS(birth))/365 AS age
      ->  FROM pet ORDER BY age;
    +----------+------+
  | name     | age  |
    +----------+------+
  | Puffball | 0.00 |
  | Chirpy   | 0.55 |
  | Whistler | 1.30 |
  | Slim     | 2.92 |
  | Claws    | 5.04 |
  | Fluffy   | 6.15 |
  | Fang     | 8.59 |
  | Bowser   | 9.58 |
  | Buffy    | 9.88 |
    +----------+------+
 
Query  yang  mirip  dapat  digunakan  untuk  menentukan  umur  saat  kematian  hewan yang sudah mati. Anda menentukan hewan yang mana dengan mengecek apakah nilai death-nya  NULL.  Lalu,  untuk  yang  nilainya  tidak  NULL,  hitung  selisih  antara  nilai death dan birth:

 mysql>  SELECT name, birth, death, (TO_DAYS(death)-
 TO_DAYS(birth))/365 AS age
      ->  FROM pet WHERE death IS NOT NULL ORDER BY age;
        +--------+------------+------------+------+
  | name   | birth      | death      | age  |
        +--------+------------+------------+------+
  | Bowser | 1989-08-31 | 1995-07-29 | 5.91 |
        +--------+------------+------------+------+
 
Query ini menggunakan death IS NOT NULL dan bukannya death != NULL karena NULL adalah nilai khusus.
Bagaimana  jika  Anda  ingin  tahu  hewan  mana  yang  berulang  tahun  bulan  depan?
Untuk  perhitungan  semacam  ini,  tahun  dan  tanggal  tidak  sesuai,  Anda  cuma  ingin mengambil  bagian  bulan  dari  kolom  birth..  MySQL  menyediakan  beberapa  fungsi untuk  mengambil  bagian  dari  tanggal,  seperti  YEAR(),  MONTH()  dan DAYOFMONTH().

MONTH  adalah  fungsi  yang  tepat  untuk  hal  ini.  Untuk  melihat  cara  kerjanya, jalankan query sederhana yang menampilkan nila untuk birth dan MONTH(birth):

  mysql> SELECT name, birth, MONTH(birth) FROM pet;
      +----------+------------+--------------+
  | name     | birth      | MONTH(birth) |
      +----------+------------+--------------+
  | Fluffy   | 1993-02-04 |            2 |
  | Claws    | 1994-03-17 |            3 |
  | Buffy    | 1989-05-13 |            5 |
  | Fang     | 1990-08-27 |            8 |
  | Bowser   | 1989-08-31 |            8 |
  | Chirpy   | 1998-09-11 |            9 |
  | Whistler | 1997-12-09 |           12 |
  | Slim     | 1996-04-29 |            4 |
  | Puffball | 1999-03-30 |            3 |
      +----------+------------+--------------+   

 Menemukan  hewan  yang  berulang  tahun  bulan  depan  itu  mudah  juga.  Anggaplah bulan

sekarang adalah April. Maka nilai month-nya 4 dan Anda cari hewan yang lahir di bulan Mei (month=5) seperti ini:

  mysql> SELECT name, birth FROM pet WHERE MONTH(birth) = 5;
    +-------+------------+
  | name  | birth      |
    +-------+------------+
  | Buffy | 1989-05-13 |
    +-------+------------+
Tetapi ada masalah jika  bulan sekarang adalah Desember. Anda tidak bisa langsung  menambahkan  satu  ke  nilai  bulan  (12)  dan  mencari  hewan  yang  lahir  di  bulan  13, karena tidak ada bulan 13. Namun, Anda mencari hewan yang lahir di bulan Januari (month 1).

Anda  bahkan  dapat  menulis  query  yang  dapat  bekerja  dengan  benar,  tidak  peduli bulan  apa  sekarang  ini.  Dengan  cara  ini  Anda  tidak  harus  menggunakan  nilai  bulan sekarang  dalam  query.  DATE_ADD()  membolehkan  Anda  untuk  menambahkan  interval  waktu  untuk  tanggal  tertentu.  Jika  Anda  menambahkan  satu  bulan  ke  nilai dari  NOW(),  maka  bagian  month  untuk  MONTH()  akan  menghasilkan  bulan  yang  digunakan untuk mencari ulang tahun:

  mysql> SELECT name, birth FROM pet
      -> WHERE MONTH(birth) = MONTH(DATE_ADD(NOW(), INTERVAL 1 MONTH));
 
  Cara  lain  untuk  melakukannya  adalah  menambahkan  1  untuk  mendapatkan  bulan
  selanjutnya setelah bulan ini :
  mysql> SELECT name, birth FROM pet
      -> WHERE MONTH(birth) = MOD(MONTH(NOW()), 12) + 1;
 
Ingat  bahwa  MONTH  mengembalikan  nilai  antara  1  dan  12.  Dan  MOD(sesuatu,12)  mengembalikan  nilai  antara  0  dan  11.  Jadi  penambahan  harus  dilakukan  setelah MOD().  

 
Nilai NULL

Secara konsep, NULL berarti “nilai yang hilang” atau “nilai yang tidak diketahui” dan diperlakukan lain daripada nilai  yang lain. Untuk mengetes nilai  NULL, Anda tidak dapat  menggunakan  operator  perbandingan  aritmatik  seperti  =,  <  atau  !=.  Untuk mendemonstrasikannya sendiri, cobalah query berikut:

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

  mysql> SELECT 1 IS NULL, 1 IS NOT NULL;
        +-----------+---------------+
  | 1 IS NULL | 1 IS NOT NULL |
        +-----------+---------------+
  |         0 |             1 |
        +-----------+---------------+
 
pada MySQL, 0 berarti false dan 1 berarti true. Perlakuan yang khusus untuk NULL inilah sebabnya, pada bagian di atas, Anda harus menggunakan death IS NOT NULL dan bukannya death != NULL.

Pengenalan Pola (Pattern Matching)
MySQL  menyediakan  pengenalan  pola  standar  SQL  juga  pengenalan  pola berdasarkan  ekspresi  regular  yang  mirip  dengan  yang  digunakan  pada  utiliti  UNIX seperti vi, grep dan sed. Pengenalan pola memperbolehkan Anda untuk menggunakan „_‟ untuk menggantikan  satu karakter, dan „%‟ untuk menggantikan sembarang jumlah karakter (termasuk nol karakter).  Pada  MySQL,  pola  SQL  defaultnya  adalah  case  insensitive.  Beberapa contoh ditunjukkan di bawah. Perhatikan bahwa Anda tidak menggunakan = atau !=  ketika menggunakan pola SQL; gunakan perbandingan LIKE atau NOT LIKE sebagai gantinya. Untuk menemukan nama yang dimulai dengan „b‟:

  mysql> SELECT * FROM pet WHERE name LIKE "b%";
            +--------+--------+---------+------+------------+------------+
  | name   | owner  | species | sex  | birth      | death      |
            +--------+--------+---------+------+------------+------------+
  | Buffy  | Harold | dog     | f    | 1989-05-13 | NULL       |
  | Bowser | Diane  | dog     | m    | 1989-08-31 | 1995-07-29 |
            +--------+--------+---------+------+------------+------------+
  Untuk menemukan nama yang diakhiri denga „fy‟:
  mysql> SELECT * FROM pet WHERE name LIKE "%fy";
          +--------+--------+---------+------+------------+-------+
  | name   | owner  | species | sex  | birth      | death |
          +--------+--------+---------+------+------------+-------+
  | Fluffy | Harold | cat     | f    | 1993-02-04 | NULL  |
  | Buffy  | Harold | dog     | f    | 1989-05-13 | NULL  |
          +--------+--------+---------+------+------------+-------+
  Untuk menemukan nama yang mengandung sebuah „w‟:
  mysql> SELECT * FROM pet WHERE name LIKE "%w%";
              +----------+-------+---------+------+------------+------------+
  | name     | owner | species | sex  | birth      | death      |
              +----------+-------+---------+------+------------+------------+
  | Claws    | Gwen  | cat     | m    | 1994-03-17 | NULL       |
  | Bowser   | Diane | dog     | m    | 1989-08-31 | 1995-07-29 |
  | Whistler | Gwen  | bird    | NULL | 1997-12-09 | NULL       |
              +----------+-------+---------+------+------------+------------+
  Untuk menemukan nama yang berisi tepat lima karakter, gunakan karakter pola „_‟ :
  mysql> SELECT * FROM pet WHERE name LIKE "_____";
          +-------+--------+---------+------+------------+-------+
  | name  | owner  | species | sex  | birth      | death |
          +-------+--------+---------+------+------------+-------+
  | Claws | Gwen   | cat     | m    | 1994-03-17 | NULL  |
  | Buffy | Harold | dog     | f    | 1989-05-13 | NULL  |
          +-------+--------+---------+------+------------+-------+
                                                                           Jenis  pengenalan  pola lain  yang  disediakan  oleh  MySQL  menggunakan  ekspresi regular  (extended  regular  expressions).  Jika  Anda  ingin  mengetes  untuk  jenis  pola seperti ini, gunakan operator REGEXP  dan  NOT REGEXP  (atau RLIKE dan NOT  RLIKE, yang sinonim).  Beberapa karakteristik dari ekspresi regular:

  - „.‟ menggantikan satu karakter.
  - Sebuah kelas karakter „[…]‟ menggantikan sembarang karakter yang termasuk di
     dalam  tanda  kurung  siku.  Contohnya,  „[abc]‟  menggantikan  „a‟,  „b‟,  atau  „c‟.
     untuk  menyebutkan jangkauan karakter,  gunakan tanda „-„. „[a-z]‟ menggantikan
     sembarang huruf kecil, dan „[0-9]‟ menggantikan sembarang digit.
  - „*‟  menggantikan  nol  atau  lebih  karakter  yang  didepannya.  Contohnya,  „x*‟
      menggantikan  sembarang  panjang  dari  karakter  „x‟,  „[0-9]*‟  menggantikan
      sembarang  jumlah digit,  dan  „.*‟  menggantikan  sembarang  jumlah  dari
      sembarang.
  - Ekspresi regular ini case sensitive, tetapi Anda dapat menggunakan kelas karakter
     untuk  menggantikan  kedua  jenis  huruf.  Contohnya,  „[aA]‟  menggantikan  huruf
     kecil dan huruf besar dari „a‟ dan „[a-zA-Z]‟ menggantikan sembarang huruf baik
     huruf besar maupun kecil.
  - Pola ini cocok jika ditemukan dimanapun di dalam nilai  yang sedang dites (pola
    SQL cuma cocok jika sesuai untuk keseluruhan nilai).
  - Untuk memastikan bahwa pola harus sesuai untuk awal atau akhir nilai yang dites,
     gunakan „^‟ pada awal atau „$‟ pada akhir pola.

Untuk mendemokan cara kerja ekspresi regular, query LIKE yang ditunjukkan di atas ditulis ulang menggunakan REGEXP: Untuk  menemukan  nama  yang  dimulai  dengan  „b‟,  gunakan  „^‟  untuk mencocokkannya  dengan  awal  nama  dan  „[bB]‟  untuk  mencocokkannya  baik  untuk huruf b besar maupun kecil:

  mysql> SELECT * FROM pet WHERE name REGEXP "^[bB]";
            +--------+--------+---------+------+------------+------------+
  | name   | owner  | species | sex  | birth      | death      |
            +--------+--------+---------+------+------------+------------+
  | Buffy  | Harold | dog     | f    | 1989-05-13 | NULL       |
  | Bowser | Diane  | dog     | m    | 1989-08-31 | 1995-07-29 |
            +--------+--------+---------+------+------------+------------+
 
Untuk  menemukan  nama  yang  diakhiri  dengan  „fy‟,  gunakan  „$‟  untuk  mencocokkannya dengan akhir dari nama:

  mysql> SELECT * FROM pet WHERE name REGEXP "fy$";
          +--------+--------+---------+------+------------+-------+
  | name   | owner  | species | sex  | birth      | death |
          +--------+--------+---------+------+------------+-------+
  | Fluffy | Harold | cat     | f    | 1993-02-04 | NULL  |
  | Buffy  | Harold | dog     | f    | 1989-05-13 | NULL  |
          +--------+--------+---------+------+------------+-------+
 
Untuk  mencari  nama  yang  mengandung  sebuah  „w‟,  gunakan  „[wW]‟  untuk mencocokkannya dengan huruf „w‟ kecil maupun besar:

  mysql> SELECT * FROM pet WHERE name REGEXP "[wW]";
              +----------+-------+---------+------+------------+------------+
  | name     | owner | species | sex  | birth      | death      |
              +----------+-------+---------+------+------------+------------+
  | Claws    | Gwen  | cat     | m    | 1994-03-17 | NULL       |
  | Bowser   | Diane | dog     | m    | 1989-08-31 | 1995-07-29 |
  | Whistler | Gwen  | bird    | NULL | 1997-12-09 | NULL       |
              +----------+-------+---------+------+------------+------------+
 
karena pola ekspresi regular mencocokkan jika terjadi dimanapun dalam nilai, maka  pada  query  di  atas  tidak  perlu  memakai  „*‟  pada  sisi kiri  maupun  kanan  dari  pola untuk  mencocokkannya  dengan  keseluruhan  nilai  seperti  jika  Anda  menggunakan pola SQL.
Untuk  menemukan  nama  yang  tepat  berisi  lima  huruf,  gunakan  „^‟  dan  „$‟  untuk mencocokkan dengan awal dan akhir nama, dan lima „.‟ di antaranya:

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

  mysql> SELECT * FROM pet WHERE name REGEXP "^.{5}$";
          +-------+--------+---------+------+------------+-------+
  | name  | owner  | species | sex  | birth      | death |
          +-------+--------+---------+------+------------+-------+
  | Claws | Gwen   | cat     | m    | 1994-03-17 | NULL  |
  | Buffy | Harold | dog     | f    | 1989-05-13 | NULL  |
          +-------+--------+---------+------+------------+-------+
Database juga sering digunakan untuk menjawab pertanyaan, “Seberapa sering suatu  tipe  data terdapat  dalam  suatu  tabel?”.  Sebagai  contoh,  Anda  mungkin  ingin  tahu berapa  banyak  hewan  yang  Anda  miliki,  atau  berapa  hewan  yang  dimiliki  tiap pemiliknya, atau Anda mungkin ingin membuat sensus tertentu untuk hewan Anda.  Menghitung  jumlah  total  hewan  yang  Anda  miliki  ini  sama  dengan  pertanyaan “Berapa  banyak baris  yang  ada  dalam  tabel  pet?,”  karena  terdapat  satu  record  per hewan.  Fungsi  COUNT()  menghitung  jumlah  hasil  yang  bukan  NULL,  jadi  query  untuk menghitung hewan Anda tampak seperti berikut:

  mysql> SELECT COUNT(*) FROM pet;
    +----------+
  | COUNT(*) |
    +----------+
  |        9 |
    +----------+
 
Pada query di atas, Anda mengambil nama orang yang memiliki hewan. Anda dapat  menggunakan  COUNT()  jika  Anda  ingin  menemukan  berapa  banyak  yang  dimiliki tiap pemilik:

  mysql> SELECT owner, COUNT(*) FROM pet GROUP BY owner;
      +--------+----------+
  | owner  | COUNT(*) |
      +--------+----------+
  | Benny  |        2 |
  | Diane  |        2 |
  | Gwen   |        3 |
  | Harold |        2 |
      +--------+----------+
Ingat  bahwa  penggunaan  GROUP  BY  untuk  menggabungkan  semua  record  yang  sama owner-nya. Tanpa ini, Anda akan mendapatkan pesan error:
  mysql> SELECT owner, COUNT(owner) FROM pet;
  ERROR 1140 at line 1: Mixing of GROUP columns (MIN(),MAX(),COUNT()...)
  with no GROUP columns is illegal if there is no GROUP BY clause
 
COUNT() dan GROUP BY sangat berguna untuk mengkarakterisasi data Anda dalam cara  tertentu.  Contoh  berikut  menunjukkan  cara  berbeda  untuk  melakukan  operasi konsensus hewan.
Jumlah hewan per spesies:

  mysql> SELECT species, COUNT(*) FROM pet GROUP BY species;
    +---------+----------+
  | species | COUNT(*) |
    +---------+----------+
  | bird    |        2 |
  | cat     |        2 |
  | dog     |        3 |
  | hamster |        1 |
  | snake   |        1 |
    +---------+----------+
jumlah hewan per jenis kelamin:

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

(pada output ini, NULL menunjukkan “jenis kelamin tidak diketahui”) Jumlah hewan per kombinasi dari spesies dan jenis kelamin:
  mysql> SELECT species, sex, COUNT(*) FROM pet GROUP BY species, sex;
        +---------+------+----------+
  | species | sex  | COUNT(*) |
        +---------+------+----------+
  | bird    | NULL |        1 |
  | bird    | f    |        1 |
  | cat     | f    |        1 |
  | cat     | m    |        1 |
  | dog     | f    |        1 |
  | dog     | m    |        2 |
  | hamster | f    |        1 |
  | snake   | m    |        1 |
        +---------+------+----------+
 Anda  tidak  perlu  mengambil  keseluruhan  tabel  ketika  menggunakan  COUNT().  Contohnya, pada query sebelumnya, ketika digunakan hanya untuk anjing dan kucing, tampak seperti ini:
  mysql> SELECT species, sex, COUNT(*) FROM pet
      -> WHERE species = "dog" OR species = "cat"
      -> GROUP BY species, sex;
        +---------+------+----------+
  | species | sex  | COUNT(*) |
        +---------+------+----------+
  | cat     | f    |        1 |
  | cat     | m    |        1 |
  | dog     | f    |        1 |
  | dog     | m    |        2 |
        +---------+------+----------+
Atau,  jika  Anda  ingin  jumlah hewan  per  jenis  kelamin  cuma  untuk  hewan  yang diketahui jenis kelaminnya:

  mysql> SELECT species, sex, COUNT(*) FROM pet
      -> WHERE sex IS NOT NULL
      -> GROUP BY species, sex;
        +---------+------+----------+
  | species | sex  | COUNT(*) |
        +---------+------+----------+
  | bird    | f    |        1 |
  | cat     | f    |        1 |
  | cat     | m    |        1 |
  | dog     | f    |        1 |
  | dog     | m    |        2 |
  | hamster | f    |        1 |
  | snake   | m    |        1 |
        +---------+------+----------+
Menggunakan Lebih Dari Satu Tabel
Tabel  pet  menunjukkan  hewan  apa  saja  yang  Anda  miliki.  Jika  Anda  ingin menyimpan  informasi  lain  mengenai  mereka,  seperti  kejadian  pada  kehidupan mereka, Anda membutuhkan tabel lain. Seperti apa tabel ini seharusnya?
  - Perlu berisi nama hewan jadi Anda tahu hewan mana yang mengalaminya.
  - Perlu tanggal jadi Anda tahu kapan hal ini terjadi.
  - Perlu field yang menggambarkan kejadian ini
  - Jika  Anda  ingin  bisa  mengkategorikan  kejadian,  akan  sangat  berguna  untuk
    memiliki field jenis kejadian.
Berdasarkan  pertimbangan  di  atas,  pernyataan  CREATE  TABLE  untuk  tabel  event mungkin tampak seperti berikut:
  mysql> CREATE TABLE event (name VARCHAR(20), date DATE,
      -> type VARCHAR(15), remark VARCHAR(255)); 
Seperti  ada  tabel  pet,  cara  termudah  untuk  mulai  mengisi  record  dengan  membuat  file teks yang berisi informasi berikut:

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

  Masukkan record ini dengan cara:
  mysql> LOAD DATA LOCAL INFILE "event.txt" INTO TABLE event;
Berdasarkan  apa  yang  Anda  pelajari  dari  query  yang  Anda  jalankan  pada  tabel  pet,  Anda  seharusnya  sudah  mampu  untuk  melakukan  pengambilan  record  pada  tabel event, prinsipnya sama. Anggaplah Anda ingin menemukan umur untuk tiap hewan ketika mereka melahirkan (litter).  Tabel  event  menunjukkan  kapan  ini  terjadi,  tetapi  untuk  menunjukkan  umur dari  induknya,  Anda  butuh tanggal  lahirnya.  Karena  ini  disimpan  dalam  tabel  pet, Anda butuh kedua tabel untuk querynya:

  mysql> SELECT pet.name, (TO_DAYS(date) - TO_DAYS(birth))/365 AS age,
  remark
      -> FROM pet, event

 -> WHERE pet.name = event.name AND type = "litter";
            +--------+------+-----------------------------+
  | name   | age  | remark                      |
            +--------+------+-----------------------------+
  | Fluffy | 2.27 | 4 kittens, 3 female, 1 male |
  | Buffy  | 4.12 | 5 puppies, 2 female, 3 male |
  | Buffy  | 5.10 | 3 puppies, 3 female         |
            +--------+------+-----------------------------+
 
 Ada beberapa hal yang harus diperhatikan tentang query ini:

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

  - Ketika  menggabungkan  (join)  informasi  dari  multiple  tabel,  Anda  harus
    menspesifikasi bagaimana record dalam satu tabel dapat cocok dengan record dari
    tabel  lain.  Ini  mudah  karena  mereka  keduanya  memiliki  kolom  name.  Query  ini
    menggunakan  klausa  WHERE  untuk  mencocokkan  record  dari  kedua  tabel
    berdasarkan value name.

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

Anda  tidak  harus  memiliki  dua  tabel  yang  berbeda  untuk  melakukan  join.  Kadang-kadang ada gunanya untuk menggabungkan sebuah tabel ke dirinya sendiri, jika Anda  ingin membandingkan record dalam suatu tabel ke record lain dalam tabel yang sama.

Contohnya,  untuk  menemukan  hewan  yang  merupakan  pasangan diantara  hewan Anda,  Anda  dapat  menggabungkan  tabel  pet  dengan  dirinya  sendiri  untuk memadukan hewan jantan dan betina yang sejenis:

  mysql> SELECT p1.name, p1.sex, p2.name, p2.sex, p1.species
      -> FROM pet AS p1, pet AS p2
      -> WHERE p1.species = p2.species AND p1.sex = "f" AND p2.sex =
  "m";
        +--------+------+--------+------+---------+
  | name   | sex  | name   | sex  | species |
        +--------+------+--------+------+---------+
  | Fluffy | f    | Claws  | m    | cat     |
  | Buffy  | f    | Fang   | m    | dog     |
  | Buffy  | f    | Bowser | m    | dog     |
        +--------+------+--------+------+---------+
Pada  query  ini,  kita  menulis  alias  dari  nama  tabel  agar  bisa  mereferensi  kolom  dan menjelaskan asosiasi dari tiap kolom.

Mengambil Informasi Mengenai Database Dan Tabel
Bagaimana  jika  Anda  lupa  nama  dari  database  atau  tabel,  atau  struktur  dari  suatu tabel?  MySQL  memecahkan  masalah  ini  melalui  beberapa  pernyataan  yang  menyediakan informasi mengenai database dan tabel yang didukungnya.
Anda sudah melihat SHOW DATABASES, yang menunjukkan daftar database yang dikelola  oleh  server.  Untuk  menemukan  database  mana  yang  sedang  digunakan, gunakan fungsi DATABASE():

  mysql> SELECT DATABASE();
    +------------+
  | DATABASE() |
    +------------+
  | hewan      |
    +------------+
 
  Jika Anda belum memilih database, hasilnya akan kosong. Untuk melihat daftar tabel dari database yang sedang digunakan, gunakan perintah:

  mysql> SHOW TABLES;
      +---------------------+
  | Tables in hewan     |
      +---------------------+
  | event               |
  | pet                 |
      +---------------------+
 
Jika  Anda  ingin  melihat  struktur  dari  suatu  tabel,  perintah  DESCRIBE  sangat berguna, perintah ini menampilkan informasi tentang tiap kolom tabel:

  mysql> DESC pet;
          +---------+-------------+------+-----+---------+-------+
  | Field   | Type        | Null | Key | Default | Extra |
          +---------+-------------+------+-----+---------+-------+
  | name    | varchar(20) | YES  |     | NULL    |       |
  | owner   | varchar(20) | YES  |     | NULL    |       |
  | species | varchar(20) | YES  |     | NULL    |       |
  | sex     | char(1)     | YES  |     | NULL    |       |
  | birth   | date        | YES  |     | NULL    |       |
  | death   | date        | YES  |     | NULL    |       |
          +---------+-------------+------+-----+---------+-------+
 
Field  menunjukkan  nama  kolom,  Type  adalah  tipe  data  kolom,  Null  menunjukkan apakah kolom yang bersangkutan dapat berisi nilai NULL, Key menunjukkan apakah kolom diindex dan Default menunjukkan nilai default kolom.
Jika  Anda  memiliki  index  pada  suatu  tabel,  SHOW  INDEX  FROM  tbl_name  akan menghasilkan informasi mengenainya.

  Index
Semua  tipe  kolom  MySQL  dapat  diindex.  Penggunaan  index  pada  kolom  yang  relevan adalah cara terbaik untuk meningkatkan performa operasi SELECT.
Sebuah  tabel  dapat  memiliki  max  16 index.  Panjang  maximum  index  adalah  256 bytes, meskipun hal ini dapat diubah ketika meng-compile MySQL.
Untuk  kolom CHAR  dan  VARCHAR,  Anda  dapat  mengindex  sebagian  dari  kolom.  hal  ini  jauh  lebih  cepat  dan  memerlukan  ruang  harddisk  yang  lebih  sedikit  daripada mengindex keseluruhan kolom. Sintaks yang digunakan dalam pernyataan CREATE TABLE untuk mengindex sebagian awal kolom seperti berikut:

  KEY index_name (col_name(length))
 
  Contoh berikut membuat sebuah index untuk 10 karakter pertama dari kolom name:

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

  mysql> CREATE TABLE test (
             id INT NOT NULL,
             last_name CHAR(30) NOT NULL,
             first_name CHAR(30) NOT NULL,
             PRIMARY KEY (id),
             INDEX name (last_name,first_name));

Kemudian index name adalah index untuk last_name dan first_name. Index ini akan digunakan untuk query yang menspesifikasi nilai untuk jangkauan yang diketahui dari last_name  atau  last_name  dan  first_name.  Maka,  index  name  akan  digunakan  pada query berikut:

  mysql> SELECT * FROM test WHERE last_name="Widenius";
  mysql> SELECT * FROM test WHERE last_name="Widenius"
                            AND first_name="Michael";
  mysql> SELECT * FROM test WHERE last_name="Widenius"
                            AND (first_name="Michael" OR
    first_name="Monty");
  mysql> SELECT * FROM test WHERE last_name="Widenius"
                            AND first_name >="M" AND first_name < "N";
 
Namun, index name tidak akan digunakan untuk query berikut:

 mysql> SELECT * FROM test WHERE first_name="Michael";
 mysql> SELECT * FROM test WHERE last_name="Widenius"
                            OR first_name="Michael";
 
Program Yang Ada Dalam MySQL:
  myisamchk 
Program  utilitas  untuk  menggambarkan,  mengecek,  mengoptimasi  dan memperbaiki tabel MySQL. 
    make_binary_release 
Membuat versi binary dari MySQL yang sudah di-compile. 
    msql2mysql 
Sebuah  skrip  shell  yang  mengubah  program  mSQL  ke  MySQL.  Ini  tidak menangani semua kasus, tetapi memberikan awal yang baik ketika pengubahan.
   mysqlaccess 

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

Utilitas untuk melakukan operasi administrative, seperti membuat atau menghapus  database,  reload  grant table,  mem-flush  taabel  ke  disk  dan  membuka  ulang  file log.  mysqladmin  dapat  juga  digunakan  untuk  mengambil  informasi  versi,  proses  dan status dari server.
  mysqlbug 
Skrip untuk melaporkan bug MySQL. Skrip ini seharusnya selalu digunakan detika mengisi laporan bug ke list MySQL.
  mysqld 

Daemon SQL. Ini harus selalu berjalan.
  mysqldump 
Untuk men-dump database MySQL ke sebuah file sebagai pernyataan-pernyataan SQL atau sebagai file teks yang dipisahkan oleh tab.
  mysqlimport 
Untuk  mengimpor  file  teks  ke  tabel  yang  bersangkutan  menggunakan  LOAD DATA INFILE.

    mysqlshow 
 Menampilkan informasi mengenai database, tabel, kolom, dan index.
    mysql_install_db 
Membuat  tabel  grant  MySQL  dengan  hak  akses  default.  Ini  biasanya  dijalankan cuma sekali, ketika pertama kali menginstall MySQL.
    replace 
Program  utilitas  yang  digunakan  oleh  mysql2mysql,  tetapi  memiliki  kegunaan  yang  lainnya.  replace  mengubah  string  di  dalam  file  atau  pada  input  standar. Dapat digunakan untuk menukar string. Contohnya, perintah ini menukar a dan b dalam file yang bersangkutan:

      shell> replace a b b a -- file1 file2 ...
  safe_mysqld 

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

Men-dump Struktur Dan Data Dari Database Dan Tabel MySQL
Utiliti untuk men-dump database atau koleksi dari database untuk backup atau untuk mentransfer  data  ke  server  SQL  lain.  Dump  ini  akan  berisi  pernyataan  SQL  untuk membuat tabel dan/atau mengisi tabel.

  shell> mysqldump [OPTIONS] database [tables]
  OR     mysqldump [OPTIONS] --databases [OPTIONS] DB1 [DB2 DB3...]
  OR     mysqldump [OPTIONS] --all-databases [OPTIONS]
 
Jika  Anda  tidak  memberikan  tabel  apapun  atau  menggunakan –databases  atau –all-databases, seluruh database akan di-dump. Anda  akan  mendapatkan  daftar  option  dari  mysqldump  yang  didukung  oleh  versi Anda dengan menjalankan perintah :
  shell> mysqldump –help
Penggunaan  yang  normal  dari  mysqldump  mungkin  adalah  membuat  backup  dari seluruh database.
  mysqldump --opt database > backup-file.sql 
Namun,  juga  sangat  berguna  untuk  membuat  server  MySQL  lain  dengan  informasi dari suatu database:
  mysqldump --opt database | mysql --host=remote-host -C database 

Mungkin juga untuk men-dump beberapa database dengan satu perintah:
  mysqldump --databases database1 [database2 database3...] >
    my_databases.sql
Jika Anda ingin men-dump seluruh database, dapat menggunakan:
  mysqldump --all-databases > all_databases.sql   

 
Mengimpor Data Dari File Teks

Mysqlimport  menyediakan  interface  baris  perintah  untuk  pernyataan  SQL:  LOAD DATA INFILE. Sebagian besar option untuk mysqlimport berkaitan langsung dengan option yang sama dari LOAD DATA INFILE. mysqlimport dijalankan seperti berikut:
  shell> mysqlimport [options] database textfile1 [textfile2....]
Untuk  tiap  file  teks  yang  disebutkan  di  baris  perintah,  mysqlimport  menghapus ekstensi  dari  nama  file  dan  menggunakan  hasilnya  untuk  menentukan  tabel  mana yang harus diisi hasil impor.

 



















 

Share