Expressions régulières

S’applique à :case cochée oui Databricks SQL case cochée oui Databricks Runtime

Une expression régulière (regex) est un modèle qui décrit un ensemble de chaînes. Plusieurs Azure Databricks fonctions ET opérateurs SQL prennent une expression régulière pour faire correspondre, localiser, compter, extraire, remplacer ou fractionner du texte :

Les opérateurs like et ilike n’utilisent pas d’expressions régulières. Ils utilisent un langage de modèle plus simple basé sur _ et %.

Moteur Regex

Azure Databricks évalue les expressions régulières à l’aide du moteur Javajava.util.regex. Les modèles doivent suivre Java syntaxe d’expression régulière, qui est largement compatible avec les expressions régulières de style Perl, mais diffère dans certains détails. Pour obtenir la référence complète et faisant autorité, consultez la documentation de la classe JavaPattern.

Les sections suivantes décrivent les constructions les plus couramment utilisées.

Classes de caractères

Construction Matches
. Tout caractère unique à l’exception d’un terminateur de ligne (sauf si l’indicateur s est défini).
[abc] Un des caractères répertoriés : a, bou c.
[^abc] Tout caractère unique qui n’est pasa, bou c.
[a-z] Tout caractère de la plage a à travers z.
\d, \D Un chiffre ([0-9]) ; \D correspond à n’importe quel autre chiffre.
\w, \W Caractère de mot ([a-zA-Z_0-9]) ; \W correspond à n’importe quel caractère non-mot.
\s, \S Caractère d’espace blanc ; \S correspond à n’importe quel caractère non blanc.

Ancres et limites

Construction Matches
^ Début de l’entrée (ou d’une ligne avec l’indicateur m ).
$ Fin de l’entrée (ou d’une ligne avec l’indicateur m ).
\b, \B Limite de mot ; \B correspond à une limite non-word.

Quantificateurs

Les quantificateurs spécifient le nombre de fois où l’élément précédent doit correspondre. Par défaut, les quantificateurs sont gourmands et correspondent autant que possible. Ajoutez ? pour rendre un quantificateur réticent (faire correspondre le moins possible), par exemple .*?.

Construction Correspond à l’élément précédent...
* Zéro ou plusieurs fois.
+ Une ou plusieurs fois.
? Zéro ou une fois.
{n} Exactement n des fois.
{n,} Au moins n des fois.
{n,m} Entre n et m les temps.

Groupes et modification

Construction Description
(...) Un groupe de capture. Utilisez l’index de groupe avec regexp_extract.
(?:...) Un groupe de non-capture. Groupes sans capturer la correspondance.
a\|b Alternance. Correspond à l’une ou l’autre a ou b.

Indicateurs inline

Placez un indicateur au début du modèle pour modifier la façon dont le modèle entier est mis en correspondance.

Flag Résultat
(?i) Correspondance qui ne respecte pas la casse.
(?s) Mode Dotall. . correspond aux terminateurs de ligne.
(?m) Mode multiligne. ^ et $ correspondent aux sauts de ligne.
(?x) Mode Commentaires. Ignore les espaces blancs non bouctés dans le modèle.

Par exemple, (?i)ste(v\|ph)en correspond Steven, stevenet STEPHEN quel que soit le cas.

Échappement et littéraux de chaîne

Pour faire correspondre un caractère qui est également un métacharacteur regex (par .exemple, , , [*(, ou \), précèdez-le avec une barre oblique inverse. Par exemple, \. correspond à une période littérale et \\ correspond à une barre oblique inverse littérale.

Étant donné qu’une barre oblique inverse est également le caractère d’échappement dans les littéraux de chaîne SQL ordinaires, vous devez doubler chaque barre oblique inverse que vous envisagez de passer au moteur regex. Par exemple, pour passer le modèle \d+ à une fonction, écrivez-le comme '\\d+' dans un littéral de chaîne standard.

Pour éviter cette double échappement, utilisez un raw-literal (r préfixe) qui désactive le prétraitement des caractères d’échappement. Dans un littéral brut, écrivez le modèle exactement comme le moteur regex l’attend :

-- Regular string literal: backslashes must be doubled.
> SELECT regexp_substr('item 42 in stock', '\\d+');
 42

-- Raw literal: write the pattern as-is.
> SELECT regexp_substr('item 42 in stock', r'\d+');
 42

Modèles courants

Les modèles suivants couvrent les tâches fréquentes. Ils sont écrits en tant que littéraux bruts afin que les barres obliques inverses passent au moteur regex inchangé. Les modèles e-mail, URL et IP sont des illustrations intentionnellement simples, et non des validateurs stricts.

Objectif Pattern
Entier, éventuellement signé r'-?\d+'
Nombre décimal r'-?\d+(\.\d+)?'
Un mot r'\w+'
Le mot cat entier uniquement r'\bcat\b'
Adresse e-mail (simple) r'[\w.%+-]+@[\w.-]+\.\w{2,}'
Hôte dans une URL r'https?://([^/]+)'
Adresse IPv4 (ne vérifie pas 0 à 255) r'\d{1,3}(\.\d{1,3}){3}'
Date ISO (YYYY-MM-DD) r'\d{4}-\d{2}-\d{2}'
Espace blanc de début ou de fin r'^\s+\|\s+$'
Numéro de téléphone américain (simple) r'\d{3}-\d{3}-\d{4}'

Word limites (\b) correspondent à une word entière plutôt qu’à une sous-chaîne :

-- 'cat' as a standalone word
> SELECT 'the cat sat on the mat' rlike r'\bcat\b';
 true

-- 'cat' only as part of a larger word
> SELECT 'category' rlike r'\bcat\b';
 false

Combinez un préfixe littéral avec un quantificateur pour extraire un jeton structuré, tel qu’un ID d’ordre :

> SELECT regexp_substr('Ref: ORD-12345 shipped on 2024-03-15', r'ORD-\d+');
 ORD-12345

Choisir la fonction appropriée

Utilisez ce tableau pour sélectionner la fonction qui correspond à votre objectif.

Vous voulez... Utiliser
Testez si une chaîne correspond. rlike / Regexp / regexp_like
Retourne la première sous-chaîne correspondante. regexp_substr
Retourne un groupe de capture. regexp_extract
Retourne toutes les correspondances. regexp_extract_all
Retourne la position d’une correspondance. regexp_instr
Compter le nombre de correspondances. regexp_count
Remplacez les correspondances par d’autres textes. regexp_replace
Fractionner une chaîne autour des correspondances. split
Mettre en correspondance un modèle simple _ / % . Comme / Ilike