Tutorial Belajar MySQL Part 13: Tipe Data Numerik MySQL

Jika kita membuat tabel, seperti yang telah kita pelajari pada Tutorial Belajar MySQL: Membuat dan Menghapus Tabel, untuk mendefiniskan kolom kita harus mendefenisikan tipe data untuk kolom tersebut.

Dalam tutorial ini, kita akan mempelajari tentang tipe-tipe data numerik (angka), yang meliputi Integer, Fixed Point, dan Floating Point dalam MySQL.


Tipe Data Integer MySQL: Tinyint , Smallint, Mediumint, Integer (Int), dan Bigint

Integer adalah tipe data untuk angka bulat (misalnya: 1,6, 59, -533, 1449). MySQL menyediakan beberapa tipe data untuk integer, perbedaannya lebih kepada jangkauan yang juga berpengaruh terhadap ukuran tipe data tersebut.

Jangkauan serta ukuran penyimpanan tipe data integer dalam MySQL dapat dilihat dari tabel dibawah ini:

Tipe DataJangkauan SIGNEDJangkauan UNSIGNEDUkuran
TINYINT-128 to 1270 to 2551 byte
SMALLINT-32,768 to 32,7670 to 65,5352 bytes
MEDIUMINT-8,388,608 to 8,388,6070 to 16,777,2153 bytes
INT-2,147,483,648 to 2,147,483,6470 to 4,294,967,2954 bytes
BIGINT-9,223,372,036,854,775,808 to
9,223,372,036,854,775,807
0 to
18,446,744,073,709,551,615
8 bytes
Selain INT, kita dapat juga menuliskan INTEGER dalam query MySQL, keduanya sama persis, hanya beda pada penamaan.

Pemilihan tipe data ini tergantung akan kebutuhan data kita. Misalkan untuk nomor urut absensi pada suatu kelas yang memiliki maksimal 30 orang, tipe data TINYINT sudah mencukupi. Namun jika kita bermaksud membuat absensi seluruh rakyat indonesia, tipe data TINYINT sampai dengan MEDIUMINT tidak akan mencukupi. Kita harus memilih INT atau BIGINT.

Idealnya, sedapat mungkin kita menggunakan tipe data paling kecil, karena menyangkut dengan ukuran dari database. Menggunakan INT untuk jumlah anggota keluarga seseorang mungkin tidak efisien. Namun lebih baik mengantisipasi besarnya data sedapat mungkin pada awal pembuatan database.

Perubahan tipe data disaat aplikasi telah diimplementasikan akan berpotensi membuat sebagian data hilang, atau aplikasi gagal berjalan. Dengan ukuran media penyimpanan yang semakin besar dan murah, mengorbankan ukuran demi aplikasi yang handal bukan sesuatu yang buruk.


Cara Penulisan Tipe Data Integer MySQL

Format query untuk tipe data integer adalah:

INT[(M)] [UNSIGNED] [ZEROFILL]

Setiap tipe data integer dapat di definisikan sebagai UNSIGNED, dimana kita mengorbankan nilai negatif, untuk mendapatkan jangkauan nilai positif yang lebih tinggi.

Dalam deklarasi tipe data integer, nilai M adalah jumlah digit yang disediakan untuk menampilkan data. Misalnya kita mendefiniskan suatu kolom dengan INT(5), jika kita input angka 102, maka MySQL akan menambahkan spasi sebanyak 2 buah di depan angka, agar tampilan data menjadi 5 digit (istilah pemogramannya : padding left).

Nilai M tidak mempengaruhi nilai maksimal dari integer. Jika angka yang diinputkan melebihi digit M, MySQL akan tetap menampilkan hasilnya (selama masih dalam jangkauan tipe data tersebut). Jika kita deklarasikan INT(4), nilai maksimal tetap 2,147,483,647 bukan 9999.

Selain opsional query UNSIGNED, pendeklarasian integer juga terdapat opsional atribut ZEROFILL. ZEROFILL ini berhubungan dengan nilai M, yang akan mengisi angka 0 pada bagian kiri nilai yang diinput alih-alih spasi.

Contoh query pembuatan tabel dengan deklarasi integer :

mysql> CREATE TABLE contoh_int (mini TINYINT,  kecil SMALLINT UNSIGNED, 
sedang MEDIUMINT(4) ZEROFILL, biasa INT(4) UNSIGNED, 
besar BIGINT(6) UNSIGNED ZEROFILL);

Query OK, 0 rows affected (0.06 sec)

mysql> DESC contoh_int;
+--------+--------------------------------+------+-----+---------+-------+
| Field  | Type                           | Null | Key | Default | Extra |
+--------+--------------------------------+------+-----+---------+-------+
| mini   | tinyint(4)                     | YES  |     | NULL    |       |
| kecil  | smallint(5) unsigned           | YES  |     | NULL    |       |
| sedang | mediumint(4) unsigned zerofill | YES  |     | NULL    |       |
| biasa  | int(4) unsigned                | YES  |     | NULL    |       |
| besar  | bigint(6) unsigned zerofill    | YES  |     | NULL    |       |
+--------+--------------------------------+------+-----+---------+-------+
5 rows in set (0.21 sec)

Dari query DESC kita dapat melihat kolom mini dan kecil, secara otomatis akan bersisi nilai M, walaupun dalam deklarasi pembuatan tabel kita tidak menyatakannya secara langsung. Nilai ini didapat dari jangkauan terbesar tipe data tersebut

Jika kita inputkan angka 122 kedalam seluruh kolom, hasilnya adalah sebagai berikut:

mysql> INSERT INTO contoh_int values ((122), (122), (122), 
(122), (122));

Query OK, 1 row affected (0.07 sec)

mysql> SELECT * FROM contoh_int;

+------+-------+--------+-------+--------+
| mini | kecil | sedang | biasa | besar  |
+------+-------+--------+-------+--------+
|  122 |   122 |   0122 |   122 | 000122 |
+------+-------+--------+-------+--------+
1 row in set (0.00 sec)

Untuk perintah INSERT dan SELECT, kita akan mempelajarinya lebih jauh pada tutorial berikutnya, query INSERT digunakan untuk input data ke dalam tabel, dan SELECT digunakan untuk menampilkan nilai dari tabel. Dari contoh diatas kita setidaknya mendapat gambaran bagaimana cara deklarasi tipe data integer. Perhatikan untuk kolom sedang dan besar, terdapat angka nol di depan angka. Hal ini karena kedua kolom tersebut kita deklarasikan sebagai ZEROFILL.


Tipe Fixed Point MySQL: DECIMAL

Tipe data fixed point adalah tipe data angka pecahan (desimal), dimana jumlah angka pecahan (angka di belakang koma) sudah di tentukan dari awal. Format penulisan query fixed point adalah:

DECIMAL [(M[,D])] [UNSIGNED] [ZEROFILL]

DECIMAL merupakan kata kunci untuk mendefiniskan suatu kolom sebagai fixed point.

Besar dari tipe data fixed point ini tergantung dari opsional query [M,D] dimana M adalah total jumlah digit keseluruhan, dan D adalah jumlah digit dibekang koma (pecahan). Contohnya DEC [6,2] akan mendefiniskan suatu kolom agar memuat 6 digit angka, dengan 4 angka di depan koma, dan 2 digit angka di belakang koma.

DeklarasiJangkauan
DECIMAL (4,1)-999,9 to 999,9
DECIMAL (6,2)-9999,99 to 9999,99
DECIMAL (3,2)-9,99 to 9,99
DECIMAL (8,2)-999999,99 to 999999,99

Maksimal nilai untuk M adalah 65, dan maksimal nilai D adalah 30. Dengan syarat, nilai D tidak boleh lebih besar dari nilai M. Jika kita tidak menyertakan M dan D dalam mendefinisikan suatu kolom DECIMAL, maka secara sistem M akan di set 10. Dan D default 0. Tipe data DECIMAL ini cocok digunakan untuk kolom yang difungsikan untuk menampung nilai uang.

Opsional query UNSIGNED jika disertakan hanya semata-mata membuang nilai negatif dari DECIMAL, tanpa memperbesar jangkauannya. Opsional query ZEROFILL sama seperti integer, akan mengisi angka 0 pada bagian kiri angka.

Contoh pendefinisian tabel dengan kolom DECIMAL:

mysql> CREATE TABLE contoh_dec (satuan DECIMAL(3,2), puluhan DECIMAL(4,2), 
ribuan DECIMAL(5,2), normal DECIMAL, cantik DECIMAL(8,2) ZEROFILL);

Query OK, 0 rows affected (0.13 sec)

mysql> DESCRIBE contoh_dec;
+---------+--------------------------------+------+-----+---------+-------+
| Field   | Type                           | Null | Key | Default | Extra |
+---------+--------------------------------+------+-----+---------+-------+
| satuan  | decimal(3,2)                   | YES  |     | NULL    |       |
| puluhan | decimal(4,2)                   | YES  |     | NULL    |       |
| ribuan  | decimal(5,2)                   | YES  |     | NULL    |       |
| normal  | decimal(10,0)                  | YES  |     | NULL    |       |
| cantik  | decimal(8,2) unsigned zerofill | YES  |     | NULL    |       |
+---------+--------------------------------+------+-----+---------+-------+
5 rows in set (0.08 sec)

Perhatikan kolom normal, bahwa nilai DECIMAL di deklarasikan sebagai DECIMAL(10,0), ini adalah default MySQL jika kita tidak menuliskan jumlah digit.

mysql> INSERT INTO contoh_dec values ((1.3), (55.32), 
(523.77), (7832.3), (150000.45));

Query OK, 1 row affected, 1 warning (0.07 sec)

mysql> SELECT * FROM contoh_dec;
+--------+---------+--------+--------+-----------+
| satuan | puluhan | ribuan | normal | cantik    |
+--------+---------+--------+--------+-----------+
|   1.30 |   55.32 | 523.77 |   7832 | 150000.45 |
+--------+---------+--------+--------+-----------+
1 row in set (0.00 sec)

Khusus untuk kolom normal, kita perhatikan karena deklarasinya adalah DECIMAL (10,0), maka seluruh digit dibelakang koma dari inputan kita akan dihilangkan.

Selain menggunakan DECIMAL untuk fixed point, MySQL juga menyediakan beberapa nama lain, yang sama persis dengan fungsi DECIMAL, yaitu: NUMERIC, FIXED dan DEC. Pilihan ini disediakan agar MySQL sesuai dengan standard SQL yang digunakan pada berbagai RDBMS lain, seperti Oracle.

Tipe Floating Point : FLOAT dan DOUBLE

Jika pada tipe fixed point kita mendefiniskan suatu kolom dengan nilai pecahan yang tetap, untuk tipe floating point, nilai pecahan yang dapat diinput bisa berbeda-beda. Untuk tipe floating point, MySQL menyediakan 2 jenis tipe data, yaitu FLOAT dan DOUBLE. Perbedaan keduanya terletak pada presisi (ketelitian) pembulatan. FLOAT menggunakan single-precision, sedangkan DOUBLE menggunakan  double-precision.

Tipe Floating Point juga diperuntukkan untuk nilai desimal, perbedaan antara Fixed Point dengan Floating Point lebih kedalam arsitektur (cara perhitungannya pada prosesor komputer) dan ketelitian (presisi) yang digunakan. Tentang perbedaan fixed dan floating point tidak akan kita bahas, namun setidaknya kita mengetahui bahwa MySQL menyediakan tipe data untuk keduanya.
Tipe DataJangkauanUkuran
FLOAT-3.402823466E+38 to 3.402823466E+384 bytes
DOUBLE-1.7976931348623157E+308 to 1.7976931348623157E+3088 bytes

Untuk tipe data FLOAT dan DOUBLE, format querynya adalah:

FLOAT[(M,D)] [UNSIGNED] [ZEROFILL]
DOUBLE[(M,D)] [UNSIGNED] [ZEROFILL]

Sama seperti pada tipe data DECIMAL, nilai opsional query [M, D] dimana M adalah total jumlah digit keseluruhan, dan D adalah jumlah digit dibekang koma (pecahan). Maksimal nilai M dan D akan berbeda pada tiap komputer, tergantung kemampuan prosesor mengolah tipe data floating point. FLOAT biasanya akan akurat untuk penyimpanan sekitar 7 angka desimal, sedangkan DOUBLE mencapai 15 angka desimal.

Opsional query UNSIGNED jika di nyatakan, akan menghilangkan kemampuan tipe data untuk meyimpan angka negatif (tidak menambah jangkauan sebagaimana tipe data integer)

Opsional query ZEROFILL sama seperti integer, akan mengisi angka 0 pada bagian kiri angka.

Contoh pendefinisan tipe data floating point:

mysql> CREATE TABLE contoh_float (satuan FLOAT(3,2), puluhan FLOAT(4,2), 
ribuan FLOAT(5,2), positif DOUBLE ZEROFILL UNSIGNED, 
cantik DOUBLE(8,2) ZEROFILL);

Query OK, 0 rows affected (1.21 sec)

mysql> DESCRIBE contoh_float;
+---------+-------------------------------+------+-----+---------+-------+
| Field   | Type                          | Null | Key | Default | Extra |
+---------+-------------------------------+------+-----+---------+-------+
| satuan  | float(3,2)                    | YES  |     | NULL    |       |
| puluhan | float(4,2)                    | YES  |     | NULL    |       |
| ribuan  | float(5,2)                    | YES  |     | NULL    |       |
| positif | double unsigned zerofill      | YES  |     | NULL    |       |
| cantik  | double(8,2) unsigned zerofill | YES  |     | NULL    |       |
+---------+-------------------------------+------+-----+---------+-------+
5 rows in set (0.04 sec)

mysql> INSERT INTO contoh_float values ((1.3), (55.32), (523.77), 
(7832.3), (150000.45));

Query OK, 1 row affected (0.15 sec)

mysql> SELECT * FROM contoh_float;
+--------+---------+--------+------------------------+-----------+
| satuan | puluhan | ribuan | positif                | cantik    |
+--------+---------+--------+------------------------+-----------+
|   1.30 |   55.32 | 523.77 | 00000000000000007832.3 | 150000.45 |
+--------+---------+--------+------------------------+-----------+
1 row in set (0.00 sec)
Karena tipe data floating point menggunakan pendekatan nilai, menggunakan tipe data ini untuk perbandingan akan menyebabkan masalah. Hal ini disebabkan cara penyimpanan arsitektur prosesor dalam menangani tipe floating point, bukan semata-mata permasalahan pada MySQL. Pertimbangkan untuk menggunakan tipe data fixed point jika lebih membutuhkan presisi/ketelitian.

Dalam tutorial belajar MySQL kali ini kita telah mempelajari tipe-tipe data numerik dalam MySQL, yakni meliputi Tipe data Integer, Decimal, dan Float. Dalam tutorial selanjutnya, kita akan membahas tentang tipe data huruf (string) dalam MySQL.


Tutorial Terkait:

56 Comments

  1. surico H
    19 Dec 12
  2. Alifya salsadila
    06 Jun 13
    • Duniailkom
      07 Jun 13
  3. Nasir usman
    20 Feb 14
    • Nasir usman
      20 Feb 14
  4. Reza Dumet
    23 Apr 14
  5. Ibnu Toha
    22 Nov 14
    • Andre
      24 Nov 14
  6. deden surya
    29 Dec 14
    • Andre
      29 Dec 14
  7. robbyalaziz
    29 Jan 15
    • Andre
      29 Jan 15
  8. Dani Sukma
    07 Apr 15
  9. andika
    17 May 15
    • Andre
      18 May 15
  10. junardi
    30 May 15
    • Andre
      30 May 15
  11. junardi
    19 Jun 15
    • Andre
      19 Jun 15
    • Andre
      19 Jun 15
  12. junardi
    20 Jun 15
  13. marco
    25 Aug 15
    • Andre
      25 Aug 15
  14. marco
    27 Aug 15
    • Andre
      27 Aug 15
  15. edy akbar
    16 Oct 15
    • Andre
      17 Oct 15
  16. muyas
    29 Oct 15
    • Andre
      30 Oct 15
  17. rachmat
    27 Dec 15
    • Andre
      29 Dec 15
  18. Elva
    30 Mar 16
    • Andre
      30 Mar 16
  19. Lutfi
    21 May 16
    • Andre
      22 May 16
  20. Lutfi
    22 May 16
    • Andre
      26 May 16
  21. riyad
    16 Jun 16
    • Andre
      17 Jun 16
  22. putri
    16 Aug 16
  23. Lasthope
    02 Dec 16
  24. Anonymous
    08 Dec 16
  25. Syarif
    13 Mar 17
    • Andre
      15 Mar 17
  26. Jeri
    27 Mar 17
    • Andre
      24 May 17
  27. Teguh widodo
    14 Jul 17
    • Andre
      15 Jul 17
      • Teguh widodo
        19 Jul 17
        • Andre
          21 Jul 17
  28. fitri
    30 Sep 17
    • Andre
      01 Oct 17

Add Comment