Documentazione di PostgreSQL 9.0 > Il linguaggio SQL > Funzioni e Operatori > Confronto con modelli
PrecedenteFunzioni e operatori per stringhe di bitFunzioni di formattazione dei tipi di datoSuccessivo

9.7. Confronto con modelli

Ci sono tre approcci separati forniti da PostgreSQL™ per il confronto con modelli: il tradizionale operatore SQL LIKE, l'operatore più recente SIMILAR TO (aggiunto in SQL:1999) e le espressioni regolari stile-POSIX. Oltre aigli operatori di base «questa stringa corrisponde a questo modello?», sono disponibili le funzioni per estrarre o rimpiazzare substringhe e per dividere una stringa in locazioni definite.

[Suggerimento]

Suggerimento

Se si ha bisogno di confronti con modelli che vanno oltre questo, considerare la possibilità di scrivere funzioni definite dall'utente in Perl o Tcl.

9.7.1. LIKE

string LIKE pattern [ESCAPE escape-character]
string NOT LIKE pattern [ESCAPE escape-character]

Ogni pattern definisce un insieme di stringhe. L'espressione LIKE restituisce true se string è contenuta nell'insieme di stringhe rappresentate dal pattern. (Come previsto, l'espressione NOT LIKE restituisce false se LIKE restituisce true, e viceversa. Una espressione equivalente è NOT (string LIKE pattern)).

Se il pattern non contiene simboli di percentuale o underscore, allora il modello rappresenta solo la stringa stessa; in questo caso LIKE si comporta in modo simile all'operatore uguale. Un sottolineato (_) in un pattern sta per (corrisponde a) ogni singolo carattere; un simbolo di precentuale (%) corrosponde ad ogni sequenza di zero o più caratteri.

Some examples:

'abc' LIKE 'abc'    true
'abc' LIKE 'a%'     true
'abc' LIKE '_b_'    true
'abc' LIKE 'c'      false

Il modello LIKE effettua sempre il confronto con la stringa intera. Per trovare una sequenza in qualsiasi punto della stringa, il modello deve dunque iniziare e terminare con un simbolo di percentuale.

Per confrontare un simbolo letterale underscore o di percentuale senza confrontare altri caratteri, il rispettivo carattere nel pattern deve essere preceduto dal carattere di escape. Il carattere di escape predefinito è la barra inversa ma se ne può selezionare un altro utilizzando la clausula ESCAPE. Per confrontare lo stesso carattere di escape, bisogna scrivere due caratteri di escape.

Notare che il carattere di barra inversa ha già uno speciale significato nei letterali stringa, per cui per scrivere una costante di modello che contiene una barra inversa in una istruzione SQL, bisogna scrivere due barre inverse (supponendo che si stia usando la sintassi stringa escape, consultare Sezione 4.1.2.1, «Costanti stringa»). Quindi, per scrivere un modello che deve confrontare una effettiva barra inversa, bisogna scrivere quattro barre inverse nell'istruzione. Si può evitare ciò selezionando un diverso carattere di escape con ESCAPE; dopodiche una barra inversa non è più speciale per LIKE. (Ma è ancora speciale per l'analizzatore di stringhe letterali, per cui, per esso, è ancora necessario scriverne due).

È anche possibile non scrivere nessun carattere di escape scrivendo ESCAPE ''. Ciò effettivamente disabilita il meccanismo di escape, che rende impossibile disabilitare il significato speciale dei simboli di sottolineato e di percentuale nel modello.

La parola chiave ILIKE può essere usata al posto di LIKE per rendere il confronto non sensibile alle maiuscole in conformità con la localizzazione attiva. Questo non è nello standard SQL ma è un'estensione di PostgreSQL™.

L'operatore ~~ è equivalente a LIKE, e ~~* corrisponde a ILIKE. Ci sono anche gli operatori !~~ e !~~* che rappresentano, rispettivamente, NOT LIKE e NOT ILIKE. Tutti questi operatori sono specifici di PostgreSQL™.

9.7.2. Espressioni regolari SIMILAR TO

string SIMILAR TO pattern [ESCAPE escape-character]
string NOT SIMILAR TO pattern [ESCAPE escape-character]

L'operatore SIMILAR TO restituisce true o false a seconda che il suo modello corrisponda o meno alla stringa data. Esso è molto simile a LIKE, eccetto che esso interpreta il modello utilizzando la definizione di una espressione regolare standard SQL. Le espressioni regolari SQL sono un incrocio curioso tra la notazione LIKE e la notazione comune di espressione regolare.

L'operatore SIMILAR TO come LIKE, ha successo soltanto se il suo modello uguaglia la stringa intera; ciò è diverso dalla pratica delle comuni espressioni regolari, dove il modello può confrontare qualsiasi parte della stringa. Anche SIMILAR TO come LIKE, utilizza _ e % come caratteri jolly riferendosi, rispettivamente, ad ogni singolo carattere e ad ogni stringa, (questi sono paragonabili a . e .* nelle espressioni regolari POSIX).

Oltre a queste facilitazioni prese in prestito da LIKE, SIMILAR TO supporta questi metacaratteri di confronto dei modelli presi in prestito dalle espressioni regolari POSIX:

  • | indica un alternanza (una di due alternative).

  • * indica ripetizione del precedente elemento zero o più volte.

  • + indica ripetizione del precedente elemento, una o più volte.

  • ? denota la ripetizione del precedente elemento zero o una volta.

  • {m} denota la ripetizione dell'elemento precedente esattamente m volte.

  • {m,} denota la ripetizione dell'elemento precedente m o più volte.

  • {m,n} denota la ripetizione dell'elemento precedente almeno m e non più di n volte.

  • Le parentesi () possono essere usate per raggruppare elementi in un singolo insieme logico.

  • Una espressione tra parentesi quadre [...] specifica una classe caratteri, proprio come nelle espressioni regolari POSIX.

Notare che il punto (.) non è un metacarattere per SIMILAR TO.

Come con LIKE, una barra inversa disabilita lo speciale significato di ognuno di questi metacaratteri; oppure un diverso carattere di escape può essere specificato con ESCAPE.

Qualche esempio:

'abc' SIMILAR TO 'abc'      true
'abc' SIMILAR TO 'a'        false
'abc' SIMILAR TO '%(b|d)%'  true
'abc' SIMILAR TO '(b|c)%'   false

La funzione substring con tre parametri, substring(string, from pattern, for escape-character), fornisce l'estrazione di una sottostringa che confronta un modello di espressione regolare SQL. Come con SIMILAR TO, il modello specificato dovrà confrontare la stringa dati intera, altrimenti la funzione fallirà e restituirà null. Per indicare la parte del modello che dovrà essere restituita con successo, il modello dovrà contenere due occorrenze di caratteri escape seguiti da un doppio apice ("). Il testo che corrisponde alla porzione del modello compresa tra questi due marcatori viene restituita.

Alcuni esempi, con #" che delimita la stringa di ritorno:

substring('foobar' from '%#"o_b#"%' for '#')   oob
substring('foobar' from '#"o_b#"%' for '#')    NULL

9.7.3. Espressioni regolari POSIX

La Tabella 9.11, «Operatori di confronto per espressioni regolari» elenca gli operatori disponibili per i confronti di modelli usando le espressioni regolari POSIX.

Tabella 9.11. Operatori di confronto per espressioni regolari

OperatoreDescrizioneEsempio
~ Confronta espressioni regolari, sensibile alle maiuscole'thomas' ~ '.*thomas.*'
~* confronta espressioni regolari, insensibile alle maiuscole'thomas' ~* '.*Thomas.*'
!~ Non confronta espressioni regolari, sensibile alle maiuscole'thomas' !~ '.*Thomas.*'
!~* Non confronta espressioni regolari, insensibile alle maiuscole'thomas' !~* '.*vadim.*'

Le espressioni regolari POSIX forniscono un mezzo più potente, per il confronto con modelli, degli operatori LIKE e SIMILAR TO. Alcuni strumenti Unix quali egrep, sed, o awk usano un linguaggio di confronto di modelli che è simile a quello descritto quì.

Un'espressione regolare è una sequenza di caratteri che è una definizione abbreviata di un insieme di stringhe (un insieme regolare). Si dice che una stringa corrisponde a un'espressione regolare, se essa fa parte dell'insieme regolare descritto dall'espressione regolare. Come con LIKE, i caratteri del modelloi combaciano esattamente con i caratteri della stringa a meno che essi non siano caratteri speciali nel linguaggio dell'espressione regolare -- ma le espressioni regolari usano caratteri speciali diversi da quelli usati da LIKE. A differenza dei modelli LIKE, ad un'espressione regolare è consentito avere una corrispondenza dovunque all'interno di una stringa, a meno che l'espressione regolare non sia esplicitamente ancorata all'inizio o all'estremità della stringa.

Alcuni esempi:

'abc' ~ 'abc'    true
'abc' ~ '^a'     true
'abc' ~ '(b|d)'  true
'abc' ~ '^(b|c)' false

Il linguaggio dei modello POSIX è descritto in maggiori dettagli sotto.

La funzione substring con due parametri, substring(string, from pattern), fornisce l'estrazione di una sottostringa che corrisponde ad un modello di espressione regolare POSIX. Essa restituisce null se non c'è abbinamento, altrimenti restituisce la porzione del testo che corrisponde al modello. Ma se il modello contiene parentesi, viene restituita la porzione del testo che abbina la prima sottoespressione tra parentesi (quella la cui parentesi di sinistra viene per prima). È possibile mettere tra parentesi l'intera espressione se si vogliono usare parentesi all'interno di essa senza innescare la suddetta eccezione. Se si necessitano parentesi nel modello prima della espressioneespressione che si vuole estrarre, vedere le parentesi non catturanti descritte sotto.

Alcuni esempi:

substring('foobar' from 'o.b')     oob
substring('foobar' from 'o(.)b')   o

La funzione regexp_replace fornisce sostituzioni di testo per sottostringhe che combaciano con modelli di espressioni regolari POSIX. Essa ha la sintassi regexp_replace(source, pattern, substitution [, flags ]). La stringa source viene restituita non modificata se non c'è abbinamento con il pattern. Se c'è una corrispondenza, la stringa source viene restituita con la stringa substitution che rimpiazza la sottostringa corrispondente. La stringa substitution può contenere \n, dove n è un valore da 1 a 9, per indicare che la sottostringa sorgente che corrisponde alla n-esima sottoespressione parentesizzata deve essere inserita, ed essa può contenere \& per indicare che deve essere inserita la sottostringa che abbina il modello intero. Scrivere \\ se si vuole inserire un letterale barra inversa nel testo di sostituzione. (Come sempre, ricordarsi di raddoppiare le barre inverse scritte nella costante letterale stringa, presupponendo che si stia utilizzando la sintassi escape di stringa). Il parametro flags è un stringa di testo opzionale contenente zero o più flag a lettera singola che cambiano il comportamento della funzione. Il flag i specifica un confronto non sensibile alle maiuscole, mentre il flag g specifica la sostituzione di ogni sottostringa abbinata e non solo della prima. Altri flag supportati sono descritti nella tabella Tabella 9.19, «Lettere per le opzioni incorporate nelle ARE».

Alcuni esempi:

regexp_replace('foobarbaz', 'b..', 'X')
                                   fooXbaz
regexp_replace('foobarbaz', 'b..', 'X', 'g')
                                   fooXX
regexp_replace('foobarbaz', 'b(..)', E'X\\1Y', 'g')
                                   fooXarYXazY

La funzione regexp_matches ritorna un array di testo di tutte le sottostringhe catturate che risultano corrispondere a un modello di espressione regolare POSIX. Essa ha la sintassi regexp_matches(string, pattern [, flag ]). La funzione può restituire nessuna riga, una riga, o molte righe (vedere la flag g sotto). Se il pattern non corrisponde, la funzione non restituisce nessuna riga. Se il modello contiene sottoespressioni non parentesizzate, allora ogni riga ritornata è un array di testo di un solo elemento contenente la sottostringa che combacia con l'intero modello. Se il modello contiene sottoespressioni tra parentesi, la funzione ritorna un array di testo di cui l'n-simo è la sottostringa corrispondente all'n-sima sottoespressione tra parentesi del modello (senza contare le parentesi «non catturanti»; si veda sotto per dettagli). Il parametro flag è una stringa di testo opzionale contenente zero o più flag di una lettera che cambiano il comportamento della funzione. La flag g fa sì che la funzione trovi ogni occorrenza nella stringa, non solo la prima, e restituisca una riga per ogni occorrenza. Altre flag supportate sono descritte in Tabella 9.19, «Lettere per le opzioni incorporate nelle ARE».

Alcuni esempi:

SELECT regexp_matches('foobarbequebaz', '(bar)(beque)');
 regexp_matches 
----------------
 {bar,beque}
(1 row)

SELECT regexp_matches('foobarbequebazilbarfbonk', '(b[^b]+)(b[^b]+)', 'g');
 regexp_matches 
----------------
 {bar,beque}
 {bazil,barf}
(2 rows)

SELECT regexp_matches('foobarbequebaz', 'barbeque');
 regexp_matches 
----------------
 {barbeque}
(1 row)

È possibile forzare regexp_matches() a ritornare sempre una riga usando una sotto-select; Questo è particolarmente utile in una SELECT quando si vuole che tutte le righe siano ritornate, non solo quelle corrispondenti al modello:

SELECT col1, (SELECT regexp_matches(col2, '(bar)(beque)')) FROM tab;

La funzione regexp_split_to_table divide una stringa utilizzando un modello di espressione regolare POSIX come delimitatore. Essa ha la sintassi regexp_split_to_table(string, pattern [, flag ]). Se non c'è abbinamento con il pattern, la funzione restituisce la string. Se c'è almeno un abbinamento, per ogni abbinamento essa restituisce il testo dalla fine del precedente abbinamento (o dall'inizio della stringa) all'inizio dell'attuale abbinamento. Quando non ci sono più corrispondenze, essa restituisce il testo dalla fine dell'ultimo abbinamento alla fine della stringa. Il parametro flag è un opzionale stringa di testo contenente zero o più flag a singola-lettera che modifica il comportamento della funzione. regexp_split_to_table supporta i flag descritti nella tabella Tabella 9.19, «Lettere per le opzioni incorporate nelle ARE».

La funzione regexp_split_to_array si comporta come regexp_split_to_table, eccetto che regexp_split_to_array restituisce i suoi risultati come un'array di testo. Essa usa la sintassi regexp_split_to_array(string, pattern [, flag ]). I parametri sono gli stessi di regexp_split_to_table.

Alcuni esempi:


SELECT foo FROM regexp_split_to_table('the quick brown fox jumped over the lazy dog', E'\\s+') AS foo;
  foo   
--------
 the    
 quick  
 brown  
 fox    
 jumped 
 over   
 the    
 lazy   
 dog    
(9 rows)

SELECT regexp_split_to_array('the quick brown fox jumped over the lazy dog', E'\\s+');
              regexp_split_to_array             
------------------------------------------------
 {the,quick,brown,fox,jumped,over,the,lazy,dog}
(1 row)

SELECT foo FROM regexp_split_to_table('the quick brown fox', E'\\s*') AS foo;
 foo 
-----
 t         
 h         
 e         
 q         
 u         
 i         
 c         
 k         
 b         
 r         
 o         
 w         
 n         
 f         
 o         
 x         
(16 rows)

Come dimostra l'ultimo esempio, la funzione regexp split ignora abbinamenti con lunghezza-zero che si verificano all'inizio o alla fine della stringa o immediatamente dopo un precedente abbinamento. Ciò è contrario alla esatta definizione di confronto regexp implementata da regexp_matches, ma in pratica è il comportamento più conveniente. Altri sistemi software come Perl usano simili definizioni.

9.7.3.1. Dettagli sulle espressioni regolari

Le espressioni regolari PostgreSQL™ vengono implementate usando un pacchetto scritto da Henry Spencer. Gran parte delle descrizioni delle espressioni regolari esposte sotto è copiata letteralmente dal suo manuale.

Le espressioni regolari (RE), come definite in POSIX 1003.2, si presentano in due forme: RE estesa o ERE (all'incirca quella di egrep), e RE di base o BRE (all'incirca quella di ed). PostgreSQL™ supporta ambedue le forme, e implementa alcune estensioni che non sono nello standard POSIX, ma che sono state comunque ampiamente usate per la loro validità in linguaggi di programmazione quali Perl e Tcl. In questa documentazione, le RE che usano queste estensioni non-POSIX sono chiamate RE avanzate o ARE. Le ARE sono un sottoinsieme delle ERE, ma le BRE hanno maggiori incompatibilità notazionali (oltre ad essere molto più limitate). Verranno descritte prima le forme ARE ed ERE, rilevando le caratteristiche che si applicano solo alle ARE e in seguito come si differenziano dalle BRE.

[Nota]

Nota

PostgreSQL™ inizialmente presume sempre che un'espressione regolare segua le regole ARE. Comunque, le più limitate regole ERE o BRE posso essere scelte prececendo la RE da un'opzione, come descritto in Sezione 9.7.3.4, «Metasintassi nelle espressioni regolari». Questo può essere utile per compatibilità con applicazioni che si aspettano esattamente le regole POSIX 1003.2.

Una espressione regolare è definita come una o più diramazioni, separate da |. Essa confronta ogni cosa che corrisponde ad almeno una delle diramazioni.

Una diramazione è composta da zero o più atomi quantificati o vincoli, concatenati tra loro. Essa corrisponde ad un confronto per il primo, seguita da un confronto per il secondo, ecc; Una ramificazione vuota equivale a una stringa vuota.

Un atomo quantificato è un atomo seguito da un singolo quantificatore. Senza un quantificatore, esso corrisponde ad un occorrenza dell'atomo. Con un quantificatore, esso può corrispondere ad un certo numero di occorrenze dell'atomo. Un atomo può essere una delle possibilità mostrate nella tabella Tabella 9.12, «Atomi nelle espressioni regolari». I possibili quantificatori ed il loro significato sono mostrati nella tabella Tabella 9.13, «Quantificatori nelle espressioni regolari».

Un vincolo corrisponde ad una stringa vuota, ma combacia solo quando vengono incontrate specifiche condizioni. Un vincolo può essere usato quando può essere usato un atomo, ad eccezione che esso non sia seguito da un quantificatore. Un semplice vincolo è mostrato nella tabella Tabella 9.14, «Vincoli nelle espressioni regolari»; Alcuni altri vincoli sono descritti in seguito.

Tabella 9.12. Atomi nelle espressioni regolari

AtomoDescrizione
(re) (dove re è una espressione regolare) corrisponde ad un confronto con re, con il confronto notato per un possibile rapporto
(?:re) come sopra, ma il confronto non è notato per un rapporto (un insieme di parentesi «non-catturanti») (solo ARE)
. confronta ogni singolo carattere
[carat] una espressione tra parentesi quadre, confronta ognuno dei carat (consultare Sezione 9.7.3.2, «Espressioni tra parentesi quadre» per ulteriori dettagli)
\k (dove k è un carattere non-alfabetico) confronta quel carattere preso come un carattere ordinario, per esempio \\ confronta un carattere di barra inversa
\c dove c è alfanumerico (eventualmente seguito da altri caratteri) è un escape, consultare Sezione 9.7.3.3, «Escape nelle espressioni regolari» (solo per le ARE; nelle ERE e nelle BRE, viene confrontato c)
{ quando seguita da un carattere che non sia una cifra, confronta il carattere a sinistra della parentesi {; quando seguita da una cifra, essa è l'inizio di un limit (vedere sotto)
x dove x è un singolo carattere senza nessuna altro significato, confronta quel carattere

Una RE non puà terminare con \.

[Nota]

Nota

Ricordare che la barra inversa (\) ha già uno speciale significato nei letterali stringa di PostgreSQL™. Per scrivere una costante di un modello che contiene una barra inversa, bisogna scrivere due barre inverse nell'istruzione, presupponendo di utilizzare la sintassi di stringa escape (consultare Sezione 4.1.2.1, «Costanti stringa»).

Tabella 9.13. Quantificatori nelle espressioni regolari

QuantificatoreConfronti
* una sequenza di 0 o più confronti dell'atomo
+ una sequenza di uno o più confronti dell'atomo
? una sequenza di 0 o 1 confronti dell'atomo
{m} una sequenza di esattamente m confronti dell'atomo
{m,} una sequenza di m o più confronti dell'atomo
{m,n} una sequenza di confronti dell'atomo da m fino a n (compreso); m non può essere maggiore di n
*? versione non-avida di *
+? versione non-avida di +
?? versione non-avida di ?
{m}? versione non-avida di {m}
{m,}? versione non-avida di {m,}
{m,n}? versione non-avida di {m,n}

Le forme che utilizzano {...} sono conosciute come limiti. I numeri m e n in un limite sono interi decimali senza segno con estensione consentita da 0 a 255 compreso.

I quantificatori non-avidi (disponibili solo nelle ARE) confrontano le stessa possibilità dei loro simili corrispondenti normali (avidi), ma preferiscono il più piccolo numero di confronti invece del massimo numero di confronti. Consultare Sezione 9.7.3.5, «Regole di confronto nelle espressioni regolari» per ulteriori dettagli.

[Nota]

Nota

Un quantificatore non può venire subito dopo un altro quantificatore. Un quantificatore non può iniziare un'espressione o una sottoespressione o seguire ^ o |.

Tabella 9.14. Vincoli nelle espressioni regolari

VincoloDescrizione
^ confronto all'inizio della stringa
$ confronto alla fine della stringa
(?=re) lookahead positivo confronta ogni punto in cui una sottostringa abbina l'inizio della re (solo ARE)
(?!re) lookahead negativo confronta ogni punto in cui una sottostringa non abbina l'inizio della re (solo ARE)

I vincoli lookahead non possono contenere riferimenti all'indietro (consultare Sezione 9.7.3.3, «Escape nelle espressioni regolari»), e tutte le parentesi in essi contenute sono considerate non-catturanti.

9.7.3.2. Espressioni tra parentesi quadre

Una espressione tra parentesi quadre è un elenco di caratteri racchiusi tra []. Essa normalmente combacia con ogni singolo carattere dell'elenco (ma vedere sotto). Se l'elenco comincia con ^, essa abbina ogni singolo carattere non compreso nell'elenco. Se due caratteri dell'elenco sono separati da -, questa è una scorciatoia per indicare l'intervallo completo dei caratteri compresi tra loro due nella sequenza di collazione, per esempio [0-9] in ASCII abbina ogni cifra decimale. è illegale per due estensioni codividere un punto finale, per esempio a-c-e. Le estensioni sono completamente dipendenti dalla sequenza di collazione, per cui programmi portabili dovrebbero evitare di usarle.

Per includere un letterale ] nell'elenco, renderlo primo carattere (al seguito di un possibile ^). Per includere un letterale -, renderlo primo o ultimo carattere, o secondo punto finale di un'estensione. Per usare un letterale - come primo punto finale di un'estensione, racchiuderlo tra [. e .] per renderlo un elemento di collazione (vedere sotto). Con l'eccezione di questi caratteri, usando alcune combinazioni [ (vedere il seguente paragrafo), ed escape (solo ARE), tutti gli altri caratteri speciali perdono il loro significato speciale all'interno di una espressione tra parentesi quadre. In particolare, \ non è speciale quando segue le regole ERE o BRE, benchè esso sia speciale (come introduttore di un escape) in ARE.

[Nota]

Nota

Nota per il revisore: il paragrafo successivo mi dà problemi, specialmente il verbo collate, che in italiano è collazionare.

Within a bracket expression, a collating element (a character, a multiple-character sequence that collates as if it were a single character, or a collating-sequence name for either) enclosed in [. and .] stands for the sequence of characters of that collating element. The sequence is treated as a single element of the bracket expression's list. This allows a bracket expression containing a multiple-character collating element to match more than one character, e.g., if the collating sequence includes a ch collating element, then the RE [[.ch.]]*c matches the first five characters of chchcc.

[Nota]

Nota

PostgreSQL™ attualmente non supporta elementi di collazione multicarattere. Questa informazione descrive possibili futuri comportamenti.

Dentro un espressione tra parentesi quadre, un elemento di collazione racchiuso tra [= e =] è una classe di equivalenza, che corrisponde alla sequenza di caratteri di tutti gli elementi di collazione equivalenti a quello, includendo se stesso. (Se non ci sono altri elementi di collazione equivalenti, il trattamento è lo stesso come se i delimitatori includenti fossero stati [. e .]). Per esempio, se o e ^ sono i membri di una classe di equivalenza, quindi [[=o=]], [[=^=]], e [o^] sono tutti sinonimi. Una classe di equivalenza non può essere il punto finale di un intervallo.

Dentro un'espressione tra parentesi quadre, il nome di una classe di caratteri racchiuso tra [: e :] sta per l'elenco di tutti i caratteri appartenenti a quella classe. Nomi standard di classi di caratteri sono: alnum, alpha, blank, cntrl, digit, graph, lower, print, punct, space, upper, xdigit. Questo sta per le classi di caratteri definite in ctype(3). Una localizzazione può prevederne altre. Una classe di caratteri non può essere usata come un punto finale di un intervallo.

Ci sono due casi speciali di espressioni tra parentesi quadre: le espressioni [[:<:]] e [[:>:]] sono vincoli, abbinano stringhe vuote, rispettivamente, all'inizio e alla fine di una parola. Una parola è definita come una sequenza di caratteri che non è preceduta nè seguita da caratteri. Un carattere parola è un carattere alnum (come definito da ctype(3)) o un carattere di sottolineatura. Questa è una estensione, compatibile con, ma non specificato da POSIX 1003.2 e dovrebbe essere usato con attenzione nei software intesi per essere portabili su altri sistemi. I vincoli escape descritti di seguito sono normalmente preferibili (essi non sono più standard, ma sono certamente più facili da scrivere).

9.7.3.3. Escape nelle espressioni regolari

Gli escape sono sequenze speciali che iniziano con \ seguito da un carattere alfanumerico. Gli escape si presentano in diverse varietà: per immissioni di caratteri, per scorciatoie di classi, per vincoli escape, e per riferimenti all'indietro. Una \ seguita da un carattere alfanumerico ma non costituente un valido escape è illegale nelle ARE. Nelle ERE, non ci sono escape: al di fuori di una espressione tra parentesi quadre, una \ seguita da un carattere alfanumerico sta solamente ad indicare quel carattere come un carattere ordinario e dentro una espressione tra parentesi quadre, \ è un carattere ordinario. (Quest'ultima è l'unica attuale incompatibilità tra le ERE e le ARE).

Gli escape per immissione caratteri esistono per rendere più facile specificare caratteri non-stampabili ed altri fastidiosi caratteri nelle RE. Essi sono mostrati nella tabella Tabella 9.15, «Escape per immissione caratteri nelle espressioni regolari».

Gli escape per scorciatoie di classe forniscono scorciatoie per certi classi di caratteri normalmente utilizzate. Esse sono mostrate nella tabella Tabella 9.16, «Escape per scorciatoie di classe nelle espressioni regolari».

Un escape di vincolo è un vincolo, abbinante una stringa vuota se le specifiche condizioni sono soddisfatte, scritto come un escape. Essi sono mostrati nella tabella Tabella 9.17, «Escape di vincolo nelle espressioni regolari».

Un riferimento all'indietro (\n) abbina la stessa stringa abbinata dalla precedente sottoespressione specificata dal numero n (consultare la tabella Tabella 9.18, «Riferimenti all'indietro nelle espressioni regolari»). Per esempio, ([bc])\1 abbina bb o cc ma non bc o cb. La sottoespressione deve interamente precedere il riferimento all'indietro nelle RE. Le subespressioni sono numerate secondo l'ordine della parentesi di apertura. Le parentesi non-catturanti non definiscono subespressioni.

[Nota]

Nota

Ricordarsi che l'escape in testa \ dovrà essere raddoppiato quando si immette il modello come una costante stringa SQL. Per esempio:

'123' ~ E'^\\d{3}' true

Tabella 9.15. Escape per immissione caratteri nelle espressioni regolari

EscapeDescrizione
\a carattere di attenzione (campanello), come in C
\b backspace, come in C
\B sinonimo per \ aiuta a ridurre la necessità di raddoppiare le barre inverse
\cX (dove X è qualsiasi carattere) il carattere i cui 5 bit di ordine più basso sono gli stessi di X, e gli altri bit sono tutti a zero
\e il carattere il cui nome di sequenza di collazione è ESC, o in mancanza di questo, il carattere il cui valore ottale è 033
\f avanzamento pagina, come in C
\n nuova riga, come in C
\r ritorno carrello, come in C
\t tabulazione orizzontale, come in C
\uwxyz (dove wxyz sono esattamente quattro cifre esadecimali) il carattere UTF16 (Unicode, 16-bit) U+wxyz nel byte ordering locale
\Ustuvwxyz (dove stuvwxyz sono esattamente otto cifre esadecimali) riservato per una estensione Unicode a 32 bit piuttosto ipotetica
\v tabulazione verticale, come in C
\xhhh (dove hhh è una sequenza di cifre esadecimali) il carattere il cui valore esadecimale è 0xhhh (un singolo carattere non importa quante cifre esadecimali sono usate)
\0 il carattere il cui valore è 0
\xy (dove xy è esattamente due cifre ottali, e non è un riferimento all'indietro) il carattere il cui valore ottale è 0xy
\xyz (dove xyz è esattamente tre cifre ottali, e non è un riferimento all'indietro) il carattere il cui valore ottale è 0xyz

Le cifre esadecimali sono 0-9, a-f, e A-F. Le cifre ottali sono 0-7.

Il carattere escape viene sempre preso come un carattere ordinario. Per esempio, \135 è ] in ASCII, ma \135 non termina una espressione tra parentesi quadre.

Tabella 9.16. Escape per scorciatoie di classe nelle espressioni regolari

EscapeDescrizione
\d [[:digit:]]
\s [[:space:]]
\w [[:alnum:]_] (notare che la sottolineatura è compresa)
\D [^[:digit:]]
\S [^[:space:]]
\W [^[:alnum:]_] (notare che la sottolineatura è compresa)

Nelle espressioni tra parentesi quadre, \d, \s, e \w perdono le loro parentesi esterne, e \D, \S, e \W sono illegali. (Per cui, per esempio, [a-c\d] è equivalente a [a-c[:digit:]]. Mentre, [a-c\D], che sarebbe equivalente a [a-c^[:digit:]], è illegale).

Tabella 9.17. Escape di vincolo nelle espressioni regolari

EscapeDescrizione
\A confronta solo all'inizio della stringa (consultare Sezione 9.7.3.5, «Regole di confronto nelle espressioni regolari» per come questo differisce da ^)
\m confronta solo all'inizio di una parola
\M confronta solo alla fine di una parola
\y confronta solo all'inizio o alla fine di una parola
\Y confronta solo ad un punto che non è l'inizio o la fine di una parola
\Z confronta solo alla fine della stringa (consultare Sezione 9.7.3.5, «Regole di confronto nelle espressioni regolari» per come questo differisce da $)

Una parola è definita come nella specificazione di [[:<:]] e [[:>:]] sopra. Gli escape di vincolo sono illegali nelle espressioni tra parentesi quadre.

Tabella 9.18. Riferimenti all'indietro nelle espressioni regolari

EscapeDescrizione
\m (dove m è una cifra diversa da zero) un riferimento all'indietro alla m-esima sottoespressione
\mnn (dove m è una cifra diversa da zero, e nn sono alcune altre cifre, ed il valore decimale mnn non è maggiore del numero di parentesi chiuse catturanti viste finora) un riferimento all'indietro alla mnn-esima sottoespressione

[Nota]

Nota

C'è una ambiguità storica tra la escape ottale per immissione caratteri ed i riferimenti all'indietro, che è risolta dalla seguente euristica, come suggerito sopra. Uno zero in testa indica sempre un escape ottale. Una cifra singola diversa da zero, non seguita da un altra cifra, viene sempre presa come un riferimento all'indietro. Una sequenza di diverse cifre che non ha uno zero in testa viene presa come un riferimento all'indietro se viene dopo una adatta sottoespressione (cioè il numero è compreso nell'intervallo valido per un riferimento all'indietro), altrimenti viene considerato come ottale.

9.7.3.4. Metasintassi nelle espressioni regolari

In aggiunta alla sintassi principale descritta sopra, sono disponibili alcune forme speciali e un assortimento di agevolazioni sintattiche.

[Nota]

Nota

Nota per il revisore: director?

Una RE può cominciare con uno dei due prefissi director speciali. Se una RE comincia con ***:, il resto della RE è preso come una ARE. (Questo normalmente non ha effetto in PostgreSQL™, dato che le RE sono assunte essere ARE; Ma ha effetto se è stato specificato ERE o BRE come parametro di flag per una funzione regex). Se una RE comincia con ***=, il resto della RE è assunto essere una stringa letterale, con tutti i caratteri considerati normali caratteri.

Una ARE può iniziare con opzioni incorporate: una sequenza (?xyz) (dove xyz è uno o più caratteri alfabetici) specifica opzioni che interessano il resto della RE. Queste opzioni sovrascrivono opzioni precedentemente determinate -- in particolare, possono sovrascrivere il comportamento della sensibilità alle maiuscole implicito di un operatore regex, o il parametro flag di una funzione regex. Le lettere per le opzionai disponibili sono mostrate nella tabella Tabella 9.19, «Lettere per le opzioni incorporate nelle ARE». Notare che queste stesse opzioni sono usate nei parametri flag delle funzioni regex.

Tabella 9.19. Lettere per le opzioni incorporate nelle ARE

OpzioneDescrizione
b il resto della RE è una BRE
c confronto sensibile alle maiuscole (sovrascrive il tipo di operatore)
e il resto della RE è una ERE
i confronto non sensibile alle maiuscole (consutare Sezione 9.7.3.5, «Regole di confronto nelle espressioni regolari») (sovrascrive il tipo di operatore)
m sinonimo storico per n
n confronto sensibile al newline (consultare Sezione 9.7.3.5, «Regole di confronto nelle espressioni regolari»)
p confronto parzialmente sensibile al newline (consultare Sezione 9.7.3.5, «Regole di confronto nelle espressioni regolari»)
q il resto della RE è un stringa letterale («tra apici»), sono tutti caratteri ordinari
s confronto non sensibile al newline (predefinito)
t sintassi stretta (predefinita; vedere sotto)
w confronto («bizzarro») parzialmente sensibile al newline inverso (consultare Sezione 9.7.3.5, «Regole di confronto nelle espressioni regolari»)
x sintassi espansa (si veda sotto)

Le opzioni incorporate hanno effetto dopo ) che termina la sequenza. Esse possono apparire solo all'inizio di una ARE (dopo il ***: se presente).

In aggiunta alla normale (stretta) sintassi delle RE, in cui tutti i caratteri sono significativi, c'è una sintassi espansa, disponibile specificando l'opzione incorporata x. Nella sintassi espansa, i caratteri spazio vuoto nelle RE vengono ignorati, come pure tutti i caratteri tra un # e la successiva newline (o la fine della RE). Questo consente di paragrafare e commentare una RE complessa. Ci sono tre eccezioni alle regole di base:

  • un carattere spazio vuoto o # preceduto da \ viene mantenuto

  • Uno spazio vuoto o un # dentro una espressione tra parentesi viene mantenuto

  • spazi vuoti e commenti possono apparire dentro simboli multicarattere, come (?:

Per questo scopo, i caratteri di spazio vuoto sono blank, tab, newline, e ogni carattere che appartiene alla classe dei caratteri space.

Infine, nelle ARE, al di fuori delle espressioni tra parentesi quadre, la sequenza (?#ttt) (dove ttt è ogni testo non contenente una )) è un commento, completamente ignorato. Per concludere, questo non è consentito tra i caratteri di simboli multicarattere, come (?:. Tali commenti sono più un manufatto storico che una funzione utile, e il loro uso è deprecabile; conviene utilizzare invece la sintassi espansa.

[Nota]

Nota

Nota per il revisore: director?

Nessuna di queste espansioni di metasintassi sarà disponibile se un director iniziale ***= ha specificato che l'input dell'utente sarà trattato come una stringa letterale anzichè come una RE.

9.7.3.5. Regole di confronto nelle espressioni regolari

Nel caso che una RE possa abbinare più di una sottostringa in una stringa fornita, la RE combacia con quella che viene incontrata per prima nella stringa. A questo punto, se la RE può abbinare più di una sottostringa, sarà preso l'abbinamento più lungo possibile o il più corto possibile, a seconda che la RE sia avida o non-avida.

Se una RE è avida o meno, viene determinato dalle seguenti regole:

  • La maggior parte degli atomi e tutti i vincoli, non hanno attributo di avidità (perchè essi non possono comunque abbinare variabili di testo).

  • L'aggiunta di parentesi intorno ad una RE non modifica il suo attributo di avidità.

  • Un atomo quantificato con un quantificatore di ripetizione fissato ({m} o {m}?) ha lo stesso attributo di avidità (probabilmente nessuno) dell'atomo stesso.

  • Un atomo quantificato con altri normali quantificatori (compreso {m,n} con m uguale a n) è avido (preferisce l'abbinamneto più lungo).

  • Un atomo quantificato con un quantificatore non-avido (compreso {m,n}? con m uguale a n) è non-avido (preferisce l'abbinamento più corto).

  • Un ramo -- che è, una RE che non ha un operatore | di livello superiore -- ha lo stesso attributo di avidità del primo atomo quantificato, contenuto in esso, che ha un attributo di avidità.

  • Una RE consistente di due o più rami connessi dall'operatore | è sempre avido.

Le regole sopra associano gli attributi di avidità non solo con singoli atomi quantificati, ma con i rami e le intere RE che contengono atomi quantificati. Questo significa che l'abbinamento viene fatto in modo che il ramo, o l'intera RE, abbinano complessivamente la più lunga o la più corta possibile sottostringa. Una volta determinata la lunghezza dell'intero abbinamento, la parte di esso che abbina ogni particolare sottoespressione viene determinata sulla base dell'attributo di avidità di quella sottoespressione, con le sottoespressioni che cominciano prima nella RE che prendono la priorità su quelle che cominciano dopo.

Un esempio di cosa significa questo:

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

Nel primo caso, la RE è complessivamente avida perchè Y* è avido. Esso può corrispondere cominciando dalla Y, e corrisponde la stringa più lunga possibile partendo da lì, cioè, Y123. L'output è la parte tra parentesi di essa, o 123. Nel secondo caso, la RE è complessivamente non-avida perchè Y*? è non-avido. Essa può abbinare cominciando dalla Y, e abbinare la stringa più corta possibile partendo da lì, cioè, Y1. La sottoespressione [0-9]{1,3} è avida ma essa non può cambiare la decisione relativa alla lunghezza complessiva dell'abbinamento; per cui è forzata ad abbinare solo 1.

In breve, quando una RE contiene sottoespressioni sia avide che non-avide, la lunghezza totale dell'abbinamento può essere la più lunga possibile o la più corta possibile, in funzione dell'attributo assegnato all'intera RE. Gli attributi assegnati alle sottoespressioni riguardano solo la quantità di abbinamenti che essi possono «mangiare» rispetto ad ogni altro.

I quantificatori {1,1} e {1,1}? possono essere usati per forzare, rispettivamente, avidità o non-avidità in una sottoespressione o in una intera RE.

Le lunghezze degli abbinamenti sono misurate in caratteri e non in elementi di collazione. Una stringa vuota è considerata più lunga di nessun abbinamento. Per esempio: bb* abbina i tre caratteri in mezzo ad abbbc; (week|wee)(night|knights) abbina tutti e dieci i caratteri di weeknights; quando (.*).* viene confrontata con abc la sottoespressione tra parentesi abbina tutti e tre i caratteri; e quando (a*)* viene confrontata con bc sia l'intera RE che la sottoespressione tra parentesi abbinano una stringa vuota.

Se si specifica un confronto non sensibile alle maiuscole, l'effetto è che tutte le distinzioni tra maiuscole e minuscole scompaiono dall'alfabeto. Quando un carattere alfabetico che esiste sia nel formato maiuscolo che minuscolo compare come un carattere ordinario al di fuori di una parentesi quadra, esso viene effettivamente trasformato in una espressione tra parentesi quadre, contenente ambedue i formati, per es. x diventa [xX]. Quando esso appare dentro una espressione tra parentesi quadre, tutti i formati complementari ad esso vengono aggiunti nella espressione tra parentesi quadre, per esempio [x] diventa [xX] e [^x] diventa [^xX].

Se si specifica un confronto sensibile al newline, il . e le espressioni tra parentesi quadre che utilizzano ^ non abbineranno mai il carattere di newline (per cui tutti i confronti non incroceranno mai newline a meno che la RE non lo disponga esplicitamente) e ^ e $ abbineranno la stringa vuota, rispettivamente, dopo e prima un newline, in aggiunta all'abbinamento rispettivamente all'inizio e alla fine della stringa. Ma gli escape ARE \A e \Z continueranno ad abbinare solo l'inizio e la fine della stringa.

Se viene specificato un confronto parzialmente sensibile al newline, questo influenza il . e le espressioni tra parentesi quadre come con il confronto sensibile al newline, ma non ^ e $.

Se viene specificato un confronto inverso parzialmente sensibile al newline, questo influenza ^ e $ come con il confronto sensibile al newline, ma non il . e le espressioni tra parentesi quadre. Questo non è molto utile, ma è fornito per simmetria.

9.7.3.6. Limiti e compatibilità

Nessun limite particolare è imposto sulla lunghezza delle RE in questa implementazione. Tuttavia, i programmi intesi per essere altamente portabili non dovrebbero impiegare RE più lunghe di 256 byte, poichè un'implementazione conforme-POSIX può rifiutarsi di accettare tali RE.

La sola caratteristica delle ARE che è attualmente incompatibile con le ERE POSIX è che \ non perde il suo significato speciale nelle espressioni tra parentesi quadre. Tutte le altre caratteristiche ARE usano una sintassi che è illegale o ha effetti non definiti o non specificati nelle ERE; la sintassi dei director *** è anch'essa al di fuori della sintassi POSIX sia per le BRE che per le ERE.

Molte delle estensioni ARE sono prese in prestito dal Perl, ma alcune sono state cambiate per pulirle, e alcune altre estensioni Perl non sono presenti. La note di incompatibilità includono \b, \B, l'assenza di un trattamento speciale per le newline finale, l'aggiunta di espressioni tra parentesi quadre complementate alle cose influenzate dai confronti sensibili al newline, le restrizioni nelle parentesi e nei riferimenti all'indietro nei vincoli lookahead, e la semantica di confronto più lungo/più corto (invece di quella prima-occorrenza).

Due incompatibilità significative esistono tra la sintassi delle ARE e delle ERE riconosciuta dalle versioni precedenti la 7.4 di PostgreSQL™:

  • Nelle ARE, \ seguito da un carattere alfabetico o è un escape oppure un errore, mentre nelle versioni precedenti, esso era solo un altro modo per scrivere l'alfanumerico. Questo non doveva essere un grande problema in quanto non c'era ragione di scrivere una tale sequenza, nelle versioni precedenti.

  • Nelle ARE, \ rimane un carattere speciale dentro [], per cui un letterale \ dentro una espressione tra parentesi quadre deve essere scritto in questo modo: \\.

9.7.3.7. Espressioni regolari di base

Le BRE differiscono dalle ERE per diversi aspetti. Nelle BRE, |, +, e ? sono caratteri ordinari e non c'è equivalenza per le loro funzionalità. I delimitatori per i limiti sono \{ e \}, con { e } da soli caratteri ordinari. Le parentesi per le sottoespressioni annidate sono \( e \), con ( e ) da soli caratteri ordinari. ^ è un carattere ordinario eccetto che all'inizio della RE o all'inizio di una sottoespressione tra parentesi, $ è un carattere ordinario eccetto alla fine della RE o alla fine di una sottoespressione tra parentasi, e * è un carattere ordinario se appare all'inizio della RE o all'inizio di una espressione tra parentesi (dopo un possibile ^ iniziale). Infine, sono disponibili riferimenti all'indietro a cifra singola, e \< e \> sono sinonimi, rispettivamente, per [[:<:]] e [[:>:]]; nelle BRE non sono disponibili altri escape.

Documentazione di PostgreSQL 9.0 > Il linguaggio SQL > Funzioni e Operatori > Confronto con modelli
PrecedenteFunzioni e operatori per stringhe di bitFunzioni di formattazione dei tipi di datoSuccessivo