Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Fungsi string
Fungsi string memproses dan memanipulasi string karakter atau ekspresi yang mengevaluasi string karakter. Ketika argumen *string* dalam fungsi ini adalah nilai literal, itu harus diapit dalam tanda kutip tunggal. Tipe data yang didukung termasuk CHAR dan VARCHAR.
Bagian berikut menyediakan nama fungsi, sintaks, dan deskripsi untuk fungsi yang didukung. Semua offset menjadi string berbasis satu.
**Topics**
+ [\$1\$1 Operator (Penggabungan)](concat_op.md)
+ [Fungsi BTRIM](BTRIM.md)
+ [Fungsi CONCAT](CONCAT.md)
+ [Fungsi FORMAT\$1STRING](FORMAT_STRING.md)
+ [Fungsi KIRI dan KANAN](LEFT.md)
+ [Fungsi PANJANG](LENGTH.md)
+ [Fungsi LOWER](LOWER.md)
+ [Fungsi LPAD dan RPAD](LPAD.md)
+ [Fungsi LTRIM](LTRIM.md)
+ [Fungsi POSISI](POSITION.md)
+ [Fungsi REGEXP\$1COUNT](REGEXP_COUNT.md)
+ [Fungsi REGEXP\$1INSTR](REGEXP_INSTR.md)
+ [Fungsi REGEXP\$1REPLACE](REGEXP_REPLACE.md)
+ [Fungsi REGEXP\$1SUBSTR](REGEXP_SUBSTR.md)
+ [Fungsi REPEAT](REPEAT.md)
+ [GANTI fungsi](REPLACE.md)
+ [Fungsi REVERSE](REVERSE.md)
+ [Fungsi RTRIM](RTRIM.md)
+ [Fungsi SPLIT](split.md)
+ [Fungsi SPLIT\$1PART](SPLIT_PART.md)
+ [Fungsi SUBSTRING](SUBSTRING.md)
+ [FUNGSI TRANSLATE](TRANSLATE.md)
+ [Fungsi TRIM](TRIM.md)
+ [Fungsi UPPER](UPPER.md)
+ [Fungsi UUID](UUID.md)
# \$1\$1 Operator (Penggabungan)
Menggabungkan dua ekspresi di kedua sisi simbol \$1\$1 dan mengembalikan ekspresi gabungan.
Operator penggabungan mirip dengan. [Fungsi CONCAT](CONCAT.md)
**catatan**
Untuk fungsi CONCAT dan operator penggabungan, jika salah satu atau kedua ekspresi adalah nol, hasil penggabungan adalah nol.
## Sintaksis
```
expression1 || expression2
```
## Argumen
**ekspresi1, ekspresi2**
Kedua argumen dapat berupa string atau ekspresi karakter fixed-length atau variable-length.
## Jenis pengembalian
Operator \$1\$1 mengembalikan string. Jenis string sama dengan argumen masukan.
## Contoh
Contoh berikut menggabungkan bidang FIRSTNAME dan LASTNAME dari tabel USERS:
```
select firstname || ' ' || lastname
from users
order by 1
limit 10;
concat
-----------------
Aaron Banks
Aaron Booth
Aaron Browning
Aaron Burnett
Aaron Casey
Aaron Cash
Aaron Castro
Aaron Dickerson
Aaron Dixon
Aaron Dotson
(10 rows)
```
Untuk menggabungkan kolom yang mungkin berisi nol, gunakan ekspresi. [Fungsi NVL dan COALESCE](NVL_function.md) Contoh berikut menggunakan NVL untuk mengembalikan 0 setiap kali NULL ditemui.
```
select venuename || ' seats ' || nvl(venueseats, 0)
from venue where venuestate = 'NV' or venuestate = 'NC'
order by 1
limit 10;
seating
-----------------------------------
Ballys Hotel seats 0
Bank of America Stadium seats 73298
Bellagio Hotel seats 0
Caesars Palace seats 0
Harrahs Hotel seats 0
Hilton Hotel seats 0
Luxor Hotel seats 0
Mandalay Bay Hotel seats 0
Mirage Hotel seats 0
New York New York seats 0
```
# Fungsi BTRIM
Fungsi BTRIM memangkas string dengan menghapus bagian depan dan belakang kosong atau dengan menghapus karakter utama dan belakang yang cocok dengan string tertentu opsional.
## Sintaksis
```
BTRIM(string [, trim_chars ] )
```
## Argumen
*tali*
String input VARCHAR yang akan dipangkas.
*trim\$1chars*
String VARCHAR yang berisi karakter yang akan dicocokkan.
## Jenis pengembalian
Fungsi BTRIM mengembalikan string VARCHAR.
## Contoh
Contoh berikut memangkas bagian depan dan belakang kosong dari string: `' abc '`
```
select ' abc ' as untrim, btrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
Contoh berikut menghapus string depan dan trailing dari `'xyz'` string. `'xyzaxyzbxyzcxyz'` Kejadian leading dan trailing `'xyz'` dihapus, tetapi kejadian yang internal di dalam string tidak dihapus.
```
select 'xyzaxyzbxyzcxyz' as untrim,
btrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | axyzbxyzc
```
Contoh berikut menghapus bagian depan dan belakang dari string `'setuphistorycassettes'` yang cocok dengan salah satu karakter dalam daftar *trim\$1chars*. `'tes'` Apa pun `t``e`,, atau `s` yang terjadi sebelum karakter lain yang tidak ada dalam daftar *trim\$1chars* di awal atau akhir string input dihapus.
```
SELECT btrim('setuphistorycassettes', 'tes');
btrim
-----------------
uphistoryca
```
# Fungsi CONCAT
Fungsi CONCAT menggabungkan dua ekspresi dan mengembalikan ekspresi yang dihasilkan. Untuk menggabungkan lebih dari dua ekspresi, gunakan fungsi CONCAT bersarang. Operator penggabungan (`||`) antara dua ekspresi menghasilkan hasil yang sama dengan fungsi CONCAT.
**catatan**
Untuk fungsi CONCAT dan operator penggabungan, jika salah satu atau kedua ekspresi adalah nol, hasil penggabungan adalah nol.
## Sintaksis
```
CONCAT ( expression1, expression2 )
```
## Argumen
**ekspresi1, ekspresi2**
Kedua argumen dapat berupa string karakter fixed-length, string karakter panjang variabel, ekspresi biner, atau ekspresi yang mengevaluasi salah satu input ini.
## Jenis pengembalian
CONCAT mengembalikan ekspresi. Tipe data ekspresi adalah tipe yang sama dengan argumen masukan.
Jika ekspresi input dari jenis yang berbeda, AWS Clean Rooms mencoba untuk secara implisit mengetik cast salah satu ekspresi. Jika nilai tidak dapat dilemparkan, kesalahan dikembalikan.
## Contoh
Contoh berikut menggabungkan dua literal karakter:
```
select concat('December 25, ', '2008');
concat
-------------------
December 25, 2008
(1 row)
```
Kueri berikut, menggunakan `||` operator bukan CONCAT, menghasilkan hasil yang sama:
```
select 'December 25, '||'2008';
concat
-------------------
December 25, 2008
(1 row)
```
Contoh berikut menggunakan dua fungsi CONCAT untuk menggabungkan tiga string karakter:
```
select concat('Thursday, ', concat('December 25, ', '2008'));
concat
-----------------------------
Thursday, December 25, 2008
(1 row)
```
Untuk menggabungkan kolom yang mungkin berisi nol, gunakan kolom. [Fungsi NVL dan COALESCE](NVL_function.md) Contoh berikut menggunakan NVL untuk mengembalikan 0 setiap kali NULL ditemui.
```
select concat(venuename, concat(' seats ', nvl(venueseats, 0))) as seating
from venue where venuestate = 'NV' or venuestate = 'NC'
order by 1
limit 5;
seating
-----------------------------------
Ballys Hotel seats 0
Bank of America Stadium seats 73298
Bellagio Hotel seats 0
Caesars Palace seats 0
Harrahs Hotel seats 0
(5 rows)
```
Kueri berikut menggabungkan nilai CITY dan STATE dari tabel VENUE:
```
select concat(venuecity, venuestate)
from venue
where venueseats > 75000
order by venueseats;
concat
-------------------
DenverCO
Kansas CityMO
East RutherfordNJ
LandoverMD
(4 rows)
```
Kueri berikut menggunakan fungsi CONCAT bersarang. Kueri menggabungkan nilai CITY dan STATE dari tabel VENUE tetapi membatasi string yang dihasilkan dengan koma dan spasi:
```
select concat(concat(venuecity,', '),venuestate)
from venue
where venueseats > 75000
order by venueseats;
concat
---------------------
Denver, CO
Kansas City, MO
East Rutherford, NJ
Landover, MD
(4 rows)
```
# Fungsi FORMAT\$1STRING
Fungsi FORMAT\$1STRING membuat string yang diformat dengan mengganti placeholder dalam string template dengan argumen yang disediakan. Ia mengembalikan string diformat dari string format printf-style.
Fungsi FORMAT\$1STRING bekerja dengan mengganti placeholder dalam string template dengan nilai yang sesuai diteruskan sebagai argumen. Jenis pemformatan string ini dapat berguna ketika Anda perlu membangun string secara dinamis yang mencakup campuran teks statis dan data dinamis, seperti saat menghasilkan pesan keluaran, laporan, atau jenis teks informatif lainnya. Fungsi FORMAT\$1STRING menyediakan cara ringkas dan mudah dibaca untuk membuat jenis string yang diformat ini, membuatnya lebih mudah untuk memelihara dan memperbarui kode yang menghasilkan output.
## Sintaksis
```
format_string(strfmt, obj, ...)
```
## Pendapat
*strfmt*
Ekspresi STRING.
*obj*
Ekspresi STRING atau numerik.
## Jenis pengembalian
FORMAT\$1STRING mengembalikan STRING.
## Contoh
Contoh berikut berisi string template yang berisi dua placeholder: `%d` untuk nilai desimal (integer), dan `%s` untuk nilai string. `%d`Placeholder diganti dengan nilai desimal (integer) (`100`), dan placeholder %s diganti dengan nilai string (). `"days"` Outputnya adalah string template dengan placeholder diganti dengan argumen yang disediakan:. `"Hello World 100 days"`
```
SELECT format_string("Hello World %d %s", 100, "days");
Hello World 100 days
```
# Fungsi KIRI dan KANAN
Fungsi-fungsi ini mengembalikan jumlah karakter paling kiri atau paling kanan yang ditentukan dari string karakter.
Jumlahnya didasarkan pada jumlah karakter, bukan byte, sehingga karakter multibyte dihitung sebagai karakter tunggal.
## Sintaksis
```
LEFT ( string, integer )
RIGHT ( string, integer )
```
## Argumen
*tali*
String karakter apa pun atau ekspresi apa pun yang mengevaluasi string karakter.
*bilangan bulat*
Integer positif.
## Jenis pengembalian
KIRI dan KANAN mengembalikan string VARCHAR.
## Contoh
Contoh berikut mengembalikan 5 karakter paling kiri dan paling kanan 5 dari nama acara yang memiliki IDs antara 1000 dan 1005:
```
select eventid, eventname,
left(eventname,5) as left_5,
right(eventname,5) as right_5
from event
where eventid between 1000 and 1005
order by 1;
eventid | eventname | left_5 | right_5
--------+----------------+--------+---------
1000 | Gypsy | Gypsy | Gypsy
1001 | Chicago | Chica | icago
1002 | The King and I | The K | and I
1003 | Pal Joey | Pal J | Joey
1004 | Grease | Greas | rease
1005 | Chicago | Chica | icago
(6 rows)
```
# Fungsi PANJANG
# Fungsi LOWER
Mengkonversi string ke huruf kecil. LOWER mendukung karakter multibyte UTF-8, hingga maksimal empat byte per karakter.
## Sintaksis
```
LOWER(string)
```
## Pendapat
*tali*
Parameter input adalah string VARCHAR (atau tipe data lainnya, seperti CHAR, yang dapat secara implisit dikonversi ke VARCHAR).
## Jenis pengembalian
Fungsi LOWER mengembalikan string karakter yang merupakan tipe data yang sama dengan string input.
## Contoh
Contoh berikut mengonversi bidang CATNAME menjadi huruf kecil:
```
select catname, lower(catname) from category order by 1,2;
catname | lower
----------+-----------
Classical | classical
Jazz | jazz
MLB | mlb
MLS | mls
Musicals | musicals
NBA | nba
NFL | nfl
NHL | nhl
Opera | opera
Plays | plays
Pop | pop
(11 rows)
```
# Fungsi LPAD dan RPAD
Fungsi-fungsi ini menambahkan atau menambahkan karakter ke string, berdasarkan panjang tertentu.
## Sintaksis
```
LPAD (string1, length, [ string2 ])
```
```
RPAD (string1, length, [ string2 ])
```
## Argumen
*senar1*
String karakter atau ekspresi yang mengevaluasi string karakter, seperti nama kolom karakter.
*panjang*
Sebuah integer yang mendefinisikan panjang hasil dari fungsi. Panjang string didasarkan pada jumlah karakter, bukan byte, sehingga karakter multi-byte dihitung sebagai karakter tunggal. Jika *string1* lebih panjang dari panjang yang ditentukan, itu terpotong (di sebelah kanan). Jika *panjang* adalah angka negatif, hasil dari fungsi adalah string kosong.
*senar2*
*Satu atau lebih karakter yang ditambahkan atau ditambahkan ke string1.* Argumen ini opsional; jika tidak ditentukan, spasi digunakan.
## Jenis pengembalian
Fungsi-fungsi ini mengembalikan tipe data VARCHAR.
## Contoh
Potong satu set nama acara tertentu menjadi 20 karakter dan tambahkan nama yang lebih pendek dengan spasi:
```
select lpad(eventname,20) from event
where eventid between 1 and 5 order by 1;
lpad
--------------------
Salome
Il Trovatore
Boris Godunov
Gotterdammerung
La Cenerentola (Cind
(5 rows)
```
Potong set nama acara yang sama menjadi 20 karakter tetapi tambahkan nama yang lebih pendek dengan. `0123456789`
```
select rpad(eventname,20,'0123456789') from event
where eventid between 1 and 5 order by 1;
rpad
--------------------
Boris Godunov0123456
Gotterdammerung01234
Il Trovatore01234567
La Cenerentola (Cind
Salome01234567890123
(5 rows)
```
# Fungsi LTRIM
Memangkas karakter dari awal string. Menghapus string terpanjang yang hanya berisi karakter dalam daftar karakter trim. Pemangkasan selesai ketika karakter trim tidak muncul di string input.
## Sintaksis
```
LTRIM( string [, trim_chars] )
```
## Argumen
*tali*
Sebuah kolom string, ekspresi, atau string literal yang akan dipangkas.
*trim\$1chars*
Sebuah kolom string, ekspresi, atau string literal yang mewakili karakter yang akan dipangkas dari awal *string*. Jika tidak ditentukan, spasi digunakan sebagai karakter trim.
## Jenis pengembalian
Fungsi LTRIM mengembalikan string karakter yang merupakan tipe data yang sama dengan *string* input (CHAR atau VARCHAR).
## Contoh
Contoh berikut memangkas tahun dari `listime` kolom. Karakter trim dalam string literal `'2008-'` menunjukkan karakter yang akan dipangkas dari kiri. Jika Anda menggunakan karakter trim`'028-'`, Anda mencapai hasil yang sama.
```
select listid, listtime, ltrim(listtime, '2008-')
from listing
order by 1, 2, 3
limit 10;
listid | listtime | ltrim
-------+---------------------+----------------
1 | 2008-01-24 06:43:29 | 1-24 06:43:29
2 | 2008-03-05 12:25:29 | 3-05 12:25:29
3 | 2008-11-01 07:35:33 | 11-01 07:35:33
4 | 2008-05-24 01:18:37 | 5-24 01:18:37
5 | 2008-05-17 02:29:11 | 5-17 02:29:11
6 | 2008-08-15 02:08:13 | 15 02:08:13
7 | 2008-11-15 09:38:15 | 11-15 09:38:15
8 | 2008-11-09 05:07:30 | 11-09 05:07:30
9 | 2008-09-09 08:03:36 | 9-09 08:03:36
10 | 2008-06-17 09:44:54 | 6-17 09:44:54
```
*LTRIM menghapus salah satu karakter di *trim\$1chars* ketika mereka muncul di awal string.* Contoh berikut memangkas karakter 'C', 'D', dan 'G' ketika mereka muncul di awal VENUENAME, yang merupakan kolom VARCHAR.
```
select venueid, venuename, ltrim(venuename, 'CDG')
from venue
where venuename like '%Park'
order by 2
limit 7;
venueid | venuename | btrim
--------+----------------------------+--------------------------
121 | ATT Park | ATT Park
109 | Citizens Bank Park | itizens Bank Park
102 | Comerica Park | omerica Park
9 | Dick's Sporting Goods Park | ick's Sporting Goods Park
97 | Fenway Park | Fenway Park
112 | Great American Ball Park | reat American Ball Park
114 | Miller Park | Miller Park
```
Contoh berikut menggunakan karakter trim `2` yang diambil dari `venueid` kolom.
```
select ltrim('2008-01-24 06:43:29', venueid)
from venue where venueid=2;
ltrim
------------------
008-01-24 06:43:29
```
Contoh berikut tidak memangkas karakter apa pun `2` karena a ditemukan sebelum karakter `'0'` trim.
```
select ltrim('2008-01-24 06:43:29', '0');
ltrim
-------------------
2008-01-24 06:43:29
```
Contoh berikut menggunakan karakter trim spasi default dan memangkas dua spasi dari awal string.
```
select ltrim(' 2008-01-24 06:43:29');
ltrim
-------------------
2008-01-24 06:43:29
```
# Fungsi POSISI
Mengembalikan lokasi substring tertentu dalam string.
## Sintaksis
```
POSITION(substring IN string )
```
## Argumen
*substring*
Substring untuk mencari di dalam *string*.
*tali*
String atau kolom yang akan dicari.
## Jenis pengembalian
Fungsi POSITION mengembalikan bilangan bulat yang sesuai dengan posisi substring (berbasis satu, bukan berbasis nol). Posisi didasarkan pada jumlah karakter, bukan byte, sehingga karakter multi-byte dihitung sebagai karakter tunggal.
## Catatan penggunaan
POSITION mengembalikan 0 jika substring tidak ditemukan dalam string:
```
select position('dog' in 'fish');
position
----------
0
(1 row)
```
## Contoh
Contoh berikut menunjukkan posisi string `fish` dalam kata`dogfish`:
```
select position('fish' in 'dogfish');
position
----------
4
(1 row)
```
Contoh berikut mengembalikan jumlah transaksi penjualan dengan KOMISI lebih dari 999.00 dari tabel PENJUALAN:
```
select distinct position('.' in commission), count (position('.' in commission))
from sales where position('.' in commission) > 4 group by position('.' in commission)
order by 1,2;
position | count
---------+-------
5 | 629
(1 row)
```
# Fungsi REGEXP\$1COUNT
Mencari string untuk pola ekspresi reguler dan mengembalikan integer yang menunjukkan berapa kali pola terjadi dalam string. Jika tidak ada kecocokan yang ditemukan, maka fungsi mengembalikan 0.
## Sintaksis
```
REGEXP_COUNT ( source_string, pattern [, position [, parameters ] ] )
```
## Argumen
*source\$1string*
Ekspresi string, seperti nama kolom, yang akan dicari.
*pola*
Sebuah string literal yang mewakili pola ekspresi reguler.
*posisi*
Sebuah integer positif yang menunjukkan posisi dalam *source\$1string* untuk mulai mencari. Posisi didasarkan pada jumlah karakter, bukan byte, sehingga karakter multibyte dihitung sebagai karakter tunggal. Default-nya adalah 1. Jika *posisi* kurang dari 1, pencarian dimulai pada karakter pertama *source\$1string*. Jika *posisi* lebih besar dari jumlah karakter di *source\$1string*, hasilnya adalah 0.
*parameter*
Satu atau lebih string literal yang menunjukkan bagaimana fungsi cocok dengan pola. Nilai yang mungkin adalah sebagai berikut:
+ c — Lakukan pencocokan peka huruf besar/kecil. Defaultnya adalah menggunakan pencocokan peka huruf besar/kecil.
+ i — Lakukan pencocokan case-insensitive.
+ p — Menafsirkan pola dengan dialek Perl Compatible Regular Expression (PCRE).
## Jenis pengembalian
Bilangan Bulat
## Contoh
Contoh berikut menghitung berapa kali urutan tiga huruf terjadi.
```
SELECT regexp_count('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
regexp_count
--------------
8
```
Contoh berikut menghitung berapa kali nama domain tingkat atas adalah salah satu atau`org`. `edu`
```
SELECT email, regexp_count(email,'@[^.]*\\.(org|edu)')FROM users
ORDER BY userid LIMIT 4;
email | regexp_count
-----------------------------------------------+--------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | 1
Suspendisse.tristique@nonnisiAenean.edu | 1
amet.faucibus.ut@condimentumegetvolutpat.ca | 0
sed@lacusUtnec.ca | 0
```
Contoh berikut menghitung kemunculan string, menggunakan pencocokan `FOX` case-insensitive.
```
SELECT regexp_count('the fox', 'FOX', 1, 'i');
regexp_count
--------------
1
```
Contoh berikut menggunakan pola yang ditulis dalam dialek PCRE untuk menemukan kata-kata yang mengandung setidaknya satu angka dan satu huruf kecil. Ini menggunakan `?=` operator, yang memiliki konotasi pandangan ke depan tertentu di PCRE. Contoh ini menghitung jumlah kemunculan kata-kata tersebut, dengan pencocokan peka huruf besar/kecil.
```
SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'p');
regexp_count
--------------
2
```
Contoh berikut menggunakan pola yang ditulis dalam dialek PCRE untuk menemukan kata-kata yang mengandung setidaknya satu angka dan satu huruf kecil. Ini menggunakan `?=` operator, yang memiliki konotasi khusus di PCRE. Contoh ini menghitung jumlah kemunculan kata-kata tersebut, tetapi berbeda dari contoh sebelumnya karena menggunakan pencocokan case-insensitive.
```
SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'ip');
regexp_count
--------------
3
```
# Fungsi REGEXP\$1INSTR
Mencari string untuk pola ekspresi reguler dan mengembalikan integer yang menunjukkan posisi awal atau posisi akhir dari substring yang cocok. Jika tidak ada kecocokan yang ditemukan, maka fungsi mengembalikan 0. REGEXP\$1INSTR mirip dengan fungsi [POSITION](POSITION.md), tetapi memungkinkan Anda mencari string untuk pola ekspresi reguler.
## Sintaksis
```
REGEXP_INSTR ( source_string, pattern [, position [, occurrence] [, option [, parameters ] ] ] ] )
```
## Argumen
*source\$1string*
Ekspresi string, seperti nama kolom, yang akan dicari.
*pola*
Sebuah string literal yang mewakili pola ekspresi reguler.
*posisi*
Sebuah integer positif yang menunjukkan posisi dalam *source\$1string* untuk mulai mencari. Posisi didasarkan pada jumlah karakter, bukan byte, sehingga karakter multibyte dihitung sebagai karakter tunggal. Default-nya adalah 1. Jika *posisi* kurang dari 1, pencarian dimulai pada karakter pertama *source\$1string*. Jika *posisi* lebih besar dari jumlah karakter di *source\$1string*, hasilnya adalah 0.
*kejadian*
Sebuah bilangan bulat positif yang menunjukkan kemunculan pola yang akan digunakan. *REGEXP\$1INSTR melewatkan kejadian pertama -1 pertandingan.* Default-nya adalah 1. Jika *kejadian* kurang dari 1 atau lebih besar dari jumlah karakter di *source\$1string*, pencarian diabaikan dan hasilnya adalah 0.
*pilihan*
Nilai yang menunjukkan apakah akan mengembalikan posisi karakter pertama pertandingan (`0`) atau posisi karakter pertama setelah akhir pertandingan (`1`). Nilai bukan nol sama dengan 1. Nilai default-nya adalah 0.
*parameter*
Satu atau lebih string literal yang menunjukkan bagaimana fungsi cocok dengan pola. Nilai yang mungkin adalah sebagai berikut:
+ c — Lakukan pencocokan peka huruf besar/kecil. Defaultnya adalah menggunakan pencocokan peka huruf besar/kecil.
+ i — Lakukan pencocokan case-insensitive.
+ e — Ekstrak substring menggunakan subexpression.
*Jika *pola* menyertakan subexpression, REGEXP\$1INSTR cocok dengan substring menggunakan subexpression pertama dalam pola.* REGEXP\$1INSTR hanya mempertimbangkan subexpression pertama; subexpressions tambahan diabaikan. Jika pola tidak memiliki subexpression, REGEXP\$1INSTR mengabaikan parameter 'e'.
+ p — Menafsirkan pola dengan dialek Perl Compatible Regular Expression (PCRE).
## Jenis pengembalian
Bilangan Bulat
## Contoh
Contoh berikut mencari `@` karakter yang memulai nama domain dan mengembalikan posisi awal kecocokan pertama.
```
SELECT email, regexp_instr(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_instr
-----------------------------------------------+--------------
Etiam.laoreet.libero@example.com | 21
Suspendisse.tristique@nonnisiAenean.edu | 22
amet.faucibus.ut@condimentumegetvolutpat.ca | 17
sed@lacusUtnec.ca | 4
```
Contoh berikut mencari varian kata `Center` dan mengembalikan posisi awal kecocokan pertama.
```
SELECT venuename, regexp_instr(venuename,'[cC]ent(er|re)$')
FROM venue
WHERE regexp_instr(venuename,'[cC]ent(er|re)$') > 0
ORDER BY venueid LIMIT 4;
venuename | regexp_instr
-----------------------+--------------
The Home Depot Center | 16
Izod Center | 6
Wachovia Center | 10
Air Canada Centre | 12
```
Contoh berikut menemukan posisi awal dari kemunculan pertama string`FOX`, menggunakan logika pencocokan case-insensitive.
```
SELECT regexp_instr('the fox', 'FOX', 1, 1, 0, 'i');
regexp_instr
--------------
5
```
Contoh berikut menggunakan pola yang ditulis dalam dialek PCRE untuk menemukan kata-kata yang mengandung setidaknya satu angka dan satu huruf kecil. Ini menggunakan `?=` operator, yang memiliki konotasi pandangan ke depan tertentu di PCRE. Contoh ini menemukan posisi awal dari kata kedua tersebut.
```
SELECT regexp_instr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'p');
regexp_instr
--------------
21
```
Contoh berikut menggunakan pola yang ditulis dalam dialek PCRE untuk menemukan kata-kata yang mengandung setidaknya satu angka dan satu huruf kecil. Ini menggunakan `?=` operator, yang memiliki konotasi pandangan ke depan tertentu di PCRE. Contoh ini menemukan posisi awal dari kata kedua tersebut, tetapi berbeda dari contoh sebelumnya karena menggunakan pencocokan case-insensitive.
```
SELECT regexp_instr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'ip');
regexp_instr
--------------
15
```
# Fungsi REGEXP\$1REPLACE
Mencari string untuk pola ekspresi reguler dan menggantikan setiap kemunculan pola dengan string yang ditentukan. REGEXP\$1REPLACE mirip dengan[GANTI fungsi](REPLACE.md), tetapi memungkinkan Anda mencari string untuk pola ekspresi reguler.
REGEXP\$1REPLACE mirip dengan [FUNGSI TRANSLATE](TRANSLATE.md) dan[GANTI fungsi](REPLACE.md), kecuali bahwa TRANSLATE membuat beberapa substitusi karakter tunggal dan REPLACE menggantikan satu seluruh string dengan string lain, sementara REGEXP\$1REPLACE memungkinkan Anda mencari string untuk pola ekspresi reguler.
## Sintaksis
```
REGEXP_REPLACE ( source_string, pattern [, replace_string [ , position [, parameters ] ] ] )
```
## Argumen
*source\$1string*
Ekspresi string, seperti nama kolom, yang akan dicari.
*pola*
Sebuah string literal yang mewakili pola ekspresi reguler.
*replace\$1string*
Ekspresi string, seperti nama kolom, yang akan menggantikan setiap kemunculan pola. Defaultnya adalah string kosong (“”).
*posisi*
Sebuah integer positif yang menunjukkan posisi dalam *source\$1string* untuk mulai mencari. Posisi didasarkan pada jumlah karakter, bukan byte, sehingga karakter multibyte dihitung sebagai karakter tunggal. Default-nya adalah 1. Jika *posisi* kurang dari 1, pencarian dimulai pada karakter pertama *source\$1string*. *Jika *posisi* lebih besar dari jumlah karakter di *source\$1string, hasilnya adalah source\$1string*.*
*parameter*
Satu atau lebih string literal yang menunjukkan bagaimana fungsi cocok dengan pola. Nilai yang mungkin adalah sebagai berikut:
+ c — Lakukan pencocokan peka huruf besar/kecil. Defaultnya adalah menggunakan pencocokan peka huruf besar/kecil.
+ i — Lakukan pencocokan case-insensitive.
+ p — Menafsirkan pola dengan dialek Perl Compatible Regular Expression (PCRE).
## Jenis pengembalian
VARCHAR
Jika salah satu *pola* atau *replace\$1string* adalah NULL, pengembaliannya adalah NULL.
## Contoh
Contoh berikut menghapus `@` dan nama domain dari alamat email.
```
SELECT email, regexp_replace(email, '@.*\\.(org|gov|com|edu|ca)$')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_replace
-----------------------------------------------+----------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero
Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique
amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut
sed@lacusUtnec.ca | sed
```
Contoh berikut menggantikan nama domain alamat email dengan nilai ini:`internal.company.com`.
```
SELECT email, regexp_replace(email, '@.*\\.[[:alpha:]]{2,3}',
'@internal.company.com') FROM users
ORDER BY userid LIMIT 4;
email | regexp_replace
-----------------------------------------------+--------------------------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero@internal.company.com
Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique@internal.company.com
amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut@internal.company.com
sed@lacusUtnec.ca | sed@internal.company.com
```
Contoh berikut menggantikan semua kemunculan string `FOX` dalam nilai, menggunakan pencocokan `quick brown fox` case-insensitive.
```
SELECT regexp_replace('the fox', 'FOX', 'quick brown fox', 1, 'i');
regexp_replace
---------------------
the quick brown fox
```
Contoh berikut menggunakan pola yang ditulis dalam dialek PCRE untuk menemukan kata-kata yang mengandung setidaknya satu angka dan satu huruf kecil. Ini menggunakan `?=` operator, yang memiliki konotasi pandangan ke depan tertentu di PCRE. Contoh ini menggantikan setiap kemunculan kata seperti itu dengan nilainya`[hidden]`.
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'p');
regexp_replace
-------------------------------
[hidden] plain A1234 [hidden]
```
Contoh berikut menggunakan pola yang ditulis dalam dialek PCRE untuk menemukan kata-kata yang mengandung setidaknya satu angka dan satu huruf kecil. Ini menggunakan `?=` operator, yang memiliki konotasi pandangan ke depan tertentu di PCRE. Contoh ini menggantikan setiap kemunculan kata seperti itu dengan nilai`[hidden]`, tetapi berbeda dari contoh sebelumnya karena menggunakan pencocokan case-insensitive.
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'ip');
regexp_replace
----------------------------------
[hidden] plain [hidden] [hidden]
```
# Fungsi REGEXP\$1SUBSTR
Mengembalikan karakter dari string dengan mencarinya untuk pola ekspresi reguler. REGEXP\$1SUBSTR mirip dengan [Fungsi SUBSTRING](SUBSTRING.md) fungsinya, tetapi memungkinkan Anda mencari string untuk pola ekspresi reguler. Jika fungsi tidak dapat mencocokkan ekspresi reguler dengan karakter apa pun dalam string, ia mengembalikan string kosong.
## Sintaksis
```
REGEXP_SUBSTR ( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## Argumen
*source\$1string*
Ekspresi string yang akan dicari.
*pola*
Sebuah string literal yang mewakili pola ekspresi reguler.
*posisi*
Sebuah integer positif yang menunjukkan posisi dalam *source\$1string* untuk mulai mencari. Posisi didasarkan pada jumlah karakter, bukan byte, sehingga karakter multi-byte dihitung sebagai karakter tunggal. Default-nya adalah 1. Jika *posisi* kurang dari 1, pencarian dimulai pada karakter pertama *source\$1string*. Jika *posisi* lebih besar dari jumlah karakter di *source\$1string*, hasilnya adalah string kosong (“”).
*kejadian*
Sebuah bilangan bulat positif yang menunjukkan kemunculan pola yang akan digunakan. *REGEXP\$1SUBSTR melewatkan kejadian pertama -1 pertandingan.* Default-nya adalah 1. Jika *kejadian* kurang dari 1 atau lebih besar dari jumlah karakter di *source\$1string*, pencarian diabaikan dan hasilnya adalah NULL.
*parameter*
Satu atau lebih string literal yang menunjukkan bagaimana fungsi cocok dengan pola. Nilai yang mungkin adalah sebagai berikut:
+ c — Lakukan pencocokan peka huruf besar/kecil. Defaultnya adalah menggunakan pencocokan peka huruf besar/kecil.
+ i — Lakukan pencocokan case-insensitive.
+ e — Ekstrak substring menggunakan subexpression.
*Jika *pola* menyertakan subexpression, REGEXP\$1SUBSTR cocok dengan substring menggunakan subexpression pertama dalam pola.* Sebuah subexpression adalah ekspresi dalam pola yang dikurung dengan tanda kurung. Misalnya, untuk pola `'This is a (\\w+)'` cocok ekspresi pertama dengan string `'This is a '` diikuti oleh sebuah kata. Alih-alih mengembalikan *pola*, REGEXP\$1SUBSTR dengan `e` parameter hanya mengembalikan string di dalam subexpression.
REGEXP\$1SUBSTR hanya mempertimbangkan subexpression pertama; subexpressions tambahan diabaikan. Jika pola tidak memiliki subexpression, REGEXP\$1SUBSTR mengabaikan parameter 'e'.
+ p — Menafsirkan pola dengan dialek Perl Compatible Regular Expression (PCRE).
## Jenis pengembalian
VARCHAR
## Contoh
Contoh berikut mengembalikan bagian dari alamat email antara karakter @ dan ekstensi domain.
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | @sodalesMaurisblandit
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
```
Contoh berikut mengembalikan bagian dari input yang sesuai dengan kejadian pertama string`FOX`, menggunakan pencocokan case-insensitive.
```
SELECT regexp_substr('the fox', 'FOX', 1, 1, 'i');
regexp_substr
---------------
fox
```
Contoh berikut mengembalikan bagian pertama dari input yang dimulai dengan huruf kecil. Ini secara fungsional identik dengan pernyataan SELECT yang sama tanpa `c` parameter.
```
SELECT regexp_substr('THE SECRET CODE IS THE LOWERCASE PART OF 1931abc0EZ.', '[a-z]+', 1, 1, 'c');
regexp_substr
---------------
abc
```
Contoh berikut menggunakan pola yang ditulis dalam dialek PCRE untuk menemukan kata-kata yang mengandung setidaknya satu angka dan satu huruf kecil. Ini menggunakan `?=` operator, yang memiliki konotasi pandangan ke depan tertentu di PCRE. Contoh ini mengembalikan bagian dari input yang sesuai dengan kata kedua tersebut.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'p');
regexp_substr
---------------
a1234
```
Contoh berikut menggunakan pola yang ditulis dalam dialek PCRE untuk menemukan kata-kata yang mengandung setidaknya satu angka dan satu huruf kecil. Ini menggunakan `?=` operator, yang memiliki konotasi pandangan ke depan tertentu di PCRE. Contoh ini mengembalikan bagian input yang sesuai dengan kata kedua tersebut, tetapi berbeda dari contoh sebelumnya karena menggunakan pencocokan case-insensitive.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'ip');
regexp_substr
---------------
A1234
```
Contoh berikut menggunakan subexpression untuk menemukan string kedua yang cocok dengan pola `'this is a (\\w+)'` menggunakan pencocokan case-insensitive. Ia mengembalikan subexpression di dalam tanda kurung.
```
select regexp_substr(
'This is a cat, this is a dog. This is a mouse.',
'this is a (\\w+)', 1, 2, 'ie');
regexp_substr
---------------
dog
```
# Fungsi REPEAT
Mengulangi string jumlah yang ditentukan kali. Jika parameter input numerik, REPEAT memperlakukannya sebagai string.
## Sintaksis
```
REPEAT(string, integer)
```
## Argumen
*tali*
Parameter input pertama adalah string yang akan diulang.
*bilangan bulat*
Parameter kedua adalah bilangan bulat yang menunjukkan berapa kali untuk mengulangi string.
## Jenis pengembalian
Fungsi REPEAT mengembalikan string.
## Contoh
Contoh berikut mengulangi nilai kolom CATID dalam tabel CATEGORY tiga kali:
```
select catid, repeat(catid,3)
from category
order by 1,2;
catid | repeat
-------+--------
1 | 111
2 | 222
3 | 333
4 | 444
5 | 555
6 | 666
7 | 777
8 | 888
9 | 999
10 | 101010
11 | 111111
(11 rows)
```
# GANTI fungsi
Menggantikan semua kemunculan satu set karakter dalam string yang ada dengan karakter tertentu lainnya.
REPLACE mirip dengan [FUNGSI TRANSLATE](TRANSLATE.md) dan[Fungsi REGEXP\$1REPLACE](REGEXP_REPLACE.md), kecuali bahwa TRANSLATE membuat beberapa substitusi karakter tunggal dan REGEXP\$1REPLACE memungkinkan Anda mencari string untuk pola ekspresi reguler, sementara REPLACE mengganti satu seluruh string dengan string lain.
## Sintaksis
```
REPLACE(string1, old_chars, new_chars)
```
## Argumen
*tali*
CHAR atau VARCHAR string yang akan dicari pencarian
*old\$1chars*
String CHAR atau VARCHAR untuk diganti.
*new\$1chars*
*String CHAR atau VARCHAR baru menggantikan old\$1string.*
## Jenis pengembalian
VARCHAR
Jika *old\$1chars atau new\$1chars* *adalah NULL, pengembaliannya adalah NULL*.
## Contoh
Contoh berikut mengkonversi string `Shows` ke `Theatre` dalam bidang CATGROUP:
```
select catid, catgroup,
replace(catgroup, 'Shows', 'Theatre')
from category
order by 1,2,3;
catid | catgroup | replace
-------+----------+----------
1 | Sports | Sports
2 | Sports | Sports
3 | Sports | Sports
4 | Sports | Sports
5 | Sports | Sports
6 | Shows | Theatre
7 | Shows | Theatre
8 | Shows | Theatre
9 | Concerts | Concerts
10 | Concerts | Concerts
11 | Concerts | Concerts
(11 rows)
```
# Fungsi REVERSE
Fungsi REVERSE beroperasi pada string dan mengembalikan karakter dalam urutan terbalik. Misalnya, `reverse('abcde')` mengembalikan `edcba`. Fungsi ini bekerja pada tipe data numerik dan tanggal serta tipe data karakter; Namun, dalam banyak kasus memiliki nilai praktis untuk string karakter.
## Sintaksis
```
REVERSE ( expression )
```
## Pendapat
*ekspresi*
Ekspresi dengan karakter, tanggal, stempel waktu, atau tipe data numerik yang mewakili target pembalikan karakter. Semua ekspresi secara implisit dikonversi ke string karakter panjang variabel. Bagian belakang kosong dalam string karakter dengan lebar tetap diabaikan.
## Jenis pengembalian
REVERSE mengembalikan VARCHAR.
## Contoh
Pilih lima nama kota yang berbeda dan nama terbalik yang sesuai dari tabel USERS:
```
select distinct city as cityname, reverse(cityname)
from users order by city limit 5;
cityname | reverse
---------+----------
Aberdeen | needrebA
Abilene | enelibA
Ada | adA
Agat | tagA
Agawam | mawagA
(5 rows)
```
Pilih lima penjualan IDs dan IDs pemeran terbalik yang sesuai sebagai string karakter:
```
select salesid, reverse(salesid)::varchar
from sales order by salesid desc limit 5;
salesid | reverse
--------+---------
172456 | 654271
172455 | 554271
172454 | 454271
172453 | 354271
172452 | 254271
(5 rows)
```
# Fungsi RTRIM
Fungsi RTRIM memangkas satu set karakter tertentu dari akhir string. Menghapus string terpanjang yang hanya berisi karakter dalam daftar karakter trim. Pemangkasan selesai ketika karakter trim tidak muncul di string input.
## Sintaksis
```
RTRIM( string, trim_chars )
```
## Argumen
*tali*
Sebuah kolom string, ekspresi, atau string literal yang akan dipangkas.
*trim\$1chars*
Sebuah kolom string, ekspresi, atau string literal yang mewakili karakter yang akan dipangkas dari akhir *string*. Jika tidak ditentukan, spasi digunakan sebagai karakter trim.
## Jenis pengembalian
String yang merupakan tipe data yang sama dengan argumen *string*.
## Contoh
Contoh berikut memangkas bagian depan dan belakang kosong dari string: `' abc '`
```
select ' abc ' as untrim, rtrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
Contoh berikut menghapus string trailing dari `'xyz'` string. `'xyzaxyzbxyzcxyz'` Kejadian tertinggal `'xyz'` dihapus, tetapi kejadian yang internal di dalam string tidak dihapus.
```
select 'xyzaxyzbxyzcxyz' as untrim,
rtrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | xyzaxyzbxyzc
```
Contoh berikut menghapus bagian trailing dari string `'setuphistorycassettes'` yang cocok dengan salah satu karakter dalam daftar *trim\$1chars*. `'tes'` Apa pun `t``e`,, atau `s` yang terjadi sebelum karakter lain yang tidak ada dalam daftar *trim\$1chars* di akhir string input dihapus.
```
SELECT rtrim('setuphistorycassettes', 'tes');
rtrim
-----------------
setuphistoryca
```
Contoh berikut memangkas karakter 'Park' dari akhir VENUENAME di mana ada:
```
select venueid, venuename, rtrim(venuename, 'Park')
from venue
order by 1, 2, 3
limit 10;
venueid | venuename | rtrim
--------+----------------------------+-------------------------
1 | Toyota Park | Toyota
2 | Columbus Crew Stadium | Columbus Crew Stadium
3 | RFK Stadium | RFK Stadium
4 | CommunityAmerica Ballpark | CommunityAmerica Ballp
5 | Gillette Stadium | Gillette Stadium
6 | New York Giants Stadium | New York Giants Stadium
7 | BMO Field | BMO Field
8 | The Home Depot Center | The Home Depot Cente
9 | Dick's Sporting Goods Park | Dick's Sporting Goods
10 | Pizza Hut Park | Pizza Hut
```
Perhatikan bahwa RTRIM menghapus salah satu karakter`P`,`a`,`r`, atau `k` ketika mereka muncul di akhir VENUENAME.
# Fungsi SPLIT
Fungsi SPLIT memungkinkan Anda untuk mengekstrak substring dari string yang lebih besar dan bekerja dengan mereka sebagai array. Fungsi SPLIT berguna ketika Anda perlu memecah string menjadi komponen individual berdasarkan pembatas atau pola tertentu.
## Sintaksis
```
split(str, regex, limit)
```
## Pendapat
*str*
Ekspresi string untuk dibagi.
*regex*
Sebuah string yang mewakili ekspresi reguler. String *regex* harus berupa ekspresi reguler Java.
*batasi*
Ekspresi integer yang mengontrol berapa kali *regex diterapkan*.
+ limit > 0: Panjang array yang dihasilkan tidak akan lebih dari batas, dan entri terakhir array yang dihasilkan akan berisi semua input di luar *regex* terakhir yang cocok.
+ limit <= 0: *regex* akan diterapkan sebanyak mungkin, dan array yang dihasilkan dapat berukuran berapa pun.
## Jenis pengembalian
Fungsi SPLIT mengembalikan ARRAY.
Jika`limit > 0`: Panjang array yang dihasilkan tidak akan lebih dari batas, dan entri terakhir array yang dihasilkan akan berisi semua input di luar regex terakhir yang cocok.
Jika`limit <= 0`: regex akan diterapkan sebanyak mungkin, dan array yang dihasilkan dapat berukuran berapa pun.
## Contoh
Dalam contoh ini, fungsi SPLIT membagi string input di `'oneAtwoBthreeC'` mana pun ia bertemu karakter`'A'`,`'B'`, atau `'C'` (seperti yang ditentukan oleh pola `'[ABC]'` ekspresi reguler). Output yang dihasilkan adalah array dari empat elemen: `"one"``"two"`,`"three"`,, dan string kosong`""`.
```
SELECT split('oneAtwoBthreeC', '[ABC]');
["one","two","three",""]
```
# Fungsi SPLIT\$1PART
Membagi string pada pembatas yang ditentukan dan mengembalikan bagian pada posisi yang ditentukan.
## Sintaksis
```
SPLIT_PART(string, delimiter, position)
```
## Argumen
*tali*
Sebuah kolom string, ekspresi, atau string literal yang akan dibagi. String dapat berupa CHAR atau VARCHAR.
*pembatas*
*String pembatas menunjukkan bagian dari string input.*
Jika *pembatas* adalah literal, lampirkan dalam tanda kutip tunggal.
*posisi*
Posisi bagian *string* untuk kembali (menghitung dari 1). Harus bilangan bulat lebih besar dari 0. Jika *posisi* lebih besar dari jumlah bagian string, SPLIT\$1PART mengembalikan string kosong. Jika *pembatas* tidak ditemukan dalam *string*, maka nilai yang dikembalikan berisi isi dari bagian yang ditentukan, yang mungkin seluruh *string* atau nilai kosong.
## Jenis pengembalian
*Sebuah string CHAR atau VARCHAR, sama dengan parameter string.*
## Contoh
Contoh berikut membagi string literal menjadi beberapa bagian menggunakan `$` pembatas dan mengembalikan bagian kedua.
```
select split_part('abc$def$ghi','$',2)
split_part
----------
def
```
Contoh berikut membagi string literal menjadi beberapa bagian menggunakan `$` pembatas. Ia mengembalikan string kosong karena bagian `4` tidak ditemukan.
```
select split_part('abc$def$ghi','$',4)
split_part
----------
```
Contoh berikut membagi string literal menjadi beberapa bagian menggunakan `#` pembatas. Ia mengembalikan seluruh string, yang merupakan bagian pertama, karena pembatas tidak ditemukan.
```
select split_part('abc$def$ghi','#',1)
split_part
------------
abc$def$ghi
```
Contoh berikut membagi bidang timestamp LISTTIME menjadi komponen tahun, bulan, dan hari.
```
select listtime, split_part(listtime,'-',1) as year,
split_part(listtime,'-',2) as month,
split_part(split_part(listtime,'-',3),' ',1) as day
from listing limit 5;
listtime | year | month | day
---------------------+------+-------+------
2008-03-05 12:25:29 | 2008 | 03 | 05
2008-09-09 08:03:36 | 2008 | 09 | 09
2008-09-26 05:43:12 | 2008 | 09 | 26
2008-10-04 02:00:30 | 2008 | 10 | 04
2008-01-06 08:33:11 | 2008 | 01 | 06
```
Contoh berikut memilih bidang timestamp LISTTIME dan membaginya pada `'-'` karakter untuk mendapatkan bulan (bagian kedua dari string LISTTIME), lalu menghitung jumlah entri untuk setiap bulan:
```
select split_part(listtime,'-',2) as month, count(*)
from listing
group by split_part(listtime,'-',2)
order by 1, 2;
month | count
-------+-------
01 | 18543
02 | 16620
03 | 17594
04 | 16822
05 | 17618
06 | 17158
07 | 17626
08 | 17881
09 | 17378
10 | 17756
11 | 12912
12 | 4589
```
# Fungsi SUBSTRING
Mengembalikan subset dari string berdasarkan posisi awal yang ditentukan.
Jika input adalah string karakter, posisi awal dan jumlah karakter yang diekstraksi didasarkan pada karakter, bukan byte, sehingga karakter multi-byte dihitung sebagai karakter tunggal. Jika input adalah ekspresi biner, posisi awal dan substring yang diekstraksi didasarkan pada byte. Anda tidak dapat menentukan panjang negatif, tetapi Anda dapat menentukan posisi awal negatif.
## Sintaksis
```
SUBSTRING(charactestring FROM start_position [ FOR numbecharacters ] )
```
```
SUBSTRING(charactestring, start_position, numbecharacters )
```
```
SUBSTRING(binary_expression, start_byte, numbebytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## Argumen
*Charactertestring*
String yang akan dicari. Tipe data non-karakter diperlakukan seperti string.
*start\$1position*
Posisi dalam string untuk memulai ekstraksi, mulai dari 1. *Start\$1position* didasarkan pada jumlah karakter, bukan byte, sehingga karakter multi-byte dihitung sebagai karakter tunggal. Angka ini bisa negatif.
*numbecharacters*
Jumlah karakter yang akan diekstrak (panjang substring). *Numbecharacters* didasarkan pada jumlah karakter, bukan byte, sehingga karakter multi-byte dihitung sebagai karakter tunggal. Angka ini tidak bisa negatif.
*start\$1byte*
Posisi dalam ekspresi biner untuk memulai ekstraksi, mulai dari 1. Angka ini bisa negatif.
*numbebyte*
Jumlah byte untuk mengekstrak, yaitu, panjang substring. Angka ini tidak bisa negatif.
## Jenis pengembalian
VARCHAR
## Catatan penggunaan untuk string karakter
Contoh berikut mengembalikan string empat karakter yang dimulai dengan karakter keenam.
```
select substring('caterpillar',6,4);
substring
-----------
pill
(1 row)
```
*Jika *numbecharacters* *start\$1position* \$1 melebihi panjang *string*, SUBSTRING mengembalikan substring mulai dari start\$1position hingga akhir string.* Misalnya:
```
select substring('caterpillar',6,8);
substring
-----------
pillar
(1 row)
```
Jika negatif atau 0, fungsi SUBSTRING mengembalikan substring yang dimulai pada karakter pertama string dengan panjang `start_position` `numbecharacters` \$1-1. `start_position` Misalnya:
```
select substring('caterpillar',-2,6);
substring
-----------
cat
(1 row)
```
Jika `start_position` \$1 `numbecharacters` -1 kurang dari atau sama dengan nol, SUBSTRING mengembalikan string kosong. Misalnya:
```
select substring('caterpillar',-5,4);
substring
-----------
(1 row)
```
## Contoh
Contoh berikut mengembalikan bulan dari string LISTTIME dalam tabel LISTING:
```
select listid, listtime,
substring(listtime, 6, 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
Contoh berikut sama seperti di atas, tetapi menggunakan opsi FROM... FOR:
```
select listid, listtime,
substring(listtime from 6 for 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
Anda tidak dapat menggunakan SUBSTRING untuk mengekstrak awalan string yang mungkin berisi karakter multi-byte karena Anda perlu menentukan panjang string multi-byte berdasarkan jumlah byte, bukan jumlah karakter. *Untuk mengekstrak segmen awal string berdasarkan panjang dalam byte, Anda dapat CAST string sebagai VARCHAR (*byte\$1length) untuk memotong string, di mana byte\$1length* adalah panjang yang diperlukan.* Contoh berikut mengekstrak 5 byte pertama dari string`'Fourscore and seven'`.
```
select cast('Fourscore and seven' as varchar(5));
varchar
-------
Fours
```
Contoh berikut mengembalikan nama depan `Ana` yang muncul setelah spasi terakhir dalam string input`Silva, Ana`.
```
select reverse(substring(reverse('Silva, Ana'), 1, position(' ' IN reverse('Silva, Ana'))))
reverse
-----------
Ana
```
# FUNGSI TRANSLATE
Untuk ekspresi tertentu, menggantikan semua kemunculan karakter tertentu dengan pengganti tertentu. *Karakter yang ada dipetakan ke karakter pengganti berdasarkan posisinya dalam argumen characters\$1to\$1replace dan *characters\$1to\$1substitusi*.* *Jika lebih banyak karakter ditentukan dalam argumen *characters\$1to\$1replace daripada dalam argumen characters\$1to\$1substitusi**, karakter tambahan dari argumen characters\$1to\$1replace* dihilangkan dalam nilai pengembalian.*
TRANSLATE mirip dengan [GANTI fungsi](REPLACE.md) dan[Fungsi REGEXP\$1REPLACE](REGEXP_REPLACE.md), kecuali bahwa REPLACE mengganti satu seluruh string dengan string lain dan REGEXP\$1REPLACE memungkinkan Anda mencari string untuk pola ekspresi reguler, sementara TRANSLATE membuat beberapa substitusi karakter tunggal.
Jika ada argumen nol, pengembaliannya adalah NULL.
## Sintaksis
```
TRANSLATE ( expression, characters_to_replace, characters_to_substitute )
```
## Argumen
*ekspresi*
Ekspresi yang akan diterjemahkan.
*characters\$1to\$1replace*
Sebuah string yang berisi karakter yang akan diganti.
*characters\$1to\$1substitusi*
Sebuah string yang berisi karakter untuk menggantikan.
## Jenis pengembalian
VARCHAR
## Contoh
Contoh berikut menggantikan beberapa karakter dalam string:
```
select translate('mint tea', 'inea', 'osin');
translate
-----------
most tin
```
Contoh berikut menggantikan tanda at (@) dengan periode untuk semua nilai dalam kolom:
```
select email, translate(email, '@', '.') as obfuscated_email
from users limit 10;
email obfuscated_email
-------------------------------------------------------------------------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu Etiam.laoreet.libero.sodalesMaurisblandit.edu
amet.faucibus.ut@condimentumegetvolutpat.ca amet.faucibus.ut.condimentumegetvolutpat.ca
turpis@accumsanlaoreet.org turpis.accumsanlaoreet.org
ullamcorper.nisl@Cras.edu ullamcorper.nisl.Cras.edu
arcu.Curabitur@senectusetnetus.com arcu.Curabitur.senectusetnetus.com
ac@velit.ca ac.velit.ca
Aliquam.vulputate.ullamcorper@amalesuada.org Aliquam.vulputate.ullamcorper.amalesuada.org
vel.est@velitegestas.edu vel.est.velitegestas.edu
dolor.nonummy@ipsumdolorsit.ca dolor.nonummy.ipsumdolorsit.ca
et@Nunclaoreet.ca et.Nunclaoreet.ca
```
Contoh berikut menggantikan spasi dengan garis bawah dan menghapus periode untuk semua nilai dalam kolom:
```
select city, translate(city, ' .', '_') from users
where city like 'Sain%' or city like 'St%'
group by city
order by city;
city translate
--------------+------------------
Saint Albans Saint_Albans
Saint Cloud Saint_Cloud
Saint Joseph Saint_Joseph
Saint Louis Saint_Louis
Saint Paul Saint_Paul
St. George St_George
St. Marys St_Marys
St. Petersburg St_Petersburg
Stafford Stafford
Stamford Stamford
Stanton Stanton
Starkville Starkville
Statesboro Statesboro
Staunton Staunton
Steubenville Steubenville
Stevens Point Stevens_Point
Stillwater Stillwater
Stockton Stockton
Sturgis Sturgis
```
# Fungsi TRIM
Memangkas string dengan menghapus bagian depan dan belakang kosong atau dengan menghapus karakter utama dan belakang yang cocok dengan string tertentu opsional.
## Sintaksis
```
TRIM( [ BOTH ] [ trim_chars FROM ] string
```
## Argumen
*trim\$1chars*
(Opsional) Karakter yang akan dipangkas dari string. Jika parameter ini dihilangkan, blanko dipangkas.
*tali*
Tali yang akan dipangkas.
## Jenis pengembalian
Fungsi TRIM mengembalikan string VARCHAR atau CHAR. Jika Anda menggunakan fungsi TRIM dengan perintah SQL, secara AWS Clean Rooms implisit mengubah hasilnya ke VARCHAR. Jika Anda menggunakan fungsi TRIM dalam daftar SELECT untuk fungsi SQL, AWS Clean Rooms tidak secara implisit mengonversi hasilnya, dan Anda mungkin perlu melakukan konversi eksplisit untuk menghindari kesalahan ketidakcocokan tipe data. Lihat [Fungsi CAST](CAST_function.md) fungsi untuk informasi tentang konversi eksplisit.
## Contoh
Contoh berikut memangkas bagian depan dan belakang kosong dari string: `' abc '`
```
select ' abc ' as untrim, trim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
Contoh berikut menghapus tanda kutip ganda yang mengelilingi string: `"dog"`
```
select trim('"' FROM '"dog"');
btrim
-------
dog
```
*TRIM menghapus salah satu karakter di *trim\$1chars* ketika mereka muncul di awal string.* Contoh berikut memangkas karakter 'C', 'D', dan 'G' ketika mereka muncul di awal VENUENAME, yang merupakan kolom VARCHAR.
```
select venueid, venuename, trim(venuename, 'CDG')
from venue
where venuename like '%Park'
order by 2
limit 7;
venueid | venuename | btrim
--------+----------------------------+--------------------------
121 | ATT Park | ATT Park
109 | Citizens Bank Park | itizens Bank Park
102 | Comerica Park | omerica Park
9 | Dick's Sporting Goods Park | ick's Sporting Goods Park
97 | Fenway Park | Fenway Park
112 | Great American Ball Park | reat American Ball Park
114 | Miller Park | Miller Park
```
# Fungsi UPPER
Mengkonversi string ke huruf besar. UPPER mendukung karakter multibyte UTF-8, hingga maksimal empat byte per karakter.
## Sintaksis
```
UPPER(string)
```
## Argumen
*tali*
Parameter input adalah string VARCHAR (atau tipe data lainnya, seperti CHAR, yang dapat secara implisit dikonversi ke VARCHAR).
## Jenis pengembalian
Fungsi UPPER mengembalikan string karakter yang merupakan tipe data yang sama dengan string input.
## Contoh
Contoh berikut mengkonversi bidang CATNAME ke huruf besar:
```
select catname, upper(catname) from category order by 1,2;
catname | upper
----------+-----------
Classical | CLASSICAL
Jazz | JAZZ
MLB | MLB
MLS | MLS
Musicals | MUSICALS
NBA | NBA
NFL | NFL
NHL | NHL
Opera | OPERA
Plays | PLAYS
Pop | POP
(11 rows)
```
# Fungsi UUID
Fungsi UUID menghasilkan Universe Unique Identifier (UUID).
UUIDs adalah pengidentifikasi unik global yang biasanya digunakan untuk menyediakan pengidentifikasi unik untuk berbagai tujuan, seperti:
+ Mengidentifikasi catatan basis data atau entitas data lainnya.
+ Menghasilkan nama atau kunci unik untuk file, direktori, atau sumber daya lainnya.
+ Melacak dan menghubungkan data di seluruh sistem terdistribusi.
+ Menyediakan pengidentifikasi unik untuk paket jaringan, komponen perangkat lunak, atau aset digital lainnya.
Fungsi UUID menghasilkan nilai UUID yang unik dengan probabilitas yang sangat tinggi, bahkan di seluruh sistem terdistribusi dan dalam jangka waktu yang lama. UUIDs biasanya dihasilkan menggunakan kombinasi stempel waktu saat ini, alamat jaringan komputer, dan data acak atau pseudo-acak lainnya, memastikan bahwa setiap UUID yang dihasilkan sangat tidak mungkin bertentangan dengan UUID lainnya.
Dalam konteks kueri SQL, fungsi UUID dapat digunakan untuk menghasilkan pengidentifikasi unik untuk catatan baru yang dimasukkan ke dalam database, atau untuk menyediakan kunci unik untuk partisi data, pengindeksan, atau tujuan lain di mana pengidentifikasi unik diperlukan.
**catatan**
Fungsi UUID bersifat non-deterministik.
## Sintaksis
```
uuid()
```
## Pendapat
Fungsi UUID tidak membutuhkan argumen.
## Jenis pengembalian
UUID mengembalikan string pengenal unik universal (UUID). Nilai dikembalikan sebagai string 36 karakter UUID kanonik.
## Contoh
Contoh berikut menghasilkan Universally Unique Identifier (UUID). Outputnya adalah string 36 karakter yang mewakili Universally Unique Identifier.
```
SELECT uuid();
46707d92-02f4-4817-8116-a4c3b23e6266
```