Les expressions rationnelles de PostgreSQL sont implémentées en utilisant un paquet logiciel écrit par Henry Spencer. La plupart des descriptions d'expressions rationnelles ci-dessous est copiée verbatim de son manuel.

Les expressions rationnelles (connus sous l'acronyme RE), tel qu'elles sont définies dans POSIX 1003.2, viennent sous deux formes : les RE étendues ou ERE (en gros celles de egrep), et les RE basiques ou BRE (en gros celles de ed). PostgreSQL accepte les deux formes, et implémente aussi certaines extensions qui ne font pas partie du standard POSIC, mais sont devenues largement utilisées grâce à leur disponibilité dans les langages de programmation tels que Perl et Tcl. Les RE utilisant ces extensions de POSIX sont appelées des RE avancées ou ARE dans cette documentation. Les ARE sont pratiquement un sur-ensemble des ERE, mais les BRE ont des incompatibilités de notation (et sont bien plus limitées). Nous décrivons tout d'abord les formes ARE et ERE, en notant les fonctionnalités qui s'appliquent uniquement aux ARE, puis nous décrivons comment les BRE diffèrent.

Une expression rationnelle est définie comme une ou plusieurs branches, séparées par |. Elle correspond à tout ce qui correspond à une des branches.

Une branche est zéro ou plus atomes quantifiés ou contraintes, concaténés. Elle établie une correspondance pour le premier, puis pour le second, etc ; une branche vide établit une correspondance à une chaîne vide.

Un atome quantifié est un atome potentiellement suivi par un quantifieur simple. Sans quantifieur, il peut établir une correspondance pour l'atome. Avec un quantifieur, il peut établir un certain nombre de correspondances à l'atome Un atom peut être une des possibilités indiquées dans Tableau 9.17. Les quantifieurs possibles et leur signification sont montrés dans Tableau 9.18.

Une contrainte correspond à une chaîne vide, mais correspond seulement quand certaines conditions spécifiques sont rencontrées. Une contrainte peut être utilisée là où un atome peut être utilisé, sauf qu'il ne peut pas être suivi d'un quantifieur. Les contraintes simples sont montrées dans Tableau 9.19 ; d'autres contraintes sont décrites après.

Un RE ne peut pas se terminer avec un antislash (\).

Les formes utilisant {...} sont connues comme des limites. Les nombres m et n d'une limite sont des entiers décimaux non signés avec des valeurs autorisées allant de 0 à 255, valeurs comprises.

Des quantifieurs non gourmands (Non-greedy en VO), disponibles uniquement dans les ARE, correspondent aux mêmes capacités que leur version gourmande correspondante (greedy), mais préfèrent le plus petit nombre plutôt que le plus grand nombre de correspondantes. Voir Section 9.7.3.5 pour plus de détails.

Les contraintes de recherche en avant et de recherche en arrière ne peuvent pas contenir des références arrières (voir Section 9.7.3.3), et toutes les parenthèses comprises en elles sont considérées comme non capturantes.

Une expression entre crochets est une liste de caractères compris dans []. Cela établit habituellement une correspondance avec tout caractère seul à partir de la liste (mais voir ci-dessous). Si la liste commence avec ^, cela établit une correspondance avec tout caractère seul ne faisant pas parti de la liste. Si deux caractères de la liste sont séparés par un caractère -, c'est un raccourci pour l'intervalle complet de caractères entre ces deux caractères (en les incluant) dans la séquence, par exemple [0-9] en ASCII correspond à tout chiffre décimal. Il est illégal pour deux intervalles de partager la même limite finale, par exemple a-c-e. Les intervalles sont particulièrement dépendants de la collation, donc les programmes portables devraient éviter de se baser sur eux.

Pour inclure un caractère ] littéral dans la liste, faites-en le premier caractère (après ^, si nécessaire). Pour inclure un - littéral, faites-en le premier ou dernier caractère, ou le deuxième point final d'un intervalle. Pour utiliser un - littéral comme premier point final d'un intervalle, placez le entre [. et .] pour en faire un élément d'assemblage (voir ci-dessous). À l'exception de ces caractères, certaines combinaisons utilisant [ (voir les prochains paragraphes), et des échappements (ARE seulement), tous les autres caractères spéciaux perdent leur signification à l'intérieur d'une expression entre crochets. En particulier, \ n'est pas spécial quand il suit les règles ERE et BRE, bien qu'il soit spécial (pour introduire un échappement) dans les ARE.

À l'intérieur d'une expression entre crochets, un élément d'assemblage (un caractère, une séquence multi-caractères qui s'assemblent comme s'il s'agissait d'un seul caractère, ou un nom de séquence d'assemblage) englobé dans [. and .] signifie la séquence de caractères de cet élément d'assemblage. La séquence est traitée comme un seul élément de liste d'expression entre crochets. Ceci permet à une expression entre crochets contenant un élément d'assemblage multi-caractères de correspondre à plus d'un caractère. Par exemple, si la séquence d'assemblage inclut un élément d'assemblage ch, alors le RE [[.ch.]]*c correspond aux cinq premiers caractères de chchcc.

À l'intérieur d'une expression entre crochets, un élément d'assemblage compris entre [= et =] est une classe d'équivalence, représentant les séquences de caractères de tous les éléments d'assemblage équivalent à cette classe, incluant lui-même. (S'il n'existe pas d'autres éléments d'assemblage équivalents, le traitement est identique, comme si les délimiteurs é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'équivalent ne peut pas être un point final d'un intervalle.

À l'intérieur d'une expression entre crochets, le nom d'une classe de caractères entouré entre [: et :] signifie la liste de tous les caractères appartenant à cette classe. Une classe de caractères ne peut pas être utilisée comme point final d'un intervalle. Le standard POSIX définit les noms de ces classes de caractères : alnum (lettres et chiffres), alpha (lettres), blank (espace et tabulation), cntrl (caractères de contrôle), digit (chiffres), graph (caractères affichages, sauf l'espace), lower (lettres minuscules), print (caractères affichages, incluant l'espace), punct (ponctuation), space (tout espace blanc), upper (lettres majuscules), et xdigit (chiffres hexadécimaux). Le comportement de ces classes de caractères standards est généralement cohérent sur les plateformes pour les caractères de l'ensemble ASCII 7 bits. Qu'un caractère non ASCII donné appartienne ou non à une de ces classes dépend de la collation utilisée par la fonction ou l'opérateur de l'expression rationnelle, (voir Section 23.2), ou par défaut de la locale indiquée par LC_CTYPE pour cette base (voir Section 23.1). La classification de caractères non ASCII peut varier entre les plateformes même pour des locales de nom similaire. (Mais la locale C ne considère jamais tout caractère non ASCII comme appartenant à une de ces classes.) En plus de ces classes de caractères standard, PostgreSQL définit la classe de caractères mot, ce qui revient au même que alnum plus le caractère underscore (_), et la classe de caractères ascii, qui contient l'ensemble ASCII 7 bits exactement.

Il existe deux cas spéciaux d'expressions entre crochets : les expressions entre crochets [[:<:]] et [[:>:]] sont des contraintes, correspondant à des chaînes vides au début et à la fin d'un mot caractère respectivement. Un mot est défini comme une séquence de mots qui n'est ni précédée ni suivie de mots. Un mot caractère correspond à n'importe quel caractère appartenant à la classe de caractères word, c'est-à-dire n'importe quel lettre, nombre ou l'underscore. C'est une extension, compatible avec, mais non spécifiée par POSIX 1003.2, et elle devrait être utilisée avec précaution dans les logiciels portables sur d'autres systèmes. Les échappements de contrainte décrits ci-dessous sont généralement préférables ; ils ne sont pas plus standards, mais plus simples à écrire.

Les échappements sont des séquences spéciales commençant avec \ et suivies par un caractère alphanumérique. Les échappements sont de différents types : entrée de caractère, raccourci de classe, échappements de contrainte, et références. Un \ suivi d'un caractère alphanumérique mais ne constituant pas un échappement valide est illégal dans les ARE. Dans le ERE, il n'y a pas d'échappement : en dehors d'une expression entre crochets, un \ suivi d'un caractère alpha-numérique signifie ce caractère alors qu'à l'intérieur d'une expression entre crochets, \ est un caractère standard. (Ce dernier est la seule incompatibilité entre ERE et ARE.)

Les échappements d'entrée de caractère existent pour rendre plus simple l'ajout de caractères non affichables, ainsi que d'autres caractères désagréables à saisir dans les RE. Ils sont affichés dans Tableau 9.20.

Les échappements de raccourci de classe fournissent des raccourcis pour certaines classes de caractères fréquemment utilisées. Ils sont affichés dans Tableau 9.21.

Un échappement de contrainte est une contrainte, correspondant à la chaîne vide si des conditions spécifiques sont rencontrées, écrites comme un échappement. Ils sont affichés dans Tableau 9.22.

Une référence (\n) établit une correspondance de la même chaîne avec la sous-expression entre parenthèses précédente spécifiée par le numéro n (voir Tableau 9.23). Par exemple, ([bc])\1 établit une correspondance avec bb et cc, mais pas bc et cb. La sous-expression doit précéder entièrement la référence dans le RE. Les sous-expressions sont numérotées dans l'ordre de leur parenthèses de début. Les parenthèses sans capture ne définissent pas de sous-expressions. La référence considère seulement la chaîne de caractères correspondant à la sous-expression référencée, pas les contraintes qu'elle contient. Par exemple, (^\d)\1 établira une correspondance avec 22.

Les chiffres hexadécimaux sont 0-9, a-f et A-F. Les chiffres octaux sont 0-7.

Les échappements d'entrés de caractères numériques spécifiant des valeurs en dehors de l'intervalle ASCII (0–127) ont des significations dépendantes de l'encodage de la base de données. Quand l'encodage est UTF-8, les valeurs d'échappement sont équivalents à des points code Unicode. Par exemple, \u1234 signifie le caractère U+1234. Pour les autres encodages multi-octets, les échappements d'entrée de caractères spécifient habituellement juste la concaténation des valeurs d'octet pour le caractère. Si la valeur d'échappement ne correspond pas à tout caractère légale dans l'encodage de la base de données, aucune erreur ne sera levée, mais elle ne correspondra à aucune donnée.

Les échappements d'entrée de classe sont toujours pris comme des caractères ordinaires. Par exemple, \135 est ] en ASCII, mais \135 ne termine pas une expression entre crochets.

Les échappements de raccourci de classe fonctionnent également dans des expressions entre crochets, bien que les définitions ci-dessus ne soient pas tout-à-fait syntaxiquement valides dans ce contexte. Par exemple, [a-c\d] est équivalent à [a-c[:digit:]].

Un mot est défini comme dans la spécification de [[:<:]] et [[:>:]] ci-dessus. Les échappements de contrainte sont illégales à l'intérieur d'une expression entre crochets.

En plus de la syntaxe principale décrite ci-dessus, il existe des formes spéciales et des fonctionnalités syntaxiques diverses disponibles.

Une RE peut commencer avec un des deux préfixes director spéciaux. Si une RE commence avec ***:, le reste de la RE est prise pour une ARE. (Ceci n'a normalement aucun effet dans PostgreSQL, car les RE sont supposées être des ARE ; mais cela a un effet si le mode ERE ou le mode BRE a été spécifié avec le paramètre flags dans une fonction d'expression rationnelle.) Si une RE commence avec ***=, le reste de la RE est prise comme une chaîne littérale, tous les caractères étant considérés comme des caractères ordinaires.

Une ARE peut commander avec des options intégrées : une séquence (?xyz) (où xyz est un ou plusieurs caractères alphabétiques) indique des options affectant le reste de la RE. Ces options surchargent toutes les options préalablement déterminées -- en particulier, elles peuvent surcharger le comportement de sensibilité à la base impliqué par un opérateur d'expression rationnelle ou le paramètre flags d'une fonction d'expression rationnelle. Les lettres disponibles pour les options sont indiquées dans Tableau 9.24. Notez que ces mêmes lettres sont utilisées dans les paramètres flags des fonctions d'expression rationnelle.

Les options intégrées prennent effet au ) terminant la séquence. Elles peuvent apparaître seulement au début d'une ARE (après le directeur ***: le cas échéant).

En plus de l'habituelle syntaxe RE (serrée), dans laquelle tous les caractères sont signifiants, il existe une syntaxe étendue, disponible en spécifiant l'option étendue x. Dans la syntaxe étendue, les caractères d'espace blanc de la RE sont ignorés, comme le sont tous les caractères entre un # et la nouvelle ligne suivante (ou la fin de la RE). Ceci permet les paragraphes et les commentaires dans une RE complexe. Il existe trois exceptions à cette règle basique :

Pour cela, les caractères d'espace blanc sont un blanc, une tabulation, un retour à la ligne et tout caractère qui appartient à la classe de caractères space.

Enfin, dans une ARE, les expressions en dehors des crochets, la séquence (?#ttt) (où ttt est tout texte ne contenant pas )) est un commentaire, complètement ignoré. Encore une fois, ceci n'est pas autorisé 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 déconseillée ; utilisez la syntaxe étendue à la place.

Aucune de ces extensions de métasyntaxe n'est disponible si un directeur ***= initial n'a spécifié que l'entrée de l'utilisateur doit être traitée comme une chaîne littérale plutôt que comme une RE.

Dans le cas où une RE correspond à plus d'une sous-chaîne d'une chaîne donnée, la RE établit une correspondance avec la sous-chaîne la plus proche du début de la chaîne. Si la RE correspond à plus d'une sous-chaîne commençant à ce point, la correspondance conservée sera soit la plus longue, soir, la plus courte, suivant que la RE est gourmande (greedy) ou non (non-greedy).

Le fait qu'une RE est gourmande ou non se détermine avec les règles suivantes :

Les règles ci-dessus associent les attributs de gourmandise non seulement aux atomes quantifiés individuels mais aussi aux branches et aux RE complets qui contiennent des atomes quantifiés. Cela signifie que la correspondance est faite de tel façon que la branche ou la RE complète correspondant à la sous-chaîne la plus longue ou la plus courte au complet. Une fois que la longueur de la correspondance entière est déterminée, la partie de celle-ci correspondant à une 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 la RE prenant priorité sur les autres.

Un exemple de ce que cela signifie :

SELECT SUBSTRING('XY1234Z', 'Y*([0-9]{1,3})');
Résultat : 123
SELECT SUBSTRING('XY1234Z', 'Y*?([0-9]{1,3})');
Résultat : 1
    

Dans le premier cas, la RE complète est gourmande parce que Y* est gourmand. Elle peut correspondance en commençant au Y, et elle correspond à la chaîne la plus longue commençant là, donc Y123. La sortie est la partie entre parenthèse, ou 123. Dans le deuxième cas, la RE complète est non gourmande parce que Y*? est non gourmande. Elle peut correspondre en commençant à Y, et elle correspond à la chaîne laplus courte possible commençant là, donc Y1. La sous-expression [0-9]{1,3} est gourmande mais elle ne peut pas modifier la décision sur la longue de la correspondance ; donc elle est forcée à une correspondance sur simplement 1.

En court, quand une RE contient des sous-expressions gourmandes et non gourmandes, la longueur de correspondance totale est soit aussi longue ou aussi courte que possible, suivant l'attribut affecté à la RE complète. Les attributs affectés aux sous-expressions affectent seulement la quantité de correspondance qu'elles sont autorisées de « manger » par rapport aux autres.

Les quantifieurs {1,1} et {1,1}? peuvent être utilisés pour forcer la gourmandise ou la non gourmandise, respectivement, d'une sous-expression ou de la RE complète. Ceci est utile quand vous avez que la RE complète contienne un attribut de gourmandise différent de celui déduit de ces éléments. Comme exemple, supposez que nous essayons de séparer une chaîne contenant quelques chiffres dans les chiffres et les parties avant et après eux. Nous pourrions essayer de le faire ainsi :

SELECT regexp_match('abc01234xyz', '(.*)(\d+)(.*)');
Résultat : {abc0123,4,xyz}
    

Cela n'a pas fonctionné : le premier .* est gourmand donc il « mange » autant qu'il peut, laissant le \d+ correspondre à la dernière place possible, le dernier chiffre. Nous pourrions essayer de corriger cela en le rendant non gourmand :

SELECT regexp_match('abc01234xyz', '(.*?)(\d+)(.*)');
Résultat : {abc,0,""}
    

Ceci n'a pas fonctionné non plus parce que, maintenant, la RE entière est non gourmande et donc, elle termine la correspondance globale aussi tôt que possible. Nous pouvons obtenir ce que vous voulons en forçant la RE entière à être gourmande :

SELECT regexp_match('abc01234xyz', '(?:(.*?)(\d+)(.*)){1,1}');
Résultat : {abc,01234,xyz}
    

Contrôler la gourmandise globale de la RE séparément de la gourmandise de ses composants donne plus de flexibilité dans la gestion des motifs de longueur variable.

Lors de la décision sur ce qui est une correspondance longue ou courte, les longueurs des correspondances sont mesurés en caractères, pas en éléments. Toute chaîne vide est considérée plus longue qu'aucune correspondance. Par exemple : bb* correspond au trois caractères du milieu de abbbc ; (week|wee)(night|knights) correspond aux dix caractères de weeknights ; quand (.*).* est comparé à abc, la sous-expression entre parenthèses correspond aux trois caractères ; et quand (a*)* est comparé à bc, la RE complète et la sous-expression entre parenthèses correspond à une chaîne vide.

Si une correspondance indépendante à la casse est demandée, l'effet est comme si toutes les distinctions de casse disparaissaient de l'alphabet. Quand un caractère alphabétique qui existe dans plusieurs casses apparaît comme un caractère ordinaire en dehors d'une expression entre crochets, il est en fait transformé en une expression entre crochets contenant les deux casses, par exemple x devient [xX]. Quand il apparaît dans une expression entre crochets, toutes les casses sont ajoutées dans l'expression entre crochets, par exemple [x] devient [xX] et [^x] devient [^xX].

Si une correspondance sensible aux nouvelles lignes est spécifiée, . et les expressions entre crochets utilisant ^ ne correspondront jamais au caractère de nouvelle ligne (pour que les correspondances ne croisent pas les nouvelles lignes sauf si la RE inclut explicitement un saut de ligne) et ^ et $ correspondront à la chaîne vide respectivement après et avant une nouvelle ligne, en plus d'une correspondance en début et en fin de chaîne respectivement. Cependant, les échappements d'ARE \A et \Z continuent de correspondre seulement au début et à la fin de chaine. Également, les raccourcis de classes de caractères \D et \W correspondront à une nouvelle ligne indépendamment de ce mode. (Avant PostgreSQL 14, ils ne correspondaient pas à de nouvelles lignes dans le mode sensible aux nouvelles lignes. Écrire [^[:digit:]] ou [^[:word:]] pour retrouver cet ancien comportement.)

Si la correspondance partielle sensible aux nouvelles lignes est spécifiée, ceci affecte . et les expressions entre crochets comme avec la correspondance sensible à la nouvelle ligne, mais pas à ^ et $.

Si la correspondance partielle inverse sensible aux nouvelles lignes est spécifiée, ceci affecte ^ et $ comme avec la correspondance sensible aux nouvelles lignes, mais pas à . et aux expressions entre crochets. Ceci n'est pas très utile mais est fourni pour la symétrie.

Aucune limite particulière n'est imposée sur la longueur des RE dans cette implémentation. Néanmoins, les programmes hautement portablees ne devraient pas employer des RE plus longs que 256 octets, car une implémentation compatible POSIX peut refuser de telles RE.

La seule fonctionnalité des ARE actuellement 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 ARE utilisent une syntaxe illégale ou a des effets non définis ou spécifiés dans les ERE POSIX ; la syntaxe *** des directeurs est en dehors de la syntaxe POSIX pour les BRE et les ERE.

Beaucoup d'extensions ARE sont empruntés de Perl, mais certaines ont été modifiées pour les nettoyer, et quelques extensions Perl ne sont pas présentes. Les incompatibilités de note incluent \b, \B, le manque de traitement spécial pour une nouvelle ligne en fin, l'addition des expressions entre crochets complémentées, les restrictions sur les parenthèses et des références inverses dans les contraintes lookahead/lookbehind et les sémantiques de correspondance pour la correspondance la plus longue/courte (plutôt que la première correspondance).

Les BRE diffèrent des ERE dans différents aspects. Dans les BRE, |, + et ? sont des caractères ordinaires et il n'existe pas d'équivalent à leur fonctionnalité. Les BRE diffèrent des ERE dans différents aspects. Dans les BRE, |, + et ? sont des caractères ordinaires et il n'existe pas d'équivalent à leur fonctionnalité. Les délimiteurs des limites sont \{ et \}. Les parenthèses pour les sous-expressions imbriquées sont \( and \), with ( et ). ^ est un caractère ordinaire, sauf en début de la RE ou au commencement de la sous-expression entre parenthèses, $ est un caractère standard sauf en fin de RE ou en fin d'une sous-expression entre parenthèses, et * est un caractère standard s'il apparaît au début de la RE ou au début de la sous-expression entre parenthèses (après potentiellement un ^). Enfin, les références inverses d'un simple chiffre sont disponibles, et \< et \> sont des synonymes pour, respectivement, [[:<:]] and [[:>:]]  aucun autre échappement n'est dispn,ible dans le BRE.

Depuis SQL:2008, le standard SQL inclut des fonctions et opérateurs pour les expressions rationnelles qui réalise de la correspondance de motif suivant le standard d'expression rationnelle XQuery.

PostgreSQL n'implémente pas actuellement ces opérateurs et fonctions. Vous pouvez obtenir approximativement des fonctionnalités équivalentes dans chaque cas affichés dans Tableau 9.25. (Différentes clauses optionnelles des deux côtés ont été omises dans cette table.)

Des fonctions d'expression rationnelles similaires à celles fournies par PostgreSQL sont aussi disponibles dans un certain nombre d'autres implémentations SQL alors que les fonctions du standard SQL ne sont pas aussi largement implémentées. Certains détails de la syntaxe des expressions rationnelles pourraient différer dans chaque implémentation.

Les opérateurs et fonctions du standard SQL utilisent les expressions rationnelles XQuery, qui sont très proches de la syntaxe ERA décrite ci-dessus. Les différences notables entre la fonctionnalité existante d'expressions rationnelles POSIX et les expressions rationnelles XQuery incluent :