| Documentation PostgreSQL 8.0.25 | ||||
|---|---|---|---|---|
| Précédent | Arrière rapide | Chapitre 9. Fonctions et opérateurs | Avance rapide | Suivant |
Il existe trois différents approches aux correspondances de modèles fournies
par PostgreSQL: l'opérateur
SQL traditionnel
LIKE, le plus récent SIMILAR TO
(ajouté dans SQL:1999) et les expressions rationnelles
du type POSIX. De plus, une fonction de correspondance
de modèles, substring, est disponible. Elle utilise
soit le style SIMILAR TO soit le style POSIX des
expressions rationnelles.
Astuce : Si vous avez besoin des correspondances de modèles qui vont au delà de ça, considérez l'écriture d'une fonction en Perl ou Tcl.
LIKEchaîne LIKE modèle [ESCAPE caractère d'échappement] chaîne NOT LIKE modèle [ESCAPE caractère d'échappement]
Chaque modèle définit un ensemble de chaîne.
L'expression LIKE renvoie true si la
chaîne est contenu dans l'ensemble de chaînes
représenté par le modèle. (Comme attendu,
l'expression NOT LIKE renvoie false si
LIKE renvoie true et vice versa. Une expression
équivalente est NOT (chaîne LIKE
modèle).)
Si le modèle ne contient pas de signe de
pourcentage ou de tirets bas, alors le modèle représente seulement la
chaîne elle-même ; dans ce cas, LIKE agit
exactement comme l'opérateur d'égalité. Un tiret bas (_)
dans modèle correspond à un seul
caractère ; un signe de pourcentage (%) correspond
à toutes les chaînes de zéro à plus de caractères.
Quelques exemples :
'abc' LIKE 'abc' true 'abc' LIKE 'a%' true 'abc' LIKE '_b_' true 'abc' LIKE 'c' false
Le modèle LIKE correspond toujours à la chaîne
entière. Pour faire correspondre une séquence à l'intérieur d'une chaîne, le
modèle doit donc commencer et finir avec un signe de pourcentage.
Pour faire correspondre un vrai tiret bas ou un vrai signe de pourcentage sans qu'ils remplacent d'autres caractères, le caractère correspondant dans modèle doit être précédé du caractère d'échappement. Par défaut, il s'agit de l'antislash mais un autre caractère peut être sélectionné en utilisant la clause ESCAPE. Pour correspondre au caractère d'échappement lui-même, écrivez deux fois ce caractère.
Notez que l'antislash a déjà une signification particulière dans les
chaînes littérales, donc écrite une constante du modèle avec un antislash
signifie écrire quatre antislash dans l'instruction. Vous pouvez éviter
ceci en sélectionnant un autre caractère d'échappement avec
ESCAPE ; ensuite un antislash n'est plus spécial
dans un LIKE. (Mais il est toujours spécial dans
l'analyseur de chaînes littérales, donc vous aurez besoin des deux.)
Il est aussi possible de ne sélectionner aucun caractère d'échappement en écrivant ESCAPE ''. Ceci désactive complètement le mécanisme d'échappement, ce qui rend impossible la désactivation de la signification particulière du tiret bas et du signe de pourcentage dans le modèle.
Le mot clé ILIKE est utilisé à la place de LIKE pour faire des correspondances sans tenir compte de la casse mais en tenant compte de la locale active. Ceci ne fait pas partie du standard SQL mais est une extension PostgreSQL.
L'opérateur ~~ est équivalent à
LIKE alors que ~~* correspond à
ILIKE. Il existe aussi les opérateurs
!~~ et !~~* représentant
respectivement NOT LIKE et NOT
ILIKE. Tous ces opérateurs sont spécifiques à
PostgreSQL.
SIMILAR TOchaîne SIMILAR TO modèle [ESCAPE caractère d'échappement] chaîne NOT SIMILAR TO modèle [ESCAPE caractère d'échappement]
L'opérateur SIMILAR TO renvoie true ou false
suivant le fait que son modèle corresponde ou non à la chaîne donnée.
C'est identique à LIKE sauf qu'il interprète le
modèle en utilisant la définition SQL d'une expression rationnelle. Les
expressions rationnelles SQL99 sont un curieux mélange de la notation
LIKE et de la notation habituelle des
expressions rationnelles.
Comme LIKE, l'opérateur SIMILAR
TO réussit uniquement si son modèle correspond à la chaîne
entière ; ceci ne ressemble pas aux pratiques habituelles des
expressions rationnelles où le modèle peut se situer n'importe où dans la
chaîne. Ainsi comme LIKE, SIMILAR
TO utilise _ et % comme caractères
joker dénotant respectivement un caractère seul et toute chaîne (ils sont
comparables à . and .* dans les expressions
compatibles POSIX).
En plus de ces fonctionnalités empruntées à LIKE,
SIMILAR TO supporte trois méta-caractères de
correspondance de modèle empruntés aux expressions rationnelles de
POSIX :
| dénote une alternative (une des deux alternatives).
* dénote la répétition des précédents éléments, entre zéro et un nombre illimité de fois.
+ dénote la répétition des précédents éléments, entre une et un nombre illimité de fois.
Parenthèses () peuvent être utilisées pour grouper des éléments en un seul élément logique.
Une expression entre crochets [...] spécifie une classe de caractères, comme dans les expressions rationnelles POSIX.
Notez que les répétitions (? and {...}) ne sont pas permises bien qu'elles existent en POSIX. De même, le point (.) n'est pas un méta-caractère.
Comme avec LIKE, un antislash désactive la signification
spéciale de tous les méta-caractères ; un autre caractère
d'échappement peut être spécifié avec ESCAPE.
Quelques exemples :
'abc' SIMILAR TO 'abc' true 'abc' SIMILAR TO 'a' false 'abc' SIMILAR TO '%(b|d)%' true 'abc' SIMILAR TO '(b|c)%' false
La fonction substring avec trois paramètres,
substring(chaîne from
modèle for
caractère d'échappement), fournit une
extraction qu'une sous-chaîne correspondant à un
modèle d'expression rationnelle SQL. Comme avec
SIMILAR TO, le modèle spécifié doit correspondre à l'entière
chaîne de données, sinon la fonction échouera et renverra NULL. Pour
indiquer la partie du modèle qui devrait être renvoyée en cas de succès,
le modèle doit contenir deux occurrences du caractères d'échappement suivi
d'un guillemet double ("). Le texte correspondant à la portion
du modèle entre ces deux marqueurs est renvoyé.
Quelques exemples :
substring('foobar' from '%#"o_b#"%' for '#')
oob
substring('foobar' from '#"o_b#"%' for '#')
NULL
Tableau 9-11 liste les opérateurs disponibles pour la correspondance de modèles en utilisant les expressions rationnelles POSIX.
Tableau 9-11. Opérateurs de correspondance des expressions rationnelles
| Opérateur | Description | Exemple |
|---|---|---|
| ~ | Correspond à l'expression rationnelle, en tenant compte de la casse | 'thomas' ~ '.*thomas.*' |
| ~* | Correspond à l'expression rationnelle, sans tenir compte de la casse | 'thomas' ~* '.*Thomas.*' |
| !~ | Ne correspond pas à l'expression rationnelle, en tenant compte de la casse | 'thomas' !~ '.*Thomas.*' |
| !~* | Ne correspond pas à l'expression rationnelle, sans tenir compte de la casse | 'thomas' !~* '.*vadim.*' |
Les expressions rationnelles POSIX fournissent un moyen
plus puissant pour la correspondance de modèles par rapport aux opérateurs
LIKE et SIMILAR TO. Beaucoup d'outils
Unix comme egrep, sed ou
awk utilise un langage de correspondance de modèles
similaire à celui décrit ici.
Une expression rationnelle est une séquence de caractères qui est une
définition abrégée d'un ensemble de chaînes (un ensemble
rationnel). Une chaîne est dite correspondante à une
expression rationnelle si elle est membre de l'ensemble rationnel décrit
par l'expression rationnelle. Comme avec LIKE, les
caractères modèles correspondent exactement aux caractères de chaîne sauf
s'ils représentent des caractères spéciaux dans le langage des expressions
rationnelles mais les expressions rationnelles utilisant des caractères
spéciaux différents de ceux de LIKE. Contrairement
aux modèles pour LIKE, une expression rationnelle est
autorisée à correspondre quelque part dans la chaîne, sauf si l'expression
rationnelle est explicitement ancrée au début ou à la fin de la chaîne.
Quelques exemples :
'abc' ~ 'abc' true 'abc' ~ '^a' true 'abc' ~ '(b|d)' true 'abc' ~ '^(b|c)' false
La fonction substring avec deux paramètres,
substring(chaîne from
modèle), fournit une extraction
d'une sous-chaîne correspondant à un modèle d'expression rationnelle
POSIX. Il renvoie NULL s'il n'y a pas de correspondance et la portion
de texte correspondant au modèle dans le cas contraire. Mais si le modèle
contient des parenthèses, la portion de texte ayant correspondu à la
première sous-expression entre parenthèses (la première dont la parenthèse
gauche apparaît) est renvoyée. Vous pouvez placer ces parenthèses
entre l'expression complète si vous voulez utiliser des parenthèses à
l'intérieur sans déclencher cette exception. Si vous avez besoin des
parenthèses dans le modèle avant la sous-expression que vous voulez
extraire, voir les parenthèses sans capture décrites plus bas.
Quelques exemples :
substring('foobar' from 'o.b') oob
substring('foobar' from 'o(.)b') o
Les expressions rationnelles de PostgreSQL sont implémentées en utilisant un paquetage écrit par Henry Spencer. La plupart des descriptions d'expressions rationnelles ci-dessous sont copiés directement de sa page man.
Les expressions rationnelles (ERs), ainsi qu'elles sont définies dans POSIX 1003.2, viennent en deux formats : les ER étendues ou ERE (en gros celles de egrep) et les ER élémentaires ou ERB (principalement celles d'ed). PostgreSQL supporte les deux formes et implémente aussi quelques extensions ne faisant pas partie du standard POSIX mais devenant malgré tout de plus en plus populaire à cause de leur disponibilité dans les langages de programmation tels que Perl et Tcl. Les ER utilisant ces extensions non POSIX sont appelées des ER avancées ou des ARE dans cette documentation. Les ARE sont un surensemble exact des ERE alors que les ERB ont des incompatibilités de notation (en dehors du fait qu'elles sont bien plus limitées). Nous décrivons tout d'abord les formats ARE et ERE, notant les fonctionnalités qui s'appliquent seulement aux ARE et puis nous décrivons la différence avec les ERB.
Note : La forme des expressions rationnelles acceptées par PostgreSQL peut être choisie en initialisant le paramètres à l'exécution regex_flavor (décrit dans Section 16.4). La configuration habituelle est advanced (NdT : pour avancées) mais il est possible de sélectionner extended (pour étendues) avec un maximum de compatibilité avec les versions antérieures à la 7.4 de PostgreSQL.
Une expression rationnelle est définie par une ou plusieurs branches branches séparées par des caractères |. Elle établit une correspondance avec tout ce qui correspond à une des branches.
Une branche contient des atomes quantifiés ou des contraintes, concaténés. Elle établit une correspondance pour le premier suivie d'une correspondance pour le second, etc ; une branche vide établit une correspondance avec une chaîne vide.
Un atome quantifié est un atome suivi le cas échéant d'un seul quantificateur. Sans quantificateur, il établit une correspondance avec l'atome. Avec un quantificateur, il peut établir autant de correspondances avec l'atome que possible. Un atome peut être toute possibilité montrée dans Tableau 9-12. Les quantifieurs possibles et leurs significations sont disponibles dans Tableau 9-13.
Une contrainte correspond à une chaîne vide mais correspond seulement si des conditions spécifiques sont rencontrées. Une contrainte peut être utilisée mais elle ne peut pas être suivie d'un quantificateur. Les contraintes simples sont affichées dans Tableau 9-14 ; quelques contraintes supplémentaires sont décrites après.
Tableau 9-12. Atomes d'expressions rationnelles
| Atome | Description |
|---|---|
| (re) | (où re est toute expression rationnelle) établie une correspondance avec re, la correspondance étant conservée pour un rapport possible |
| (?:re) | comme ci-dessus mais la correspondance n'est pas conservée (un ensemble de parenthèses << sans capture >>) (seulement ARE) |
| . | correpond à tout caractère seul |
| [caractères] | une expression entre crochets, correspondant à n'importe lequel des caractères (voir Section 9.7.3.2 pour plus de détails) |
| \k | (où k est tout sauf un caractère alpha-numérique) établit une correspondance avec un caractère ordinaire, c'est-à-dire \\ correspond à un caractère antislash |
| \c | où c est un caractère alphanumérique (probablement suivi d'autres caractères) est un échappement, voir Section 9.7.3.3 (ARE seulement ; pour les ERE et ERB, ceci correspond à c) |
| { | lorsqu'il est suivi d'un caractère autre qu'un chiffre, établit une correspondance avec l'accolade ouvrante { ; si elle est suivie d'un chiffre, c'est le début d'une limite (voir ci-dessous) |
| x | où x est un simple caractère sans signification et correspondant donc à ce caractère |
Une ER pourrait ne pas terminer avec \.
Note : Rappelez-vous que l'antislash (\) a déjà une signification particulière dans les chaînes littérales PostgreSQL. Pour écrire un modèle constant contenant un antislash, vous devez écrire deux antislashs dans l'instruction.
Tableau 9-13. Quantifiant d'expressions rationnelles
| Quantifiant | Correspondance |
|---|---|
| * | une séquence de 0 ou plus correspondance de l'atome |
| + | une séquence de 1 ou plus correspondance de l'atome |
| ? | une séquence 0 ou 1 correspondance de l'atome |
| {m} | une séquence d'exactement m correspondance de l'atome |
| {m,} | une séquence de m ou plus correspondance de l'atome |
| {m,n} | une séquence de m à n (inclus) correspondance de l'atome ; m ne doit pas être supérieur à n |
| *? | version non gourmande de * |
| +? | version non gourmande de + |
| ?? | version non gourmande de ? |
| {m}? | version non gourmande de {m} |
| {m,}? | version non gourmande de {m,} |
| {m,n}? | version non gourmande de {m,n} |
Les formes utilisant {...} sont connues comme des limites. Les nombres m et n à l'intérieur d'une limite sont des entiers décimaux non signés avec des droits allant de 0 à 255 inclus.
Les quantificateurs non gourmands (disponibles uniquement avec les ERA) correspondent aux même possibilités que leur équivalent normal (gourmand) mais préfèrent le plus petit nombre plutôt que le plus grand nombre de correspondance. Voir Section 9.7.3.5 pour plus de détails.
Note : Un quantificateur ne peut pas immédiatement suivre un autre quantificateur. Un quantificateur ne peut pas commencer une expression ou une sous-expression ou suivre ^ ou |.
Tableau 9-14. Contraintes des expressions rationnelles
| Contrainte | Description |
|---|---|
| ^ | correspond au début d'une chaîne |
| $ | correspond à la fin d'une chaîne |
| (?=re) | positive lookahead correspond à tout point où une sous-chaîne correspondant à re commence (uniquement pour les ERA) |
| (?!re) | negative lookahead correspond à tout point où aucune sous-chaîne correspondant à re commence (uniquement pour les ERA) |
Les contraintes << lookahead >> ne doivent pas contenir de références arrières (voir Section 9.7.3.3), et toutes les parenthèses contenues sont considérées comme non capturantes.
Une expression entre crochets est une liste de caractères contenus dans []. Cela correspond normalement à tout caractère de la liste (mais voir plus bas). Si la liste commence avec ^, cela correspond à tout caractère non compris dans la liste. Si deux caractères de la liste sont séparés par un tiret (-), c'est un raccourci pour tous les caractères compris entre ces deux, c'est-à-dire qu'en ASCII, [0-9] correspond à tout chiffre. Il est illégal d'avoir deux séquences partageant la même fin, par exemple a-c-e. Ces séquences dépendent grandement de la façon dont elles sont créées, les programmes portables devraient donc éviter leur utilisation.
Pour inclure un littéral ] dans la liste, faites en sorte qu'il soit le premier caractère (suivant un possible ^). Pour inclure un littéral -, faites en sorte qu'il soit le premier ou le dernier caractère, ou qu'il soit dans le deuxième point final d'une séquence. Pour utiliser un littéral - comme premier point final d'une séquence, englobez-le dans [. et .] pour en faire un élément de cohésion (voir ci-dessous). Avec l'exception de ces caractères, quelques combinaisons utilisant [ (voir les paragraphes suivants) et les échappements (uniquement pour les ERA), tous les autres caractères spéciaux perdent leur signification spéciale à l'intérieur d'une expression entre crochets. En particulier, \ n'est pas spécial lorsqu'il suit les règles des ERE ou des ERB bien qu'il soit spécial (en tant qu'introduction d'un échappement) dans les ERA.
À l'intérieur d'une expression entre crochets, un élément liant (un caractère, une séquence de caractères multiples qui se suivent comme s'il n'y avait qu'un seul caractère, ou le nom d'une séquence liée) englobé dans [. et .] correspond à une séquence de caractères de cet élément liant. La séquence est un simple élément de la liste de l'expression entre crochets. Une expression entre crochets contenant un élément liant avec plusieurs caractères peut donc correspondre à plus d'un caractère, c'est-à-dire que si la séquence liante inclut un élément liant ch, alors la ER [[.ch.]]*c établit une correspondance avec les cinq premiers caractères de chchcc.
Note : PostgreSQL n'a pas d'éléments multi-caractères qui se suivent. Cette information décrit les comportements futurs possibles.
À l'intérieur d'une expression entre crochets, un élément liant englobé dans [= et =] est une classe d'équivalence, correspondant aux séquences de caractères de tous les éléments liant équivalent à celui-là, lui-même étant compris. (S'il n'existe pas d'éléments liants correspondants, le traitement est comme si les délimiteurs englobant étaient [. et .].) Par exemple, si o et ^ sont les membres d'une classe d'équivalence, alors [[=o=]], [[=^=]] et [o^] sont tous synonymes. Une classe d'équivalence ne peut pas être le point final d'une séquence.
À l'intérieur d'une expression entre crochets, le nom d'une classe de caractères englobé dans [: et :] correspond à la liste de tous les caractères appartenant à cette classe. Les noms de classes de caractères standards sont alnum, alpha, blank, cntrl, digit, graph, lower, print, punct, space, upper, xdigit. Ils correspondent aux classes de caractère définies dans ctype. Une locale pourrait en fournir d'autres. Une classe de caractères pourrait ne pas être utilisée comme point final d'une séquence.
Il existe deux cas spéciaux d'expressions entre crochets : les expressions entre crochets [[:<:]] et [[:>:]] sont contraintes, correspondant à des chaînes vides respectivement au début et à la fin d'un mot. Un mot est défini comme une séquence de caractères qui n'est ni précédée ni suivie de caractères. Un caractère de mot est un caractère alnum (comme défini par ctype) ou un tiret bas. C'est une extension, compatible avec mais non spécifiée dans POSIX 1003.2, et devrait être utilisé avec précaution dans les logiciels conçus pour être portables sur d'autres systèmes. Les échappements de contraintes décrites ci-dessous sont généralement préférables (elles ne sont pas plus standard mais elles sont certainement plus simple à saisir).
Les échappements sont des séquences spéciales commençant avec \ et suivies d'un caractère alphanumérique. Les échappements viennent en plusieurs variétés : entrée de caractère, raccourci de classe et références. Un \ suivi d'un caractère alphanumérique mais ne constituant pas un échappement valide est illégal dans une ERA. Pour les ERE, il n'y pas d'échappement : en dehors d'une expression entre crochets, un \ suivi d'un caractère alphanumérique signifie simplement ce caractère (ordinaire) et, à l'intérieur d'une expression entre crochets, \ est un caractère ordinaire. (ce dernier est la vraie incompatibilité entre les ERE et les ERA.)
Les échappements d'entrée de caractères existent pour faciliter la spécification de caractères non affichables ou indésirables pour toute autre raison dans les ER. Ils sont disponibles dans Tableau 9-15.
Les échappements de raccourci de classes fournissent des raccourcis pour des classes de caractères communément utilisées. Ils sont disponibles dans Tableau 9-16.
Un échappement à contrainte est une contrainte, correspondant à la chaîne vide si les conditions spécifiques sont rencontrées, écrite avec un échappement. Ils sont disponibles dans Tableau 9-17.
Une référence (\n) correspond à la même chaîne que la sous-expression précédente entre parenthèses spécifiée par le nombre n (voir Tableau 9-18). Par exemple, ([bc])\1 correspond à bb ou cc mais ni bc ni cb. La sous-expression doit complètement précédée la référence dans la ER. Les sous-expressions sont numérotées dans l'ordre des parenthèses ouvrantes. Les parenthèses non capturantes ne définissent pas de sous-expressions.
Note : Gardez à l'esprit qu'un symbole d'échappement \ devra être doublé si vous souhaitez le saisir comme une chaîne SQL constante. Par exemple :
'123' ~ '^\\d{3}' true
Tableau 9-15. Échappements d'entrée de caractère des expressions rationnelles
| Échappement | Description |
|---|---|
| \a | caractère alerte (sonnerie), comme en C |
| \b | effacement, comme en C |
| \B | synonyme de \ pour aider à la réduction des doubles antislashs |
| \cX | (où X est un caractère quelconque) le caractère dont les 5 bits de poids faible sont les mêmes que ceux de X et dont tous les autres bits sont à zéro |
| \e | le caractère dont le nom de séquence liante est ESC ou, en dehors de ça, le caractère de valeur octale 033 |
| \f | retour chariot, comme en C |
| \n | retour à la ligne, comme en C |
| \r | retour à la ligne, comme en C |
| \t | tabulation horizontale, comme en C |
| \uwxyz | (où wxyz est exactement quatre chiffres hexadécimaux) le caractère Unicode U+wxyz dans l'ordre des octets locaux |
| \Ustuvwxyz | (où stuvwxyz représentent exactement huit chiffres hexadécimaux) réservé pour une extension Unicode vers le 32 bits, un peu hypothétique |
| \v | tabulation verticale, comme en C |
| \xhhh | (où hhh est toute séquence de chiffres hexadécimaux) le caractère dont la valeur hexadécimale est 0xhhh (un simple caractère, peu importe le nombre de chiffres hexadécimaux utilisés) |
| \0 | le caractère dont la valeur est 0 |
| \xy | (où xy représente exactement deux chiffres octaux et qui n'est pas une référence) le caractère dont la valeur octale est 0xy |
| \xyz | (où xyz représente exactement trois chiffres octaux et qui n'est pas une référence) le caractère dont la valeur octale est 0xyz |
Les chiffres hexadécimaux sont 0-9, a-f et A-F. Les chiffres octaux sont 0-7.
Les échappements d'entrée de caractères sont toujours pris comme des caractères ordinaires. Par exemple, \135 est ] en ASCII mais \135 ne termine pas une expression entre crochets.
Tableau 9-16. Échappement de raccourcis de classes des expressions rationnelles
| Échappement | Description |
|---|---|
| \d | [[:digit:]] |
| \s | [[:space:]] |
| \w | [[:alnum:]_] (notez que le tiret bas est inclus) |
| \D | [^[:digit:]] |
| \S | [^[:space:]] |
| \W | [^[:alnum:]_] (notez que le tiret bas est inclus) |
À l'intérieur d'expressions entre crochets, \d, \s, et \w perdent leurs crochets externes, et \D, \S et \W sont illégales. (Donc, par exemple, [a-c\d] est équivalent à [a-c[:digit:]]. De plus, [a-c\D], qui est équivalent à [a-c^[:digit:]], est illégal.)
Tableau 9-17. Échappements de contraintes des expressions rationnelles
| Échappement | Description |
|---|---|
| \A | correspond seulement au début de la chaîne (voir Section 9.7.3.5 pour comprendre comment ceci diffère de ^) |
| \m | correspond seulement au début d'un mot |
| \M | correspond seulement à la fin d'un mot |
| \y | correspond seulement au début ou à la fin d'un mot |
| \Y | correspond seulement à un point qui n'est ni le début ni la fin d'un mot |
| \Z | correspond seulement à la fin d'une chaîne (voir Section 9.7.3.5 pour comprendre comment ceci diffère de $) |
Un mot est défini suivant la spécification de [[:<:]] et [[:>:]] ci-dessus. Les contraintes d'échappements sont illégales à l'intérieur d'expressions entre crochets.
Tableau 9-18. Références dans les expressions rationnelles
| Échappement | Description |
|---|---|
| \m | (où m est un chiffre différent de zéro) une référence de la mème sous-expression |
| \mnn | (où m est un chiffre différent de zéro et nn quelques chiffres supplémentaires et la valeur décimale mnn n'est pas plus grande que le nombre de parenthèses fermantes capturantes vues jusqu'à maintenant) une référence de la mnnème sous-expression |
Note : Il existe une ambiguïté historique inhérente entre les échappements d'entrée de caractères en octal et les référencées, ambiguïté résolue par des heuristiques, comme montré ci-dessus. Un zéro en début indique toujours un échappement octal. Un seul caractère différent de zéro et suivi d'un autre caractère est toujours pris comme une référence. Une séquence à plusieurs chiffres ne commençant pas avec un zéro est pris comme une référence si une sous-expression convenable (c'est-à-dire que le nombre fait partie des numéros de référence). Dans le cas contraire, il est pris pour un nombre octal.
En plus de la syntaxe principale décrite ci-dessus, il existe quelques formes spéciales et autres possibilités syntaxiques disponibles.
Normalement, la recette de ER en cours d'utilisation est déterminé par regex_flavor. Néanmoins, cela peut être surchargé par un préfixe directeur. Si un ER commence avec ***:, le reste de l'ER est considéré comme une ERA, quelque soit regex_flavor. Si un ER commence avec ***=, le reste de l'ER est considéré comme une chaîne littérale, tous les caractères étant donc considérés ordinaires.
Une ERA pourrait commencer avec des options intégrées : une séquence (?xyz) (où xyz correspond à un ou plusieurs caractères alphabétiques) spécifie les options affectant le reste de l'ER. Ces options surchargent toutes options précédemment déterminées (incluant le type de l'ER et la sensibilité à la casse). Les lettres d'options disponibles sont indiquées dans Tableau 9-19.
Tableau 9-19. Lettres d'option intégré à une ERA
| Option | Description |
|---|---|
| b | le reste de l'ER est une ERB |
| c | activation de la sensibilité à la casse (surcharge l'opérateur type) |
| e | le reste de l'ER est une ERE |
| i | désactivation de la sensibilité à la casse (voir Section 9.7.3.5) (surcharge l'opérateur type) |
| m | synonyme historique pour n |
| n | activation de la sensibilité aux nouvelles lignes (voir Section 9.7.3.5) |
| p | activation partielle de la sensibilité aux nouvelles lignes (voir Section 9.7.3.5) |
| q | le reste de l'ER est une chaîne littérale (<< entre guillemets >>), composé uniquement de caractères ordinaires |
| s | désactivation de la sensibilité aux nouvelles lignes (par défaut) |
| t | syntaxe légère (par défaut ; voir ci-dessous) |
| w | désactivation de la sensibilité aux nouvelles lignes (<< étrange >>) correspondantes (voir Section 9.7.3.5) |
| x | syntaxe étendue (voir ci-dessous) |
Les options intégrées prennent effet au ) terminant la séquence. Elles pourraient seulement apparaître au début d'une ERA (après le directeur ***: s'il y en a un).
En plus de la syntaxe habituelle d'une ER (légère), dans laquelle tous les caractères ont une signification, il existe une syntaxe étendue, disponible en signifiant l'option intégrée x. Avec la syntaxe étendue, les caractères d'espace blanc d'une ER sont ignorés comme le sont tous les caractères entre un # et la nouvelle ligne suivante (ou la fin de l'ER). Ceci permet le commentaire d'une ER complexe. Il existe trois exceptions à cette règle de base :
un caractère espace blanc # suivi d'un \ est retenu
un caractère espace blanc # à l'intérieur d'une expression entre crochets est retenu
un espace blanc et des commentaires ne peuvent pas apparaître à l'intérieur de symboles multi-caractères, tels que (?:
Dans ce cas, les caractères d'espace blanc sont l'espace, la tabulation, le retour chariot et tout caractère appartenant à la classe de caractère space.
Enfin, dans une ARE, à l'extérieur des expressions entre crochets, la séquence (?#ttt) (où ttt est tout texte ne contenant pas )) est un commentaire totalement ignoré. De nouveau, cela n'est pas permis entre les caractères des symboles multi-caractères comme (?:. De tels commentaires sont plus un artéfact historique qu'une fonctionnalité utile et leur utilisation est obsolète ; utilisez plutôt la syntaxe étendue.
Aucune de ces extensions métasyntaxe n'est disponible si un directeur initial ***= a spécifié que la saisie de l'utilisateur doit être traité comme une chaîne littérale plutôt que comme une ER.
Dans l'hypothèse qu'une ER pourrait correspondre à plus d'une sous-chaîne d'une chaîne donnée, l'ER correspond à la première. De même, dans l'hypothèse que l'ER pourrait correspondre à plus d'une sous-chaîne commençant au même endroit, soit la correspondance la plus longue possible soit la correspondance la plus courte possible sera prise suivant si l'ER est gourmande ou non-gourmande.
Le fait qu'une ER est gourmande ou non est déterminé par les règles suivantes :
La plupart des atomes, et toutes les contraintes, n'ont pas d'attribut de gourmandise (parce qu'ils ne correspondent pas à des quantités variables de texte de toute façon).
Ajouter des parenthèses autour d'une ER ne change pas sa gourmandise.
Un atome quantifié avec un quantificateur à répétition fixe ({m} ou {m}?) a la même gourmandise (peut-être aucune) que l'atome lui-même.
Un atome quantifié avec d'autres quantifieurs standards (incluant {m,n} avec m égal à n) est gourmand (préfère la plus grande correspondance).
Un atome quantifié avec un quantificateur non gourmand (incluant {m,n}? avec m égal à n) n'est pas gourmand (préfère la plus courte correspondance).
Une branche — c'est-à-dire une ER qui n'a pas d'opérateur | de haut niveau — est aussi gourmand que le premier atome quantifié dans lui qui a un attribut de gourmandise.
Une ER consistant en deux branches, ou plus, connectées par l'opérateur | est toujours gourmande.
Les règles ci-dessus associent les attributs de gourmandise pas seulement avec les atomes quantifiés individuels, mais aussi avec les branches et les ER entiers contenant des atomes quantifiés. Cela signifie que la correspondance est faite d'une telle façon que la branche, ou l'ER complète, correspond à la sous-chaîne la plus longue ou la plus courte possible comme un tout. Une fois la longueur de la longueur entière déterminée, la partie en lui qui correspond à toute sous-expression particulière est déterminée sur la base de l'attribut de gourmandise de cette sous-expression, avec les sous-expressions commençant plus tôt dans l'ER ayant priorité sur celles commençant après.
Un exemple de ce que cela signifie :
SELECT SUBSTRING('XY1234Z', 'Y*([0-9]{1,3})');
Result: 123
SELECT SUBSTRING('XY1234Z', 'Y*?([0-9]{1,3})');
Result: 1Dans le premier cas, l'ER est gourmand en un tout parce que Y* est gourmand. Elle peut correspondre au début de Y et cela correspond à la chaîne la plus longue commençant à partir de là, donc Y123. La sortie est la partie entre parenthèses, soit 123. Dans le second cas, l'ER en un tout n'est pas gourmand car Y*? ne l'est pas non plus. Cela peut correspondre au début de Y et cela correspond à la chaîne la plus courte commençant là, donc Y1. La sous-expression [0-9]{1,3} est gourmande mais cela ne peut pas changer la décision sur la longueur totale de la correspondance ; donc, cela le force à correspondre à seulement 1.
En bref, quand une ER contient à la fois des sous-expressions gourmandes et non gourmandes, la longueur de la correspondance totale est soit aussi longue que possible soit aussi courte que possible, suivant l'attribut affecté à l'ER complète. Les attributs affectés aux sous-expressions affectent seulement quelles parties de cette correspondance ils sont autorisés à << manger >>.
Les quantifieurs {1,1} et {1,1}? peuvent être utilisés pour forcer la préférence la plus longue ou la plus courte, respectivement, sur une sous-expression ou sur l'ER complète.
Les longueurs de correspondance sont mesurés en caractères, et non pas en éléments liants. Une chaîne vide est considérée comme plus grande que pas de correspondance du tout. Par exemple : bb* correspond aux trois caractères du milieu de abbbc ; (week|wee)(night|knights) correspond aux dix caractères de weeknights ; lorsque (.*).* correspond à abc, la sous-expression entre parenthèses correspond aux trois caractères ; et quand (a*)* correspond à bc, à la fois l'ER et la sous-expression entre parenthèses correspondent à une chaîne vide.
Si la correspondance ne tient pas compte de la casse, l'effet revient à ce que toutes les distinctions de casse aient disparu de l'alphabet. Quand un caractère alphabétique, existant en plusieurs cas, apparaît comme un caractère ordinaire en dehors d'une expression entre crochets, il est effectivement transformé en une expression entre crochets contenant les deux cas, c'est-à-dire que x devient [xX]. Quand il apparaît dans une expression entre crochets, toutes les transformations de casse sont ajoutées à l'expression entre crochets, c'est-à-dire que [x] devient [xX] et que [^x] devient [^xX].
Si la sensibilité aux retours chariots est spécifiée, . et les expressions entre crochets utilisant ne correspondront jamais au caractère de retour à la ligne (de façon à ce que les correspondances ne croisent jamais les retours chariots sauf si l'ER arrange ceci explicitement), et ^ et $ correspondront à la chaîne vide respectivement après et avant un retour chariot, en plus de correspondre respectivement au début et à la fin de la chaîne. Mais les échappements ERA \A and \Z continuent de correspondre seulement au début et à la fin de la chaîne.
Si la sensibilité partielle aux retours chariot est spécifiée, ceci affecte . et les expressions entre crochets comme avec la sensibilité aux retours chariot mais sans ^ et $.
Si la sensibilité partielle inverse aux retours chariot est spécifiée, ceci affecte ^ et $ comme avec la sensibilité aux retours chariot mais sans . et les sous-expressions. Ceci n'est pas très utile mais est fournie pour des raisons de symétrie.
Aucune limite particulière n'est imposée sur la longueur des ER dans cette implémentation. Néanmoins, les programmes souhaitant être particulièrement portables ne devraient pas employer d'ER de plus de 256 octets car l'implémentation POSIX peut refuser d'accepter de telles ER.
La seule fonctionnalité des ERA, incompatible avec les ERE POSIX, est que \ ne perd pas sa signification spéciale à l'intérieur des expressions entre crochets. Toutes les autres fonctionnalités ERA utilisent une syntaxe qui est illégale ou a des effets indéfinis ou non spécifiés dans les ERE POSIX ; la syntaxe *** des directeurs est en dehors de la syntaxe POSIX pour les ERB et les ERE.
Un grand nombre des extensions ERA sont empruntées de Perl mais certaines ont été modifiées pour les nettoyer et quelques extensions Perl ne sont pas présentes. Les incompatibilités incluent \b, \B, le manque de traitement spécial pour le retour à la ligne en fin de chaîne, l'ajout d'expressions entre crochets aux expressions affectées par les correspondance avec retour à la ligne, les restrictions sur les parenthèses et les références dans les contraintes, et la correspondance des chaînes suivant leur taille (au lieu de la première rencontrée).
Deux incompatibilités importantes existent entre les syntaxes ERA et ERE reconnues par les pré-versions 7.4 de PostgreSQL:
Dans les ERA, \ suivi d'un caractère alphanumérique est soit un échappement soit une erreur alors que dans les versions précédentes, c'était simplement un autre moyen d'écrire un caractère alphanumérique. Ceci ne devrait pas poser trop de problèmes car il n'existe aucune raison pour écrire une telle séquence dans les versions précédentes.
Dans les ERA, \ reste un caractère spécial y compris à l'intérieur de [], donc un \ littéral à l'intérieur d'une expression entre crochets doit être écrit \\.
Alors que ces différences ne devraient pas poser problèmes pour la plupart des applications, vous pouvez les éviter si nécessaire en initialisant regex_flavor à extended.
Les ERB diffèrent des ERE sur plusieurs aspects. |, + et ? sont des caractères ordinaires et il n'existe pas d'équivalent pour leur fonctionnalité. Les délimiteurs sont \{ et \}, avec { et } étant eux-même des caractères ordinaires. Les parenthèses pour les sous-expressions imbriquées sont \( et \), avec ( et ) étant eux-mêmes des caractères ordinaires. ^ est un caractère ordinaire sauf au début d'une ER ou au début d'une sous-expression entre parenthèses, $ est un caractère ordinaire sauf à la fin d'une ER ou à la fin d'une sous-expression entre parenthèses et * est un caractère ordinaire s'il apparaît au début d'une ER ou au début d'une sous-expression entre parenthèses (après un possible ^). Enfin, les références à un seul chiffre sont disponibles, et \< et \> sont des synonymes pour respectivement [[:<:]] et [[:>:]] ; aucun autre échappement n'est disponible.
| Précédent | Sommaire | Suivant |
| Fonctions et opérateurs pour les chaînes de bits | Niveau supérieur | Fonctions de formatage des types de données |