Fungsi-Fungsi Pustaka MySQL
Menciptakan Tabel
Berikut diciptakan sebuah
tabel bernama mobil:
mysql> CREATE TABLE mobil(
-> PEMBUAT VARCHAR
(25),
-> MODEL VARCHAR
(25),
-> HARGA NUMERIC
-> );
Query OK, 0 rows affected (0.37 sec)
mysql> INSERT INTO mobil VALUES ('CHRYSLER', 'CROSSFIRE',
33620);
Query OK, 1 row affected (0.05 sec)
mysql> INSERT INTO mobil VALUES ('CHRYSLER', '300M', 29185);
Query OK, 1 row affected (0.05 sec)
mysql> INSERT INTO mobil VALUES ('CHRYSLER', 'CIVIC', 15610);
Query OK, 1 row affected (0.06 sec)
mysql> INSERT INTO mobil VALUES ('HONDA', 'ACCORD', 19300);
Query OK, 1 row affected (0.06 sec)
mysql> INSERT INTO MOBIL VALUES('FORD', 'MUSTANG', 15610);
Query OK, 1 row affected (0.05 sec)
mysql> INSERT INTO MOBIL VALUES('FORD', 'LATESTnGREATEST',
NULL);
Query OK, 1 row affected (0.08 sec)
mysql> INSERT INTO MOBIL VALUES('FORD', 'FOCUS', 13005);
Query OK, 1 row affected (0.06 sec)
Fungsi AVG()
Fungsi AVG()
menghitung rerata aritmatik dari serangkaian angka pada argumennya. Sebagai
contoh, query berikut dapat dipakai untuk mengumpulkan informasi statistik
tentang setiap kendaraan pada tabel mobil:
mysql> SELECT
-> AVG(harga)
harga_rerata
-> FROM mobil;
+--------------+
| harga_rerata |
+--------------+
| 21055.0000 |
+--------------+
1 row in set (0.00 sec)
Untuk menghitung
harga rerata untuk tiap manufaktur (pembuat), Anda bisa menggunakan klausa
GROUP BY:
mysql> SELECT
-> pembuat,
-> AVG(harga)
harga_rerata
-> FROM mobil
-> GROUP BY
pembuat;
+----------+--------------+
| pembuat | harga_rerata
|
+----------+--------------+
| CHRYSLER | 26138.3333
|
| FORD | 14307.5000 |
| HONDA | 19300.0000 |
+----------+--------------+
3 rows in set (0.00 sec)
Fungsi COUNT()
Fungsi ini menjawab
pertanyaan, “Berapa banyak kendaraan yang Anda miliki di parkir?”. Perhatikan
contoh berikut:
mysql> SELECT
-> COUNT(*)
hitung_mobil
-> FROM mobil;
+--------------+
| hitung_mobil |
+--------------+
| 7 |
+--------------+
1 row in set (0.00 sec)
Dengan menggunakan
klausa GROUP BY, Anda bisa menghitung berapa banyak mobil dari tiap vendor yang
Anda miliki di garasi Anda:
mysql> SELECT
-> pembuat,
-> COUNT(harga)
hitung_mobil
-> FROM mobil
-> GROUP BY
pembuat;
+----------+--------------+
| pembuat | hitung_mobil
|
+----------+--------------+
| CHRYSLER | 3
|
| FORD | 2 |
| HONDA | 1 |
+----------+--------------+
3 rows in set (0.00 sec)
Fungsi COUNT(*)
melaporkan bahwa nilai dari hitung_mobil sama dengan 7, sedangkan COUNT(harga) menegaskan
bahwa Anda hanya memiliki enam mobil. Anda bisa mengamati bahwa pada tabel
mobil terlihat bahwa satu model Ford memiliki harga NULL.
mysql> SELECT
-> pembuat,
-> COUNT(*)
hitung_total,
-> COUNT(harga)
harga_mobil
-> FROM mobil
-> GROUP BY
pembuat;
+----------+--------------+-------------+
| pembuat | hitung_total
| harga_mobil |
+----------+--------------+-------------+
| CHRYSLER | 3
| 3 |
| FORD | 3 | 2 |
| HONDA | 1 |
1 |
+----------+--------------+-------------+
3 rows in set (0.00 sec)
Fungsi MAX() dan MIN()
Dari namanya, kedua
fungsi ini bisa ditebak maknanya. Kedua fungsi tersebut dapat Anda pakai untuk
menampilkan nilai maksimum dan nilai minimum dari suatu himpunan nilai. Untuk
mencari harga tertinggi dan harga terendah dari semua mobil, query berikut
dapat digunakan:
mysql> SELECT
-> MAX(harga)
harga_maks,
-> MIN(harga)
harga_min
-> FROM mobil;
+------------+-----------+
| harga_maks | harga_min |
+------------+-----------+
| 33620 | 13005 |
+------------+-----------+
1 row in set (0.05 sec)
Untuk menghitung
rentang harga mobil yang dikaitkan dengan pembuatnya, Anda bisa menggunakan
klausa GROUP BY berikut:
mysql> SELECT
-> pembuat,
-> MAX(harga)
harga_maks,
-> MIN(harga)
harga_min
-> FROM mobil
-> GROUP BY
pembuat;
+----------+------------+-----------+
| pembuat | harga_maks |
harga_min |
+----------+------------+-----------+
| CHRYSLER | 33620 |
15610 |
| FORD | 15610 | 13005 |
| HONDA | 19300 | 19300 |
+----------+------------+-----------+
3 rows in set (0.00 sec)
Fungsi SUM()
Fungsi SUM()
melakukan penjumlahan. Sebagai contoh, untuk menghitung total harga dari semua
mobil, Anda menggunakan query berikut:
mysql> SELECT
-> SUM(harga) total
-> FROM mobil;
+--------+
| total |
+--------+
| 126330 |
+--------+
1 row in set (0.00 sec)
Fungi GROUP BY akan
menghasilkan sudut lain terhadap data: total inventori yang terdistribusi pada
pelbagai vendor:
mysql> SELECT
-> pembuat,
-> SUM(harga) total
-> FROM mobil
-> GROUP BY
pembuat;
+----------+-------+
| pembuat | total |
+----------+-------+
| CHRYSLER | 78415 |
| FORD | 28615 |
| HONDA | 19300 |
+----------+-------+
3 rows in set (0.00 sec)
Fungsi ASCII()
Fungsi ini
menghasilkan nilai numerik dari karakter pojok-kiri dari sebuah string.
Menghasilkan 0 jika string adalah string kosong. Menghasilkan NULL jika string
adalah NULL. Fungsi ASCII() dipakai untuk karakter dengan nilai numerik dari 0
sampai 255.
mysql> SELECT
-> ASCII('A')
a_hurufbesar,
-> ASCII('abc')
a_hurufkecil;
+--------------+--------------+
| a_hurufbesar | a_hurufkecil |
+--------------+--------------+
| 65 | 97 |
+--------------+--------------+
1 row in set (0.01 sec)
Fungsi CHAR()
Fungsi CHAR()
kebalikan dari fungsi ASCII(), yang menghasilkan sebuah karakter bila diberikan
kode ASCII. Sebagai contoh, perhatikan berikut:
mysql> SELECT
-> CHAR(65)
a_hurufbesar,
-> CHAR(97)
a_hurufkecil;
+--------------+--------------+
| a_hurufbesar | a_hurufkecil |
+--------------+--------------+
| A | a |
+--------------+--------------+
1 row in set (0.00 sec)
Fungsi CONCAT()
Fungsi CONCAT()
menggabungkan dua (atau lebih) string. MySQL mengijinkan penggabungan lebih
dari dua string. Perhatikan contoh berikut:
mysql> SELECT
-> CONCAT('Teknik',
'Elektro', 'Yamaguchi') hasil;
+------------------------+
| hasil |
+------------------------+
| TeknikElektroYamaguchi |
+------------------------+
1 row in set (0.05 sec)
Fungsi LOWER() dan UPPER()
Fungsi LOWER() dan
UPPER() saling berkomplemen. Fungsi LOWER() mengkonversi semua karakter dalam
sebuah string menjadi huruf kecil dan fungsi UPPER() mengkonversinya menjadi
huruf besar. Perhatikan contoh berikut:
mysql> SELECT
->
LOWER('INFORMATIKA') hurufkecil,
->
UPPER('inforMATIKA') hurufbesar;
+-------------+-------------+
| hurufkecil |
hurufbesar |
+-------------+-------------+
| informatika | INFORMATIKA |
+-------------+-------------+
1 row in set (0.02 sec)
Fungsi LENGTH() dan LEN()
Fungsi LENGTH()
menghasilkan banyaknya karakter dalam sebuah string. Perhatikan query berikut:
mysql> SELECT
->
LENGTH('elektro') hasil;
+-------+
| hasil |
+-------+
| 7 |
+-------+
1 row in set (0.00 sec)
Fungsi REPLACE()
Contoh berikut
mengganti setiap huruf besar “A” dalam sebuah string menjadi asterisk “*” pada
bidang pertama. Pada bidang kedua, dimana argumen ketiga diabaikan, dihasilkan sebuah
string dengan semua “A” dihapus.
mysql> SELECT
-> REPLACE('ABCDA',
'A', '*') ganti_A,
-> REPLACE('ABCDA',
'A', '') hapus_A;
+---------+---------+
| ganti_A | hapus_A |
+---------+---------+
| *BCD* | BCD |
+---------+---------+
1 row in set (0.00 sec)
Fungsi ABS()
Fungsi ABS()
menghasilkan nilai absolut dari sebuah argumen masukan numerik. Seperti
contoh-contoh berikut, angka yang dihasilkan selalu positif:
mysql> SELECT
-> ABS(-100)
negatif,
-> ABS(100)
positif;
+---------+---------+
| negatif | positif |
+---------+---------+
| 100 | 100 |
+---------+---------+
1 row in set (0.03 sec)
Fungsi ACOS()
Fungsi ACOS()
dipakai untuk menghasilkan arkus kosinus dari ekspresi numerik yang dilewatkan
kepadanya. Ekspresi numerik tersebut harus berupa suatu nilai pecahan dalam
rentang -1 dan 1. Nilai yang dihasilkan adalah dalam format radian. Kode
berikut memberikan contoh penggunaan fungsi ACOS():
mysql> SELECT
->
ROUND(DEGREES(ACOS(.5)),0) as SUDUT_PERTAMA,
->
ROUND(DEGREES(ACOS(.75)),0) as SUDUT_KEDUA,
->
ROUND(DEGREES(ACOS(1.0)),0) as SUDUT_KETIGA;
+---------------+-------------+--------------+
| SUDUT_PERTAMA | SUDUT_KEDUA | SUDUT_KETIGA |
+---------------+-------------+--------------+
| 60 | 41 | 0 |
+---------------+-------------+--------------+
1 row in set (0.05 sec)
Fungsi ASIN()
Fungsi ASIN()
dipakai untuk menghasilkan arkus sinus dari ekspresi numerik yang dilewatkan
kepadanya. Ekspresi numerik tersebut harus berupa suatu nilai pecahan dalam
rentang -1 dan 1. Nilai yang dihasilkan adalah dalam format radian. Kode
berikut memberikan contoh penggunaan fungsi ASIN():
mysql> SELECT
->
ROUND(DEGREES(ASIN(.5)),0) as SUDUT_PERTAMA,
->
ROUND(DEGREES(ASIN(.75)),0) as SUDUT_KEDUA,
->
ROUND(DEGREES(ASIN(1.0)),0) as SUDUT_KETIGA;
+---------------+-------------+--------------+
| SUDUT_PERTAMA | SUDUT_KEDUA | SUDUT_KETIGA |
+---------------+-------------+--------------+
| 30 | 49 | 90 |
+---------------+-------------+--------------+
1 row in set (0.00 sec)
Fungsi ATAN() dan ATAN2()
Fungsi ATAN dan
ATAN2() dipakai untuk menghasilkan format arkus tangent dari argumen yang
dilewatkan. Kode berikut menampilkan sebuah contoh penggunaan kedua fungsi
tersebut:
mysql> SELECT
-> ATAN(.5) AS
HASIL_PERTAMA,
-> ATAN2(.5, 1.0)
AS HASIL_KEDUA
-> FROM DUAL;
+--------------------+--------------------+
| HASIL_PERTAMA |
HASIL_KEDUA |
+--------------------+--------------------+
| 0.4636476090008061 | 0.4636476090008061 |
+--------------------+--------------------+
1 row in set (0.00 sec)
Fungsi CEIL() dan FLOOR()
Kedua fungsi
membulatkan angka, secara berbeda. CEIL() membulatkan ke integer terdekat atas.
FLOOR() membulatkan ke integer bawah terdekat. Perhatikan contoh berikut:
mysql> SELECT
-> CEIL(109.19)
nil_ceil,
-> FLOOR(109.19)
nil_floor;
+----------+-----------+
| nil_ceil | nil_floor |
+----------+-----------+
| 110 | 109 |
+----------+-----------+
1 row in set (0.00 sec)
Fungsi COS()
Fungsi COS()
menghasilkan nilai kosinus dari argumen yang dilewatkan kepadanya. Argumen
harus berupa sebuah nilai pecahan yang merepresentasikan sudut dalam radian.
Contoh berikut mendemonstrasikan kegunaan dari fungsi COS():
mysql> SELECT
-> COS(RADIANS(0))
AS SUDUT_PERTAMA,
-> COS(RADIANS(45))
AS SUDUT_KEDUA,
-> COS(RADIANS(90))
AS SUDUT_KETIGA;
+---------------+--------------------+-----------------------+
| SUDUT_PERTAMA | SUDUT_KEDUA | SUDUT_KETIGA |
+---------------+--------------------+-----------------------+
| 1 |
0.7071067811865476 | 6.123233995736766e-17 |
+---------------+--------------------+-----------------------+
1 row in set (0.00 sec)
Fungsi COT()
Fungsi COT()
menghasilkan nilai kosinus hiperbolik dari argumen yang dilewatkan kepadanya.
Argumen harus berupa sebuah nilai pecahan yang merepresentasikan sudut dalam
radian. Contoh berikut mendemonstrasikan kegunaan dari fungsi COT():
mysql> SELECT
-> COT(RADIANS(90))
AS SUDUT;
+-----------------------+
| SUDUT |
+-----------------------+
| 6.123233995736766e-17 |
+-----------------------+
1 row in set (0.00 sec)
Fungsi DEGREES() dan
RADIANS()
Fungsi DEGREES() dan
RADIANS() saling melengkapi satu sama lain. DEGREES() mengambil argumen radian
dan menghasilkan derajat, sedangkan RADIANS() melakukan operasi kebalikannya.
Perhatikan contoh berikut:
mysql> SELECT
-> RADIANS(45)
radian,
->
CEIL(DEGREES(0.7853981633)) derajat;
+--------------------+---------+
| radian |
derajat |
+--------------------+---------+
| 0.7853981633974483 |
45 |
+--------------------+---------+
1 row in set (0.00 sec)
Fungsi EXP()
Fungsi EXP()
menghasilkan e (basis dari logaritma natural) yang dipangkatkan dengan
argumennya. Perhatikan contoh berikut:
mysql> SELECT
-> EXP(10)
eksponen;
+--------------------+
| eksponen |
+--------------------+
| 22026.465794806718 |
+--------------------+
1 row in set (0.00 sec)
Fungsi MOD()
Fungsi MOD()
menghasilkan sisa dari ekspresi numerik 1 yang dibagi dengan ekspresi numerik
2, seperti ditunjukkan sebagai berikut:
mysql> SELECT
-> MOD(10, 5)
sisa1,
-> MOD(10, 3)
sisa2;
+-------+-------+
| sisa1 | sisa2 |
+-------+-------+
| 0 | 1 |
+-------+-------+
1 row in set (0.01 sec)
Fungsi PI()
Fungsi PI()
menghasilkan nilai konstan dari pi. Kode berikut mendemonstrasikan hasil dari
fungsi PI():
mysql> SELECT
-> PI() AS
HASIL_DARI_PI;
+---------------+
| HASIL_DARI_PI |
+---------------+
| 3.141593 |
+---------------+
1 row in set (0.00 sec)
Fungsi POWER()
Fungsi POWER()
menghasilkan ekspresi numerik (argumen pertama) yang dipangkatkan dengan
argumen kedua. Berikut adalah sebuah contoh pemangkatan 100 dengan 2:
mysql> SELECT
-> POWER(100, 2)
pangkat;
+---------+
| pangkat |
+---------+
| 10000 |
+---------+
1 row in set (0.00 sec)
Fungsi RAND()
Fungsi RAND()
dipakai untuk menghasilkan suatu angka acak. Perhatikan contoh berikut:
mysql> SELECT
-> RAND()
angka_acak;
+------------------+
| angka_acak |
+------------------+
| 0.77515100108008 |
+------------------+
1 row in set (0.00 sec)
Untuk menghasilkan
angka acak dalam rentang di luar 0-1, Anda dapat mengalikan keluaran fungsi
RAND() dengan sebuah faktor pengali, dan kemudian melakukan pemotongan (dengan
fungsi TRUNCATE()) atau pembulatan (dengan fungsi ROUND()) terhadap hasil.
Berikut adalalah salah satu contohnya:
mysql> SELECT
-> ROUND((RAND() *
10000), 0) dari_nol_sampai_10000
+-----------------------+
| dari_nol_sampai_10000 |
+-----------------------+
| 8124 |
+-----------------------+
1 row in set (0.00 sec)
Fungsi SIGN()
Fungsi SIGN()
menghasilkan -1 ketika argumen masukan bernilai negatif, 1 ketika argumen
bernilai positif, dan 0 ketika argumen bernilai nol, seperti berikut:
mysql> SELECT
-> SIGN(-50) minus,
-> SIGN(50) plus,
-> SIGN(0) nol,
-> SIGN(NULL)
nilai_null;
+-------+------+-----+------------+
| minus | plus | nol | nilai_null |
+-------+------+-----+------------+
| -1 | 1 |
0 | NULL |
+-------+------+-----+------------+
1 row in set (0.00 sec)
Fungsi SQRT()
Fungsi SQRT()
mengekstrak akar kuadrat dari argumen masukan. Fungsi ini hanya menerima
argumen positif dan menghasilkan error bila argumen negatif dilewatkan
kepadanya.
mysql> SELECT
-> SQRT(100) akar;
+------+
| akar |
+------+
| 10 |
+------+
1 row in set (0.00 sec)
Fungsi TAN()
Fungsi TAN()
menghasilkan nilai tangent dari argumen yang dilewatkan kepadanya. Argumen
merepresentasikan sudut dalam radian. Kode berikut memberikan contoh dari
penggunaan fungsi TAN():
mysql> SELECT
-> TAN(36) AS
HASIL;
+-------------------+
| HASIL |
+-------------------+
| 7.750470905699148 |
+-------------------+
1 row in set (0.00 sec)
Fungsi FORMAT()
Fungsi FORMAT()
dipakai untuk memformat angka X dalam format berikut:###,###,###.### yang
dipotong menjadi D titik desimal. Contoh berikut mendemonstrasikan kegunaan dan
keluaran dari fungsi FORMAT():
mysql> SELECT
->
FORMAT(423423234.65434452,2) AS ANGKA_BESAR;
+----------------+
| ANGKA_BESAR |
+----------------+
| 423,423,234.65 |
+----------------+
1 row in set (0.03 sec)
Fungsi GREATEST()
Fungsi GREATEST()
menghasilkan nilai terbesar dari suatu himpunan argumen (n1, n2, n3, dan
seterusnya). Contoh berikut menggunakan fungsi GREATEST untuk menghasilkan
angka terbesar dari suatu himpunan nilai numerik:
mysql> SELECT
->
GREATEST(2,3,4,5,32,34,65,97,65,32,3) AS PEMENANG;
+----------+
| PEMENANG |
+----------+
| 97 |
+----------+
1 row in set (0.00 sec)
Fungsi INTERVAL()
Fungsi INTERVAL()
membandingkan nilai N dengan suatu daftar nilai (N1, N2, N3, dan seterusnya).
Fungsi ini menghasilkan 0 jika N<N1, 1 jika N<N2, 2 jika N<N3, dan
seterusnya. Ia akan menghasilkan -1 jika N adalah NULL. Daftar nilai harus
dalam format N1<N2<N3. Kode berikut merupakan contoh sederhana bagaimana
fungsi INTERVAL() bekerja:
mysql> SELECT INTERVAL(6,1,2,3,4,5,6,7,8,9,10) AS PEMENANG;
+----------+
| PEMENANG |
+----------+
| 6 |
+----------+
1 row in set (0.03 sec)
Fungsi LEAST()
Fungsi LEAST()
merupakan kebalikan dari fungsi GREATEST(). Tujuannya adalah untuk menghasilkan
item dengan nilai terkecil dari suatu daftar nilai (N1, N2, N3, dan
seterusnya). Contoh berikut menunjukkan kegunaan dan keluaran dari fungsi LEAST():
mysql> SELECT
->
LEAST(3,5,1,8,7,44,55,67,43) AS PEMENANG;
+----------+
| PEMENANG |
+----------+
| 1 |
+----------+
1 row in set (0.00 sec)
Fungsi LOG()
Versi satu argumen
dari fungsi ini akan menghasilkan logaritma natural dari argumennya. Jika ia
dipanggil dengan dua argumen, maka akan dihasilkan logaritma dari argumen kedua
untuk basis pada argumen pertama. Perhatikan contoh berikut:
mysql> SELECT LOG(45);
+--------------------+
| LOG(45) |
+--------------------+
| 3.8066624897703196 |
+--------------------+
1 row in set (0.00 sec)
mysql> SELECT LOG(2,63727);
+--------------------+
| LOG(2,63727) |
+--------------------+
| 15.959617125863682 |
+--------------------+
1 row in set (0.00 sec)
Fungsi LOG10()
Fungsi ini
menghasilkan logaritma basis-10 dari argumennya. Perhatikan contoh berikut:
mysql> SELECT LOG10(100);
+------------+
| LOG10(100) |
+------------+
| 2 |
+------------+
1 row in set (0.00 sec)
Fungsi CONV()
Tujuan dari fungsi
CONV() adalah mengkonversi angka dengan pelbagai basis yang berbeda. Fungsi ini
menghasilkan sebuah string dengan nilai argumen pertama yang dikonversi dari
basis pada argumen kedua menjadi basis pada argumen ketiga. Nilai basis minimum
adalah 2 dan maksimum 36. Jika terdapat argumen yang bernilai NULL, maka fungsi
ini menghasilkan NULL. Perhatikan contoh berikut, yang mengkonversi angka 5
dari basis 16 menjadi basis 2:
mysql> SELECT
-> CONV(5,16,2) AS
KONVERSI;
+----------+
| KONVERSI |
+----------+
| 101 |
+----------+
1 row in set (0.00 sec)
Fungsi OCT()
Fungsi OCT()
menghasilkan representasi string dari bilangan oktal yang menjadi argumennya.
Ini sama dengan CONV(N, 10, 8). Kode berikut mendemonstrasikan kegunaan dari
fungsi OCT():
mysql> SELECT
-> OCT(12) AS
OKTAL;
+-------+
| OKTAL |
+-------+
| 14 |
+-------+
1 row in set (0.00 sec)
Fungsi STD() atau STDDEV()
Fungsi STD dipakai
untuk menghasilkan deviasi standar dari sebuah ekspresi. Ini ekivalen dengan
akar kuadrat dari VARIANCE() atas suatu ekspresi. Contoh berikut menghitung
deviasi standar dari kolom harga pada tabel mobil:
mysql> SELECT
-> STD(HARGA)
DEVIASI_STD
-> FROM MOBIL;
+-------------------+
| DEVIASI_STD |
+-------------------+
| 7650.214593940051 |
+-------------------+
1 row in set (0.00 sec)
Fungsi BIT_AND()
Fungsi BIT_AND()
menghasilkan AND bitwise dari semua bit. Premis dasarnya adalah bahwa jika dua
bit sama, maka operasi AND bitwise akan menghasilkan 1, sedangkan jika kedua
bit berbeda, maka operasi AND bitwise akan menghasilkan 0. Contoh berikut
menerapkan fungsi BIT_AND() pada kolom HARGA yang dikolompokkkan berdasarkan
PEMBUAT mobil:
mysql> SELECT
-> PEMBUAT,
BIT_AND(HARGA) HASIL
-> FROM MOBIL
-> GROUP BY
PEMBUAT;
+----------+-------+
| PEMBUAT | HASIL |
+----------+-------+
| CHRYSLER | 0 |
| FORD | 12488 |
| HONDA | 19300 |
+----------+-------+
3 rows in set (0.00 sec)
Fungsi BIT_COUNT()
Fungsi BIT_COUNT()
menghasilkan jumlah bit yang aktif pada argumennya. Contoh berikut
mendemonstrasikan penggunaan fungsi BIT_COUNT() untuk menghasilkan jumlah bit
aktif pada beberapa angka:
mysql> SELECT BIT_COUNT(2) AS DUA,
-> BIT_COUNT(4) AS
EMPAT,
-> BIT_COUNT(7) AS
TUJUH;
+-----+-------+-------+
| DUA | EMPAT | TUJUH |
+-----+-------+-------+
| 1 | 1 |
3 |
+-----+-------+-------+
1 row in set (0.00 sec)
Fungsi BIT_OR()
Fungsi BIT_OR()
menghasilkan OR bitwise dari semua bit. Premis dasarnya adalah bahwa jika dua
bit sama, maka operasi OR bitwise akan menghasilkan 0, sedangkan jika kedua bit
berbeda, maka operasi OR bitwise akan menghasilkan 1. Contoh berikut menerapkan
fungsi BIT_OR() pada kolom HARGA yang dikolompokkkan berdasarkan PEMBUAT mobil:
mysql> SELECT
-> PEMBUAT,
BIT_OR(HARGA) HASIL
-> FROM MOBIL
-> GROUP BY
PEMBUAT;
+----------+-------+
| PEMBUAT | HASIL |
+----------+-------+
| CHRYSLER | 65535 |
| FORD | 16127 |
| HONDA | 19300 |
+----------+-------+
3 rows in set (0.00 sec)
Fungsi TRUNCATE()
Fungsi TRUNCATE()
menghasilkan argumen yang dipotong menjadi sejumlah titik desimal yang
ditetapkan pada argumen kedua. Perhatikan contoh berikut:
mysql> SELECT
-> TRUNCATE(109.29,
1) DIPOTONG;
+----------+
| DIPOTONG |
+----------+
| 109.2 |
+----------+
1 row in set (0.00 sec)
Fungsi COALESCE()
Fungsi COELESCE()
menghasilkan ekspresi tak-null pertama dalam daftar ekspresi. Sedikitnya harus
terdapat satu ekspresi yang tidak NULL. Jika semua ekspresi bernilai NULL, maka
fungsi ini menghasilkan NULL. Perhatikan contoh berikut:
mysql> SELECT
-> COALESCE(NULL,
NULL, 'TAK NULL', NULL) UJI
-> ;
+----------+
| UJI |
+----------+
| TAK NULL |
+----------+
1 row in set (0.03 sec)
Fungsi NULLIF()
Fungsi NULLIF()
membandingkan dua ekspresi. Jika keduanya sama, maka fungsi ini menghasilkan
NULL. Sebaliknya, ia menghasilkan ekspresi pertama. Berikut adalah contohnya:
mysql> SELECT
-> NULLIF('ABC',
'ABC') sama,
-> NULLIF('ABC',
'DEF') beda;
+------+------+
| sama | beda |
+------+------+
| NULL | ABC |
+------+------+
1 row in set (0.00 sec)
Fungsi BIN()
Fungsi BIN()
menghasilkan sebuah representasi string atas nilai biner pada argumen
masukannya. Argumen harus bertipe BIGINT. Jika nilai argumen adalah NULL, maka
fungsi ini menghasilkan NULL. Perhatikan contoh berikut:
mysql> SELECT BIN(48) AS NILAI_BIT;
+-----------+
| NILAI_BIT |
+-----------+
| 110000 |
+-----------+
1 row in set (0.00 sec)
Fungsi COMPRESS()
Fungsi COMPRESS()
dipakai untuk memampatkan isi sebuah string. String yang termampatkan dapat
dikembalikan menggunakan fungsi UNCOMPRESS(). Perhatikan contoh berikut yang
memampatkan sebuah frase dan kemudian menggunakan fungsi UNCOMPRESS() untuk
membalikannya:
mysql> SELECT
-> COMPRESS('SAYA
ADALAH MAHASISWA TEKNIK INFORMATIKA') AS TERMAMPATKAN,
->
UNCOMPRESS(COMPRESS('SAYA ADALAH MAHASISWA TEKNIK INFORMATIKA')) AS TAK_MAMPAT;
+------------------------------------------------------+------------------------------------------+
| TERMAMPATKAN |
TAK_MAMPAT
|
+------------------------------------------------------+------------------------------------------+
| (
x£♂vîtTptq¶q¶P-u¶p♀÷♀♫wq§÷_¶V-¶s_☼_u♀±¶v♦ █Y
O | SAYA ADALAH MAHASISWA TEKNIK INFORMATIKA |
+------------------------------------------------------+------------------------------------------+
1 row in set (0.00 sec)
Fungsi ELT()
Fungsi ELT()
menghasilkan argumen kedua jika argumen pertama sama dengan 1, argumen ketiga
jika argumen pertama sama dengan 2, dan seterusnya. Nilai dari argumen pertama harus
lebih dari 1 dan kurang dari banyak argumen dalam fungsi. Jika tidak, maka fungsi ELT akan menghasilkan NULL. Perhatikan
contoh berikut:
mysql> SELECT ELT(1, 'Pertama', 'Kedua', 'Ketiga', 'Keempat')
AS TEMPAT;
+---------+
| TEMPAT |
+---------+
| Pertama |
+---------+
1 row in set (0.05 sec)
Fungsi FIELD()
Fungsi FIELD
merupakan komplemen dari fungsi ELT(). Tujuannya adalah untuk menghasilkan
indeks dari string (pada argumen pertama) yang dilewatkan kepada fungsi
tersebut dalam himpunan str1, str2, str3, …. Jika tidak ditemukan, maka 0 akan
dihasilkan. Perhatikan contoh berikut, yang mendemonstrasikan perbedaan antara
fungsi ini dengan ELT():
mysql> SELECT FIELD('KETIGA', 'PERTAMA', 'KEDUA', 'KETIGA',
'KEEMPAT') AS TEMPAT;
+--------+
| TEMPAT |
+--------+
| 3 |
+--------+
1 row in set (0.00 sec)
Fungsi HEX()
Jika argumen
merupakan sebuah angka, maka fungsi HEX() akan menghasilkan representasi string
yang merupakan nilai heksadesimal dari argumen. Jika argumen berupa string,
maka fungsi ini menghasilkan sebuah string dimana di dalamnya setiap karakter
dalam argumen dikonversi menjadi dua dijit heksadesimal. Perhatikan contoh
berikut, yang menampilkan bagaimana mengkonversi sebuah angka numerik menjadi
heksadesimal:
mysql> SELECT
-> HEX(1234) AS
ANGKA;
+-------+
| ANGKA |
+-------+
| 4D2 |
+-------+
1 row in set (0.00 sec)
Fungsi INSERT()
Berikut merupakan
sintaks dari fungsi INSERT():
INSERT( str, pos, pjg, strbaru)
Fungsi ini
menghasilkan string basis str, dimana substring yang diawali pada posisi pos
dan dengan panjang pjg diganti dengan string baru strbaru. Perhatikan contoh
berikut:
mysql> SELECT
->
INSERT('Newfoundland',4,5,'Eng') HASIL;
+------------+
| HASIL |
+------------+
| NewEngland |
+------------+
1 row in set (0.00 sec)
Fungsi INSTR()
Fungsi INSTR()
menghasilkan posisi dari kemunculan pertama dari argumen kedua di dalam argumen
pertama. Fungsi ini sama dengan fungsi LOCATE(). Jika argumen kedua tidak dapat
ditemukan, maka fungsi ini menghasilkan 0. Perhatikan contoh berikut:
mysql> SELECT INSTR('pemberani','rani') AS DIMANA;
+--------+
| DIMANA |
+--------+
| 6 |
+--------+
1 row in set (0.00 sec)
mysql> SELECT INSTR('pemberanipemberanipemberani','rani') AS
DIMANA;
+--------+
| DIMANA |
+--------+
| 6 |
+--------+
1 row in set (0.00 sec)
Fungsi ISNULL()
Fungsi ISNULL()
menentukan apakah argumennya merupakan suatu nilai NULL atau tidak. Jika
argumen bernilai NULL, maka 1 akan dihasilkan, sebaliknya 0 yang dihasilkan
fungsi ini. Fungsi ISNULL() berguna untuk menempatkan sebuah nilai default
untuk menggantikan NULL dalam query Anda. Contoh berikut mendemonstrasikan
penggunaan fungsi ISNULL() jika bidang HARGA bernilai NULL:
mysql> SELECT MODEL, ISNULL(HARGA) AS APA_NULL
-> FROM MOBIL;
+-----------------+----------+
| MODEL | APA_NULL
|
+-----------------+----------+
| CROSSFIRE | 0 |
| 300M | 0 |
| CIVIC | 0 |
| ACCORD | 0 |
| MUSTANG | 0 |
| LATESTnGREATEST |
1 |
| FOCUS | 0 |
+-----------------+----------+
7 rows in set (0.00 sec)
Fungsi LEFT()
Fungsi LEFT()
menghasilkan sebanyak karakter (ditetapkan pada argumen kedua) dari string pada
argumen pertama. Perhatikan contoh berikut:
mysql> SELECT
-> LEFT('Namamu
selalu terukir di hatiku', 11) AS NAMAMU;
+-------------+
| NAMAMU |
+-------------+
| Namamu sela |
+-------------+
1 row in set (0.00 sec)
Fungsi LENGTH()
Fungsi LENGTH()
menghasilkan panjang dari string pada argumennya dalam byte. Perhatikan contoh berikut:
mysql> SELECT
-> MODEL,
LENGTH(MODEL) AS PANJANG_MODEL
-> FROM MOBIL;
+-----------------+---------------+
| MODEL |
PANJANG_MODEL |
+-----------------+---------------+
| CROSSFIRE | 9 |
| 300M | 4 |
| CIVIC | 5 |
| ACCORD | 6 |
| MUSTANG | 7 |
| LATESTnGREATEST |
15 |
| FOCUS | 5 |
+-----------------+---------------+
7 rows in set (0.00 sec)
Fungsi LOCATE()
Ada dua varian
fungsi ini:
LOCATE(substr, str)
LOCATE(substr, str, pos)
Versi pertama
menghasilkan posisi dari kemunculan pertama dari substring substr di dalam
string str. Versi kedua melakukan hal yang sama, kecuali bahwa ia memulainya
pada posisi pos di dalam string str. Jika substring tidak ditemukan, maka
fungsi ini menghasilkan 0. Fungsi LOCATE() sama dengan fungsi INSTR(), tetapi
dengan urutan argumen terbalik. Perhatikan contoh berikut:
mysql> SELECT LOCATE('tar','siantar') AS DIMANA;
+--------+
| DIMANA |
+--------+
| 5 |
+--------+
1 row in set (0.00 sec)
mysql> SELECT LOCATE('tar','siantarsiantarsiantar') AS
DIMANA;
+--------+
| DIMANA |
+--------+
| 5 |
+--------+
1 row in set (0.00 sec)
mysql> SELECT LOCATE('tar','siantarsiantarsiantar', 10) AS
DIMANA;
+--------+
| DIMANA |
+--------+
| 12 |
+--------+
1 row in set (0.00 sec)
Fungsi LPAD()
Sintaks dari fungsi
LPAD() adalah
LPAD(str, pjg, padstr)
Fungsi ini
menghasilkan str yang diganjal dengan karakter-karakter dalam padstr sampai
panjang dari string str mencapai pjg. Jika panjang dari str lebih dari panjang
pjg, maka string dipotong menjadi sebanyak pjg karakter. Perhatikan contoh
berikut:
mysql> SELECT LPAD('NONTON',10,'*') AS HASIL;
+------------+
| HASIL |
+------------+
| ****NONTON |
+------------+
1 row in set (0.03 sec)
Fungsi LTRIM()
Fungsi ini
menghasilkan argumen str dengan semua spasi depan (leading space) dihapus. Perhatikan conton berikut:
mysql> SELECT
-> LTRIM(' JOGJA') AS HASIL;
+-------+
| HASIL |
+-------+
| JOGJA |
+-------+
1 row in set (0.00 sec)
Fungsi MAKE_SET()
Sintaks dari fungsi
MAKE_SET() adalah
MAKE_SET(himpbit,str1,str2,..........)
Fungsi ini
menghasilkan sebuah string yang dibatasi dengan koma, sebuah himpunan, yang
memuat string-string yang memiliki bit-bit terkait dalam himpunan himpbit.
Dalam himpbit, str1 terkait dengan bit 0, str2 dengan bit 1, dan seterusnya.
Perhatikan contoh berikut:
mysql> SELECT
-> MAKE_SET(1|8,
'SELAMAT','SORE','MALAM','PAGI','SIANG','KERJA');
+----------------------------------------------------------------+
| MAKE_SET(1|8, 'SELAMAT','SORE','MALAM','PAGI','SIANG','KERJA')
|
+----------------------------------------------------------------+
| SELAMAT,PAGI
|
+----------------------------------------------------------------+
1 row in set (0.05 sec)
Fungsi REPEAT()
Sintaks dari fungsi
REPEAT() adalah
REPEAT(str,hitung)
Fungsi REPEAT()
menghasilkan sebuah nilai string yang memuat string str yang diulang sebanyak
hitung kali. Jika hitung kurang dari 1, maka string kosong akan dihasilkan.
Jika salah satu argumen bernilai NULL, maka NULL yang akan dihasilkan fungsi
ini. Perhatikan contoh berikut:
mysql> SELECT
-> REPEAT('BAH!',7)
AS HASIL;
+------------------------------+
| HASIL
|
+------------------------------+
| BAH!BAH!BAH!BAH!BAH!BAH!BAH! |
+------------------------------+
1 row in set (0.00 sec)
Fungsi REVERSE()
Fungsi REVERSE()
membalik string basis pada argumen dengan semua karakter-karakternya dalam
urutan terbalik. Perhatikan contoh berikut:
mysql> SELECT
->
REVERSE('MEMAJUKAN') AS HASIL;
+-----------+
| HASIL |
+-----------+
| NAKUJAMEM |
+-----------+
1 row in set (0.05 sec)
Fungsi RIGHT()
Sintaks dari fungsi
RIGHT() adalah
RIGHT(str,pjg)
Fungsi RIGHT()
menghasilkan sebanyak pjg dari karakter-karakter pojok-kanan dari string basis
str. Perhatikan contoh berikut:
mysql> SELECT
-> RIGHT('NERAKA
ATAU SURGA',5) AS HASIL;
+-------+
| HASIL |
+-------+
| SURGA |
+-------+
1 row in set (0.00 sec)
Fungsi RPAD()
Sintaks dari fungsi
RPAD() adalah
RPAD(str,pjg,padstr)
Fungsi RPAD()
menghasilkan string str, yang diganjal (di kiri) dengan string padstr sampai
panjangnya sebesar pjg karakter. Jika panjang dari str lebih dari pjg, maka
string tersebut akan dipotong menjadi pjg karakter. Perhatikan contoh berikut:
mysql> SELECT RPAD('HALO',8,'!') AS HASIL;
+----------+
| HASIL |
+----------+
| HALO!!!! |
+----------+
1 row in set (0.00 sec)
Fungsi RTRIM()
Fungsi ini
menghasilkan string basis (argumennya) dengan semua spasi ekor (trailing space)
dihapus. Perhatikan contoh berikut:
mysql> SELECT
->
RTRIM('KEBERANIAN ') AS HASIL;
+------------+
| HASIL |
+------------+
| KEBERANIAN |
+------------+
1 row in set (0.00 sec)
Fungsi SOUNDEX()
Fungsi SOUNDEX()
menghasilkan string SOUNDEX() dari string basis pada argumennya. Dua string
yang mempunyai bunyi sama akan memiliki nilai SOUNDEX() yang sama. Perhatikan
contoh berikut:
mysql> SELECT
-> SOUNDEX('COW')
AS COW,
-> SOUNDEX('BOW')
AS BOW,
-> SOUNDEX('YOW')
AS YOW,
-> SOUNDEX('BROWN')
AS BROWN;
+------+------+------+-------+
| COW | BOW | YOW
| BROWN |
+------+------+------+-------+
| C000 | B000 | Y000 | B650
|
+------+------+------+-------+
1 row in set (0.00 sec)
Fungsi SUBSTRING_INDEX()
Sintaks dari fungsi
SUBSTRING_INDEX() adalah
SUBSTRING_INDEX(str,delim,hitung)
Fungsi
SUBSTRING_INDEX() menghasilkan sebuah substring dari str sebelum sebanyak
hitung dari delimiter dijumpai. Jika hitung bernilai positif, maka segala
sesuatu sampai sebelah kiri dari delimiter terakhir akan dihasilkan. Jika hitung
bernilai negatif, maka segala sesuatu sampai sebelah kanan dari delimiter akhir
akan dihasilkan, dan fungsi mulai menghitung jumlah delimiter dari kanan.
Perhatikan contoh berikut:
mysql> SELECT
->
SUBSTRING_INDEX('www.namadomainku.com','.',1) AS BASIS;
+-------+
| BASIS |
+-------+
| www |
+-------+
1 row in set (0.00 sec)
mysql> SELECT
->
SUBSTRING_INDEX('www.namadomainku.com','.',-2) AS DOMAIN;
+------------------+
| DOMAIN |
+------------------+
| namadomainku.com |
+------------------+
1 row in set (0.02 sec)
Fungsi CURDATE()
Fungsi ini
menghasilkan tanggal sekarang sebagai YYYY-MM-DD atau YYYYMMDD. Format hasil
tergantung dari apakah fungsi dipakai di dalam konteks sebuah string atau
numerik. Perhatikan contoh berikut:
mysql> SELECT
-> CURDATE();
+------------+
| CURDATE() |
+------------+
| 2014-08-22 |
+------------+
1 row in set (0.03 sec)
Fungsi CURTIME()
Fungsi ini
menghasilkan waktu sekarang sebagai HH:MM:SS atau HHMMSS. Format hasil
tergantung dari apakah fungsi dipakai di dalam konteks sebuah string atau
numerik. Perhatikan contoh berikut:
mysql> SELECT
-> CURTIME();
+-----------+
| CURTIME() |
+-----------+
| 18:33:25 |
+-----------+
1 row in set (0.00 sec)
Fungsi DATE_ADD() atau DATE_SUB()
Sintaks dari kedua
fungsi ini adalah
DATE_ADD(tanggal,tipe ekspresi INTERVAL)
DATE_SUB(tanggal, tipe ekspresi INTERVAL)
Kedua fungsi ini
melakukan aritmatika tanggal, dan tanggal merupakan sebuah nilai DATE atau
DATETIME yang menetapkan tanggal awal yang akan digunakan. Argumen ekspresi
merupakan sebuah ekspresi yang menetapkan nilai interval yang akan
ditambahkan/dikurangi dari tanggal basis. Tabel berikut menjelaskan hubungan
antara nilai tipe dan format ekspresi.
Contoh berikut
menambahkan lima tahun pada nilai tanggal sekarang:
mysql> SELECT
->
DATE_ADD(CURDATE(),INTERVAL 5 YEAR) AS TANGGAL_BARU;
+--------------+
| TANGGAL_BARU |
+--------------+
| 2019-08-22 |
+--------------+
1 row in set (0.03 sec)
Contoh berikut
mengurangi tujuh tahun pada nilai tanggal sekarang:
mysql> SELECT
->
DATE_SUB(CURDATE(),INTERVAL 7 YEAR) AS TANGGAL_BARU;
+--------------+
| TANGGAL_BARU |
+--------------+
| 2007-08-22 |
+--------------+
1 row in set (0.00 sec)
Fungsi DATE_FORMAT()
Sintaks dari fungsi
DATE_FORMAT() adalah
DATE_FORMAT(tanggal, format)
Fungsi ini memformat
tanggal menjadi string format. Perhatikan contoh berikut:
mysql> SELECT
->
DATE_FORMAT(CURDATE(),'%a %e %M, %X') AS TANGGAL_BARU;
+---------------------+
| TANGGAL_BARU |
+---------------------+
| Fri 22 August, 2014 |
+---------------------+
1 row in set (0.02 sec)
Fungsi DAYNAME()
Fungsi ini
menghasilkan nama hari dari nilai tanggal tertentu. Perhatikan contoh berikut:
mysql> SELECT
->
DAYNAME('1977-04-25');
+-----------------------+
| DAYNAME('1977-04-25') |
+-----------------------+
| Monday |
+-----------------------+
1 row in set (0.05 sec)
Fungsi DAYOFMONTH()
Fungsi ini
menghasilkan hari tertentu dari bulan pada tanggal tertentu. Rentang hari
adalah 1 sampai 31. Perhatikan contoh berikut:
mysql> SELECT
->
DAYOFMONTH('2001-04-09');
+--------------------------+
| DAYOFMONTH('2001-04-09') |
+--------------------------+
| 9
|
+--------------------------+
1 row in set (0.05 sec)
Fungsi DAYOFYEAR()
Fungsi ini
menghasilkan hari tertentu dari tahun pada tanggal tertentu. Rentang hari
adalah 1 sampai 366. Perhatikan contoh berikut:
mysql> SELECT
-> DAYOFYEAR('1998-02-27');
+-------------------------+
| DAYOFYEAR('1998-02-27') |
+-------------------------+
| 58
|
+-------------------------+
1 row in set (0.00 sec)
Fungsi FROM_DAYS()
Fungsi ini
menghasilkan sebuah nilai tanggal yang didasrkan pada nilai argumennya. Tanggal
didasarkan pada jumlah hari sejak 1 Januari 1472 BC (awal dari kalender
Julian). Perhatikan contoh berikut:
mysql> SELECT
->
FROM_DAYS(710325) AS TANGGAL_LAMA;
+--------------+
| TANGGAL_LAMA |
+--------------+
| 1944-10-21 |
+--------------+
1 row in set (0.00 sec)
Fungsi FROM_UNIXTIME()
Fungsi ini
menghasilkan sebuah representasi string dari argumennya. Format string dapat
berupa YYYY-MM-DD HH:MM:SS atau YYYYMMDDHHMMSS. Format tergantung dari apakah
fungsi ini digunakan dalam konteks string atau numerik. Perhatikan contoh
berikut:
mysql> SELECT FROM_UNIXTIME(871723980) AS TANGGAL_LAMA;
+---------------------+
| TANGGAL_LAMA |
+---------------------+
| 1997-08-16 16:33:00 |
+---------------------+
1 row in set (0.00 sec)
Fungsi HOUR()
Fungsi ini
menghasilkan jam dari nilai waktu yang diberikan. Rentang nilai yang dihasilkan
adalah 0 sampai 23. Perhatikan contoh berikut:
mysql> SELECT
->
HOUR('14:32:33');
+------------------+
| HOUR('14:32:33') |
+------------------+
| 14 |
+------------------+
1 row in set (0.00 sec)
Fungsi MINUTE()
Fungsi ini
menghasilkan menit dari nilai waktu yang diberikan. Rentang nilai yang
dihasilkan adalah 0 sampai 59. Perhatikan contoh berikut:
mysql> SELECT
->
MINUTE('14:32:33');
+--------------------+
| MINUTE('14:32:33') |
+--------------------+
| 32 |
+--------------------+
1 row in set (0.00 sec)
Fungsi MONTH()
Fungsi ini
menghasilkan bulan dari nilai tanggal yang diberikan. Rentang nilai yang
dihasilkan adalah 1 sampai 12. Perhatikan contoh berikut:
mysql> SELECT
->
MONTH('2001-04-03');
+---------------------+
| MONTH('2001-04-03') |
+---------------------+
| 4 |
+---------------------+
1 row in set (0.00 sec)
Fungsi MONTHNAME()
Fungsi ini
menghasilkan nama bulan dari nilai tanggal yang diberikan. Perhatikan contoh
berikut:
mysql> SELECT
->
MONTHNAME('2001-04-03');
+-------------------------+
| MONTHNAME('2001-04-03') |
+-------------------------+
| April
|
+-------------------------+
1 row in set (0.00 sec)
Fungsi NOW() atau SYSDATE()
Fungsi ini
menghasilkan waktu dan tanggal sekarang dalam format YYYY-MM-DD HH:MM:SS atau
YYYYMMDDHHMMSS. Format yang dihasilkan ditentukan oleh konteks saat fungsi
digunakan. Perhatikan contoh berikut:
mysql> SELECT
-> NOW();
+---------------------+
| NOW() |
+---------------------+
| 2014-08-22 19:02:29 |
+---------------------+
1 row in set (0.01 sec)
Fungsi PERIOD_ADD()
Sintaks dari fungsi
PERIOD_ADD() adalah
PERIOD_ADD(P,N)
Fungsi ini akan
menambahkan sejumlah N bulan pada periode P, diformat sebagai YYMM atau YYYYMM.
Fungsi ini menghasilkan sebuah nilai dalam format YYYYMM. P bukan merupakan
nilai tanggal. Perhatikan contoh berikut:
mysql> SELECT
->
PERIOD_ADD(200405,4);
+----------------------+
| PERIOD_ADD(200405,4) |
+----------------------+
| 200409 |
+----------------------+
1 row in set (0.00 sec)
Fungsi PERIOD_DIFF()
Sintaks dari fungsi
PERIOD_DIFF() adalah
PERIOD_ADD(P1,P2)
Fungsi ini akan
menambahkan jumlah bulan antara periode P1 dan P2, diformat sebagai YYMM atau
YYYYMM. Perhatikan contoh berikut:
mysql> SELECT
->
PERIOD_DIFF(200110,200102);
+----------------------------+
| PERIOD_DIFF(200110,200102) |
+----------------------------+
| 8 |
+----------------------------+
1 row in set (0.00 sec)
Fungsi SECOND()
Fungsi ini
menghasilkan nilai kedua dari nilai waktu pada argumen dalam sebuah rentang 0
sampai 59. Perhatikan contoh berikut:
mysql> SELECT
-> SECOND(CURTIME())
AS DETIK_SKRG;
+------------+
| DETIK_SKRG |
+------------+
| 33 |
+------------+
1 row in set (0.00 sec)
Fungsi SEC_TO_TIME()
Fungsi ini
menghasilkan argumen detik yang dikonversi menjadi jam, menit, dan detik.
Format berupa HH:MM:SS atau HHMMSS, tergantung pada konteks yang dipakai.
Perhatikan contoh berikut:
mysql> SELECT
->
SEC_TO_TIME(487362);
+---------------------+
| SEC_TO_TIME(487362) |
+---------------------+
| 135:22:42 |
+---------------------+
1 row in set (0.00 sec)
Fungsi TIME_FORMAT()
Sintaks dari fungsi
TIME_FORMAT() adalah
TIME_FORMAT(waktu,format)
Fungsi ini dipakai
seperti fungsi DATE_FORMAT(). Namun, string format hanya dapat memuat
penspesifikasi format yang menangani nilai-nilai waktu. Jika nilai jam lebih
dari 23, maka Anda perlu menggunakan %H atau %h. Jika tidak, hasilnya akan
berupa hasil dari modulo 12. Perhatikan contoh berikut:
mysql> SELECT
->
TIME_FORMAT(CURTIME(),'%H %k %h %I %l') AS TANGGAL_FORMAT;
+----------------+
| TANGGAL_FORMAT |
+----------------+
| 19 19 07 07 7 |
+----------------+
1 row in set (0.00 sec)
Fungsi TIME_TO_SEC()
Fungsi ini merupakan
kebalikan dari fungsi SEC_TO_TIME. Ia menghasilkan nilai waktu yang dikonversi
menjadi detik. Perhatikan contoh berikut:
mysql> SELECT
->
TIME_TO_SEC('16:43:23');
+-------------------------+
| TIME_TO_SEC('16:43:23') |
+-------------------------+
| 60203
|
+-------------------------+
1 row in set (0.00 sec)
Fungsi TO_DAYS()
Fungsi ini kebalikan
dari fungsi FROM_DAYS(). Jika diberikan sebuah nilai tanggal, maka fungsi ini
akan menghasilkan jumlah hari sejak tahun 0. Perhatikan contoh berikut:
mysql> SELECT
->
TO_DAYS(CURDATE()) AS JUM_HARI;
+----------+
| JUM_HARI |
+----------+
| 735832 |
+----------+
1 row in set (0.00 sec)
Fungsi UNIX_TIMESTAMP()
Sintaks dari fungsi
UNIX_TIMESTAMP() adalah
UNIX_TIMESTAMP()
UNIX_TIMESTAMP(tanggal)
Fungsi ini, jika
dipanggil tanpa argumen, akan menghasilkan sebuah stempel waktu UNIX berupa
sebuah integer tak-bertanda. Stempel waktu UNIX merupakan jumlah detik sejak 1
Januari 1970. Jika argumen tanggal digunakan, maka fungsi ini menghasilkan
jumlah detik sejak 1 Januari 1970 sampai tanggal yang diberikan pada argumen.
Perhatikan contoh berikut:
mysql> SELECT UNIX_TIMESTAMP(CURDATE()) AS STEMPEL_UNIX;
+--------------+
| STEMPEL_UNIX |
+--------------+
| 1408640400 |
+--------------+
1 row in set (0.00 sec)
Fungsi LOAD_FILE()
Sintaks dari fungsi
LOAD_FILE() adalah
LOAD_FILE(namafile)
Fungsi ini membaca
file dengan nama namafile dan menghasilkan isi file sebagai sebuah string. Agar
fungsi ini bisa digunakan, file harus ditempatkan pada server, Anda harus
menetapkan nama path, dan Anda harus memiliki previlige FILE.
mysql> SELECT
->
LOAD_FILE('C:\wamp\www\SQL.txt') AS ISI_FILE;
+----------+
| ISI_FILE |
+----------+
| Uji..... |
1...2...3 |
Uji..... |
+----------+
1 row in set (0.00 sec)
