REGEXP_LIKE (Transact-SQL)

Aplica-se a: SQL Server 2025 (17.x) Base de Dados SQL do Azure AzureSQL Managed InstanceSQL database in Microsoft Fabric

Indica se o padrão de expressão regular corresponde em uma cadeia de caracteres.

REGEXP_LIKE
(
    string_expression,
    pattern_expression [ , flags ]
)

REGEXP_LIKE requer compatibilidade de banco de dados nível 170 e superior. Se o nível de compatibilidade do banco de dados for inferior a 170, REGEXP_LIKE não estará disponível. Outras funções escalares de expressão regular estão disponíveis em todos os níveis de compatibilidade.

Você pode verificar o nível de compatibilidade na exibição ou nas propriedades do sys.databases banco de dados. Você pode alterar o nível de compatibilidade de um banco de dados com o seguinte comando:

ALTER DATABASE [DatabaseName]
    SET COMPATIBILITY_LEVEL = 170;

Arguments

string_expression

Uma expressão de uma cadeia de caracteres.

Pode ser uma constante, variável ou coluna de cadeia de caracteres.

Tipos de dados: char, nchar, varcharou nvarchar.

pattern_expression

Padrão de expressão regular a ser correspondido. Geralmente um texto literal.

Tipos de dados: char, nchar, varcharou nvarchar. pattern_expression suporta um comprimento máximo de caracteres de 8.000 bytes.

flags

Um ou mais caracteres que especificam os modificadores usados para pesquisar correspondências. Type é varchar ou char, com um máximo de 30 caracteres.

Por exemplo, ims. O padrão é c. Se uma (' ') de cadeia de caracteres vazia for fornecida, ela será tratada como o valor padrão ('c'). Forneça c ou quaisquer outras expressões de caracteres. Se o sinalizador contiver vários caracteres contraditórios, o SQL Server usará o último caractere.

Por exemplo, se você especificar ic o regex retornará a correspondência que diferencia maiúsculas de minúsculas.

Se o valor contiver um caractere diferente daqueles listados em valores de sinalizador suportados, a consulta retornará um erro como o exemplo a seguir:

Invalid flag provided. '<invalid character>' are not valid flags. Only {c,i,s,m} flags are valid.

Valores de sinalizador suportados

Valor de retorno

Valor booleano. true ou false.

Remarks

Estimativa da cardinalidade

Para aumentar a precisão da estimativa de cardinalidade da REGEXP_LIKE função, utilize as ASSUME_FIXED_MIN_SELECTIVITY_FOR_REGEXP dicas e ASSUME_FIXED_MAX_SELECTIVITY_FOR_REGEXP query para ajustar os valores de seletividade por defeito. Para obter mais informações, consulte Dicas de consulta.

Estas dicas de consulta também se integram com o feedback de estimativa de cardinalidade (CE). O modelo de feedback CE identifica automaticamente consultas que utilizam a REGEXP_LIKE função onde há uma diferença significativa entre o número estimado e o número real de linhas. Em seguida, ele aplica a dica de seletividade apropriada no nível de consulta para melhorar a qualidade do plano sem exigir entrada manual.

Para desativar o comportamento de feedback automático, ative o sinalizador de rastreamento 16268.

Suporte a padrões SARGable

REGEXP_LIKE é SARGável apenas quando o padrão começa com a âncora ^. Além disso, o padrão ancorado pode incluir:

• Um quantificador: *, +, ?, {n}, {n,}, ou {n,m}. Por exemplo, ^ab+ ou ^ab*.
• Caracteres de intervalo, como [0-9A-Za-z].

Para escapar a um metacarácter, use a barra diagonal (\).

Estas condições permitem que o otimizador de consultas utilize operações de procura de índice para melhorar o desempenho das consultas.

As expressões regulares não respeitam as regras de colação. O seu comportamento pode ser diferente de outras funções de comparação de cadeias, como LIKE. Esta diferença é mais importante em colunas indexadas que têm colações específicas da língua.

Por exemplo, no agrupamento turco, os caracteres i e I são tratados distintamente, mesmo no agrupamento sem distinção de maiúsculas e minúsculas, devido a regras específicas do idioma. Para mais informações, veja o exemplo F. Compare a correspondência de padrões SARGable e não-SARGable com a colation turca.

Examples

Um. Valores de correspondência que começam e terminam com personagens específicas

Selecione todos os registos da Employees tabela onde o primeiro nome começa A e termina com Y:

SELECT *
FROM Employees
WHERE REGEXP_LIKE (FIRST_NAME, '^A.*Y$');

B. Realizar uma correspondência de padrão insensível a maiúsculas minúsculas

Selecione todos os registos da Employees tabela onde o primeiro nome começa A e termina em Y, usando o modo insensível a maiúsculas e minúsculas:

SELECT *
FROM Employees
WHERE REGEXP_LIKE (FIRST_NAME, '^A.*Y$', 'i');

C. Datas de correspondência usando um padrão de expressão regular

Selecione todos os registros na tabela onde a Orders data do pedido é em fevereiro de 2020:

SELECT *
FROM Orders
WHERE REGEXP_LIKE (ORDER_DATE, '2020-02-\d\d');

D. Corresponder a padrões de caracteres repetidos

Selecione todos os registros na Products tabela em que o nome do produto contém pelo menos três vogais consecutivas:

SELECT *
FROM Products
WHERE REGEXP_LIKE (PRODUCT_NAME, '[AEIOU]{3,}');

E. Impor validação de dados com restrições CHECK

Crie uma tabela de colaboradores com CHECK restrições para as Email colunas e Phone_Number :

DROP TABLE IF EXISTS Employees;
CREATE TABLE Employees
(
    ID INT IDENTITY (101, 1),
    [Name] VARCHAR (150),
    Email VARCHAR (320)
        CHECK (REGEXP_LIKE (Email, '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$')),
    Phone_Number NVARCHAR (20)
        CHECK (REGEXP_LIKE (Phone_Number, '^(\d{3})-(\d{3})-(\d{4})$'))
);

F. Compare a correspondência de padrões SARGable e não-SARGable com a colação turca

Este exemplo demonstra o uso SARGável e não SARGável da REGEXP_LIKE função com a colação turca.

-- Create a temporary table with Turkish collation and and an index
CREATE TABLE #Users
(
    Username NVARCHAR (100) COLLATE Turkish_100_CI_AS_SC_UTF8 NOT NULL,
    INDEX idx_username (Username)
);

-- Insert sample data
INSERT INTO #Users (Username)
VALUES (N'i'), -- lowercase i
       (N'I'), -- uppercase dotless I
       (N'İ'), -- uppercase dotted İ
       (N'abc');

-- SARGable pattern: starts with ^ and uses quantifier
-- This will use index seek if applicable, but REGEXP_LIKE ignores collation
-- So 'i' and 'I' are treated as different characters
SELECT 'SARGable' AS PatternType,
       *
FROM #Users
WHERE REGEXP_LIKE (Username, '^i');

-- Non-SARGable pattern: does not start with ^.
-- REGEXP_LIKE performs full scan, and matches are
-- case-insensitive since 'i' flag is supplied,
-- so both 'i' and 'I' match.
SELECT 'Non-SARGable' AS PatternType,
       *
FROM #Users
WHERE REGEXP_LIKE (Username, 'i', 'i');

-- Cleanup
DROP TABLE #Users;

Conteúdo relacionado

• Expressões regulares
• Funções de expressões regulares (Transact-SQL)