Amazon Redshift ne prendra plus en charge la création de nouveaux Python à UDFs partir du patch 198. UDFs Le Python existant continuera de fonctionner jusqu'au 30 juin 2026. Pour plus d’informations, consultez le [ billet de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

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

L’opérateur LIKE compare une expression de chaîne, comme un nom de colonne, avec un modèle qui utilise les caractères génériques % (pourcentage) et \_ (soulignement). La correspondance de modèle LIKE couvre toute la chaîne. Pour faire correspondre une séquence à n’importe quel emplacement au sein d’une chaîne, le modèle doit commencer et finir par un signe %. 

LIKE est sensible à la casse, ILIKE ne l’est pas.

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

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

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

 *expression*   
Expression de caractère UTF-8 valide, comme un nom de colonne. 

LIKE \| ILIKE   
LIKE effectue une correspondance sensible à la casse. ILIKE effectue une correspondance de modèle non sensible à la casse pour les caractères UTF-8 (ASCII) codés sur un octet. Pour effectuer une correspondance de modèle non sensible à la casse pour les caractères codés sur plusieurs octets, utilisez la fonction [LOWER](r_LOWER.md) sur *expression* et *pattern* avec une condition LIKE.  
Contrairement aux prédicats de comparaison, tels que = et <>, les prédicats LIKE et ILIKE n’ignorent pas implicitement les espaces de fin. Pour ignorer les espaces de fin, utilisez RTRIM ou convertissez explicitement une colonne CHAR en VARCHAR.  
L’opérateur `~~` est équivalent à LIKE et `~~*` est équivalent à ILIKE. Les opérateurs `!~~` et `!~~*` sont également équivalents à NOT LIKE et NOT ILIKE.

 *pattern*   
Expression de caractère UTF-8 valide avec le modèle à mettre en correspondance. 

 *escape\_char*   
Expression de caractère qui utilise une séquence d’échappement pour les méta-caractères du modèle. La valeur par défaut est deux barres obliques inverses (’\\\\ »). 

Si *pattern* ne contient pas de méta-caractères, le modèle représente uniquement la chaîne elle-même ; dans ce cas, LIKE agit de même que l’opérateur d’égalité.

Les expressions de caractère peuvent avoir CHAR ou VARCHAR comme type de données. En cas de différence, Amazon Redshift convertit *pattern* au type de données de l’*expression*. 

LIKE prend en charge les méta-caractères de correspondance de modèle suivants : 


| Opérateur  | Description  | 
| --- | --- | 
| %  | Met en correspondance une séquence de zéro ou plusieurs caractères. | 
| \_ | Met en correspondance un seul caractère. | 

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

Le tableau suivant montre des exemples de correspondance de modèle avec LIKE :


| Expression  | Renvoie  | 
| --- | --- | 
| 'abc' LIKE 'abc' | True | 
| 'abc' LIKE 'a%' | True | 
| 'abc' LIKE '\_B\_' | False | 
| 'abc' ILIKE '\_B\_' | True | 
| 'abc' LIKE 'c%' | False | 

L’exemple suivant recherche toutes les villes dont le nom commence par « 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
...
```

L’exemple suivant recherche les utilisateurs dont le nom contient « ten » :

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

L’exemple suivant montre comment associer plusieurs modèles.

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

L’exemple suivant recherche villes dont les troisième et quatrième caractères sont « ea ». La commande utilise ILIKE pour démontrer l’insensibilité à la casse : 

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

L’exemple suivant utilise la chaîne d’échappement par défaut (\\\\) pour rechercher les chaînes qui incluent « start\_» (texte `start` suivi d’un trait de soulignement `_`) : 

```
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)
```

L’exemple suivant spécifie « ^ » comme caractère d’échappement, puis utilise ce dernier pour rechercher des chaînes qui incluent « start\_ » (texte `start` suivi d’un trait de soulignement `_`) : 

```
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)
```

L’exemple suivant utilise l’opérateur `~~*` pour effectuer une recherche non sensible à la casse (ILIKE) pour les villes commençant par « Ag ». 

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