Dasar Regular Expression dalam Oracle

Dalam Oracle 10g, fungsi SUBSTR, INSTR, LIKE, dan REPLACE telah ditingkatkan kemampuannya untuk melakukan pencarian menggunakan regular expression. Regular expression mendukung standarisasi kontrol dan pengecekan, misalnya pencocokan nilai lebih dari satu kali, pencarian tanda baca dalam suatu string. Fungs-fungsi baru ini dinamakan REGEXP_SUBSTR, REGEXP_INSTR, REGEXP_LIKE dan REGEXP_REPLACE.

Kita mulai pembahasan dengan menggunakan contoh sederhana, misalnya kita ingin mengambil angka yang berada di posisi tengah dari string ’123-456-7890′ yaitu angka ’456′. Persoalan ini dapat diselesaikan dengan menggunakan kombinasi fungsi SUBSTR dan INSTR, tentunya kita harus mendapatkan dulu posisi tanda ‘-’ yang pertama. Dengan menggunakan fungsi baru kita yaitu REGEXP_SUBSTR kita hanya perlu memberitahu Oracle dimana kita memulai pencarian dan sampai dimana karakter akan diambil.

Pertama kita beritahukan kepada Oracle bahwa kita mencari tanda ‘-’, bentuk regular expressionnya adalah seperti ini:

SELECT REGEXP_SUBSTR(’123-456-7890′, ‘-’

Kemudian kita beritahukan Oracle untuk meneruskan pencarian sampai menemukan tanda ‘-’. Untuk melakukan ini kita gunakan operator ‘[^-' yang dapat diartikan "ambil semua nilai kecuali '-'", sehingga bentuk akhir perintah akan menjadi seperti:

SELECT REGEXP_SUBSTR('123-456-7890', '-[^-]+’) FROM dual

Tanda ‘+’ dimaksudkan untuk mengambil lebih dari satu nilai yang cocok. Apabila kita ingin menambahkan hasil dengan tanda ‘-’ maka bentuk perintahnya:

SELECT REGEXP_SUBSTR(’123-456-7890′, ‘-[^-]+-’) FROM dual

Untuk orang yang baru mulai mempelajari regular expression (termasuk saya) bentuk-bentuk seperti ‘-[^-]+-’ tentu sangatlah sulit dipahami tanpa latihan yang banyak.
Di bawah ini merupakan operator-operator yang dipakai dalam regular expresission, jika anda masih kurang paham silahkan bertanya kepada paman google tentang penggunaan masing-masing operator.

• \
  Karakter backslash dapat memiliki 4 arti: dapat berarti backslash itu sendiri, quote untuk karakter berikutnya, memperkenalkan operator, atau tidak berarti apa-apa.
• *
  Kecocokan 0 atau lebih kemunculan.
• +
  Kecocokan 1 atau lebih kemunculan.
• ?
  Kecocokan 0 atau 1 kemunculan.
• |
  Menyatakan pilihan.
• ^
  Kecocokan dari awal baris suatu karakter.
• $
  Kecocokan dari akhir baris suatu karakter.
• .
  Mencocokan setiap karakter dari himpunan kecuali NULL.
• []
  Menekspresikan daftar kecocokan karakter. Apabila dimulai dengan tanda ^ berarti daftar tersebut merupakan daftar ketidakcocokan
• ()
  Mengelompokan suatu expression.
• {m}
  Kecocokan tepat hanya 1 kali.
• {m,}
  Kecocokan setidaknya 1 kali.
• {m,n}
  Kecocokan setidaknya 1 kali tetapi lebih sedikit dari n.
• \n
  n merupakan bilangan dari 1-9. Mencocokan subexpression ke-n yang diapit oleh tanda ().
• [..]
  Menspesifikaskan collation element.
• [::]
  Menspesifikasikan class karakter, misalnya [:punct:] berarti mencocokan semua tanda baca.
• [==]
  Menspesifikasikan class equivalent.

Cukup bingung setelah membaca penjelasan masing-masing operator di atas? Saya pun demikian  . Tapi tenang saja, sebentar lagi kita akan melihat penggunaan beberapa operator yang biasanya digunakan. Untuk operator yang lain silahkan bertanya kepada paman google  .

REGEXP_SUBSTR

Fungsi ini sama saja kegunaannya dengan SUBSTR, hanya saja ada penambahan regular expression untuk menspesifikasikan awal dan akhir pemotongan string. Nilai yang dikembalikan bertipe VARCHAR2 atau CLOB, bentuk umunya seperti di bawah ini

REGEXP_SUBSTR(string_asal, pattern
[,posisi
[,kemunculan
[,parameter_pencocokan]
]
])

Argumen pattern adalah tempat diletakkannya regular expression, dapat menampung sampai 512 byte. Argumen posisi menentukan dimana harus dimulai proses pencarian dalam string_asal, defaultnya 1 (mulai dari awal). Argumen kemunculan menentukan pada kemunculan keberapa string mulai dipotong. Terakhir argumen parameter_pencocokan digunakan untuk menentukan sifat pencarian, nilai yang boleh diisikan:

• ‘i’ Pencarian bersifat case insensitive.
• ‘c’ Pencarian bersifat case sensitive.
• ‘n’ Menyatakan tanda ‘.’ yang merupakan wildcard diperlakukan sebagai pembatas baris baru.
• ‘m’ Memperlakukan string sebagai string dengan banyak baris.

Apabila variabel parameter_pencocokan ditulis dalam dua nilai, maka nilai terakhir yang akan dipakai, misal ‘ic’, maka pencarian akan dilakukan secara case sensitive. Jika kita memberikan nilai selain nilai-nilai di atas maka Oracle akan mengembalikan error. Apabila parameter_pencocokan tidak diisi, maka efeknya adalah:

• Pencarian bersifat case sensitive.
• Tanda ‘.’ tidak dianggap sebagai pertanda baris baru.
• String diperlakukan sebagai string tunggal.

Perhatikan contoh di bawah ini:

SELECT REGEXP_SUBSTR(‘IT FROM ZERO TO HERO’, ‘TO’, 1, 1, ‘i’) FROM dual

Bandingkan dengan

SELECT REGEXP_SUBSTR(‘IT FROM ZERO TO HERO’, ‘To’, 1, 1, ‘c’) FROM dual

Misalnya pada contoh berikut ini kita ingin mengambil angka ketiga yang terdapat dalam string ’20 itu lebih besar dari 10 loch’. Perhatikan penggunaan class karakter [:digit:].

SELECT REGEXP_SUBSTR(’20 itu lebih besar dari 10 loch’, ‘[[:digit:]]’, 1, 3) FROM dual

Dengan adanya regular expression maka kita tidak perlu lagi repot mencari posisi karakter sebagai awal pemotongan string  .

REGEXP_INSTR

Fungsi REGEXP_INSTR menggunakan regular expression untuk mengembalikan titik permulaan dan akhir dari pattern pencarian. Fungsi ini mengembalikan angka yang merupakan posisi dari awal atau akhir pattern yang dicari atau mengembalikan nol jika tidak ditemukan. Bentuk umumnya:

REGEXP_INSTR(string_asli, pattern
[,posisi
[,kemunculan
[,opsi_pengembalian
[,parameter_pencocokan]
]
]
])

Argumen yang baru di sini adalah opsi_pengembalian. Ada dua nilai yang bisa dimasukan:

• Jika bernilai 0, Oracle akan mengembalikan posisi dari karakter pertama yang cocok, ini defaultnya.
• Jika bernilai 1 Oracle akan mengembalikan posisi setelah karakter pertama yang cocok.

Misalnya kita ingin mencari posisi dari angka kedua yang berada dalam string ‘Umur saya 25 tahun’.

SELECT REGEXP_INSTR(‘Umur saya 25 tahun’, ‘[[:digit:]]’,1, 1, 1) FROM dual

Bandingkan jika argumen opsi_pengembalian bernilai default

SELECT REGEXP_INSTR(‘Umur saya 25 tahun’, ‘[[:digit:]]’) FROM dual

Misalnya kita ingin menampilkan nomor telepon yang memiliki angka 6 lebih dari dua dari tabel employees

SELECT phone_number FROM employees WHERE REGEXP_INSTR(phone_number, ’6′, 1, ’3′) > 0

Untuk pencarian selain angka hati-hati dalam penggunaan argumen parameter_pencocokan.

REGEXP_LIKE

Fungsi ini dapat digunakan sebagai pengganti operator LIKE dalam clausa WHERE. Bentuk umumnya:

REGEXP_LIKE(string_asli, pattern
[,parameter_pencocokan
])

Misalnya kita ingin menampilkan daftar no telp dari tabel employee yang mengandung urutan angka 123.

SELECT phone_number FROM employees WHERE REGEXP_LIKE(phone_number, ’123′)

REPLACE dan REGEXP_REPLACE

Fungsi REPLACE berguna untuk menggantikan satu nilai dalam string dengan nilai yang lain. Bentuk umumnya:

REPLACE(char, string_pencari [,string_pengganti])

Jika string_pengganti tidak diisi, maka jika pencarian menemeui string_pencari string tersebut akan dihilangkan. Inputnya dapat berupa data bertipe CHAR, VARCHAR2, NCHAR, NVARCHAR2, CLOB, atau NCLOB. Contohnya seperti di bawah ini:

SELECT REPLACE(‘IT FROM ZERO TO HERO’, ‘TO’ , ‘to’) FROM dual

Kata ‘TO’ akan diganti dengan ‘to’, contoh di bawah ini akan memperlihatkan jika string_pengganti dihilangkan:

SELECT REPLACE(‘IT FROM ZERO TO HERO’, ‘TO’) FROM dual

Fungsi REGEXP_REPLACE menambahkan kemampuan dari fungsi REPLACE. Dia mendukung penggunaan regular expression untuk menggantikan string_pencarian. Bentuk umumnya:

REGEXP_REPLACE(string_asli, pattern
[,string_pengganti
[,posisi
[,kemunculan
[,parameter_pencarian
]
]
]
])

Jika argumen kemunculan bernilai nol, maka setiap kecocokan string dengan argumen pattern akan dilakukan pergantia dengan string_pengganti. Contoh di bawah ini akan memperlihatkan penggunaan fungsi REGEXP_REPLACE:

SELECT REGEXP_REPLACE(’555-2234′, ’5′, ‘-’, 1, 3) FROM dual
SELECT REGEXP_REPLACE(’021-555-2234′, ‘([[:digit:]]{3})-([[:digit:]]{3})-([[:digit:]]{4})’, ‘(\1) \2-\3′) FROM dual