Emparejar patrones con expresiones regulares

14 minutos

El procesamiento de texto en bases de datos a menudo requiere coincidencias de patrones que van más allá de lo que el LIKE operador puede controlar. Las expresiones regulares proporcionan una sintaxis estandarizada para la coincidencia de patrones complejas, la validación y la transformación de texto. Las bases de datos SQL Server 2025 y SQL de Microsoft Fabric incluyen compatibilidad con expresiones regulares a través de nuevas funciones de T-SQL.

Tenga en cuenta escenarios en los que LIKE se queda corto: validar direcciones de correo electrónico con un formato adecuado, extraer números de teléfono independientemente de las variaciones en el formato, encontrar códigos de producto que cumplan con convenciones específicas de nomenclatura o detectar patrones como caracteres que se repiten consecutivamente. El LIKE operador solo admite caracteres comodín simples (% para cualquier carácter, _ para un solo carácter), que no puede expresar estos patrones complejos.

Las expresiones regulares resuelven estas limitaciones proporcionando un lenguaje de patrón enriquecido. Con expresiones regulares (regex), puede buscar grupos de caracteres específicos, pedir volúmenes exactos de repeticiones, usar alternancias (buscar esto O BIEN lo otro) y capturar fragmentos del texto que coincide para extraerlo o reemplazarlo. Una vez que aprenda la sintaxis regex, puede aplicarla en muchos lenguajes de programación y herramientas: los patrones que escribe para SQL Server funcionan de forma similar en utilidades de Python, JavaScript y línea de comandos.

Comprender los conceptos básicos de las expresiones regulares

Las expresiones regulares (regex) usan una sintaxis de patrón para describir patrones de texto. Antes de aprender las funciones de SQL Server, vamos a revisar estos componentes comunes de regex:

Modelo	Description	Coincidencia de ejemplo
`.`	Cualquier carácter único	`a.c` coincide con "abc", "a1c"
`*`	Ninguno o más que los anteriores	`abc` coincide con "ac", "abc", "abbc"*
`+`	Uno o varios de los anteriores	`ab+c` coincide con "abc", "abbc", pero no "ac"
`?`	Ninguno o uno de los anteriores	`colou?r` coincide con "color","colour"
`^`	Inicio de la cadena	`^Hello` coincide con cadenas que comienzan con "Hello"
`$`	Fin de la cadena	`world$` coincide con cadenas que terminan con "world"
`[abc]`	Clase de personaje	`[aeiou]` coincide con cualquier vocal
`[^abc]`	Clase negada	`[^0-9]` busca cualquier carácter que no sea un dígito
`\d`	Dígito (0-9)	`\d{3}` coincide con tres dígitos
`\w`	Carácter de palabra	`\w+` corresponde a caracteres de palabra
`{n}`	Exactamente n ocurrencias	`\d{4}` coincide exactamente con cuatro dígitos
`{n,m}`	Entre n y m repeticiones	`\d{2,4}` coincide con de 2 a 4 dígitos

Nota:

Las funciones de expresión regular de SQL Server usan la sintaxis regex estándar de ECMAScript . Esta es la misma sintaxis que se usa en JavaScript y muchos otros lenguajes de programación, lo que hace que los patrones sean portátiles entre tecnologías.

Hacer coincidir patrones con `REGEXP_LIKE`

REGEXP_LIKE devuelve 1 (true) si una cadena coincide con un patrón de expresión regular o 0 (false) si no lo hace. Use esta función en WHERE cláusulas para filtrar filas basadas en patrones complejos:

-- 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;

Validar formatos de datos:

-- 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;

Utilice la búsqueda de coincidencias que no distingan mayúsculas de minúsculas con el parámetro de indicadores:

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

Sugerencia

Se usa REGEXP_LIKE para la validación y el filtrado. Es más eficaz que extraer subcadenas cuando solo es necesario saber si existe un patrón.

Reemplazar texto por `REGEXP_REPLACE`

REGEXP_REPLACE busca todas las apariciones de un patrón y las reemplaza por una cadena especificada. Esta función es útil para la limpieza y normalización de datos:

-- 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;

En los ejemplos siguientes se muestra cómo usar grupos de captura con referencias inversas:

-- 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

En los ejemplos siguientes se muestra cómo limpiar y normalizar los datos:

-- 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;

Extracción de subcadenas con REGEXP_SUBSTR

REGEXP_SUBSTR extrae la parte de una cadena que coincide con un patrón de expresión regular. Úselo para extraer elementos de datos específicos del texto no estructurado, como los ejemplos siguientes:

-- 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;

En el ejemplo siguiente se muestra la firma de función, que incluye parámetros para los grupos de ocurrencia y captura:

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

Buscar posiciones de patrón con `REGEXP_INSTR`

REGEXP_INSTR devuelve la posición inicial de una coincidencia de patrón dentro de una cadena. Devuelve 0 si no se encuentra ninguna coincidencia, como en los ejemplos siguientes:

-- 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;

Recuento de ocurrencias de patrones con `REGEXP_COUNT`

REGEXP_COUNT devuelve el número de veces que aparece un patrón en una cadena. En los ejemplos siguientes se muestra su uso:

-- 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;

Dividir cadenas con `REGEXP_SPLIT_TO_TABLE`

REGEXP_SPLIT_TO_TABLE es una función con valores de tabla que divide una cadena en filas en función de un patrón delimitador:

-- 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, '[,;|]');

Puede combinar REGEXP_SPLIT_TO_TABLE con otras consultas mediante 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;

Devolver todas las coincidencias con `REGEXP_MATCHES`

REGEXP_MATCHES es una función con valores de tabla que devuelve todas las coincidencias de patrones como filas independientes:

-- 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

Importante

Las funciones de expresiones regulares están disponibles en bases de datos SQL Server 2025 y SQL en Microsoft Fabric. Para versiones anteriores de SQL Server, considere la posibilidad de usar funciones CLR o procesamiento de capas de aplicación para operaciones regulares complejas.

Para obtener más información sobre las funciones de expresiones regulares, vea Expresiones regulares.

Comentarios

¿Le ha resultado útil esta página?

Emparejar patrones con expresiones regulares

Comprender los conceptos básicos de las expresiones regulares

Hacer coincidir patrones con REGEXP_LIKE

Reemplazar texto por REGEXP_REPLACE

Extracción de subcadenas con REGEXP_SUBSTR

Buscar posiciones de patrón con REGEXP_INSTR

Recuento de ocurrencias de patrones con REGEXP_COUNT

Dividir cadenas con REGEXP_SPLIT_TO_TABLE

Devolver todas las coincidencias con REGEXP_MATCHES