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. # Conditions de correspondance de modèles **Topics** + [ # LIKE ](r_patternmatching_condition_like.md) + [ # SIMILAR TO ](pattern-matching-conditions-similar-to.md) + [ # Opérateurs POSIX ](pattern-matching-conditions-posix.md) Un opérateur de correspondance de modèle recherche une chaîne d’un modèle spécifié dans l’expression conditionnelle et retourne true ou false selon qu’il a trouvé ou non une correspondance. Amazon Redshift utilise trois méthodes pour la correspondance des modèles : + Expressions LIKE 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. LIKE effectue une correspondance sensible à la casse et ILIKE effectue une correspondance non sensible à la casse. + Expressions régulières SIMILAR TO L’opérateur SIMILAR TO correspond à une expression de chaîne avec un modèle d’expression régulière SQL standard, ce qui peut inclure un ensemble de métacaractères de correspondance de modèle incluant les deux pris en charge par l’opérateur LIKE. SIMILAR TO correspond à la totalité de la chaîne et effectue une correspondance sensible à la casse. + Expressions régulières POSIX Les expressions régulières POSIX fournissent un moyen plus puissant pour la correspondance de modèles que les opérateurs LIKE et SIMILAR TO. Les modèles d’expressions régulières POSIX peuvent correspondre à n’importe quelle partie de la chaîne et effectuent une correspondance sensible à la casse. La correspondance d’expressions régulières, à l’aide des opérateurs SIMILAR TO ou POSIX, est coûteuse en termes de calcul. Nous vous conseillons d’utiliser LIKE autant que possible, notamment lors du traitement d’un très grand nombre de lignes. Par exemple, les requêtes suivantes sont fonctionnellement identiques, mais la requête qui utilise LIKE s’exécute infiniment plus vite que la requête qui utilise une expression régulière : ``` select count(*) from event where eventname SIMILAR TO '%(Ring|Die)%'; select count(*) from event where eventname LIKE '%Ring%' OR eventname LIKE '%Die%'; ``` # LIKE 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 \$1 (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 ``` expression [ NOT ] LIKE | ILIKE pattern [ ESCAPE 'escape_char' ] ``` ## Arguments *expression* Expression de caractère UTF-8 valide, comme un nom de colonne. LIKE \$1 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\$1char* 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 (’\$1\$1 »). 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 : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_patternmatching_condition_like.html) ## Exemples Le tableau suivant montre des exemples de correspondance de modèle avec LIKE : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_patternmatching_condition_like.html) 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 (\$1\$1) pour rechercher les chaînes qui incluent « start\$1» (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\$1 » (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 ``` # SIMILAR TO L’opérateur SIMILAR TO met en correspondance une expression de chaîne, comme un nom de colonne, avec un modèle d’expression régulière SQL standard. Un modèle d’expression régulière SQL peut inclure un ensemble de méta-caractères de correspondance de modèle, y compris les deux pris en charge par l’opérateur [LIKE](r_patternmatching_condition_like.md). L’opérateur SIMILAR TO retourne true uniquement si son modèle correspond à l’ensemble de la chaîne, à la différence du comportement de l’expression régulière POSIX, où le modèle peut correspondre à n’importe quelle partie de la chaîne. SIMILAR TO effectue une correspondance sensible à la casse. **Note** La correspondance d’expression régulière à l’aide de SIMILAR TO est coûteuse en termes de calcul. Nous vous conseillons d’utiliser LIKE autant que possible, notamment lors du traitement d’un très grand nombre de lignes. Par exemple, les requêtes suivantes sont fonctionnellement identiques, mais la requête qui utilise LIKE s’exécute infiniment plus vite que la requête qui utilise une expression régulière : ``` select count(*) from event where eventname SIMILAR TO '%(Ring|Die)%'; select count(*) from event where eventname LIKE '%Ring%' OR eventname LIKE '%Die%'; ``` ## Syntaxe ``` expression [ NOT ] SIMILAR TO pattern [ ESCAPE 'escape_char' ] ``` ## Arguments *expression* Expression de caractère UTF-8 valide, comme un nom de colonne. SIMILAR TO SIMILAR TO effectue une correspondance sensible à la casse pour toute la chaîne de l’*expression*. *pattern* Expression de caractères UTF-8 valide représentant un modèle d’expression régulière SQL standard. *escape\$1char* Expression de caractères 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 (’\$1\$1 »). Si *pattern* ne contient pas de méta-caractères, le modèle représente uniquement la chaîne elle-même. 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*. SIMILAR TO prend en charge les méta-caractères de correspondance de modèle suivants : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/pattern-matching-conditions-similar-to.html) ## Exemples Le tableau suivant illustre des exemples de correspondance de modèle à l’aide de SIMILAR TO : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/pattern-matching-conditions-similar-to.html) L’exemple suivant recherche toutes les villes dont le nom contient « E » ou « H » : ``` SELECT DISTINCT city FROM users WHERE city SIMILAR TO '%E%|%H%' ORDER BY city LIMIT 5; city ----------------- Agoura Hills Auburn Hills Benton Harbor Beverly Hills Chicago Heights ``` L’exemple suivant utilise la chaîne d’échappement par défaut (« `\\` ») pour rechercher les chaînes qui incluent « `_` » : ``` SELECT tablename, "column" FROM pg_table_def WHERE "column" SIMILAR TO '%start\\_%' ORDER BY tablename, "column" LIMIT 5; tablename | column --------------------------+--------------------- stcs_abort_idle | idle_start_time stcs_abort_idle | txn_start_time stcs_analyze_compression | start_time stcs_auto_worker_levels | start_level stcs_auto_worker_levels | start_wlm_occupancy ``` Les exemples suivants spécifient « `^` » comme caractère d’échappement, puis utilise le caractère d’échappement pour rechercher des chaînes qui incluent « `_` » : ``` SELECT tablename, "column" FROM pg_table_def WHERE "column" SIMILAR TO '%start^_%' ESCAPE '^' ORDER BY tablename, "column" LIMIT 5; tablename | column --------------------------+--------------------- stcs_abort_idle | idle_start_time stcs_abort_idle | txn_start_time stcs_analyze_compression | start_time stcs_auto_worker_levels | start_level stcs_auto_worker_levels | start_wlm_occupancy ``` # Opérateurs POSIX Une expression régulière POSIX est une séquence de caractères qui spécifie un modèle de correspondance. Une chaîne correspond à une expression régulière si elle fait partie du jeu régulier décrit par l’expression régulière. Les expressions régulières POSIX fournissent un moyen plus puissant pour la correspondance de modèle que les opérateurs [LIKE](r_patternmatching_condition_like.md) et [SIMILAR TO](pattern-matching-conditions-similar-to.md). Les modèles d’expressions régulières POSIX peuvent correspondre à une partie quelconque d’une chaîne, contrairement à l’opérateur SIMILAR TO, qui retourne true uniquement si son modèle correspond à la totalité de la chaîne. **Note** La correspondance d’expressions régulières à l’aide des opérateurs POSIX est coûteuse en termes de calcul. Nous vous conseillons d’utiliser LIKE autant que possible, notamment lors du traitement d’un très grand nombre de lignes. Par exemple, les requêtes suivantes sont fonctionnellement identiques, mais la requête qui utilise LIKE s’exécute infiniment plus vite que la requête qui utilise une expression régulière : ``` select count(*) from event where eventname ~ '.*(Ring|Die).*'; select count(*) from event where eventname LIKE '%Ring%' OR eventname LIKE '%Die%'; ``` ## Syntaxe ``` expression [ ! ] ~ pattern ``` ## Arguments *expression* Expression de caractère UTF-8 valide, comme un nom de colonne. \$1 Opérateur de négation. Ne correspond pas à l’expression régulière. \$1 Effectuez une correspondance sensible à la casse pour une sous-chaîne d’*expression*. `~~` est un synonyme pour [LIKE](r_patternmatching_condition_like.md). *pattern* Chaîne littérale qui représente un modèle d’expression régulière. Si *pattern* ne contient pas de caractères génériques, le modèle représente uniquement la chaîne elle-même. Pour rechercher des chaînes qui incluent des méta-caractères, tels que « `. * | ? ` », et ainsi de suite, faites précéder le caractère de la séquence d’échappement composée de deux barres obliques inverses « ` \\`  »). Contrairement à `SIMILAR TO` et `LIKE`, la syntaxe des expressions régulières POSIX ne gère pas de caractère d’échappement défini par l’utilisateur. 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*. Toutes les expressions de caractères peuvent avoir CHAR ou VARCHAR comme type de données. Si les expressions diffèrent par le type de données, Amazon Redshift les convertit au type de données de l’*expression*. Le modèle de correspondance POSIX prend en charge les méta-caractères suivants : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/pattern-matching-conditions-posix.html) Amazon Redshift prend en charge les classes de caractères POSIX suivantes. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/pattern-matching-conditions-posix.html) Amazon Redshift prend en charge les opérateurs suivants, influencés par Perl, dans les expressions régulières. Échappez l’opérateur à l’aide de deux barres obliques inverses («  »). (‘`\\`’).   [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/pattern-matching-conditions-posix.html) ## Exemples Le tableau suivant montre des exemples de correspondance de modèle à l’aide des opérateurs POSIX : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/pattern-matching-conditions-posix.html) L’exemple suivant recherche toutes les villes dont le nom contient `E` ou `H` : ``` SELECT DISTINCT city FROM users WHERE city ~ '.*E.*|.*H.*' ORDER BY city LIMIT 5; city ----------------- Agoura Hills Auburn Hills Benton Harbor Beverly Hills Chicago Heights ``` L’exemple suivant recherche toutes les villes dont le nom ne contient pas `E` ou `H` : ``` SELECT DISTINCT city FROM users WHERE city !~ '.*E.*|.*H.*' ORDER BY city LIMIT 5; city ----------------- Aberdeen Abilene Ada Agat Agawam ``` L’exemple suivant utilise la chaîne d’échappement (« `\\` ») pour rechercher les chaînes qui incluent un point. ``` SELECT venuename FROM venue WHERE venuename ~ '.*\\..*' ORDER BY venueid; venuename ------------------------------ St. Pete Times Forum Jobing.com Arena Hubert H. Humphrey Metrodome U.S. Cellular Field Superpages.com Center E.J. Nutter Center Bernard B. Jacobs Theatre St. James Theatre ```