Mengategorikan Data – MySQL Dasar #61

Selanjutnya kita akan belajar untuk bagaimana mengelompokan nilai- nilai ke dalam beberapa kategori dari sebua data yang memiliki nilai yang unik.

Lihat daftar isi : Menghasilkan Kesimpulan - MySQL Dasar #50  

Nilai unik yang dimaksud disini adalah setiap nilai yang terdapat pada tabel memiliki perbedaan antara satau dengan yang lainnya. Perhatikan disini bahwa saya memiliki tabel propinsi dengan nilai yang unik

MariaDB [root93]> SELECT * FROM propinsi;
+------------------+-----------+------------+-----------+
| nama             | singkatan | pendirian  | populasi  |
+------------------+-----------+------------+-----------+
| Banda Aceh       | ACH       | 1899-12-12 |    746389 |
| Sumatera Utara   | SUMUT     | 1919-04-3  |  15746389 |
| Sumatera Barat   | SUMBAR    | 1719-05-25 | 107383746 |
| Kepulauan Riau   | KEPRI     | 1998-08-21 |   1257333 |
| Bangka Belitung  | BABEL     | 1999-09-29 |   2333998 |
| Riau             | RIAU      | 1835-04-13 |   7383635 |
| Bengkulu         | BENG      | 1921-08-17 |   4573848 |
| Sumatera Selatan | SUMSEL    | 1835-10-30 |  12888997 |
| Lampung          | LAMP      | 1822-08-31 |  11783823 |
| Banten           | BAN       | 2001-08-22 |  15783675 |
| Jawa Barat       | JABAR     | 1911-09-27 |  25783436 |
| Jawa Tengah      | JATENG    | 1912-11-23 |  24753566 |
| Jawa Timur       | JATIM     | 1913-12-24 |  24889569 |
+------------------+-----------+------------+-----------+
13 rows in set (0.020 sec)

MariaDB [root93]> SELECT COUNT(populasi), COUNT(DISTINCT populasi)
    -> FROM propinsi;
+-----------------+--------------------------+
| COUNT(populasi) | COUNT(DISTINCT populasi) |
+-----------------+--------------------------+
|              13 |                       13 |
+-----------------+--------------------------+
1 row in set (0.001 sec)

Dengan nilai seperti diatas maka nilai – nilai tidak dapat dikelompokan ke dalam beberapa himpunan kecil nilai sehingga kita perlu melakukan transformasu untuk memaksa nilai – nilai agar dikelompokan ke dalam beberapa kategori. Pertama kita perlu menentukan rentang populasi.

MariaDB [root93]> SELECT MIN(populasi), MAX(populasi)
    -> FROM propinsi;
+---------------+---------------+
| MIN(populasi) | MAX(populasi) |
+---------------+---------------+
|        746389 |     107383746 |
+---------------+---------------+
1 row in set (0.001 sec)

Agar tiap nilai populasi ada pada kategori yang tepat, maka kita perlu membaginya dengan lima juta kemudian menggunakan hasil integer seperti berikut :

MariaDB [root93]> SELECT FLOOR(populasi/5000000) AS 'populasi (juta)',
    -> COUNT(*) AS 'jumlah propinsi'
    -> FROM propinsi
    -> GROUP by 1;
+-----------------+-----------------+
| populasi (juta) | jumlah propinsi |
+-----------------+-----------------+
|               0 |               4 |
|               1 |               1 |
|               2 |               2 |
|               3 |               2 |
|               4 |               2 |
|               5 |               1 |
|              21 |               1 |
+-----------------+-----------------+
7 rows in set (0.001 sec)

Perhatikan bahwa ekspresi memang sudah mengelompokan nilai populasi kedalam sejumlah kecil kategori tetapi nilai – nilai kategorinya tidak tepat sehingga FLOOR nantinya perlu dikalikan lima seperti berikut ini :

MariaDB [root93]> SELECT FLOOR(populasi/5000000)*5 AS 'populasi (juta)',
    -> COUNT(*) AS 'jumlah propinsi'
    -> FROM propinsi
    -> GROUP by 1;
+-----------------+-----------------+
| populasi (juta) | jumlah propinsi |
+-----------------+-----------------+
|               0 |               4 |
|               5 |               1 |
|              10 |               2 |
|              15 |               2 |
|              20 |               2 |
|              25 |               1 |
|             105 |               1 |
+-----------------+-----------------+
7 rows in set (0.001 sec)

Perhatikan bahwa hasil diatas masih menunjukan sedikit kesalahan, nilai maksimum adalah 107 jutaan tetapi disini nilainya menjadi 105 juta, seharusnya 110 juta. Hal tersebut menunjukan bahwa ekspresi penghasil kategori mengelompokan nilai – nilai ke batas bawah pada tiap kategori. Untuk itu kita perlu mengakalinya dengan contoh seperti berikut

MariaDB [root93]> SELECT FLOOR((populasi+4999999)/5000000)*5 AS 'populasi (juta)',
    -> COUNT(*) AS 'jumlah propinsi'
    -> FROM propinsi
    -> GROUP by 1;
+-----------------+-----------------+
| populasi (juta) | jumlah propinsi |
+-----------------+-----------------+
|               5 |               4 |
|              10 |               1 |
|              15 |               2 |
|              20 |               2 |
|              25 |               2 |
|              30 |               1 |
|             110 |               1 |
+-----------------+-----------------+
7 rows in set (0.001 sec)

Pada hasil query diatas kita bisa melihat bahwa terdapat 4 propinsi yang memiliki populasi lima juta atau kurang. Cara ini bisa juga Anda terapkan untuk semua jenis nilai numerik. Misalnya disini saya memiliki tabel mail yang memuat berbagai macam ukuran. Anda dapat mengelompokan nilai – nilai pada tabel mail misalnya kedalam kategori 100.000 byte seperti berikut :

MariaDB [root93]> SELECT FLOOR((ukuran+99999)/100000) AS 'ukuran (100KB)',
    -> COUNT(*) AS 'jumlah pesan'
    -> FROM mail
    -> GROUP by 1
    -> ;
+----------------+--------------+
| ukuran (100KB) | jumlah pesan |
+----------------+--------------+
|              1 |           12 |
|              3 |            1 |
+----------------+--------------+
2 rows in set (0.001 sec)

Jika Anda ingin melihat hasil dengan jelas, maka kalikan 100 setelah floor. Selanjutnya kita juga bisa menkategorikan kedalam 50.000 byte, Anda juga bisa mengkalikan 50 setelah FLOOR jika ingin melihat nilainya secara detail

MariaDB [root93]> SELECT FLOOR((ukuran+49999)/50000) AS 'ukuran (50KB)', 
    -> COUNT(*) AS 'jumlah pesan'
    -> FROM mail
    -> GROUP by 1;
+---------------+--------------+
| ukuran (50KB) | jumlah pesan |
+---------------+--------------+
|             1 |           10 |
|             2 |            2 |
|             5 |            1 |
+---------------+--------------+
3 rows in set (0.001 sec)

Jika misal pengkategoriannya masih terlihat terlalu besar, maka Anda bisa mempersempitnya menjadi 20.000 byte

MariaDB [root93]> SELECT FLOOR((ukuran+19999)/20000) AS 'ukuran (20KB)',
    -> COUNT(*) AS 'jumlah pesan'
    -> FROM mail
    -> GROUP by 1;
+---------------+--------------+
| ukuran (20KB) | jumlah pesan |
+---------------+--------------+
|             1 |            8 |
|             2 |            2 |
|             3 |            1 |
|             5 |            1 |
|            12 |            1 |
+---------------+--------------+
5 rows in set (0.001 sec)

MariaDB [root93]> SELECT FLOOR((ukuran+19999)/20000)*20 AS 'ukuran (20KB)',
    -> COUNT(*) AS 'jumlah pesan'
    -> FROM mail
    -> GROUP by 1;
+---------------+--------------+
| ukuran (20KB) | jumlah pesan |
+---------------+--------------+
|            20 |            8 |
|            40 |            2 |
|            60 |            1 |
|           100 |            1 |
|           240 |            1 |
+---------------+--------------+
5 rows in set (0.001 sec)

Pada contoh kasus tertentu, kita bisa mengkategorikan grup-grup pada skala logaritmik. Misalnya nilai – nilai pada populasi dapat ditulis dengan cara sebagai berikut :

MariaDB [root93]> SELECT FLOOR(LOG10(populasi)) AS 'log10(populasi)',
    -> COUNT(*) AS 'jumlah propinsi'
    -> FROM propinsi
    -> GROUP BY 1;
+----------------+-----------------+
| log10(populasi | jumlah propinsi |
+----------------+-----------------+
|              5 |               1 |
|              6 |               4 |
|              7 |               7 |
|              8 |               1 |
+----------------+-----------------+
4 rows in set (0.001 sec)

Baca selanjutnya : Mengendalikan Urutan Kesimpulan – MySQL Dasar #62

PLEASE SHARE

Share it Share it Tweet Share it Pin it

Ahmad Zaelani

Seorang laki - laki biasa yang senang duduk sendirian di pinggir pantai, pengagum embun pagi dan lembayung senja, suka blogging, coding dan jogging. Moto hidupnya adalah hidup santai dan simple