Matcha mönster med reguljära uttryck

14 minuter

Textbearbetning i databaser kräver ofta mönstermatchning som går utöver vad operatorn LIKE kan hantera. Reguljära uttryck ger en standardiserad syntax för komplex mönstermatchning, validering och texttransformering. SQL Server 2025- och SQL-databaser i Microsoft Fabric innehåller stöd för reguljära uttryck via nya T-SQL-funktioner.

Tänk på scenarier där LIKE inte räcker till: verifiera e-postadresser med rätt format, extrahera telefonnummer oavsett formateringsvariationer, hitta produktkoder som följer specifika namngivningskonventioner eller identifiera mönster som upprepar sig, exempelvis tecken som följer varandra. Operatorn LIKE stöder endast enkla jokertecken (% för alla tecken, _ för ett enda tecken), som inte kan uttrycka dessa komplexa mönster.

Reguljära uttryck löser dessa begränsningar genom att tillhandahålla ett rikt mönsterspråk. Med regex kan du matcha specifika teckenintervall, kräva exakta upprepningsantal, använda alternation (matcha detta ELLER som) och samla in delar av matchad text för extrahering eller ersättning. När du har lärt dig regex-syntax kan du tillämpa den på många programmeringsspråk och verktyg – mönstren du skriver för SQL Server fungerar på samma sätt i Python, JavaScript och kommandoradsverktyg.

Förstå grunderna för reguljära uttryck

Reguljära uttryck (regex) använder en mönstersyntax för att beskriva textmönster. Innan du lär dig SQL Server-funktioner ska vi gå igenom de här vanliga regex-komponenterna:

Mönster	Description	Exempelmatchning
`.`	Valfritt enskilt tecken	`a.c` matchar "abc", "a1c"
`*`	Noll eller mer av föregående	`abc` matchar "ac", "abc", "abbc"*
`+`	En eller flera av föregående	`ab+c` matchar "abc","abbc" men inte "ac"
`?`	Noll eller något av föregående	`colou?r` matchar "färg","färg"
`^`	Början av strängen	`^Hello` matchar strängar som börjar med "Hello"
`$`	Strängens slut	`world$` matchar strängar som slutar med "world"
`[abc]`	Klass Tecken	`[aeiou]` matchar alla vokaler
`[^abc]`	Negerad klass	`[^0-9]` matchar ickesiffror
`\d`	Siffra (0–9)	`\d{3}` matchar tre siffror
`\w`	Word-tecken	`\w+` matchar tecken i ord
`{n}`	Exakt n förekomster	`\d{4}` matchar exakt fyra siffror
`{n,m}`	Mellan n- och m-förekomster	`\d{2,4}` matchar 2 till 4 siffror

Anmärkning

SQL Server-funktionerna för reguljära uttryck använder ecmascript-standardsyntaxen för regex. Det här är samma syntax som används i JavaScript och många andra programmeringsspråk, vilket gör mönster portabla mellan olika tekniker.

Matcha mönster med `REGEXP_LIKE`

REGEXP_LIKE returnerar 1 (sant) om en sträng matchar ett mönster för reguljära uttryck eller 0 (falskt) om den inte gör det. Använd den här funktionen i WHERE -satser för att filtrera rader baserat på komplexa mönster:

-- Find customers with email addresses from specific domains
SELECT CustomerID, FirstName, LastName, EmailAddress
FROM SalesLT.Customer
WHERE REGEXP_LIKE(EmailAddress, '@(contoso|adventure-works|fabrikam)\.com$') = 1;

Verifiera dataformat:

-- Find valid US phone numbers (various formats)
SELECT CustomerID, Phone
FROM SalesLT.Customer
WHERE REGEXP_LIKE(Phone, '^\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$') = 1;

-- Validate product numbers match expected format (XX-XXXX)
SELECT ProductID, ProductNumber, Name
FROM SalesLT.Product
WHERE REGEXP_LIKE(ProductNumber, '^[A-Z]{2}-[A-Z0-9]{4,6}$') = 1;

Använd skiftlägesoberoende matchning med parametern flaggor:

-- 'i' flag enables case-insensitive matching
SELECT Name
FROM SalesLT.Product
WHERE REGEXP_LIKE(Name, 'frame', 'i') = 1;

Tips/Råd

Används REGEXP_LIKE för validering och filtrering. Det är effektivare än att extrahera delsträngar när du bara behöver veta om det finns ett mönster.

Ersätt text med `REGEXP_REPLACE`

REGEXP_REPLACE hittar alla förekomster av ett mönster och ersätter dem med en angiven sträng. Den här funktionen är användbar för datarensning och standardisering:

-- Standardize phone numbers to (XXX) XXX-XXXX format
SELECT 
    Phone AS OriginalPhone,
    REGEXP_REPLACE(
        REGEXP_REPLACE(Phone, '[^\d]', ''),  -- First remove all non-digits
        '^(\d{3})(\d{3})(\d{4})$',
        '($1) $2-$3'
    ) AS StandardizedPhone
FROM SalesLT.Customer
WHERE Phone IS NOT NULL;

Följande exempel visar hur du använder insamlingsgrupper med backreferences:

-- Swap first and last name
DECLARE @name NVARCHAR(100) = 'Smith, John';
SELECT REGEXP_REPLACE(@name, '^(\w+),\s*(\w+)$', '$2 $1') AS SwappedName;
-- Returns: John Smith

-- Mask credit card numbers (show last 4 digits only)
DECLARE @card NVARCHAR(20) = '4532-1234-5678-9012';
SELECT REGEXP_REPLACE(@card, '\d(?=[\d-]{4,})', '*') AS MaskedCard;
-- Returns: ****-****-****-9012

Följande exempel visar hur du rensar och normaliserar data:

-- Remove extra whitespace (multiple spaces to single space)
SELECT REGEXP_REPLACE(Description, '\s+', ' ') AS CleanedDescription
FROM Products;

-- Remove HTML tags
SELECT REGEXP_REPLACE(HtmlContent, '<[^>]+>', '') AS PlainText
FROM WebPages;

Extrahera delsträngar med REGEXP_SUBSTR

REGEXP_SUBSTR extraherar den del av en sträng som matchar ett mönster för reguljära uttryck. Använd den för att hämta specifika dataelement från ostrukturerad text som i följande exempel:

-- Extract domain from email address
SELECT 
    EmailAddress,
    REGEXP_SUBSTR(EmailAddress, '@(.+)$', 1, 1, '', 1) AS Domain
FROM SalesLT.Customer
WHERE EmailAddress IS NOT NULL;

-- Extract the first number from a string
SELECT 
    ProductNumber,
    REGEXP_SUBSTR(ProductNumber, '\d+') AS FirstNumber
FROM SalesLT.Product;

I följande exempel visas funktionssignaturen, som innehåller parametrar för förekomst- och insamlingsgrupper:

REGEXP_SUBSTR(source, pattern, start_position, occurrence, flags, capture_group)

Hitta mönsterpositioner med `REGEXP_INSTR`

REGEXP_INSTR returnerar startpositionen för en mönstermatchning i en sträng. Returnerar 0 om ingen matchning hittas, som i följande exempel:

-- Find position of first digit in product number
SELECT 
    ProductNumber,
    REGEXP_INSTR(ProductNumber, '\d') AS FirstDigitPosition
FROM SalesLT.Product;

-- Find position of email domain
SELECT 
    EmailAddress,
    REGEXP_INSTR(EmailAddress, '@') AS AtPosition,
    REGEXP_INSTR(EmailAddress, '\.[a-z]+$', 1, 1, 0, 'i') AS TldPosition
FROM SalesLT.Customer
WHERE EmailAddress IS NOT NULL;

Räkna mönsterförekomster med `REGEXP_COUNT`

REGEXP_COUNT returnerar antalet gånger ett mönster visas i en sträng. Följande exempel illustrerar dess användning:

-- Count words in a description
SELECT  
    Name,
    REGEXP_COUNT(Name, '\w+') AS WordCount
FROM SalesLT.Product;

-- Count vowels in product names
SELECT 
    Name,
    REGEXP_COUNT(Name, '[aeiou]', 1, 'i') AS VowelCount
FROM SalesLT.Product;

-- Find products with multiple numbers in their name
SELECT Name
FROM SalesLT.Product
WHERE REGEXP_COUNT(Name, '\d+') > 1;

Dela strängar med `REGEXP_SPLIT_TO_TABLE`

REGEXP_SPLIT_TO_TABLE är en tabellvärdesfunktion som delar upp en sträng i rader baserat på ett avgränsarmönster:

-- Split comma-separated values
DECLARE @tags NVARCHAR(200) = 'sql,database,azure,analytics';
SELECT value AS Tag
FROM REGEXP_SPLIT_TO_TABLE(@tags, ',');

-- Split on multiple delimiters (comma, semicolon, or pipe)
DECLARE @data NVARCHAR(200) = 'apple,banana;cherry|date';
SELECT value AS Fruit
FROM REGEXP_SPLIT_TO_TABLE(@data, '[,;|]');

Du kan kombinera REGEXP_SPLIT_TO_TABLE med andra frågor med hjälp av CROSS APPLY:

-- Assuming Products table has a Tags column with comma-separated values
SELECT 
    p.ProductID,
    p.Name,
    t.value AS Tag
FROM Products AS p
CROSS APPLY REGEXP_SPLIT_TO_TABLE(p.Tags, ',\s*') AS t;

Returnera alla matchningar med `REGEXP_MATCHES`

REGEXP_MATCHES är en tabellvärdesfunktion som returnerar alla mönstermatchningar som separata rader:

-- Find all numbers in a string
DECLARE @text NVARCHAR(200) = 'Order 12345 contains 3 items totaling $99.99';
SELECT match_value, match_index
FROM REGEXP_MATCHES(@text, '\d+\.?\d*');
-- Returns: 12345, 3, 99.99

Viktigt!

Reguljära uttrycksfunktioner är tillgängliga i SQL Server 2025- och SQL-databaser i Microsoft Fabric. För tidigare SQL Server-versioner bör du överväga att använda CLR-funktioner eller bearbetning på programnivå för komplexa regex-åtgärder.

Mer information om reguljära uttrycksfunktioner finns i Reguljära uttryck.

Feedback

Var den här sidan till hjälp?

Matcha mönster med reguljära uttryck

Förstå grunderna för reguljära uttryck

Matcha mönster med REGEXP_LIKE

Ersätt text med REGEXP_REPLACE

Extrahera delsträngar med REGEXP_SUBSTR

Hitta mönsterpositioner med REGEXP_INSTR

Räkna mönsterförekomster med REGEXP_COUNT

Dela strängar med REGEXP_SPLIT_TO_TABLE

Returnera alla matchningar med REGEXP_MATCHES