Amazon Redshift tidak akan lagi mendukung penggunaan Python UDF setelah 30 Juni 2026. Kami akan mulai menegakkannya secara bertahap. Untuk informasi lebih lanjut tentang detail opsi akhir masa pakai dan migrasi Python, 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/) yang diterbitkan pada 30 Juni 2025. 

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# SUKA
<a name="r_patternmatching_condition_like"></a>

Operator LIKE membandingkan ekspresi string, seperti nama kolom, dengan pola yang menggunakan karakter wildcard% (persen) dan \_ (garis bawah). Pencocokan pola LIKE selalu mencakup seluruh string. Untuk mencocokkan urutan di mana saja dalam string, pola harus dimulai dan diakhiri dengan tanda persen. 

LIKE peka huruf besar/kecil; ILIKE tidak peka huruf besar/kecil.

## Sintaksis
<a name="r_patternmatching_condition_like-synopsis"></a>

```
expression [ NOT ] LIKE | ILIKE pattern [ ESCAPE 'escape_char' ]
```

## Argumen
<a name="r_patternmatching_condition_like-arguments"></a>

 *ekspresi*   
Eksp UTF-8 resi karakter yang valid, seperti nama kolom. 

SUKA \| ILIKE   
LIKE melakukan kecocokan pola peka huruf besar-kecil. ILIKE melakukan pencocokan pola yang tidak peka huruf besar/kecil untuk karakter single-byte UTF-8 (ASCII). Untuk melakukan pencocokan pola yang tidak peka huruf besar/kecil untuk karakter multibyte, gunakan [ fungsi ](r_LOWER.md) LOWER pada * ekspresi * dan * pola * dengan kondisi LIKE.  
Berbeda dengan predikat perbandingan, seperti = dan <>, predikat LIKE dan ILIKE tidak secara implisit mengabaikan spasi akhir. Untuk mengabaikan spasi akhir, gunakan RTRIM atau secara eksplisit memberikan kolom CHAR ke VARCHAR.  
`~~`Operator setara dengan LIKE, dan `~~*` setara dengan ILIKE. Juga `!~~*` operator `!~~` dan setara dengan NOT LIKE dan NOT ILIKE.

 *pola *   
Ekspresi UTF-8 karakter yang valid dengan pola yang akan dicocokkan. 

 *escape\_char *   
Ekspresi karakter yang akan lolos dari karakter metakarakter dalam pola. Defaultnya adalah dua garis miring terbalik ('\\\\'). 

Jika * pola * tidak mengandung metakarakter, maka pola hanya mewakili string itu sendiri; dalam hal ini LIKE bertindak sama dengan operator yang sama.

Salah satu ekspresi karakter dapat berupa tipe data CHAR atau VARCHAR. Jika berbeda, Amazon Redshift mengon * versi pola * ke tipe data * ekspresi*. 

LIKE mendukung metakarakter pencocokan pola berikut: 


| Operator  | Deskripsi  | 
| --- | --- | 
| %  | Cocokkan urutan nol atau lebih karakter. | 
| \_ | Cocokkan dengan karakter tunggal. | 

## Contoh
<a name="r_patternmatching_condition_like-examples"></a>

Tabel berikut menunjukkan contoh pencocokan pola menggunakan LIKE:


| Ekspresi  | Pengembalian  | 
| --- | --- | 
| 'abc' LIKE 'abc' | True | 
| 'abc' LIKE 'a%' | Benar | 
| 'abc' LIKE '\_B\_' | Salah | 
| 'abc' ILIKE '\_B\_' | Benar | 
| 'abc' LIKE 'c%' | False | 

Contoh berikut menemukan semua kota yang namanya dimulai dengan “E”: 

```
select distinct city from users
where city like 'E%' order by city;
city
---------------
East Hartford
East Lansing
East Rutherford
East St. Louis
Easthampton
Easton
Eatontown
Eau Claire
...
```

Contoh berikut menemukan pengguna yang nama belakangnya berisi “sepuluh”:

```
select distinct lastname from users
where lastname like '%ten%' order by lastname;
lastname
-------------
Christensen
Wooten
...
```

Contoh berikut menunjukkan bagaimana untuk mencocokkan beberapa pola.

```
select distinct lastname from tickit.users
where lastname like 'Chris%' or lastname like '%Wooten' order by lastname;
lastname
-------------
Christensen
Christian
Wooten
...
```

Contoh berikut menemukan kota yang karakter ketiga dan keempatnya adalah “ea”. Perintah menggunakan ILIKE untuk menunjukkan ketidakpekaan huruf besar/kecil: 

```
select distinct city from users where city ilike '__EA%' order by city;
city
-------------
Brea
Clearwater
Great Falls
Ocean City
Olean
Wheaton
(6 rows)
```

Contoh berikut menggunakan string escape default (\\\\) untuk mencari string yang menyertakan “start\_” (teks `start` diikuti oleh garis bawah): `_` 

```
select tablename, "column" from pg_table_def 
where "column" like '%start\\_%'
limit 5;

     tablename     |    column
-------------------+---------------
 stl_s3client      | start_time
 stl_tr_conflict   | xact_start_ts
 stl_undone        | undo_start_ts
 stl_unload_log    | start_time
 stl_vacuum_detail | start_row
(5 rows)
```

Contoh berikut menentukan '^' sebagai karakter escape, kemudian menggunakan karakter escape untuk mencari string yang menyertakan “start\_” (teks `start` diikuti oleh garis bawah`_`): 

```
select tablename, "column" from pg_table_def 
where "column" like '%start^_%' escape '^' 
limit 5;

     tablename     |    column
-------------------+---------------
 stl_s3client      | start_time
 stl_tr_conflict   | xact_start_ts
 stl_undone        | undo_start_ts
 stl_unload_log    | start_time
 stl_vacuum_detail | start_row
(5 rows)
```

Contoh berikut menggunakan `~~*` operator untuk melakukan pencarian case-insensitive (ILIKE) untuk kota yang dimulai dengan “Ag”. 

```
select distinct city from users where city ~~* 'Ag%' order by city;
                   
city
------------
Agat	
Agawam	
Agoura Hills	
Aguadilla
```