Dimulai dengan SQL Server 2017, Anda sekarang dapat menggunakan T-SQL TRANSLATE() berfungsi untuk menerjemahkan satu atau lebih karakter ke dalam kumpulan karakter lainnya.
Sekilas, Anda mungkin berpikir bahwa TRANSLATE() fungsi melakukan hal yang persis sama dengan REPLACE() fungsi, tetapi ada perbedaan yang signifikan antara keduanya.
Definisi
Pertama, mari kita lihat definisi dari masing-masing fungsi:
REPLACE()- Mengganti semua kemunculan nilai string tertentu dengan nilai string lain.
TRANSLATE()- Mengembalikan string yang diberikan sebagai argumen pertama setelah beberapa karakter yang ditentukan dalam argumen kedua diterjemahkan ke dalam kumpulan karakter tujuan.
Perbedaan utama adalah bagaimana setiap fungsi berhubungan dengan banyak karakter. REPLACE() menggantikan satu string dengan string lain. Oleh karena itu, jika string berisi beberapa karakter, setiap karakter harus dalam urutan yang sama. TRANSLATE() di sisi lain, mengganti setiap karakter satu per satu, terlepas dari urutan karakter tersebut.
Contoh – Hasil yang sama
Ada beberapa kasus di mana kedua fungsi akan mengembalikan hasil yang sama. Seperti ini:
SELECT
REPLACE('123', '123', '456') AS Replace,
TRANSLATE('123', '123', '456') AS Translate;
Hasil:
Replace Translate ------- --------- 456 456
Dalam hal ini, REPLACE() mengembalikan 456 karena string yang tepat pada argumen kedua cocok dengan string dalam argumen pertama (dalam hal ini, string adalah keseluruhan).
TRANSLATE() mengembalikan 456 karena setiap karakter di argumen kedua ada di argumen pertama.
Contoh – Hasil Berbeda
Sekarang untuk contoh yang menunjukkan salah satu perbedaan antara TRANSLATE() dan REPLACE() :
SELECT
REPLACE('123', '321', '456') AS Replace,
TRANSLATE('123', '321', '456') AS Translate;
Hasil:
Replace Translate ------- --------- 123 654
Dalam hal ini, REPLACE() tidak berpengaruh (mengembalikan string asli) karena argumen kedua tidak sama persis dengan argumen pertama (atau substring di dalamnya). Meskipun argumen kedua berisi karakter yang benar, urutannya tidak sama dengan argumen pertama, dan oleh karena itu, seluruh string tidak cocok.
TRANSLATE() memang memiliki efek karena setiap karakter dalam argumen kedua hadir dalam argumen pertama. Tidak masalah urutannya berbeda, karena setiap karakter diterjemahkan satu per satu. SQL Server menerjemahkan karakter pertama, lalu yang kedua, lalu yang ketiga, dan seterusnya.
String Tidak Bersebelahan
Mirip dengan contoh sebelumnya, Anda juga bisa mendapatkan hasil yang berbeda ketika argumen pertama berisi karakter dalam argumen kedua, tetapi mereka tidak bersebelahan:
SELECT
REPLACE('1car23', '123', '456') AS Replace,
TRANSLATE('1car23', '123', '456') AS Translate;
Hasil:
Replace Translate ------- --------- 1car23 4car56
Argumen dengan Panjang Berbeda
Anda juga bisa mendapatkan hasil yang berbeda antara setiap fungsi setiap kali ada perbedaan dalam jumlah karakter dalam berbagai argumen.
Berikut adalah contoh di mana argumen pertama berisi lebih sedikit karakter daripada argumen kedua dan ketiga:
SELECT
REPLACE('123', '1234', '4567') AS Replace,
TRANSLATE('123', '1234', '4567') AS Translate;
Hasil:
Replace Translate ------- --------- 123 456
Dalam hal ini, REPLACE() tidak berpengaruh karena argumen kedua berisi lebih banyak karakter daripada argumen pertama. Oleh karena itu, argumen pertama tidak mungkin memuat argumen kedua.
TRANSLATE() fungsi bagaimanapun, memang berpengaruh dalam kasus ini. Ini karena argumen kedua berisi karakter yang ada di argumen pertama. Tidak masalah bahwa argumen kedua berisi lebih banyak karakter daripada yang pertama. Yang paling penting adalah argumen ketiga berisi jumlah karakter yang sama dengan yang kedua.
Ada juga kasus ketika REPLACE() bekerja dengan sempurna tetapi TRANSLATE() membuat kesalahan.
Contoh:
SELECT REPLACE('1234', '123', '4567') AS Replace;
Hasil:
Replace ------- 45674
Dalam hal ini, REPLACE() bekerja seperti yang diharapkan.
Namun, jika kita memberikan argumen yang sama ke TRANSLATE() , kami mendapatkan kesalahan:
SELECT TRANSLATE('1234', '123', '4567') AS Translate;
Hasil:
Error: The second and third arguments of the TRANSLATE built-in function must contain an equal number of characters.
Seperti yang dinyatakan oleh pesan kesalahan, argumen kedua dan ketiga harus berisi jumlah karakter yang sama.
Kapan Saya Harus Menggunakan REPLACE()?
Anda harus menggunakan REPLACE() ketika Anda perlu mengganti semua kemunculan string tertentu, persis seperti yang tertulis. Misalnya, mengubah nama seseorang menjadi nama lain.
Menggunakan TRANSLATE() dalam kasus seperti itu dapat berakibat fatal:
SELECT
REPLACE('Homer Simpson', 'Homer', 'Jason') AS Replace,
TRANSLATE('Homer Simpson', 'Homer', 'Jason') AS Translate; Hasil:
Replace Translate ------------- ------------- Jason Simpson Jason Sispsan
Kapan Saya Harus Menggunakan TRANSLATE()?
Seperti yang ditunjukkan pada contoh sebelumnya, TRANSLATE() function dapat berguna jika Anda perlu mengganti semua kemunculan dari setiap karakter yang ditentukan, terlepas dari urutannya dalam string asli.
Itu juga dapat digunakan sebagai pengganti REPLACE() untuk sekadar kode. Berikut ini contohnya (berdasarkan contoh di situs web Microsoft):
SELECT
REPLACE(REPLACE(REPLACE(REPLACE('2*[3+4]/{7-2}','[','('), ']', ')'), '{', '('), '}', ')') AS Replace,
TRANSLATE('2*[3+4]/{7-2}', '[]{}', '()()') AS Translate; Hasil:
Replace Translate ------------- ------------- 2*(3+4)/(7-2) 2*(3+4)/(7-2)
