Amazon Redshift tidak akan lagi mendukung pembuatan Python UDFs baru mulai Patch 198. Python yang ada UDFs akan terus berfungsi hingga 30 Juni 2026. Untuk informasi lebih lanjut, lihat [posting blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Fungsi string
**Topics**
+ [\$1\$1 Operator (Penggabungan)](r_concat_op.md)
+ [Fungsi ASCII](r_ASCII.md)
+ [Fungsi BPCHARCMP](r_BPCHARCMP.md)
+ [Fungsi BTRIM](r_BTRIM.md)
+ [Fungsi BTTEXT\$1PATTERN\$1CMP](r_BTTEXT_PATTERN_CMP.md)
+ [Fungsi CHAR\$1LENGTH](r_CHAR_LENGTH.md)
+ [Fungsi CHARACTER\$1LENGTH](r_CHARACTER_LENGTH.md)
+ [Fungsi CHARINDEX](r_CHARINDEX.md)
+ [Fungsi CHR](r_CHR.md)
+ [Fungsi COLLATE](r_COLLATE.md)
+ [Fungsi CONCAT](r_CONCAT.md)
+ [CRC32 fungsi](crc32-function.md)
+ [Fungsi PERBEDAAN](DIFFERENCE.md)
+ [Fungsi INITCAP](r_INITCAP.md)
+ [Fungsi KIRI dan KANAN](r_LEFT.md)
+ [Fungsi LEN](r_LEN.md)
+ [Fungsi PANJANG](r_LENGTH.md)
+ [Fungsi LOWER](r_LOWER.md)
+ [Fungsi LPAD dan RPAD](r_LPAD.md)
+ [Fungsi LTRIM](r_LTRIM.md)
+ [Fungsi OCTETINDEX](OCTETINDEX.md)
+ [Fungsi OCTET\$1LENGTH](r_OCTET_LENGTH.md)
+ [Fungsi POSISI](r_POSITION.md)
+ [Fungsi QUOTE\$1IDENT](r_QUOTE_IDENT.md)
+ [Fungsi QUOTE\$1LITERAL](r_QUOTE_LITERAL.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](r_REPEAT.md)
+ [GANTI fungsi](r_REPLACE.md)
+ [Fungsi REPLICATE](r_REPLICATE.md)
+ [Fungsi REVERSE](r_REVERSE.md)
+ [Fungsi RTRIM](r_RTRIM.md)
+ [Fungsi SOUNDEX](SOUNDEX.md)
+ [Fungsi SPLIT\$1PART](SPLIT_PART.md)
+ [fungsi STRPOS](r_STRPOS.md)
+ [Fungsi STRTOL](r_STRTOL.md)
+ [Fungsi SUBSTRING](r_SUBSTRING.md)
+ [Fungsi TEXTLEN](r_TEXTLEN.md)
+ [FUNGSI TRANSLATE](r_TRANSLATE.md)
+ [Fungsi TRIM](r_TRIM.md)
+ [Fungsi UPPER](r_UPPER.md)
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.
**Fungsi khusus node pemimpin yang tidak digunakan lagi**
Fungsi string berikut tidak digunakan lagi karena hanya berjalan pada node pemimpin. Untuk informasi selengkapnya, lihat [Fungsi simpul pemimpin—hanya](c_SQL_functions_leader_node_only.md)
+ GET\$1BYTE
+ SET\$1BIT
+ SET\$1BYTE
+ TO\$1ASCII
# \$1\$1 Operator (Penggabungan)
Menggabungkan dua ekspresi di kedua sisi `||` simbol dan mengembalikan ekspresi gabungan.
Mirip dengan[Fungsi CONCAT](r_CONCAT.md).
**catatan**
Jika salah satu atau kedua ekspresi adalah nol, hasil penggabungan adalah. `NULL`
## Sintaksis
```
expression1 || expression2
```
## Argumen
*ekspresi1*
`CHAR`String, `VARCHAR` string, ekspresi biner, atau ekspresi yang mengevaluasi salah satu jenis ini.
*ekspresi2*
`CHAR`String, `VARCHAR` string, ekspresi biner, atau ekspresi yang mengevaluasi salah satu jenis ini.
## Jenis pengembalian
Jenis pengembalian string sama dengan jenis argumen masukan. Misalnya, menggabungkan dua string tipe `VARCHAR` mengembalikan string tipe. `VARCHAR`
## Contoh
Contoh berikut menggunakan tabel USERS dan VENUE dari database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk menggabungkan bidang FIRSTNAME dan LASTNAME dari tabel USERS dalam database sampel, gunakan contoh berikut.
```
SELECT (firstname || ' ' || lastname) as fullname
FROM users
ORDER BY 1
LIMIT 10;
+-----------------+
| fullname |
+-----------------+
| Aaron Banks |
| Aaron Booth |
| Aaron Browning |
| Aaron Burnett |
| Aaron Casey |
| Aaron Cash |
| Aaron Castro |
| Aaron Dickerson |
| Aaron Dixon |
| Aaron Dotson |
+-----------------+
```
Untuk menggabungkan kolom yang mungkin berisi nol, gunakan ekspresi. [Fungsi NVL dan COALESCE](r_NVL_function.md) Contoh berikut menggunakan NVL untuk mengembalikan `0` setiap kali ditemui`NULL`.
```
SELECT (venuename || ' seats ' || NVL(venueseats, 0)) as seating
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 ASCII
Fungsi ASCII mengembalikan kode ASCII, atau titik kode Unicode, dari karakter pertama dalam string yang Anda tentukan. Fungsi kembali `0` jika string kosong. Ia kembali `NULL` jika string adalah null.
## Sintaksis
```
ASCII('string')
```
## Pendapat
*tali*
Sebuah `CHAR` string atau `VARCHAR` string.
## Jenis pengembalian
INTEGER
## Contoh
Untuk kembali`NULL`, gunakan contoh berikut. Fungsi NULLIF mengembalikan `NULL` jika dua argumen yang sama, sehingga argumen masukan untuk fungsi ASCII adalah. `NULL` Untuk informasi selengkapnya, lihat [Fungsi NULLIF](r_NULLIF_function.md).
```
SELECT ASCII(NULLIF('',''));
+-------+
| ascii |
+-------+
| NULL |
+-------+
```
Untuk mengembalikan kode ASCII 0, gunakan contoh berikut.
```
SELECT ASCII('');
+-------+
| ascii |
+-------+
| 0 |
+-------+
```
Untuk mengembalikan kode ASCII 97 untuk huruf pertama dari kata amazon, gunakan contoh berikut.
```
SELECT ASCII('amazon');
+-------+
| ascii |
+-------+
| 97 |
+-------+
```
Untuk mengembalikan kode ASCII 65 untuk huruf pertama dari kata Amazon, gunakan contoh berikut.
```
SELECT ASCII('Amazon');
+-------+
| ascii |
+-------+
| 65 |
+-------+
```
# Fungsi BPCHARCMP
Membandingkan nilai dari dua string dan mengembalikan integer. Jika string identik, fungsi kembali`0`. Jika string pertama lebih besar menurut abjad, fungsi kembali. `1` Jika string kedua lebih besar, fungsi kembali`-1`.
Untuk karakter multibyte, perbandingan didasarkan pada pengkodean byte.
Sinonim dari. [Fungsi BTTEXT\$1PATTERN\$1CMP](r_BTTEXT_PATTERN_CMP.md)
## Sintaksis
```
BPCHARCMP(string1, string2)
```
## Argumen
*senar1*
Sebuah `CHAR` string atau `VARCHAR` string.
*senar2*
Sebuah `CHAR` string atau `VARCHAR` string.
## Jenis pengembalian
INTEGER
## Contoh
Contoh berikut menggunakan tabel USERS dari database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk menentukan apakah nama depan pengguna menurut abjad lebih besar dari nama belakang pengguna untuk sepuluh entri pertama dalam tabel USERS, gunakan contoh berikut. Untuk entri di mana string untuk FIRSTNAME kemudian menurut abjad dari string untuk LASTNAME, fungsi kembali. `1` Jika LASTNAME menurut abjad lebih lambat dari FIRSTNAME, fungsi kembali. `-1`
```
SELECT userid, firstname, lastname, BPCHARCMP(firstname, lastname)
FROM users
ORDER BY 1, 2, 3, 4
LIMIT 10;
+--------+-----------+-----------+-----------+
| userid | firstname | lastname | bpcharcmp |
+--------+-----------+-----------+-----------+
| 1 | Rafael | Taylor | -1 |
| 2 | Vladimir | Humphrey | 1 |
| 3 | Lars | Ratliff | -1 |
| 4 | Barry | Roy | -1 |
| 5 | Reagan | Hodge | 1 |
| 6 | Victor | Hernandez | 1 |
| 7 | Tamekah | Juarez | 1 |
| 8 | Colton | Roy | -1 |
| 9 | Mufutau | Watkins | -1 |
| 10 | Naida | Calderon | 1 |
+--------+-----------+-----------+-----------+
```
Untuk mengembalikan semua entri dalam tabel USERS tempat fungsi kembali`0`, gunakan contoh berikut. Fungsi kembali `0` ketika FIRSTNAME identik dengan LASTNAME.
```
SELECT userid, firstname, lastname,
BPCHARCMP(firstname, lastname)
FROM users
WHERE BPCHARCMP(firstname, lastname)=0
ORDER BY 1, 2, 3, 4;
+--------+-----------+----------+-----------+
| userid | firstname | lastname | bpcharcmp |
+--------+-----------+----------+-----------+
| 62 | Chase | Chase | 0 |
| 4008 | Whitney | Whitney | 0 |
| 12516 | Graham | Graham | 0 |
| 13570 | Harper | Harper | 0 |
| 16712 | Cooper | Cooper | 0 |
| 18359 | Chase | Chase | 0 |
| 27530 | Bradley | Bradley | 0 |
| 31204 | Harding | Harding | 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 BTTEXT\$1PATTERN\$1CMP
Sinonim untuk fungsi BPCHARCMP.
Lihat [Fungsi BPCHARCMP](r_BPCHARCMP.md) untuk detail.
# Fungsi CHAR\$1LENGTH
Sinonim dari fungsi LEN.
Lihat [Fungsi LEN](r_LEN.md).
# Fungsi CHARACTER\$1LENGTH
Sinonim dari fungsi LEN.
Lihat [Fungsi LEN](r_LEN.md).
# Fungsi CHARINDEX
Mengembalikan lokasi substring tertentu dalam string.
Lihat [Fungsi POSISI](r_POSITION.md) dan [fungsi STRPOS](r_STRPOS.md) untuk fungsi serupa.
## Sintaksis
```
CHARINDEX( substring, string )
```
## Argumen
*substring*
Substring untuk mencari di dalam *string*.
*tali*
String atau kolom yang akan dicari.
## Jenis pengembalian
INTEGER
Fungsi CHARINDEX mengembalikan yang `INTEGER` sesuai dengan posisi substring (berbasis satu, bukan berbasis nol). Posisi didasarkan pada jumlah karakter, bukan byte, sehingga karakter multi-byte dihitung sebagai karakter tunggal. CHARINDEX kembali `0` jika substring tidak ditemukan dalam string.
## Contoh
Untuk mengembalikan posisi string `fish` dalam kata`dog`, gunakan contoh berikut.
```
SELECT CHARINDEX('fish', 'dog');
+-----------+
| charindex |
+-----------+
| 0 |
+-----------+
```
Untuk mengembalikan posisi string `fish` dalam kata`dogfish`, gunakan contoh berikut.
```
SELECT CHARINDEX('fish', 'dogfish');
+-----------+
| charindex |
+-----------+
| 4 |
+-----------+
```
Contoh berikut menggunakan tabel PENJUALAN dari database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk mengembalikan jumlah transaksi penjualan yang berbeda dengan komisi lebih dari 999.00 dari tabel PENJUALAN, gunakan contoh berikut. Perintah ini menghitung komisi lebih besar dari 999.00 dengan memeriksa apakah desimal lebih dari 4 tempat dari awal nilai komisi.
```
SELECT DISTINCT CHARINDEX('.', commission), COUNT (CHARINDEX('.', commission))
FROM sales
WHERE CHARINDEX('.', commission) > 4
GROUP BY CHARINDEX('.', commission)
ORDER BY 1,2;
+-----------+-------+
| charindex | count |
+-----------+-------+
| 5 | 629 |
+-----------+-------+
```
# Fungsi CHR
Fungsi CHR mengembalikan karakter yang cocok dengan nilai titik kode ASCII yang ditentukan oleh parameter input.
## Sintaksis
```
CHR(number)
```
## Pendapat
*jumlah*
Parameter input adalah `INTEGER` yang mewakili nilai titik kode ASCII.
## Jenis pengembalian
CHAR
Fungsi CHR mengembalikan `CHAR` string jika karakter ASCII cocok dengan nilai input. Jika nomor input tidak memiliki kecocokan ASCII, fungsi kembali. `NULL`
## Contoh
Untuk mengembalikan karakter yang sesuai dengan kode ASCII titik 0, gunakan contoh berikut. Perhatikan bahwa fungsi CHR kembali `NULL` untuk input`0`.
```
SELECT CHR(0);
+-----+
| chr |
+-----+
| |
+-----+
```
Untuk mengembalikan karakter yang sesuai dengan kode ASCII poin 65, gunakan contoh berikut.
```
SELECT CHR(65);
+-----+
| chr |
+-----+
| A |
+-----+
```
Untuk mengembalikan nama peristiwa yang berbeda yang dimulai dengan huruf kapital A (ASCII code point 65), gunakan contoh berikut. Contoh berikut menggunakan tabel EVENT dari database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
```
SELECT DISTINCT eventname FROM event
WHERE SUBSTRING(eventname, 1, 1)=CHR(65) LIMIT 5;
+-----------------------+
| eventname |
+-----------------------+
| A Catered Affair |
| As You Like It |
| A Man For All Seasons |
| Alan Jackson |
| Armando Manzanero |
+-----------------------+
```
# Fungsi COLLATE
Fungsi COLLATE mengesampingkan pemeriksaan kolom string atau ekspresi.
Untuk informasi tentang cara membuat tabel menggunakan pemeriksaan database, lihat[CREATE TABLE](r_CREATE_TABLE_NEW.md).
Untuk informasi tentang cara membuat database menggunakan pemeriksaan database, lihat. [BUAT BASIS DATA](r_CREATE_DATABASE.md)
## Sintaksis
```
COLLATE( string, 'case_sensitive' | 'cs' | 'case_insensitive' | 'ci');
```
## Argumen
*tali*
Kolom string atau ekspresi yang ingin Anda timpa.
*'case\$1sensitive' \$1 'cs'* *\$1 '***case\$1insensitive' \$1 '*ci'*
Sebuah konstanta string dari nama pemeriksaan. Amazon Redshift hanya mendukung nilai berikut untuk parameter ini:
+ *case\$1sensitive*
+ *cs*
+ *case\$1insensitive*
+ *ci*
*case\$1sensitive* dan *cs* dapat dipertukarkan dan menghasilkan hasil yang sama. Demikian pula, *case\$1insensitive* dan *ci* dapat dipertukarkan dan menghasilkan hasil yang sama.
## Jenis pengembalian
Fungsi COLLATE mengembalikan`VARCHAR`,`CHAR`, atau `SUPER` tergantung pada jenis ekspresi input pertama. Fungsi ini hanya mengubah pengumpulan argumen input pertama dan tidak akan mengubah nilai outputnya.
## Contoh
Untuk membuat tabel T dan mendefinisikan col1 dalam tabel T sebagai`case_sensitive`, gunakan contoh berikut.
```
CREATE TABLE T ( col1 Varchar(20) COLLATE case_sensitive );
INSERT INTO T VALUES ('john'),('JOHN');
```
Saat Anda menjalankan kueri pertama, Amazon Redshift hanya kembali. `john` Setelah fungsi COLLATE berjalan pada col1, pemeriksaan menjadi. `case_insensitive` Query kedua mengembalikan keduanya `john` dan`JOHN`.
```
SELECT * FROM T WHERE col1 = 'john';
+------+
| col1 |
+------+
| john |
+------+
SELECT * FROM T WHERE COLLATE(col1, 'case_insensitive') = 'john';
+------+
| col1 |
+------+
| john |
| JOHN |
+------+
```
Untuk membuat tabel A dan mendefinisikan col1 dalam tabel A sebagai`case_insensitive`, gunakan contoh berikut.
```
CREATE TABLE A ( col1 Varchar(20) COLLATE case_insensitive );
INSERT INTO A VALUES ('john'),('JOHN');
```
Saat Anda menjalankan kueri pertama, Amazon Redshift mengembalikan keduanya dan`john`. `JOHN` Setelah fungsi COLLATE berjalan pada col1, pemeriksaan menjadi. `case_sensitive` Kueri kedua hanya mengembalikan`john`.
```
SELECT * FROM A WHERE col1 = 'john';
+------+
| col1 |
+------+
| john |
| JOHN |
+------+
SELECT * FROM A WHERE COLLATE(col1, 'case_sensitive') = 'john';
+------+
| col1 |
+------+
| john |
+------+
```
# 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.
## 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, Amazon Redshift mencoba untuk secara implisit mengetik cast salah satu ekspresi. Jika nilai tidak dapat dilemparkan, kesalahan dikembalikan.
## Catatan penggunaan
+ Untuk kedua fungsi CONCAT dan operator penggabungan, jika salah satu atau kedua ekspresi adalah nol, hasil penggabungan adalah nol.
## 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';
?column?
-------------------
December 25, 2008
(1 row)
```
Contoh berikut menggunakan fungsi CONCAT bersarang di dalam fungsi CONCAT lain 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 NULLs, gunakan[Fungsi NVL dan COALESCE](r_NVL_function.md), yang mengembalikan nilai yang diberikan ketika bertemu NULL. 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)
```
Contoh berikut menggabungkan dua ekspresi biner. Dimana `abc` adalah nilai biner (dengan representasi heksadesimal`616263`) dan `def` merupakan nilai biner (dengan representasi heksadesimal). `646566` Hasilnya secara otomatis ditampilkan sebagai representasi heksadesimal dari nilai biner.
```
SELECT CONCAT('abc'::VARBYTE, 'def'::VARBYTE);
concat
-------------------
616263646566
```
# CRC32 fungsi
CRC32 adalah fungsi yang digunakan untuk deteksi kesalahan. Fungsi ini menggunakan CRC32 algoritma untuk mendeteksi perubahan antara sumber dan data target. CRC32 Fungsi ini mengubah string panjang variabel menjadi string 8 karakter yang merupakan representasi teks dari nilai heksadesimal dari urutan biner 32 bit. Untuk mendeteksi perubahan antara sumber dan data target, gunakan CRC32 fungsi pada data sumber dan simpan output. Kemudian, gunakan CRC32 fungsi pada data target dan bandingkan output itu dengan output dari data sumber. Outputnya akan sama jika data tidak dimodifikasi, dan outputnya akan berbeda jika data dimodifikasi.
## Sintaksis
```
CRC32(string)
```
## Argumen
*tali*
`CHAR`String, `VARCHAR` string, atau ekspresi yang secara implisit mengevaluasi ke atau tipe. `CHAR` `VARCHAR`
## Jenis pengembalian
CRC32 Fungsi mengembalikan string 8-karakter yang merupakan representasi teks dari nilai heksadesimal dari urutan biner 32-bit. CRC32 Fungsi Amazon Redshift didasarkan pada polinomial CRC-32C.
## Contoh
Untuk menunjukkan nilai 8-bit untuk string`Amazon Redshift`.
```
SELECT CRC32('Amazon Redshift');
+----------+
| crc32 |
+----------+
| f2726906 |
+----------+
```
# Fungsi PERBEDAAN
Fungsi DIFFERENCE membandingkan kode American Soundex dari dua string. Fungsi mengembalikan `INTEGER` untuk menunjukkan jumlah karakter yang cocok antara kode Soundex.
Kode Soundex adalah string yang panjangnya empat karakter. Kode Soundex mewakili bagaimana sebuah kata terdengar daripada bagaimana itu dieja. Misalnya, `Smith` dan `Smyth` memiliki kode Soundex yang sama.
## Sintaksis
```
DIFFERENCE(string1, string2)
```
## Argumen
*senar1*
`CHAR`String, `VARCHAR` string, atau ekspresi yang secara implisit mengevaluasi ke atau tipe. `CHAR` `VARCHAR`
*senar2*
`CHAR`String, `VARCHAR` string, atau ekspresi yang secara implisit mengevaluasi ke atau tipe. `CHAR` `VARCHAR`
## Jenis pengembalian
INTEGER
Fungsi DIFFERENCE mengembalikan `INTEGER` nilai dari 0-4 yang menghitung jumlah karakter yang cocok dalam kode American Soundex dari dua string. Kode Soundex memiliki 4 karakter, sehingga fungsi DIFFERENCE kembali `4` ketika semua 4 karakter dari nilai kode American Soundex string adalah sama. PERBEDAAN kembali `0` jika salah satu dari dua string kosong. Fungsi kembali `1` jika string tidak mengandung karakter yang valid. Fungsi DIFFERENCE hanya mengkonversi huruf kecil abjad bahasa Inggris atau huruf besar ASCII karakter, termasuk a—z dan A—Z. PERBEDAAN mengabaikan karakter lain.
## Contoh
Untuk membandingkan nilai-nilai Soundex dari string `%` dan`@`, gunakan contoh berikut. Fungsi kembali `1` karena string tidak mengandung karakter yang valid.
```
SELECT DIFFERENCE('%', '@');
+------------+
| difference |
+------------+
| 1 |
+------------+
```
Untuk membandingkan nilai-nilai Soundex `Amazon` dan string kosong, gunakan contoh berikut. Fungsi kembali `0` karena salah satu dari dua string kosong.
```
SELECT DIFFERENCE('Amazon', '');
+------------+
| difference |
+------------+
| 0 |
+------------+
```
Untuk membandingkan nilai-nilai Soundex dari string `Amazon` dan`Ama`, gunakan contoh berikut. Fungsi kembali `2` karena 2 karakter dari nilai Soundex string adalah sama.
```
SELECT DIFFERENCE('Amazon', 'Ama');
+------------+
| difference |
+------------+
| 2 |
+------------+
```
Untuk membandingkan nilai-nilai Soundex dari string `Amazon` dan`+-*/%Amazon`, gunakan contoh berikut. Fungsi kembali `4` karena semua 4 karakter dari nilai Soundex string adalah sama. Perhatikan bahwa fungsi mengabaikan karakter yang tidak valid `+-*/%` dalam string kedua.
```
SELECT DIFFERENCE('Amazon', '+-*/%Amazon');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
Untuk membandingkan nilai-nilai Soundex dari string `AC/DC` dan`Ay See Dee See`, gunakan contoh berikut. Fungsi kembali `4` karena semua 4 karakter dari nilai Soundex string adalah sama.
```
SELECT DIFFERENCE('AC/DC', 'Ay See Dee See');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
# Fungsi INITCAP
Kapitalisasi huruf pertama dari setiap kata dalam string tertentu. INITCAP mendukung karakter multibyte UTF-8, hingga maksimal empat byte per karakter.
## Sintaksis
```
INITCAP(string)
```
## Pendapat
*tali*
`CHAR`String, `VARCHAR` string, atau ekspresi yang secara implisit mengevaluasi ke atau tipe. `CHAR` `VARCHAR`
## Jenis pengembalian
VARCHAR
## Catatan penggunaan
Fungsi INITCAP membuat huruf pertama dari setiap kata dalam string huruf besar, dan huruf berikutnya dibuat (atau kiri) huruf kecil. Oleh karena itu, penting untuk memahami karakter mana (selain karakter spasi) yang berfungsi sebagai pemisah kata. Karakter *pemisah kata* adalah karakter non-alfanumerik, termasuk tanda baca, simbol, dan karakter kontrol. Semua karakter berikut adalah pemisah kata:
```
! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~
```
Tab, karakter baris baru, umpan formulir, umpan baris, dan pengembalian carriage juga merupakan pemisah kata.
## Contoh
Contoh berikut menggunakan data dari tabel CATEGORY dan USERS dalam database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk menggunakan huruf besar inisiasi setiap kata di kolom CATDESC, gunakan contoh berikut.
```
SELECT catid, catdesc, INITCAP(catdesc)
FROM category
ORDER BY 1, 2, 3;
+-------+--------------------------------------------+--------------------------------------------+
| catid | catdesc | initcap |
+-------+--------------------------------------------+--------------------------------------------+
| 1 | Major League Baseball | Major League Baseball |
| 2 | National Hockey League | National Hockey League |
| 3 | National Football League | National Football League |
| 4 | National Basketball Association | National Basketball Association |
| 5 | Major League Soccer | Major League Soccer |
| 6 | Musical theatre | Musical Theatre |
| 7 | All non-musical theatre | All Non-Musical Theatre |
| 8 | All opera and light opera | All Opera And Light Opera |
| 9 | All rock and pop music concerts | All Rock And Pop Music Concerts |
| 10 | All jazz singers and bands | All Jazz Singers And Bands |
| 11 | All symphony, concerto, and choir concerts | All Symphony, Concerto, And Choir Concerts |
+-------+--------------------------------------------+--------------------------------------------+
```
Untuk menunjukkan bahwa fungsi INITCAP tidak mempertahankan karakter huruf besar ketika mereka tidak memulai kata-kata, gunakan contoh berikut. Misalnya, string `MLB` menjadi`Mlb`.
```
SELECT INITCAP(catname)
FROM category
ORDER BY catname;
+-----------+
| initcap |
+-----------+
| Classical |
| Jazz |
| Mlb |
| Mls |
| Musicals |
| Nba |
| Nfl |
| Nhl |
| Opera |
| Plays |
| Pop |
+-----------+
```
Untuk menunjukkan bahwa karakter non-alfanumerik selain spasi berfungsi sebagai pemisah kata, gunakan contoh berikut. Beberapa huruf di setiap string akan dikapitalisasi.
```
SELECT email, INITCAP(email)
FROM users
ORDER BY userid DESC LIMIT 5;
+------------------------------------+------------------------------------+
| email | initcap |
+------------------------------------+------------------------------------+
| urna.Ut@egetdictumplacerat.edu | Urna.Ut@Egetdictumplacerat.Edu |
| nibh.enim@egestas.ca | Nibh.Enim@Egestas.Ca |
| in@Donecat.ca | In@Donecat.Ca |
| sodales@blanditviverraDonec.ca | Sodales@Blanditviverradonec.Ca |
| sociis.natoque.penatibus@vitae.org | Sociis.Natoque.Penatibus@Vitae.Org |
+------------------------------------+------------------------------------+
```
# 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*
`CHAR`String, `VARCHAR` string, atau ekspresi apa pun yang mengevaluasi ke `CHAR` atau `VARCHAR` string.
*bilangan bulat*
Integer positif.
## Jenis pengembalian
VARCHAR
## Contoh
Contoh berikut menggunakan data dari tabel EVENT dalam database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk mengembalikan 5 karakter paling kiri dan paling kanan 5 dari nama acara yang memiliki peristiwa IDs antara 1000 dan 1005, gunakan contoh berikut.
```
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 |
+---------+----------------+--------+---------+
```
# Fungsi LEN
Mengembalikan panjang string yang ditentukan sebagai jumlah karakter.
## Sintaksis
LEN adalah sinonim dari[Fungsi PANJANG](r_LENGTH.md),, [Fungsi CHAR\$1LENGTH](r_CHAR_LENGTH.md)[Fungsi CHARACTER\$1LENGTH](r_CHARACTER_LENGTH.md), dan. [Fungsi TEXTLEN](r_TEXTLEN.md)
```
LEN(expression)
```
## Pendapat
*ekspresi*
`CHAR`String, `VARCHAR` string, `VARBYTE` ekspresi, atau ekspresi yang secara implisit mengevaluasi ke`CHAR`,`VARCHAR`, atau tipe. `VARBYTE`
## Jenis pengembalian
INTEGER
Fungsi LEN mengembalikan integer yang menunjukkan jumlah karakter dalam string input.
Jika string input adalah string karakter, fungsi LEN mengembalikan jumlah aktual karakter dalam string multi-byte, bukan jumlah byte. Misalnya, `VARCHAR(12)` kolom diperlukan untuk menyimpan tiga karakter Mandarin empat byte. Fungsi LEN akan kembali `3` untuk string yang sama. Untuk mendapatkan panjang string dalam byte, gunakan [OCTET\$1LENGTH](r_OCTET_LENGTH.md) fungsi.
## Catatan penggunaan
Jika *ekspresi* adalah `CHAR` string, spasi tambahan tidak dihitung.
Jika *ekspresi* adalah `VARCHAR` string, spasi tambahan dihitung.
## Contoh
Untuk mengembalikan jumlah byte dan jumlah karakter dalam string`français`, gunakan contoh berikut.
```
SELECT OCTET_LENGTH('français'),
LEN('français');
+--------------+-----+
| octet_length | len |
+--------------+-----+
| 9 | 8 |
+--------------+-----+
```
Untuk mengembalikan jumlah byte dan jumlah karakter dalam string `français` tanpa menggunakan fungsi OCTET\$1LENGTH, gunakan contoh berikut. Untuk informasi selengkapnya, lihat [Fungsi CAST](r_CAST_function.md).
```
SELECT LEN(CAST('français' AS VARBYTE)) as bytes, LEN('français');
+-------+-----+
| bytes | len |
+-------+-----+
| 9 | 8 |
+-------+-----+
```
Untuk mengembalikan jumlah karakter dalam string tanpa spasi tambahan, `cat` dengan tiga spasi trailing, `cat ` dengan tiga spasi trailing dilemparkan sebagai `CHAR` panjang 6, dan `cat ` dengan tiga spasi trailing dilemparkan sebagai panjang 6, `VARCHAR` gunakan contoh berikut. `cat ` Perhatikan bahwa fungsi tidak menghitung spasi tambahan untuk `CHAR` string, tetapi itu menghitung spasi tambahan untuk string. `VARCHAR`
```
SELECT LEN('cat'), LEN('cat '), LEN(CAST('cat ' AS CHAR(6))) AS len_char, LEN(CAST('cat ' AS VARCHAR(6))) AS len_varchar;
+-----+-----+----------+-------------+
| len | len | len_char | len_varchar |
+-----+-----+----------+-------------+
| 3 | 6 | 3 | 6 |
+-----+-----+----------+-------------+
```
Contoh berikut menggunakan data dari tabel VENUE dalam database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk mengembalikan 10 nama tempat terpanjang di tabel VENUE, gunakan contoh berikut.
```
SELECT venuename, LEN(venuename)
FROM venue
ORDER BY 2 DESC, 1
LIMIT 10;
+-----------------------------------------+-----+
| venuename | len |
+-----------------------------------------+-----+
| Saratoga Springs Performing Arts Center | 39 |
| Lincoln Center for the Performing Arts | 38 |
| Nassau Veterans Memorial Coliseum | 33 |
| Jacksonville Municipal Stadium | 30 |
| Rangers BallPark in Arlington | 29 |
| University of Phoenix Stadium | 29 |
| Circle in the Square Theatre | 28 |
| Hubert H. Humphrey Metrodome | 28 |
| Oriole Park at Camden Yards | 27 |
| Dick's Sporting Goods Park | 26 |
+-----------------------------------------+-----+
```
# Fungsi PANJANG
Sinonim dari fungsi LEN.
Lihat [Fungsi LEN](r_LEN.md).
# Fungsi LOWER
Mengkonversi string ke huruf kecil. LOWER mendukung karakter multibyte UTF-8, hingga maksimal empat byte per karakter.
## Sintaksis
```
LOWER(string)
```
## Pendapat
*tali*
`VARCHAR`String atau ekspresi apa pun yang mengevaluasi `VARCHAR` tipe.
## Jenis pengembalian
string
Fungsi LOWER mengembalikan string yang merupakan tipe data yang sama dengan string input. Misalnya, jika input adalah `CHAR` string, fungsi akan mengembalikan `CHAR` string.
## Contoh
Contoh berikut menggunakan data dari tabel CATEGORY dalam database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk mengonversi `VARCHAR` string di kolom CATNAME menjadi huruf kecil, gunakan contoh berikut.
```
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 |
+-----------+-----------+
```
# 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*
`CHAR`String, `VARCHAR` string, atau ekspresi yang secara implisit mengevaluasi ke atau tipe. `CHAR` `VARCHAR`
*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 *panjangnya* nol atau angka negatif, hasil fungsinya adalah string kosong.
*senar2*
*(Opsional) Satu atau lebih karakter yang ditambahkan atau ditambahkan ke string1.* Jika argumen ini tidak ditentukan, spasi digunakan.
## Jenis pengembalian
VARCHAR
## Contoh
Contoh berikut menggunakan data dari tabel EVENT dalam database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk memotong satu set nama acara tertentu menjadi 20 karakter dan menambahkan nama yang lebih pendek dengan spasi, gunakan contoh berikut.
```
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 |
+-----------------------+
```
Untuk memotong kumpulan nama acara yang sama menjadi 20 karakter tetapi menambahkan nama yang lebih pendek dengan`0123456789`, gunakan contoh berikut.
```
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 |
+----------------------+
```
# 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 OCTETINDEX
Fungsi OCTETINDEX mengembalikan lokasi substring dalam string sebagai sejumlah byte.
## Sintaksis
```
OCTETINDEX(substring, string)
```
## Argumen
*substring*
`CHAR`String, `VARCHAR` string, atau ekspresi yang secara implisit mengevaluasi ke atau tipe. `CHAR` `VARCHAR`
*tali*
`CHAR`String, `VARCHAR` string, atau ekspresi yang secara implisit mengevaluasi ke atau tipe. `CHAR` `VARCHAR`
## Jenis pengembalian
INTEGER
Fungsi OCTETINDEX mengembalikan `INTEGER` nilai yang sesuai dengan posisi *substring* dalam *string* sebagai sejumlah byte, di mana karakter pertama dalam *string* dihitung sebagai 1. Jika *string* tidak mengandung karakter multibyte, hasilnya sama dengan hasil fungsi CHARINDEX. Jika *string* tidak mengandung *substring*, fungsi kembali`0`. Jika *substring* kosong, fungsi kembali`1`.
## Contoh
Untuk mengembalikan posisi substring `q` dalam string`Amazon Redshift`, gunakan contoh berikut. Contoh ini kembali `0` karena *substring* tidak dalam *string*.
```
SELECT OCTETINDEX('q', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 0 |
+------------+
```
Untuk mengembalikan posisi substring kosong dalam string`Amazon Redshift`, gunakan contoh berikut. Contoh ini kembali `1` karena *substring* kosong.
```
SELECT OCTETINDEX('', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 1 |
+------------+
```
Untuk mengembalikan posisi substring `Redshift` dalam string`Amazon Redshift`, gunakan contoh berikut. *Contoh ini kembali `8` karena *substring* dimulai pada byte kedelapan dari string.*
```
SELECT OCTETINDEX('Redshift', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 8 |
+------------+
```
Untuk mengembalikan posisi substring `Redshift` dalam string`Amazon Redshift`, gunakan contoh berikut. Contoh ini kembali `21` karena enam karakter pertama dari *string* adalah karakter double-byte.
```
SELECT OCTETINDEX('Redshift', 'Άμαζον Amazon Redshift');
+------------+
| octetindex |
+------------+
| 21 |
+------------+
```
# Fungsi OCTET\$1LENGTH
Mengembalikan panjang string yang ditentukan sebagai jumlah byte.
## Sintaksis
```
OCTET_LENGTH(expression)
```
## Pendapat
*ekspresi*
`CHAR`String, `VARCHAR` string, `VARBYTE` ekspresi, atau ekspresi yang secara implisit mengevaluasi ke`CHAR`,`VARCHAR`, atau tipe. `VARBYTE`
## Jenis pengembalian
INTEGER
Fungsi OCTET\$1LENGTH mengembalikan integer yang menunjukkan jumlah byte dalam string input.
Jika string input adalah string karakter, [LEN](r_LEN.md) fungsi mengembalikan jumlah aktual karakter dalam string multi-byte, bukan jumlah byte. Misalnya, `VARCHAR(12)` kolom diperlukan untuk menyimpan tiga karakter Mandarin empat byte. Fungsi OCTET\$1LENGTH akan kembali `12` untuk string itu, dan fungsi LEN akan kembali `3` untuk string yang sama.
## Catatan penggunaan
Jika *ekspresi* adalah `CHAR` string, fungsi mengembalikan panjang `CHAR` string. Misalnya, output dari `CHAR(6)` input adalah a`CHAR(6)`.
Jika *ekspresi* adalah `VARCHAR` string, spasi tambahan dihitung.
## Contoh
Untuk mengembalikan jumlah byte ketika string `francais` dengan tiga spasi trailing dilemparkan ke `CHAR` dan `VARCHAR` tipe, gunakan contoh berikut. Untuk informasi selengkapnya, lihat [Fungsi CAST](r_CAST_function.md).
```
SELECT OCTET_LENGTH(CAST('francais ' AS CHAR(15))) AS octet_length_char, OCTET_LENGTH(CAST('francais ' AS VARCHAR(15))) AS octet_length_varchar;
+-------------------+----------------------+
| octet_length_char | octet_length_varchar |
+-------------------+----------------------+
| 15 | 11 |
+-------------------+----------------------+
```
Untuk mengembalikan jumlah byte dan jumlah karakter dalam string`français`, gunakan contoh berikut.
```
SELECT OCTET_LENGTH('français'), LEN('français');
+--------------+-----+
| octet_length | len |
+--------------+-----+
| 9 | 8 |
+--------------+-----+
```
Untuk mengembalikan jumlah byte ketika string `français` dilemparkan sebagai`VARBYTE`, gunakan contoh berikut.
```
SELECT OCTET_LENGTH(CAST('français' AS VARBYTE));
+--------------+
| octet_length |
+--------------+
| 9 |
+--------------+
```
# Fungsi POSISI
Mengembalikan lokasi substring tertentu dalam string.
Lihat [Fungsi CHARINDEX](r_CHARINDEX.md) dan [fungsi STRPOS](r_STRPOS.md) untuk fungsi serupa.
## 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 yang `INTEGER` sesuai dengan posisi substring (berbasis satu, bukan berbasis nol). Posisi didasarkan pada jumlah karakter, bukan byte, sehingga karakter multi-byte dihitung sebagai karakter tunggal. POSITION kembali `0` jika substring tidak ditemukan dalam string.
## Contoh
Untuk mengembalikan posisi string `fish` dalam kata`dog`, gunakan contoh berikut.
```
SELECT POSITION('fish' IN 'dog');
+-----------+
| position |
+-----------+
| 0 |
+-----------+
```
Untuk mengembalikan posisi string `fish` dalam kata`dogfish`, gunakan contoh berikut.
```
SELECT POSITION('fish' IN 'dogfish');
+-----------+
| position |
+-----------+
| 4 |
+-----------+
```
Contoh berikut menggunakan tabel PENJUALAN dari database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk mengembalikan jumlah transaksi penjualan yang berbeda dengan komisi lebih dari 999.00 dari tabel PENJUALAN, gunakan contoh berikut. Perintah ini menghitung komisi lebih besar dari 999.00 dengan memeriksa apakah desimal lebih dari 4 tempat dari awal nilai komisi.
```
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 |
+-----------+-------+
```
# Fungsi QUOTE\$1IDENT
Fungsi QUOTE\$1IDENT mengembalikan string yang ditentukan sebagai string dengan tanda kutip ganda terkemuka dan tanda kutip ganda tertinggal. Output fungsi dapat digunakan sebagai identifier dalam pernyataan SQL. Fungsi ini menggandakan tanda kutip ganda yang disematkan dengan tepat.
QUOTE\$1IDENT menambahkan tanda kutip ganda hanya jika diperlukan untuk membuat pengidentifikasi yang valid, ketika string berisi karakter non-pengenal atau sebaliknya akan dilipat ke huruf kecil. [Untuk selalu mengembalikan string yang dikutip tunggal, gunakan QUOTE\$1LITERAL.](r_QUOTE_LITERAL.md)
## Sintaksis
```
QUOTE_IDENT(string)
```
## Pendapat
*tali*
A `CHAR` atau `VARCHAR` string.
## Jenis pengembalian
*Fungsi QUOTE\$1IDENT mengembalikan jenis string yang sama dengan string input.*
## Contoh
Untuk mengembalikan string `"CAT"` dengan tanda kutip dua kali lipat, gunakan contoh berikut.
```
SELECT QUOTE_IDENT('"CAT"');
+-------------+
| quote_ident |
+-------------+
| """CAT""" |
+-------------+
```
Contoh berikut menggunakan data dari tabel CATEGORY dalam database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk mengembalikan kolom CATNAME dikelilingi oleh tanda kutip, gunakan contoh berikut.
```
SELECT catid, QUOTE_IDENT(catname)
FROM category
ORDER BY 1,2;
+-------+-------------+
| catid | quote_ident |
+-------+-------------+
| 1 | "MLB" |
| 2 | "NHL" |
| 3 | "NFL" |
| 4 | "NBA" |
| 5 | "MLS" |
| 6 | "Musicals" |
| 7 | "Plays" |
| 8 | "Opera" |
| 9 | "Pop" |
| 10 | "Jazz" |
| 11 | "Classical" |
+-------+-------------+
```
# Fungsi QUOTE\$1LITERAL
Fungsi QUOTE\$1LITERAL mengembalikan string tertentu sebagai string dikutip tunggal sehingga dapat digunakan sebagai string literal dalam pernyataan SQL. Jika parameter input adalah angka, QUOTE\$1LITERAL memperlakukannya sebagai string. Dengan tepat menggandakan tanda kutip tunggal dan garis miring terbalik yang disematkan.
## Sintaksis
```
QUOTE_LITERAL(string)
```
## Pendapat
*tali*
A `CHAR` atau `VARCHAR` string.
## Jenis pengembalian
*Fungsi QUOTE\$1LITERAL mengembalikan `CHAR` atau `VARCHAR` string yang merupakan tipe data yang sama dengan string input.*
## Contoh
Untuk mengembalikan string `''CAT''` dengan tanda kutip TUNGGAL, gunakan contoh berikut.
```
SELECT QUOTE_LITERAL('''CAT''');
+---------------+
| quote_literal |
+---------------+
| '''CAT''' |
+---------------+
```
Contoh berikut menggunakan data dari tabel CATEGORY dalam database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk mengembalikan kolom CATNAME dikelilingi oleh tanda kutip tunggal, gunakan contoh berikut.
```
SELECT catid, QUOTE_LITERAL(catname)
FROM category
ORDER BY 1,2;
+-------+---------------+
| catid | quote_literal |
+-------+---------------+
| 1 | 'MLB' |
| 2 | 'NHL' |
| 3 | 'NFL' |
| 4 | 'NBA' |
| 5 | 'MLS' |
| 6 | 'Musicals' |
| 7 | 'Plays' |
| 8 | 'Opera' |
| 9 | 'Pop' |
| 10 | 'Jazz' |
| 11 | 'Classical' |
+-------+---------------+
```
Untuk mengembalikan kolom CATID yang dikelilingi oleh tanda kutip tunggal, gunakan contoh berikut.
```
SELECT QUOTE_LITERAL(catid), catname
FROM category
ORDER BY 1,2;
+---------------+-----------+
| quote_literal | catname |
+---------------+-----------+
| '1' | MLB |
| '10' | Jazz |
| '11' | Classical |
| '2' | NHL |
| '3' | NFL |
| '4' | NBA |
| '5' | MLS |
| '6' | Musicals |
| '7' | Plays |
| '8' | Opera |
| '9' | Pop |
+---------------+-----------+
```
# Fungsi REGEXP\$1COUNT
Mencari string untuk pola ekspresi reguler dan mengembalikan integer yang menunjukkan berapa kali pola yang ditentukan terjadi dalam string. Jika tidak ada kecocokan yang ditemukan, maka fungsi kembali`0`. Untuk informasi selengkapnya tentang ekspresi reguler, lihat [Operator POSIX](pattern-matching-conditions-posix.md) dan [Ekspresi reguler](https://en.wikipedia.org/wiki/Regular_expression) di Wikipedia.
## Sintaksis
```
REGEXP_COUNT( source_string, pattern [, position [, parameters ] ] )
```
## Argumen
*source\$1string*
A `CHAR` atau `VARCHAR` string.
*pola*
Sebuah string UTF-8 literal yang mewakili pola ekspresi reguler. Untuk informasi selengkapnya, lihat [Operator POSIX](pattern-matching-conditions-posix.md).
*posisi*
(Opsional) Positif `INTEGER` yang menunjukkan posisi dalam *source\$1string* untuk mulai mencari. Posisi didasarkan pada jumlah karakter, bukan byte, sehingga karakter multibyte dihitung sebagai karakter tunggal. Nilai default-nya `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*
(Opsional) 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. Standarnya adalah menggunakan pencocokan peka huruf besar/kecil.
+ i — Lakukan pencocokan case-insensitive.
+ p — Menafsirkan pola dengan dialek Perl Compatible Regular Expression (PCRE). Untuk informasi selengkapnya tentang PCRE, lihat [Ekspresi Reguler Kompatibel Perl](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) di Wikipedia.
## Jenis pengembalian
INTEGER
## Contoh
Untuk menghitung berapa kali urutan tiga huruf terjadi, gunakan contoh berikut.
```
SELECT REGEXP_COUNT('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
+--------------+
| regexp_count |
+--------------+
| 8 |
+--------------+
```
Untuk menghitung kemunculan string `FOX` menggunakan pencocokan case-insensitive, gunakan contoh berikut.
```
SELECT REGEXP_COUNT('the fox', 'FOX', 1, 'i');
+--------------+
| regexp_count |
+--------------+
| 1 |
+--------------+
```
Untuk menggunakan pola yang ditulis dalam dialek PCRE untuk menemukan kata-kata yang mengandung setidaknya satu angka dan satu huruf kecil, gunakan contoh berikut. Contoh 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 |
+--------------+
```
Untuk menggunakan pola yang ditulis dalam dialek PCRE untuk menemukan kata-kata yang mengandung setidaknya satu angka dan satu huruf kecil, gunakan contoh berikut. 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 |
+--------------+
```
Contoh berikut menggunakan data dari tabel USERS dalam database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk menghitung berapa kali nama domain tingkat atas adalah salah satu `org` atau`edu`, gunakan contoh berikut.
```
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 |
+-----------------------------------------------+--------------+
```
# 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 kembali`0`. REGEXP\$1INSTR mirip dengan fungsi [POSITION](r_POSITION.md), tetapi memungkinkan Anda mencari string untuk pola ekspresi reguler. Untuk informasi selengkapnya tentang ekspresi reguler, lihat [Operator POSIX](pattern-matching-conditions-posix.md) dan [Ekspresi reguler](https://en.wikipedia.org/wiki/Regular_expression) di Wikipedia.
## Sintaksis
```
REGEXP_INSTR( source_string, pattern [, position [, occurrence] [, option [, parameters ] ] ] ] )
```
## Argumen
*source\$1string*
Ekspresi string, seperti nama kolom, yang akan dicari.
*pola*
Sebuah string UTF-8 literal yang mewakili pola ekspresi reguler. Untuk informasi selengkapnya, lihat [Operator POSIX](pattern-matching-conditions-posix.md).
*posisi*
(Opsional) Positif `INTEGER` yang menunjukkan posisi dalam *source\$1string* untuk mulai mencari. Posisi didasarkan pada jumlah karakter, bukan byte, sehingga karakter multibyte dihitung sebagai karakter tunggal. Nilai default-nya `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*
(Opsional) Positif `INTEGER` yang menunjukkan kemunculan pola mana yang akan digunakan. REGEXP\$1INSTR melewatkan pertandingan pertama. `occurrence-1` Nilai default-nya `1`. Jika *kejadian* kurang dari `1` atau lebih besar dari jumlah karakter di *source\$1string*, pencarian diabaikan dan hasilnya adalah. `0`
*pilihan*
(Opsional) Nilai yang menunjukkan apakah akan mengembalikan posisi karakter pertama pertandingan (`0`) atau posisi karakter pertama setelah akhir pertandingan (`1`). Nilai bukan nol sama `1` dengan. Nilai default-nya adalah `0`.
*parameter*
(Opsional) 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. Standarnya 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). Untuk informasi selengkapnya tentang PCRE, lihat [Ekspresi Reguler Kompatibel Perl](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) di Wikipedia.
## Jenis pengembalian
Bilangan Bulat
## Contoh
Contoh berikut menggunakan data dari tabel USERS dalam database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk mencari `@` karakter yang memulai nama domain dan mengembalikan posisi awal kecocokan pertama, gunakan contoh berikut.
```
SELECT email, REGEXP_INSTR(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+--------------+
| email | regexp_instr |
+-----------------------------------------------+--------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | 21 |
| Suspendisse.tristique@nonnisiAenean.edu | 22 |
| amet.faucibus.ut@condimentumegetvolutpat.ca | 17 |
| sed@lacusUtnec.ca | 4 |
+-----------------------------------------------+--------------+
```
Untuk mencari varian kata `Center` dan mengembalikan posisi awal kecocokan pertama, gunakan contoh berikut.
```
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 |
+-----------------------+--------------+
```
Untuk menemukan posisi awal dari kemunculan pertama string`FOX`, menggunakan logika pencocokan case-insensitive, gunakan contoh berikut.
```
SELECT REGEXP_INSTR('the fox', 'FOX', 1, 1, 0, 'i');
+--------------+
| regexp_instr |
+--------------+
| 5 |
+--------------+
```
Untuk menggunakan pola yang ditulis dalam dialek PCRE untuk menemukan kata-kata yang mengandung setidaknya satu angka dan satu huruf kecil, gunakan contoh berikut. 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 |
+--------------+
```
Untuk menggunakan pola yang ditulis dalam dialek PCRE untuk menemukan kata-kata yang mengandung setidaknya satu angka dan satu huruf kecil, gunakan contoh berikut. 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](r_REPLACE.md), tetapi memungkinkan Anda mencari string untuk pola ekspresi reguler. Untuk informasi selengkapnya tentang ekspresi reguler, lihat [Operator POSIX](pattern-matching-conditions-posix.md) dan [Ekspresi reguler](https://en.wikipedia.org/wiki/Regular_expression) di Wikipedia.
REGEXP\$1REPLACE mirip dengan [FUNGSI TRANSLATE](r_TRANSLATE.md) dan[GANTI fungsi](r_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 `CHAR` atau `VARCHAR` string, seperti nama kolom, yang akan dicari.
*pola*
Sebuah string UTF-8 literal yang mewakili pola ekspresi reguler. Untuk informasi selengkapnya, lihat [Operator POSIX](pattern-matching-conditions-posix.md).
*replace\$1string*
(Opsional) Ekspresi A `CHAR` atau `VARCHAR` string, seperti nama kolom, yang akan menggantikan setiap kemunculan pola. Defaultnya adalah string kosong (“”).
*posisi*
(Opsional) 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. Nilai default-nya `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*
(Opsional) 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. Standarnya adalah menggunakan pencocokan peka huruf besar/kecil.
+ i — Lakukan pencocokan case-insensitive.
+ p — Menafsirkan pola dengan dialek Perl Compatible Regular Expression (PCRE). Untuk informasi selengkapnya tentang PCRE, lihat [Ekspresi Reguler Kompatibel Perl](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) di Wikipedia.
## Jenis pengembalian
VARCHAR
Jika salah satu *pola* atau *replace\$1string* adalah`NULL`, fungsi kembali. `NULL`
## Contoh
Untuk mengganti semua kemunculan string `FOX` dalam nilai `quick brown fox` menggunakan pencocokan case-insensitive, gunakan contoh berikut.
```
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. Untuk mengganti setiap kemunculan kata seperti itu dengan nilainya`[hidden]`, gunakan contoh berikut.
```
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. Untuk mengganti setiap kemunculan kata seperti itu dengan nilai`[hidden]`, tetapi berbeda dari contoh sebelumnya karena menggunakan pencocokan case-insensitive, gunakan contoh berikut.
```
SELECT REGEXP_REPLACE('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'ip');
+----------------------------------+
| regexp_replace |
+----------------------------------+
| [hidden] plain [hidden] [hidden] |
+----------------------------------+
```
Contoh berikut menggunakan data dari tabel USERS dalam database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk menghapus `@` dan nama domain dari alamat email, gunakan contoh berikut.
```
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 |
+-----------------------------------------------+-----------------------+
```
Untuk mengganti nama domain alamat email dengan`internal.company.com`, gunakan contoh berikut.
```
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 |
+-----------------------------------------------+--------------------------------------------+
```
# Fungsi REGEXP\$1SUBSTR
Mengembalikan karakter dari string dengan mencarinya untuk pola ekspresi reguler. REGEXP\$1SUBSTR mirip dengan [Fungsi SUBSTRING](r_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. Untuk informasi selengkapnya tentang ekspresi reguler, lihat [Operator POSIX](pattern-matching-conditions-posix.md) dan [Ekspresi reguler](https://en.wikipedia.org/wiki/Regular_expression) di Wikipedia.
## Sintaksis
```
REGEXP_SUBSTR( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## Argumen
*source\$1string*
Ekspresi string yang akan dicari.
*pola*
Sebuah string UTF-8 literal yang mewakili pola ekspresi reguler. Untuk informasi selengkapnya, lihat [Operator POSIX](pattern-matching-conditions-posix.md).
*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 kosong.
*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. Standarnya 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). Untuk informasi selengkapnya tentang PCRE, lihat [Ekspresi Reguler Kompatibel Perl](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) di Wikipedia.
## Jenis pengembalian
VARCHAR
## Contoh
Contoh berikut mengembalikan bagian dari alamat email antara karakter @ dan ekstensi domain. `users`Data yang ditanyakan berasal dari data sampel Amazon Redshift. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
Cum@accumsan.com | @accumsan
```
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 dari input yang sesuai dengan kejadian kedua string `FOX` menggunakan pencocokan case-insensitive. Hasilnya kosong (non-null, panjang 0) karena tidak ada kejadian kedua.
```
SELECT regexp_substr('the fox', 'FOX', 1, 2, 'i');
regexp_substr
---------------
```
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.
Sinonim untuk. [Fungsi REPLICATE](r_REPLICATE.md)
## Sintaksis
```
REPEAT(string, integer)
```
## Argumen
*tali*
Parameter input pertama adalah string yang akan diulang.
*bilangan bulat*
Parameter kedua adalah `INTEGER` menunjukkan berapa kali untuk mengulangi string.
## Jenis pengembalian
VARCHAR
## Contoh
Contoh berikut menggunakan data dari tabel CATEGORY dalam database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk mengulang nilai kolom CATID dalam tabel CATEGORY tiga kali, gunakan contoh berikut.
```
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 |
+-------+--------+
```
Contoh berikut menunjukkan menghasilkan string hingga 16.000.000 byte:
```
SELECT
LEN(REPEAT('X', 5000000)) AS five_million_bytes,
LEN(REPEAT('Y', 16000000)) AS sixteen_million_bytes;
five_million_bytes | sixteen_million_bytes
----------+-----------
5000000 | 16000000
```
# GANTI fungsi
Menggantikan semua kemunculan satu set karakter dalam string yang ada dengan karakter tertentu lainnya.
REPLACE mirip dengan [FUNGSI TRANSLATE](r_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(string, old_chars, new_chars)
```
## Argumen
*tali*
`CHAR`atau `VARCHAR` string yang akan dicari pencarian
*old\$1chars*
`CHAR`atau `VARCHAR` string untuk diganti.
*new\$1chars*
Baru `CHAR` atau `VARCHAR` string menggantikan *old\$1string*.
## Jenis pengembalian
VARCHAR
Jika *old\$1chars atau *new\$1chars** adalah, pengembaliannya adalah. `NULL` `NULL`
## Contoh
Contoh berikut menggunakan data dari tabel CATEGORY dalam database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk mengonversi string `Shows` ke `Theatre` dalam bidang CATGROUP, gunakan contoh berikut.
```
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 |
+-------+----------+----------+
```
# Fungsi REPLICATE
Sinonim untuk fungsi REPEAT.
Lihat [Fungsi REPEAT](r_REPEAT.md).
# 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 `VARCHAR` string. Trailing blank dalam `CHAR` string diabaikan.
## Jenis pengembalian
VARCHAR
## Contoh
Contoh berikut menggunakan data dari tabel USERS dan SALES dalam database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk memilih lima nama kota yang berbeda dan nama terbalik yang sesuai dari tabel USERS, gunakan contoh berikut.
```
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 |
+----------+----------+
```
Untuk memilih lima penjualan IDs dan IDs pemeran terbalik yang sesuai sebagai string karakter, gunakan contoh berikut.
```
SELECT salesid, REVERSE(salesid)
FROM sales
ORDER BY salesid DESC LIMIT 5;
+---------+---------+
| salesid | reverse |
+---------+---------+
| 172456 | 654271 |
| 172455 | 554271 |
| 172454 | 454271 |
| 172453 | 354271 |
| 172452 | 254271 |
+---------+---------+
```
# 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 SOUNDEX
Fungsi SOUNDEX mengembalikan nilai American Soundex yang terdiri dari huruf pertama dari string input diikuti oleh pengkodean 3 digit suara yang mewakili pengucapan bahasa Inggris dari string yang Anda tentukan. Misalnya, `Smith` dan `Smyth` memiliki nilai Soundex yang sama.
## Sintaksis
```
SOUNDEX(string)
```
## Argumen
*tali*
Anda menentukan `CHAR` atau `VARCHAR` string yang ingin Anda konversi ke nilai kode Soundex Amerika.
## Jenis pengembalian
VARCHAR(4)
## Catatan penggunaan
Fungsi SOUNDEX hanya mengkonversi huruf kecil alfabet bahasa Inggris dan huruf besar ASCII karakter, termasuk a—z dan A—Z. SOUNDEX mengabaikan karakter lain. SOUNDEX mengembalikan nilai Soundex tunggal untuk string beberapa kata yang dipisahkan oleh spasi.
```
SELECT SOUNDEX('AWS Amazon');
+---------+
| soundex |
+---------+
| A252 |
+---------+
```
SOUNDEX mengembalikan string kosong jika string input tidak mengandung huruf bahasa Inggris.
```
SELECT SOUNDEX('+-*/%');
+---------+
| soundex |
+---------+
| |
+---------+
```
## Contoh
Untuk mengembalikan nilai Soundex untuk`Amazon`, gunakan contoh berikut.
```
SELECT SOUNDEX('Amazon');
+---------+
| soundex |
+---------+
| A525 |
+---------+
```
Untuk mengembalikan nilai Soundex untuk `smith` dan`smyth`, gunakan contoh berikut. Perhatikan bahwa nilai Soundex adalah sama.
```
SELECT SOUNDEX('smith'), SOUNDEX('smyth');
+-------+-------+
| smith | smyth |
+-------+-------+
| S530 | S530 |
+-------+-------+
```
# 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 STRPOS
Mengembalikan posisi substring dalam string tertentu.
Lihat [Fungsi CHARINDEX](r_CHARINDEX.md) dan [Fungsi POSISI](r_POSITION.md) untuk fungsi serupa.
## Sintaksis
```
STRPOS(string, substring )
```
## Argumen
*tali*
Parameter input pertama adalah `VARCHAR` string `CHAR` atau yang akan dicari.
*substring*
Parameter kedua adalah substring untuk mencari di dalam *string*.
## Jenis pengembalian
INTEGER
Fungsi STRPOS mengembalikan yang `INTEGER` 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
*STRPOS kembali `0` jika *substring* tidak ditemukan dalam string.*
```
SELECT STRPOS('dogfish', 'fist');
+--------+
| strpos |
+--------+
| 0 |
+--------+
```
## Contoh
Untuk menunjukkan posisi `fish` dalam`dogfish`, gunakan contoh berikut.
```
SELECT STRPOS('dogfish', 'fish');
+--------+
| strpos |
+--------+
| 4 |
+--------+
```
Contoh berikut menggunakan data dari tabel PENJUALAN dalam database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk mengembalikan jumlah transaksi penjualan dengan KOMISI lebih dari 999.00 dari tabel PENJUALAN, gunakan contoh berikut.
```
SELECT DISTINCT STRPOS(commission, '.'),
COUNT (STRPOS(commission, '.'))
FROM sales
WHERE STRPOS(commission, '.') > 4
GROUP BY STRPOS(commission, '.')
ORDER BY 1, 2;
+--------+-------+
| strpos | count |
+--------+-------+
| 5 | 629 |
+--------+-------+
```
# Fungsi STRTOL
Mengkonversi ekspresi string dari sejumlah basis yang ditentukan ke nilai integer setara. Nilai yang dikonversi harus berada dalam kisaran 64-bit yang ditandatangani.
## Sintaksis
```
STRTOL(num_string, base)
```
## Argumen
*num\$1string*
Ekspresi string dari angka yang akan dikonversi. Jika *num\$1string* kosong (`''`) atau dimulai dengan karakter null (`'\0'`), nilai yang dikonversi adalah. `0` Jika *num\$1string* adalah kolom yang berisi nilai NULL, STRTOL kembali. `NULL` String dapat dimulai dengan sejumlah spasi putih, secara opsional diikuti oleh tanda plus '`+`' atau minus `-` 'tunggal untuk menunjukkan positif atau negatif. Defaultnya adalah '`+`'. Jika *basisnya*`16`, string secara opsional dapat dimulai dengan '`0x`'.
*dasar*
`INTEGER`antara 2 dan 36.
## Jenis pengembalian
BIGINT
Jika *num\$1string* adalah null, fungsi kembali. `NULL`
## Contoh
Untuk mengonversi pasangan string dan nilai dasar menjadi bilangan bulat, gunakan contoh berikut.
```
SELECT STRTOL('0xf',16);
+--------+
| strtol |
+--------+
| 15 |
+--------+
SELECT STRTOL('abcd1234',16);
+------------+
| strtol |
+------------+
| 2882343476 |
+------------+
SELECT STRTOL('1234567', 10);
+---------+
| strtol |
+---------+
| 1234567 |
+---------+
SELECT STRTOL('1234567', 8);
+--------+
| strtol |
+--------+
| 342391 |
+--------+
SELECT STRTOL('110101', 2);
+--------+
| strtol |
+--------+
| 53 |
+--------+
SELECT STRTOL('\0', 2);
+--------+
| strtol |
+--------+
| 0 |
+--------+
```
# 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(character_string FROM start_position [ FOR number_characters ] )
```
```
SUBSTRING(character_string, start_position, number_characters )
```
```
SUBSTRING(binary_expression, start_byte, number_bytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## Argumen
*character\$1string*
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.
*number\$1characters*
Jumlah karakter untuk mengekstrak (panjang substring). *Number\$1characters* didasarkan pada jumlah karakter, bukan byte, sehingga karakter multi-byte dihitung sebagai karakter tunggal. Angka ini tidak bisa negatif.
*binary\$1expression*
Binary\$1expression dari tipe data VARBYTE yang akan dicari.
*start\$1byte*
Posisi dalam ekspresi biner untuk memulai ekstraksi, mulai dari 1. Angka ini bisa negatif.
*number\$1bytes*
Jumlah byte untuk mengekstrak, yaitu, panjang substring. Angka ini tidak bisa negatif.
## Jenis pengembalian
VARCHAR atau VARBYTE tergantung pada input.
## Catatan Penggunaan
Berikut adalah beberapa contoh bagaimana Anda dapat menggunakan *start\$1position dan *number\$1characters** untuk mengekstrak substring dari berbagai posisi dalam string.
Contoh berikut mengembalikan string empat karakter dimulai dengan karakter keenam.
```
select substring('caterpillar',6,4);
substring
-----------
pill
(1 row)
```
Jika *start\$1position* \$1 *number\$1characters* melebihi panjang *string*, SUBSTRING mengembalikan substring mulai dari *start\$1position* hingga akhir string. Contoh:
```
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` `number_characters` \$1-1. `start_position` Contoh:
```
select substring('caterpillar',-2,6);
substring
-----------
cat
(1 row)
```
Jika `start_position` \$1 `number_characters` -1 kurang dari atau sama dengan nol, SUBSTRING mengembalikan string kosong. Contoh:
```
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 menunjukkan posisi awal negatif dari nilai biner`abc`. Karena posisi awal adalah -3, substring diekstraksi dari awal nilai biner. Hasilnya secara otomatis ditampilkan sebagai representasi heksadesimal dari substring biner.
```
select substring('abc'::varbyte, -3);
substring
-----------
616263
```
Contoh berikut menunjukkan 1 untuk posisi awal dari nilai biner`abc`. Karena karena tidak ada panjang yang ditentukan, string diekstraksi dari posisi awal hingga akhir string. Hasilnya secara otomatis ditampilkan sebagai representasi heksadesimal dari substring biner.
```
select substring('abc'::varbyte, 1);
substring
-----------
616263
```
Contoh berikut menunjukkan 3 untuk posisi awal dari nilai biner`abc`. Karena karena tidak ada panjang yang ditentukan, string diekstraksi dari posisi awal hingga akhir string. Hasilnya secara otomatis ditampilkan sebagai representasi heksadesimal dari substring biner.
```
select substring('abc'::varbyte, 3);
substring
-----------
63
```
Contoh berikut menunjukkan 2 untuk posisi awal dari nilai biner`abc`. String diekstraksi dari posisi awal ke posisi 10, tetapi ujung string berada pada posisi 3. Hasilnya secara otomatis ditampilkan sebagai representasi heksadesimal dari substring biner.
```
select substring('abc'::varbyte, 2, 10);
substring
-----------
6263
```
Contoh berikut menunjukkan 2 untuk posisi awal dari nilai biner`abc`. String diekstraksi dari posisi awal untuk 1 byte. Hasilnya secara otomatis ditampilkan sebagai representasi heksadesimal dari substring biner.
```
select substring('abc'::varbyte, 2, 1);
substring
-----------
62
```
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 TEXTLEN
Sinonim dari fungsi LEN.
Lihat [Fungsi LEN](r_LEN.md).
# 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](r_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
Untuk mengganti beberapa karakter dalam string, gunakan contoh berikut.
```
SELECT TRANSLATE('mint tea', 'inea', 'osin');
+-----------+
| translate |
+-----------+
| most tin |
+-----------+
```
Contoh berikut menggunakan data dari tabel USERS dalam database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk mengganti tanda at (@) dengan titik untuk semua nilai dalam kolom, gunakan contoh berikut.
```
SELECT email, TRANSLATE(email, '@', '.') as obfuscated_email
FROM users LIMIT 10;
+---------------------------------------+---------------------------------------+
| email | obfuscated_email |
+---------------------------------------+---------------------------------------+
| Cum@accumsan.com | Cum.accumsan.com |
| lorem.ipsum@Vestibulumante.com | lorem.ipsum.Vestibulumante.com |
| non.justo.Proin@ametconsectetuer.edu | non.justo.Proin.ametconsectetuer.edu |
| non.ante.bibendum@porttitortellus.org | non.ante.bibendum.porttitortellus.org |
| eros@blanditatnisi.org | eros.blanditatnisi.org |
| augue@Donec.ca | augue.Donec.ca |
| cursus@pedeacurna.edu | cursus.pedeacurna.edu |
| at@Duis.com | at.Duis.com |
| quam@facilisisvitaeorci.ca | quam.facilisisvitaeorci.ca |
| mi.lorem@nunc.edu | mi.lorem.nunc.edu |
+---------------------------------------+---------------------------------------+
```
Untuk mengganti spasi dengan garis bawah dan menghapus periode untuk semua nilai dalam kolom, gunakan contoh berikut.
```
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 kosong atau karakter tertentu.
## Sintaksis
```
TRIM( [ BOTH | LEADING | TRAILING ] [trim_chars FROM ] string )
```
## Argumen
KEDUANYA \$1 MEMIMPIN \$1 TRAILING
(Opsional) Menentukan di mana untuk memangkas karakter dari. Gunakan KEDUANYA untuk menghapus karakter utama dan belakang, gunakan LEADING untuk menghapus karakter utama saja, dan gunakan TRAILING untuk menghapus karakter tertinggal saja. Jika parameter ini dihilangkan, karakter utama dan belakang dipangkas.
*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 `CHAR` string `VARCHAR` atau. Jika Anda menggunakan fungsi TRIM dengan perintah SQL, Amazon Redshift secara implisit mengonversi hasilnya menjadi. `VARCHAR` Jika Anda menggunakan fungsi TRIM dalam daftar SELECT untuk fungsi SQL, Amazon Redshift tidak secara implisit mengonversi hasilnya, dan Anda mungkin perlu melakukan konversi eksplisit untuk menghindari kesalahan ketidakcocokan tipe data. Lihat [Fungsi CAST](r_CAST_function.md) dan [Fungsi CONVERT](r_CONVERT_function.md) fungsi untuk informasi tentang konversi eksplisit.
## Contoh
Untuk memangkas bagian depan dan belakang kosong dari string` dog `, gunakan contoh berikut.
```
SELECT TRIM(' dog ');
+-------+
| btrim |
+-------+
| dog |
+-------+
```
Untuk memangkas bagian depan dan belakang kosong dari string` dog `, gunakan contoh berikut.
```
SELECT TRIM(BOTH FROM ' dog ');
+-------+
| btrim |
+-------+
| dog |
+-------+
```
Untuk menghapus tanda kutip ganda utama dari string`"dog"`, gunakan contoh berikut.
```
SELECT TRIM(LEADING '"' FROM'"dog"');
+-------+
| ltrim |
+-------+
| dog" |
+-------+
```
Untuk menghapus tanda kutip ganda dari string`"dog"`, gunakan contoh berikut.
```
SELECT TRIM(TRAILING '"' FROM'"dog"');
+-------+
| rtrim |
+-------+
| "dog |
+-------+
```
*TRIM menghapus salah satu karakter dalam *trim\$1chars* ketika mereka muncul di awal atau akhir string.* Contoh berikut memangkas karakter 'C', 'D', dan 'G' ketika mereka muncul di awal atau akhir VENUENAME, yang merupakan kolom. `VARCHAR` Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
```
SELECT venueid, venuename, TRIM('CDG' FROM venuename)
FROM venue
WHERE venuename LIKE '%Park'
ORDER BY 2
LIMIT 7;
+---------+----------------------------+---------------------------+
| venueid | venuename | btrim |
+---------+----------------------------+---------------------------+
| 121 | AT&T Park | AT&T 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 `VARCHAR` string 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. Misalnya, fungsi akan mengembalikan `VARCHAR` string jika input adalah `VARCHAR` string.
## Contoh
Contoh berikut menggunakan data dari tabel CATEGORY dalam database sampel TICKIT. Untuk informasi selengkapnya, lihat [Database sampel](c_sampledb.md).
Untuk mengonversi bidang CATNAME menjadi huruf besar, gunakan yang berikut ini.
```
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 |
+-----------+-----------+
```