Dela via

Förhandsversion av reguljära uttryck

Gäller för: SQL Server 2025 (17.x) Förhandsversion Azure SQL DatabaseAzure SQL Managed InstanceFörhandsversion av SQL-databas för Microsoft Fabric

Den här artikeln introducerar reguljära uttryck för SQL Server.

Note

Som en förhandsgranskningsfunktion omfattas tekniken som presenteras i den här artikeln av kompletterande användningsvillkor för Förhandsversioner av Microsoft Azure.

Ett reguljärt uttryck, eller regex, är en sekvens med tecken som definierar ett sökmönster för text. Regex används ofta för en mängd olika uppgifter, inklusive mönstermatchning, datavalidering, datatransformering och frågor. Det erbjuder ett flexibelt och effektivt sätt att söka, manipulera och hantera komplexa dataåtgärder.

Note

Reguljära uttryck är tillgängliga i Azure SQL Managed Instance med sql Server 2025- eller always-up-to-date update-principen.

Den här implementeringen av reguljära uttryck baseras på re2-biblioteket för reguljära uttryck. Mer information finns i RE2-syntax för reguljära uttryck.

Regex-funktioner som stöds:

Function Description
REGEXP_LIKE Returnerar ett booleskt värde som anger om textinmatningen matchar regex-mönstret.
REGEXP_REPLACE Returnerar en modifierad källsträng som ersätts av en ersättningssträng, där förekomsten av regex-mönstret hittades.
REGEXP_SUBSTR Extraherar delar av en sträng baserat på ett mönster för reguljära uttryck.

Returnerar Nth-förekomsten av en delsträng som matchar regex-mönstret.
REGEXP_INSTR Returnerar start- eller slutpositionen för den matchade delsträngen, beroende på vilket alternativ som anges.
REGEXP_COUNT Returnerar antalet gånger som regexmönstret inträffar i en sträng.
REGEXP_MATCHES Returnerar en tabell med insamlade delsträngar som matchar ett reguljärt uttrycksmönster med en sträng. Om ingen matchning hittas returnerar funktionen ingen rad.
REGEXP_SPLIT_TO_TABLE Returnerar en tabell med delade strängar, avgränsade med regex-mönstret. Om det inte finns någon matchning i mönstret returnerar funktionen strängen.

Reguljära uttryck kan bestå av literaltecken och metakarakter, som har särskilda betydelser och funktioner.

Ett grundläggande reguljärt uttryck är ett enda bokstavligt tecken. Tecknen matchar sig själva, förutom metatecknen. Metakarakterare inkluderar *, +, ?, (, )eller |. Undvik det med ett omvänt snedstreck för att matcha ett metadiagram. Matchar till exempel \* bokstavligt asterisk-tecken (*).

Två reguljära uttryck kan ändras eller sammanfogas för att bilda ett nytt reguljärt uttryck: om e1 matchar s och e2 matchar t, matchar e1 | e2s eller t och e1e2 matchar st.

Metakaraktärerna *, +, och ? är upprepningsoperatorer: e1* matchar en sekvens med noll eller fler (möjligen olika) strängar, som var och en matchar e1; e1 + matchar en eller flera; e1? matchar noll eller ett.

Operatorprioretens, från den svagaste till starkaste bindningen, är följande: - Alternation - Sammanfogning - Repetitionsoperatorer

Explicita parenteser kan användas för att framtvinga olika betydelser, som i aritmetiska uttryck. Några exempel: ab|cd motsvarar (ab)|(cd) , ab motsvarar a(b).

Mer information om syntaxen för reguljära uttryck som godkänts av RE2 finns i
RE2 Syntax för reguljära uttryck. På den här sidan visas även vissa syntaxer som godkänts av PCRE, Perl och Vim.

Godkända reguljära uttryckstecken

Uttryck med ett tecken

Typer av uttryck med ett tecken Examples
alla tecken, eventuellt inklusive newline (s=true) .
character class [xyz]
negerad teckenklass [^xyz]
Perl-teckenklasser \d
Förnekad Perl-teckenklass \D
ASCII-teckenklasser [[:alpha:]]
negerad ASCII-teckenklass [[:^alpha:]]
Unicode-teckenklass (en bokstavsnamn) \pN
Unicode-teckenklass \p{Greek}
negerad Unicode-teckenklass (en bokstavsnamn) \PN
negerad Unicode-teckenklass \P{Greek}
Kompositer Description
xy x följt av y
x | y x eller y (föredrar x)
Upprepningar Description
x* noll eller fler x, föredrar mer
x+ ett eller flera x, föredrar mer
x? noll eller ett x, föredrar en
x{n,m} n eller n+1 eller ... eller m x, föredrar mer
x{n,} n eller fler x, föredra fler
x{n} exakt n x
x*? noll eller fler x, föredrar färre
x+? ett eller flera x, föredrar färre
x?? noll eller ett x, föredrar noll
x{n,m}? n eller n+1 eller ... eller m x, föredrar färre
x{n,}? n eller mer x, föredrar färre
x{n}? exakt n x

Note

Räknarformulären x{n,m}, x{n,}och x{n} avvisar formulär som skapar ett minsta eller högsta antal upprepningar över 1 000. Obegränsade upprepningar omfattas inte av den här begränsningen.

Perl-teckenklasser

I följande tabell visas för närvarande perl-teckenklasser som stöds.

Perl-teckenklasser (endast ASCII) Description
\d siffror ( [0-9])
\D inte siffror ( [^0-9])
\s blanksteg ( [\t\n\f\r ])
\S inte tomt utrymme ( [^\t\n\f\r ])
\w ordtecken ( [0-9A-Za-z_])
\W inte ordtecken ( [^0-9A-Za-z_])

ASCII-teckenklasser

I följande tabell visas ascii-teckenklasser som stöds för närvarande.

ASCII-teckenklasser Description
[[:alnum:]] alfanumeriskt ( [0-9A-Za-z])
[[:alpha:]] alfabetisk ( [A-Za-z])
[[:ascii:]] ASCII ( [\x00-\x7F])
[[:blank:]] blank ( [\t ])
[[:cntrl:]] kontroll ( [\x00-\x1F\x7F])
[[:digit:]] siffror ( [0-9])
[[:graph:]] grafisk ( [!-~] eller [A-Za-z0-9!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])
[[:lower:]] gemener ( [a-z])
[[:print:]] utskrivbar ( [ -~] eller [ [:graph:]])
[[:punct:]] skiljetecken ( [!-/:-@[-\``{-~])
[[:space:]] blanksteg ( [\t\n\v\f\r ])
[[:upper:]] versaler ( [A-Z])
[[:word:]] ordtecken ( [0-9A-Za-z_])
[[:xdigit:]] hex-siffra ( [0-9A-Fa-f])

Literaltecken

  • Letters
  • Numbers
  • Symbols

Tomma strängar

Tomma strängar Description
^ I början av text eller rad (m=true)
$ I slutet av texten (till exempel \z, inte \Z) eller rad (m=true)
\A I början av texten
\b Vid ASCII-ordgräns (\w på ena sidan och \W, \Aeller \z på den andra)
\B Inte vid ASCII-ordgräns
\z I slutet av texten

Groupings

Fångstgruppen (underuttryck) av mönstret med:

Gruppering Description
(re) Numrerad insamlingsgrupp (delmatchning)
(?P<name>re) Namngiven och numrerad insamlingsgrupp (delmatchning)
(?:re) Icke-fångande grupp
(?<flags>) Ange <flags> inom den aktuella gruppen; icke-fångande
(?<flags>:re) Ange <flags> under re; icke-fångande gruppering

Flags

Använd flaggor för att ändra uttrycksbeteendet. Till exempel:

Flag Description
i Skiftlägesokänsligt (standard false)
m Flerradsläge: ^ och $ matcha start-/slutlinje utöver start-/sluttext (standard false)
s Låt . matcha \n (standard false)
c Skiftlägeskänsligt (standard true)

Den här implementeringen stöder POSIX-standarden för reguljära uttryck efter RE2 och har stöd för PCRE/PCRE2-varianten av syntax för reguljära uttryck, som är kompatibel med de flesta moderna reguljära uttrycksmotorer och verktyg. Det finns olika varianter av reguljära uttryck, till exempel POSIX, ANSI, Perl och PCRE, som har olika syntax och funktioner. Mer information om konstruktioner som stöds och beteende för den underliggande regexmotorn finns i RE2, ett bibliotek för reguljära uttryck.

Note

Matchning av reguljära uttryck i SQL Server uppfyller inte SQL-sortering för språkjämförelser. Det här beteendet är avsiktligt och överensstämmer med de flesta reguljära uttrycksmotorer, eftersom matchning baseras på egenskaperna för mönster och Unicode-tecken i stället för sorteringsregler. Det kan därför leda till skillnader i beteende jämfört med andra strängjämförelsefunktioner som LIKE, särskilt för indexerade kolumner med språkspecifika sorteringar.

Requirements

  • Ett SQL-klientverktyg, till exempel Azure Data Studio, SQL Server Management Studio eller Visual Studio Code.
  • Grundläggande kunskaper om SQL-syntax och frågor.
  • Grundläggande förståelse för syntax och begrepp för reguljära uttryck.

FAQ

Hur påverkas prestandan av att använda regex?

Regex-frågor kan ha en prestandapåverkan beroende på komplexiteten i regex-mönstret, storleken på textdata och antalet rader som ingår. Du kan använda exekveringsplanen och statistiken för att övervaka och optimera prestandan för dina regex-sökningar.

Kända problem, beteenden och begränsningar

Det här är de objekt som för närvarande inte stöds i den här förhandsversionen:

  • LOB-datatyper (varchar(max) eller nvarchar(max)) för string_expressions stöds i följande inbyggda funktioner:
    • REGEXP_LIKE
    • REGEXP_COUNT
    • REGEXP_INSTR

Det här stödet är dock begränsat till indatastorlekar på upp till 2 MB.

  • LOB-datatyper stöds inte i följande regex-funktioner:
    • REGEXP_REPLACE
    • REGEXP_SUBSTR
    • REGEXP_MATCHES
    • REGEXP_SPLIT_TO_TABLE
  • Reguljära uttrycksfunktioner stöds inte i inbyggda kompilerade lagrade procedurer.

Relaterat innehåll