Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Si applica a:
SQL Server 2025 (17.x) Database SQL di AzureIstanza gestita di SQL di Azuredatabase SQL in Microsoft Fabric
Questo articolo presenta le espressioni regolari per SQL Server.
Un'espressione regolare, o regex, è una sequenza di caratteri che definisce un criterio di ricerca per il testo. Regex viene comunemente usato per un'ampia gamma di attività, tra cui criteri di ricerca, convalida dei dati, trasformazione dei dati ed esecuzione di query. Offre un modo flessibile ed efficiente per cercare, modificare e gestire operazioni di dati complesse.
Note
Le espressioni regolari sono disponibili in Istanza gestita di SQL di Azure con i criteri di aggiornamentodi SQL Server 2025 o Always-up-to-date.
Questa implementazione dell'espressione regolare è basata sulla libreria di espressioni regolari RE2. Per altre informazioni, vedere sintassi delle espressioni regolari RE2.
Funzioni regex supportate:
| Function | Description |
|---|---|
| REGEXP_LIKE | Restituisce un valore booleano che indica se l'input di testo corrisponde al modello regex. |
| REGEXP_REPLACE | Restituisce una stringa di origine modificata sostituita da una stringa di sostituzione, in cui è stata trovata l'occorrenza del criterio regex. |
| REGEXP_SUBSTR | Estrae parti di una stringa in base a un criterio di espressione regolare. Restituisce l'ennesima occorrenza di una sottostringa che corrisponde al pattern regex. |
| REGEXP_INSTR | Restituisce la posizione iniziale o finale della sottostringa corrispondente, a seconda dell'opzione specificata. |
| REGEXP_COUNT | Restituisce un conteggio del numero di volte in cui si verifica un criterio regex in una stringa. |
| REGEXP_MATCHES | Restituisce una tabella di sottostringhe acquisite che corrispondono a un criterio di espressione regolare a una stringa. Se non viene trovata alcuna corrispondenza, la funzione non restituisce alcuna riga. |
| REGEXP_SPLIT_TO_TABLE | Restituisce una tabella di stringhe suddivise, delimitate dal modello regex. Se non esiste alcuna corrispondenza con il pattern, la funzione restituisce la stringa. |
Le espressioni regolari possono essere composte da caratteri letterali e metacharacter, che hanno significati e funzioni speciali.
Un'espressione regolare di base è un singolo carattere letterale. I caratteri corrispondono a se stessi, ad eccezione dei metacharacter. I metacharacter includono *, +?, (, , )o |. Per trovare una corrispondenza con un metacaracter, eseguirne l'escape con una barra rovesciata. Ad esempio, \* corrisponde al carattere asterisco letterale (*).
È possibile modificare o concatenare due espressioni regolari per formare una nuova espressione regolare: se e1 corrisponde a se2 corrisponde a t, e1 | e2 corrisponde a s o te1e2 corrisponde a st.
I metacharacters *, +e ? sono operatori di ripetizione: e1* corrisponde a una sequenza di zero o più stringhe (possibilmente diverse), ognuna delle quali corrisponde a e1; e1 + corrisponde a una o più stringhe; e1? corrisponde a zero o uno.
La precedenza degli operatori, dall'associazione più debole a quella più forte, è la seguente: - Alternanza - Concatenazione - Operatori di ripetizione
Le parentesi esplicite possono essere usate per forzare significati diversi, come nelle espressioni aritmetiche. Alcuni esempi: ab|cd equivale a ; (ab)|(cd) equivale a aba(b).
Per altre informazioni sulla sintassi dell'espressione regolare accettata da RE2, vedere
Sintassi delle espressioni regolari RE2. Questa pagina elenca anche alcune sintassi accettate da PCRE, Perl e Vim.
Caratteri di espressione regolare accettati
Espressioni con caratteri singoli
| Tipi di espressioni a caratteri singoli | Examples |
|---|---|
| qualsiasi carattere, con possibile inclusione del carattere di nuova riga (s=true) | . |
| character class | [xyz] |
| classe di caratteri negata | [^xyz] |
| Classi di caratteri perl | \d |
| classe di caratteri negata di Perl | \D |
| Classi di caratteri ASCII | [[:alpha:]] |
| classe di caratteri ASCII negata | [[:^alpha:]] |
| classe di caratteri Unicode (nome di una lettera) | \pN |
| classe di caratteri Unicode | \p{Greek} |
| classe di caratteri Unicode negati (nome di una lettera) | \PN |
| classe di caratteri Unicode negati | \P{Greek} |
| Materiali compositi | Description |
|---|---|
xy |
x seguito da y |
x | y |
x o y (preferisce x) |
| Ripetizioni | Description |
|---|---|
x* |
zero o più x, preferibilmente di più |
x+ |
uno o più x, preferisci più |
x? |
zero o una x, preferibilmente una |
x{n,m} |
n o n+1 o ... o m x, preferisci di più |
x{n,} |
n o più x, preferisci valori maggiori |
x{n} |
esattamente n x |
x*? |
zero o più x, preferire meno |
x+? |
uno o più x, preferibilmente meno |
x?? |
zero o una x, preferisci zero |
x{n,m}? |
n o n+1 o ... o m x, preferire un numero inferiore |
x{n,}? |
n o più x, preferisce meno |
x{n}? |
esattamente n x |
Note
I moduli x{n,m}di conteggio , x{n,}e x{n} rifiutano i moduli che creano un numero minimo o massimo di ripetizioni superiore a 1.000. Le ripetizioni illimitate non sono soggette a questa restrizione.
Classi di caratteri perl
Nella tabella seguente sono elencate le classi di caratteri Perl attualmente supportate.
| Classi di caratteri di Perl (tutti solo ASCII) | Description |
|---|---|
\d |
cifre ( [0-9]) |
\D |
non cifre ([^0-9]) |
\s |
spazio bianco ( [\t\n\f\r ]) |
\S |
non spazio bianco ( [^\t\n\f\r ]) |
\w |
caratteri parola ( [0-9A-Za-z_]) |
\W |
non caratteri alfanumerici ( [^0-9A-Za-z_]) |
Classe di caratteri di ASCII
Nella tabella seguente sono elencate le classi di caratteri ASCII attualmente supportate.
| Classe di caratteri di ASCII | Description |
|---|---|
[[:alnum:]] |
alfanumerico ( [0-9A-Za-z]) |
[[:alpha:]] |
alfabetico ( [A-Za-z]) |
[[:ascii:]] |
ASCII ( [\x00-\x7F]) |
[[:blank:]] |
blank ( [\t ]) |
[[:cntrl:]] |
controllo ( [\x00-\x1F\x7F]) |
[[:digit:]] |
cifre ( [0-9]) |
[[:graph:]] |
grafico ( [!-~] o [A-Za-z0-9!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]) |
[[:lower:]] |
minuscolo ( [a-z]) |
[[:print:]] |
stampabile ( [ -~] o [ [:graph:]]) |
[[:punct:]] |
punteggiatura ( [!-/:-@[-\``{-~]) |
[[:space:]] |
spazio bianco ( [\t\n\v\f\r ]) |
[[:upper:]] |
maiuscole ( [A-Z]) |
[[:word:]] |
caratteri parola ( [0-9A-Za-z_]) |
[[:xdigit:]] |
cifra esadecimale ([0-9A-Fa-f]) |
Caratteri letterali
- Letters
- Numbers
- Symbols
Stringhe vuote
| Stringhe vuote | Description |
|---|---|
^ |
All'inizio del testo o della riga (m=true) |
$ |
Alla fine del testo (ad esempio \z, non \Z) o riga (m=true) |
\A |
All'inizio del testo |
\b |
In corrispondenza del limite della parola ASCII (\w su un lato e \W, \Ao \z sull'altro) |
\B |
Non al limite delle parole ASCII |
\z |
Alla fine del testo |
Groupings
Gruppo di acquisizione (sottoespressione) del modello con:
| Grouping | Description |
|---|---|
(re) |
Gruppo di cattura numerato (sottocorrispondenza) |
(?P<name>re) |
Gruppo di cattura con nome e numero (sottocorrispondenza) |
(?:re) |
Gruppo di non acquisizione |
(?<flags>) |
Imposta <flags> all'interno del gruppo corrente; senza acquisizione |
(?<flags>:re) |
Imposta <flags> durante re; raggruppamento non acquisente |
Flags
Usare i flag per modificare il comportamento dell'espressione. Per esempio:
| Flag | Description |
|---|---|
i |
Senza distinzione tra maiuscole e minuscole (impostazione predefinita false) |
m |
Modalità multilinea: ^ e $ corrispondono all'inizio/alla fine della riga oltre che all'inizio/alla fine del testo (impostazione predefinita false) |
s |
Consenti a . di corrispondere a \n (predefinito false) |
c |
Distinzione tra maiuscole e minuscole (impostazione predefinita true) |
Questa implementazione supporta lo standard POSIX delle espressioni regolari che seguono RE2 e supporta il gusto PCRE/PCRE2 della sintassi delle espressioni regolari, compatibile con i motori e gli strumenti di espressioni regolari più moderni. Esistono diversi tipi di espressioni regolari, ad esempio POSIX, ANSI, Perl e PCRE, con sintassi e funzionalità diverse. Per altre informazioni sui costrutti supportati e sul comportamento del motore regex sottostante, vedere RE2, una libreria di espressioni regolari.
Note
La corrispondenza delle espressioni regolari in SQL Server non rispetta le regole di confronto SQL per i confronti linguistici. Questo comportamento è progettato e coerente con la maggior parte dei motori di espressioni regolari, poiché la corrispondenza si basa sulle proprietà del criterio e dei caratteri Unicode anziché sulle regole di confronto. Di conseguenza, può causare differenze di comportamento rispetto ad altre funzioni di confronto di stringhe come LIKE, in particolare sulle colonne indicizzate con regole di confronto specifiche del linguaggio.
Requirements
- Uno strumento client SQL, ad esempio SQL Server Management Studio o Visual Studio Code.
- Conoscenza di base della sintassi e delle query SQL.
- Conoscenza di base della sintassi e dei concetti relativi alle espressioni regolari.
FAQ
Qual è l'impatto sulle prestazioni dell'uso delle regex?
Le query regex possono avere un impatto sulle prestazioni a seconda della complessità del modello regex, delle dimensioni dei dati di testo e del numero di righe coinvolte. È possibile usare il piano di esecuzione e le statistiche per monitorare e ottimizzare le prestazioni delle query regex.
Limitazioni
Attualmente si applicano le limitazioni seguenti:
- I tipi di dati LOB (varchar(max) o nvarchar(max)) per
string_expressionsono supportati in tutte leREGEXP_*funzioni, ma le dimensioni di input sono limitate a 2 MB. - Le funzioni di espressione regolare non sono supportate nelle stored procedure compilate in modo nativo.