Condividi tramite

Espressioni regolari

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 Nth occorrenza di una sottostringa che corrisponde al modello 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 criterio, 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 dell'operatore, dal binding più debole a quello più sicuro, è 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, eventualmente includendo newline (s=true) .
character class [xyz]
classe di carattere negativa [^xyz]
Classi di caratteri perl \d
classe di carattere di Perl negati \D
Classi di caratteri ASCII [[:alpha:]]
classe di carattere ASCII negati [[:^alpha:]]
classe di caratteri Unicode (nome di una lettera) \pN
classe di carattere Unicode negati \p{Greek}
classe di caratteri Unicode negati (nome di una lettera) \PN
classe di caratteri Unicode negati \P{Greek}
Compositi Description
xy x seguito da y
x | y x o y (preferisce x)
Ripetizioni Description
x* zero o più x, preferire più
x+ uno o più x, preferisce di più
x? zero o una x, preferisce una
x{n,m} n o n+1 o ... o m x, preferisce di più
x{n,} n o più x, preferisce di più
x{n} esattamente n x
x*? zero o più x, preferire meno
x+? uno o più x, preferisce meno
x?? zero o una x, preferire zero
x{n,m}? n o n+1 o ... o m x, preferisce meno
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 acquisizione numerato (sottomatch)
(?P<name>re) Gruppo di acquisizione denominato e numerato (sottomatch)
(?:re) Gruppo non di acquisizione
(?<flags>) Impostare <flags> all'interno del gruppo corrente; non di acquisizione
(?<flags>:re) Impostare <flags> durante l'acquisizione redel raggruppamento

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à a più righe: ^ e $ corrispondenza della riga iniziale/finale oltre al testo di inizio/fine (impostazione predefinita false)
s Let . match \n (impostazione predefinita 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 Azure Data Studio, 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

Gli elementi seguenti non sono attualmente supportati:

  • I tipi di dati LOB (varchar(max) o nvarchar(max)) per string_expressions sono supportati nelle funzioni intrinseche seguenti:
    • REGEXP_LIKE
    • REGEXP_COUNT
    • REGEXP_INSTR

Tuttavia, questo supporto è limitato alle dimensioni di input fino a 2 MB.

  • I tipi di dati LOB non sono supportati nelle funzioni regex seguenti:

    • REGEXP_REPLACE
    • REGEXP_SUBSTR
    • REGEXP_MATCHES
    • REGEXP_SPLIT_TO_TABLE

  • Le funzioni di espressione regolare non sono supportate nelle stored procedure compilate in modo nativo.

Contenuti correlati

  • Last updated on