REGEXP_LIKE (Transact-SQL)

S’applique à : Base de données SQL Server 2025 (17.x) Azure SQL DatabaseAzure SQL Managed InstanceSQL dans Microsoft Fabric

Indique si le modèle d’expression régulière correspond dans une chaîne.

REGEXP_LIKE
(
    string_expression,
    pattern_expression [ , flags ]
)

REGEXP_LIKE nécessite le niveau de compatibilité de la base de données 170 et versions ultérieures. Si le niveau de compatibilité de la base de données est inférieur à 170, REGEXP_LIKE il n’est pas disponible. D’autres fonctions scalaires d’expression régulière sont disponibles à tous les niveaux de compatibilité.

Vous pouvez vérifier le niveau de compatibilité dans la vue ou dans les sys.databases propriétés de base de données. Vous pouvez modifier le niveau de compatibilité d’une base de données avec la commande suivante :

ALTER DATABASE [DatabaseName]
    SET COMPATIBILITY_LEVEL = 170;

Arguments

string_expression

Expression d’une chaîne de caractères.

Il peut s’agir d’une constante, d’une variable ou d’une colonne de chaîne de caractères.

Types de données : char, nchar, varcharou nvarchar.

pattern_expression

Modèle d’expression régulière à mettre en correspondance. Généralement un littéral de texte.

Types de données : char, nchar, varcharou nvarchar. pattern_expression prend en charge une longueur maximale de caractères de 8 000 octets.

flags

Un ou plusieurs caractères qui spécifient les modificateurs utilisés pour rechercher des correspondances. Le type est varchar ou char, avec un maximum de 30 caractères.

Par exemple, ims. La valeur par défaut est c. Si une chaîne vide (' ') est fournie, elle sera traitée comme la valeur par défaut ('c'). Fournissez c ou toute autre expression de caractère. Si l’indicateur contient plusieurs caractères contradictoires, SQL Server utilise le dernier caractère.

Par exemple, si vous spécifiez ic l’expression régulière retourne la correspondance respectant la casse.

Si la valeur contient un caractère autre que ceux répertoriés dans valeurs d’indicateur prises en charge, la requête retourne une erreur comme dans l’exemple suivant :

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

Valeurs d’indicateur prises en charge

Valeur retournée

Valeur booléenne. true ou false.

Remarks

Estimation de la cardinalité

Pour améliorer la précision de l’estimation de la cardinalité de la REGEXP_LIKE fonction, utilisez les ASSUME_FIXED_MIN_SELECTIVITY_FOR_REGEXP indices et ASSUME_FIXED_MAX_SELECTIVITY_FOR_REGEXP requête pour ajuster les valeurs de sélectivité par défaut. Pour plus d’informations, consultez indicateurs de requête.

Ces indices de requête s’intègrent également avec le retour d’estimation de cardinalité (CE). Le modèle de rétroaction CE identifie automatiquement les requêtes utilisant la REGEXP_LIKE fonction où il y a une différence significative entre le nombre estimé et le nombre réel de lignes. Il applique ensuite l’indicateur de sélection approprié au niveau de la requête pour améliorer la qualité du plan sans nécessiter d’entrée manuelle.

Pour désactiver le comportement de commentaires automatiques, activez l’indicateur de trace 16268.

Prise en charge du pattern SARGable

REGEXP_LIKE est SARGable uniquement lorsque le motif commence par l’ancre ^. De plus, le motif ancrage peut inclure :

• Un quantificateur : *, +, ?, {n}, {n,}, ou {n,m}. Par exemple : ^ab+ ou ^ab*.
• Les caractères de plage, tels que [0-9A-Za-z].

Pour échapper à un métapersonnage, utilisez la barre inverse (\).

Ces conditions permettent à l’optimiseur de requêtes d’utiliser des opérations de recherche d’indice pour améliorer les performances de requête.

Les expressions régulières ne respectent pas les règles de collation. Leur comportement peut différer d’autres fonctions de comparaison de chaînes, telles que LIKE. Cette différence est particulièrement importante sur les colonnes indexées qui comportent des collations spécifiques à la langue.

Par exemple, dans le classement turc, les caractères i et I sont traités séparément même dans le classement sensible à la casse en raison de règles spécifiques à la langue. Pour plus d’informations, voir l’exemple F. Comparez la correspondance de modèles SARGable et non-SARGable avec la collation turque.

Examples

A. Correspondez aux valeurs qui commencent et se terminent avec des personnages spécifiques

Sélectionnez tous les enregistrements dans le Employees tableau où le prénom commence et A se termine par Y:

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

B. Effectuer une correspondance de motifs insensible à la casse

Sélectionnez tous les enregistrements dans la Employees table où le prénom commence et A se termine par Y, en utilisant le mode insensible à la majuscule :

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

C. Dates de correspondance en utilisant un motif d’expression régulière

Sélectionnez tous les enregistrements dans la Orders table où la date de commande est en février 2020 :

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

D. Correspondre à des motifs de caractères répétés

Sélectionnez tous les enregistrements de la Products table où le nom du produit contient au moins trois voyelles consécutives :

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

E. Imposer la validation des données avec des contraintes CHECK

Créez un tableau des employés avec CHECK des contraintes pour les Email colonnes et 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. Comparez la correspondance de modèles SARGable et non-SARGable avec la collation turque

Cet exemple démontre l’utilisation SARGable et non SARGable de la REGEXP_LIKE fonction avec la collation turque.

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

Contenu connexe

• Expressions régulières
• fonctions d’expressions régulières (Transact-SQL)