LIKE (Transact-SQL)LIKE (Transact-SQL)

S’applique à :Applies to: ouiSQL ServerSQL Server (toutes les versions prises en charge) yesSQL ServerSQL Server (all supported versions) OuiAzure SQL DatabaseAzure SQL DatabaseYesAzure SQL DatabaseAzure SQL Database OuiAzure SQL Managed InstanceAzure SQL Managed InstanceYesAzure SQL Managed InstanceAzure SQL Managed Instance ouiAzure Synapse AnalyticsAzure Synapse AnalyticsyesAzure Synapse AnalyticsAzure Synapse Analytics ouiParallel Data WarehouseParallel Data WarehouseyesParallel Data WarehouseParallel Data WarehouseS’applique à :Applies to: ouiSQL ServerSQL Server (toutes les versions prises en charge) yesSQL ServerSQL Server (all supported versions) OuiAzure SQL DatabaseAzure SQL DatabaseYesAzure SQL DatabaseAzure SQL Database OuiAzure SQL Managed InstanceAzure SQL Managed InstanceYesAzure SQL Managed InstanceAzure SQL Managed Instance ouiAzure Synapse AnalyticsAzure Synapse AnalyticsyesAzure Synapse AnalyticsAzure Synapse Analytics ouiParallel Data WarehouseParallel Data WarehouseyesParallel Data WarehouseParallel Data Warehouse

Détermine si une chaîne de caractères donnée correspond à un modèle spécifié.Determines whether a specific character string matches a specified pattern. Une chaîne peut comprendre des caractères normaux ainsi que des caractères génériques.A pattern can include regular characters and wildcard characters. Au cours de l'analyse, les caractères normaux doivent correspondre exactement aux caractères spécifiés dans la chaîne de caractères.During pattern matching, regular characters must exactly match the characters specified in the character string. Toutefois, les caractères génériques peuvent être associés à des portions aléatoires de la chaîne de caractères.However, wildcard characters can be matched with arbitrary fragments of the character string. L'utilisation de caractères génériques rend l'opérateur LIKE plus flexible que lorsque les opérateurs de comparaison des chaînes = et != sont utilisés.Using wildcard characters makes the LIKE operator more flexible than using the = and != string comparison operators. Si l'un de ces arguments n'est pas du type de données chaîne de caractères, le Moteur de base de données SQL ServerSQL Server Database Engine essaie de le convertir, dans la mesure du possible.If any one of the arguments isn't of character string data type, the Moteur de base de données SQL ServerSQL Server Database Engine converts it to character string data type, if it's possible.

Icône Lien d’article Conventions de la syntaxe Transact-SQLArticle link icon Transact-SQL Syntax Conventions

SyntaxeSyntax

-- Syntax for SQL Server and Azure SQL Database  
  
match_expression [ NOT ] LIKE pattern [ ESCAPE escape_character ]  
-- Syntax for Azure Synapse Analytics and Parallel Data Warehouse  
  
match_expression [ NOT ] LIKE pattern  

Notes

Les séquences ESCAPE et STRING_ESCAPE ne sont pas pris en charge dans Azure Synapse Analytics (SQL Data Warehouse)Azure Synapse Analytics (SQL Data Warehouse) ou Parallel Data WarehouseParallel Data Warehouse.Currently ESCAPE and STRING_ESCAPE are not supported in Azure Synapse Analytics (SQL Data Warehouse)Azure Synapse Analytics (SQL Data Warehouse) or Parallel Data WarehouseParallel Data Warehouse.

Notes

Pour afficher la syntaxe Transact-SQL pour SQL Server 2014 et versions antérieures, consultez Versions antérieures de la documentation.To view Transact-SQL syntax for SQL Server 2014 and earlier, see Previous versions documentation.

ArgumentsArguments

match_expressionmatch_expression
Toute expression valide d’un type de données caractères.Is any valid expression of character data type.

patternpattern
Chaîne de caractères spécifique à rechercher dans match_expression. Peut inclure les caractères génériques valides suivants.Is the specific string of characters to search for in match_expression, and can include the following valid wildcard characters. pattern peut faire au maximum 8 000 octets.pattern can be a maximum of 8,000 bytes.

Caractère génériqueWildcard character DescriptionDescription  ExempleExample
% Toute chaîne de zéro caractère ou plus.Any string of zero or more characters. WHERE title LIKE '%computer%' trouve tous les titres de livres comportant le terme « computer ».WHERE title LIKE '%computer%' finds all book titles with the word 'computer' anywhere in the book title.
_ (souligné)_ (underscore) N'importe quel caractère.Any single character. WHERE au_fname LIKE '_ean' trouve tous les prénoms en quatre lettres terminant par « ean » (Dean, Sean, etc.).WHERE au_fname LIKE '_ean' finds all four-letter first names that end with ean (Dean, Sean, and so on).
[ ][ ] Tout caractère de l'intervalle ([a-f]) ou de l'ensemble spécifié ([abcdef]).Any single character within the specified range ([a-f]) or set ([abcdef]). WHERE au_lname LIKE '[C-P]arsen' trouve les noms d'auteurs terminant par « arsen » et commençant par un caractère compris entre C et P, tels que Carsen, Larsen, Karsen, etc.WHERE au_lname LIKE '[C-P]arsen' finds author last names ending with arsen and starting with any single character between C and P, for example Carsen, Larsen, Karsen, and so on. Dans une recherche de plages, les caractères compris dans la plage peuvent varier selon les règles de tri du classement.In range searches, the characters included in the range may vary depending on the sorting rules of the collation.
[^][^] Tout caractère en dehors de l'intervalle ([^a-f]) ou de l'ensemble spécifié ([^abcdef]).Any single character not within the specified range ([^a-f]) or set ([^abcdef]). WHERE au_lname LIKE 'de[^l]%' trouve tous les noms d'auteurs commençant par « de » et dont la lettre suivante n'est pas « l ».WHERE au_lname LIKE 'de[^l]%' all author last names starting with de and where the following letter isn't l.

escape_characterescape_character
Caractère placé devant un caractère générique pour indiquer que celui-ci doit être interprété comme un caractère normal et non comme un caractère générique.Is a character put in front of a wildcard character to indicate that the wildcard is interpreted as a regular character and not as a wildcard. escape_character est une expression de caractères qui n’a pas de valeur par défaut et qui doit être évaluée à un seul caractère.escape_character is a character expression that has no default and must evaluate to only one character.

Types des résultatsResult Types

BooléenBoolean

Valeur des résultatsResult Value

LIKE renvoie TRUE si match_expression correspond au pattern spécifié.LIKE returns TRUE if the match_expression matches the specified pattern.

RemarquesRemarks

Dans le cadre de la comparaison de chaînes avec LIKE, tous les caractères de la chaîne modèle ont une signification,When you do string comparisons by using LIKE, all characters in the pattern string are significant. espaces de début et de fin compris.Significant characters include any leading or trailing spaces. Dans le cas d’une comparaison qui retourne toutes les lignes contenant une chaîne LIKE « abc  » (abc suivi d'un seul espace), une ligne dont la valeur dans cette colonne serait « abc » (abc sans espace) ne serait pas retournée.If a comparison in a query is to return all rows with a string LIKE 'abc ' (abc followed by a single space), a row in which the value of that column is abc (abc without a space) isn't returned. Les espaces à droite dont le profil correspond à l'expression ne sont pas pris en compte.However, trailing blanks, in the expression to which the pattern is matched, are ignored. Si vous demandez une comparaison qui renvoie toutes les lignes contenant une chaîne LIKE « abc » (abc sans espace), toutes les lignes commençant par la chaîne « abc », qu'elles contiennent ou non des espaces à droite, seront renvoyées.If a comparison in a query is to return all rows with the string LIKE 'abc' (abc without a space), all rows that start with abc and have zero or more trailing blanks are returned.

Une comparaison LIKE de chaînes suivant un modèle contenant des données char et varchar risque d’échouer en raison du mode de stockage des différents types de données.A string comparison using a pattern that contains char and varchar data may not pass a LIKE comparison because of how the data is stored for each data type. L’exemple suivant transmet une variable char locale à une procédure stockée, puis utilise des critères spéciaux pour trouver tous les employés dont le nom commence par le jeu de caractères donné.The following example passes a local char variable to a stored procedure and then uses pattern matching to find all employees whose last names start with the specified set of characters.

-- Uses AdventureWorks  
  
CREATE PROCEDURE FindEmployee @EmpLName char(20)  
AS  
SELECT @EmpLName = RTRIM(@EmpLName) + '%';  
SELECT p.FirstName, p.LastName, a.City  
FROM Person.Person p JOIN Person.Address a ON p.BusinessEntityID = a.AddressID  
WHERE p.LastName LIKE @EmpLName;  
GO  
EXEC FindEmployee @EmpLName = 'Barb';  
GO  

Dans la procédure FindEmployee, aucune ligne n’est retournée car la variable char (@EmpLName) contient des espaces à droite en fin de chaîne pour chaque nom comprenant moins de 20 caractères.In the FindEmployee procedure, no rows are returned because the char variable (@EmpLName) contains trailing blanks whenever the name contains fewer than 20 characters. Comme la colonne LastName est de type varchar, elle ne contient aucun espace à droite.Because the LastName column is varchar, there are no trailing blanks. Cette procédure échouera car les espaces de droite sont significatifs.This procedure fails because the trailing blanks are significant.

En revanche, l’exemple suivant réussit, car les espaces de fin ne sont pas ajoutés à une variable varchar.However, the following example succeeds because trailing blanks aren't added to a varchar variable.

-- Uses AdventureWorks  
  
CREATE PROCEDURE FindEmployee @EmpLName varchar(20)  
AS  
SELECT @EmpLName = RTRIM(@EmpLName) + '%';  
SELECT p.FirstName, p.LastName, a.City  
FROM Person.Person p JOIN Person.Address a ON p.BusinessEntityID = a.AddressID  
WHERE p.LastName LIKE @EmpLName;  
GO  
EXEC FindEmployee @EmpLName = 'Barb';  

Voici le jeu de résultats obtenu.Here is the result set.

FirstName      LastName            City
----------     -------------------- --------------- 
Angela         Barbariol            Snohomish
David          Barber               Snohomish
(2 row(s) affected)  

Recherche générique à l'aide de LIKEPattern Matching by Using LIKE

Le mot clé LIKE prend en charge la recherche générique ASCII ainsi que la recherche générique Unicode.LIKE supports ASCII pattern matching and Unicode pattern matching. Lorsque tous les arguments (match_expression, pattern et escape_character, le cas échéant) sont des types de données caractères ASCII, une correspondance de modèles ASCII est effectuée.When all arguments (match_expression, pattern, and escape_character, if present) are ASCII character data types, ASCII pattern matching is performed. Si l'un des arguments est de type de données Unicode, tous les arguments sont convertis en Unicode et une recherche générique Unicode est effectuée.If any one of the arguments are of Unicode data type, all arguments are converted to Unicode and Unicode pattern matching is performed. Lors de l’utilisation des données Unicode (types de données nchar ou nvarchar) avec LIKE, les espaces à droite sont significatifs ; pour les données non Unicode, en revanche, ils ne le sont pas.When you use Unicode data (nchar or nvarchar data types) with LIKE, trailing blanks are significant; however, for non-Unicode data, trailing blanks aren't significant. Unicode LIKE est compatible avec la version standard de ISO.Unicode LIKE is compatible with the ISO standard. ASCII LIKE est compatible avec les versions antérieures de SQL ServerSQL Server.ASCII LIKE is compatible with earlier versions of SQL ServerSQL Server.

Voici une série d'exemples illustrant les différences dans les lignes renvoyées entre une recherche générique ASCII LIKE et une recherche générique Unicode LIKE.The following is a series of examples that show the differences in rows returned between ASCII and Unicode LIKE pattern matching.

-- ASCII pattern matching with char column  
CREATE TABLE t (col1 char(30));  
INSERT INTO t VALUES ('Robert King');  
SELECT *   
FROM t   
WHERE col1 LIKE '% King';   -- returns 1 row  
  
-- Unicode pattern matching with nchar column  
CREATE TABLE t (col1 nchar(30));  
INSERT INTO t VALUES ('Robert King');  
SELECT *   
FROM t   
WHERE col1 LIKE '% King';   -- no rows returned  
  
-- Unicode pattern matching with nchar column and RTRIM  
CREATE TABLE t (col1 nchar (30));  
INSERT INTO t VALUES ('Robert King');  
SELECT *   
FROM t   
WHERE RTRIM(col1) LIKE '% King';   -- returns 1 row  

Notes

Les comparaisons LIKE sont affectées par le classement.LIKE comparisons are affected by collation. Pour plus d’informations, consultez COLLATE (Transact-SQL).For more information, see COLLATE (Transact-SQL).

Utilisation du caractère générique %Using the % Wildcard Character

Si le symbole LIKE « 5% » est spécifié, Moteur de base de donnéesDatabase Engine recherche le nombre 5 suivi d'une chaîne de zéro caractère ou plus.If the LIKE '5%' symbol is specified, the Moteur de base de donnéesDatabase Engine searches for the number 5 followed by any string of zero or more characters.

Par exemple, la requête suivante affiche toutes les vues de gestion dynamique dans la base de données AdventureWorks2012AdventureWorks2012, parce qu'elles commencent par les lettres dm.For example, the following query shows all dynamic management views in the AdventureWorks2012AdventureWorks2012 database, because they all start with the letters dm.

-- Uses AdventureWorks  
  
SELECT Name  
FROM sys.system_views  
WHERE Name LIKE 'dm%';  
GO  

Pour voir tous les objets qui ne sont pas des vues de gestion dynamique, utilisez NOT LIKE 'dm%'.To see all objects that aren't dynamic management views, use NOT LIKE 'dm%'. S'il existe 32 objets au total et que LIKE trouve 13 noms correspondant au modèle, NOT LIKE trouvera 19 objets n’y correspondant pas.If you have a total of 32 objects and LIKE finds 13 names that match the pattern, NOT LIKE finds the 19 objects that don't match the LIKE pattern.

Il se peut qu'une recherche telle que LIKE '[^d][^m]%' ne vous renvoie pas toujours les mêmes noms.You may not always find the same names with a pattern such as LIKE '[^d][^m]%'. Au lieu de 19 noms, il se peut que vous n'en trouviez que 14 (tous les noms commençant par d ou dont la deuxième lettre est m sont exclus des résultats) avec, en prime, le nom des vues de gestion dynamique.Instead of 19 names, you may find only 14, with all the names that start with d or have m as the second letter eliminated from the results, and the dynamic management view names. Ce comportement s’explique par le fait que les chaînes correspondantes avec des caractères génériques de négation sont évaluées par étapes, un caractère générique après l'autre.This behavior is because match strings with negative wildcard characters are evaluated in steps, one wildcard at a time. Si la correspondance échoue à l'une des étapes de l'évaluation, la chaîne de caractères est éliminée.If the match fails at any point in the evaluation, it's eliminated.

Utilisation de caractères génériques comme termes littérauxUsing Wildcard Characters As Literals

Vous pouvez utiliser les caractères génériques comme termes littéraux.You can use the wildcard pattern matching characters as literal characters. Pour utiliser un caractère générique en tant que terme littéral, mettez-le entre parenthèses.To use a wildcard character as a literal character, enclose the wildcard character in brackets. Le tableau ci-après propose plusieurs exemples d'utilisation du mot clé LIKE et des caractères génériques [ ].The following table shows several examples of using the LIKE keyword and the [ ] wildcard characters.

SymboleSymbol SignificationMeaning
LIKE '5[%]'LIKE '5[%]' 5 %5%
LIKE '[]n'LIKE '[]n' _n_n
LIKE '[a-cdf]'LIKE '[a-cdf]' a, b, c, d ou fa, b, c, d, or f
LIKE '[-acdf]'LIKE '[-acdf]' -, a, c, d, ou f-, a, c, d, or f
LIKE '[ [ ]'LIKE '[ [ ]' [[
LIKE ']'LIKE ']' ]]
LIKE 'abc[]d%'LIKE 'abc[]d%' abc_d et abc_eabc_d and abc_de
LIKE 'abc[def]'LIKE 'abc[def]' abcd, abce et abcfabcd, abce, and abcf

Recherche générique avec la clause ESCAPEPattern Matching with the ESCAPE Clause

Vous pouvez rechercher des chaînes de caractères comprenant un ou plusieurs caractères génériques particuliers.You can search for character strings that include one or more of the special wildcard characters. À titre d'exemple, la table discounts de la base de données customers peut stocker les valeurs de remises comprenant un pourcentage (%).For example, the discounts table in a customers database may store discount values that include a percent sign (%). Pour rechercher un pourcentage en tant que caractère et non en tant que caractère générique, le mot clé ESCAPE et le caractère d'échappement doivent être fournis.To search for the percent sign as a character instead of as a wildcard character, the ESCAPE keyword and escape character must be provided. Par exemple, une base de données exemple contient une colonne dénommée comment comprenant la chaîne 30 %.For example, a sample database contains a column named comment that contains the text 30%. Pour rechercher les lignes contenant la chaîne 30% n'importe où dans la colonne comment, spécifiez une clause WHERE telle que WHERE comment LIKE '%30!%%' ESCAPE '!'.To search for any rows that contain the string 30% anywhere in the comment column, specify a WHERE clause such as WHERE comment LIKE '%30!%%' ESCAPE '!'. Si le mot clé ESCAPE et le caractère d’échappement ne sont pas spécifiés, le Moteur de base de donnéesDatabase Engine retourne toutes les lignes contenant la chaîne 30!.If ESCAPE and the escape character aren't specified, the Moteur de base de donnéesDatabase Engine returns any rows with the string 30!.

Un modèle LIKE qui ne contient aucun caractère après un caractère d'échappement n'est pas valide ; le mot clé LIKE retourne alors la valeur FALSE.If there is no character after an escape character in the LIKE pattern, the pattern isn't valid and the LIKE returns FALSE. Si le caractère se trouvant après un caractère d'échappement n'est pas un caractère générique, le caractère d'échappement est ignoré et le caractère suivant est traité comme un caractère normal dans le modèle.If the character after an escape character isn't a wildcard character, the escape character is discarded and the following character is treated as a regular character in the pattern. Il s'agit notamment des caractères génériques suivants : symbole de pourcentage (%), trait de soulignement () et crochet gauche ([) lorsqu'ils sont placés entre deux crochets ([ ]).These characters include the percent sign (%), underscore (), and left bracket ([) wildcard characters when they are enclosed in double brackets ([ ]). Les caractères d'échappement peuvent être utilisés à l'intérieur de doubles crochets ([ ]), notamment pour l'accent circonflexe (^), le trait d'union (-) et le crochet (]) droit.Escape characters can be used within the double bracket characters ([ ]), including to escape a caret (^), hyphen (-), or right bracket (]).

0x0000 (char(0)) est un caractère non défini dans les classements Windows, qui n’est pas utilisable avec LIKE.0x0000 (char(0)) is an undefined character in Windows collations and can't be included in LIKE.

ExemplesExamples

R.A. Utilisation de LIKE avec le caractère générique %Using LIKE with the % wildcard character

L'exemple suivant renvoie tous les numéros de téléphone comportant l'indicatif 415 dans la table PersonPhone.The following example finds all telephone numbers that have area code 415 in the PersonPhone table.

-- Uses AdventureWorks  
  
SELECT p.FirstName, p.LastName, ph.PhoneNumber  
FROM Person.PersonPhone AS ph  
INNER JOIN Person.Person AS p  
ON ph.BusinessEntityID = p.BusinessEntityID  
WHERE ph.PhoneNumber LIKE '415%'  
ORDER by p.LastName;  
GO  

Voici le jeu de résultats obtenu.Here is the result set.

 FirstName             LastName             Phone
 -----------------     -------------------  ------------
 Ruben                 Alonso               415-555-124  
 Shelby                Cook                 415-555-0121  
 Karen                 Hu                   415-555-0114  
 John                  Long                 415-555-0147  
 David                 Long                 415-555-0123  
 Gilbert               Ma                   415-555-0138  
 Meredith              Moreno               415-555-0131  
 Alexandra             Nelson               415-555-0174  
 Taylor                Patterson            415-555-0170  
 Gabrielle              Russell             415-555-0197  
 Dalton                 Simmons             415-555-0115  
 (11 row(s) affected)  

B.B. Utilisation de NOT LIKE avec le caractère générique %Using NOT LIKE with the % wildcard character

L’exemple ci-après renvoie tous les numéros de téléphone de la table PersonPhone dont l’indicatif n’est pas 415.The following example finds all telephone numbers in the PersonPhone table that have area codes other than 415.

-- Uses AdventureWorks  
  
SELECT p.FirstName, p.LastName, ph.PhoneNumber  
FROM Person.PersonPhone AS ph  
INNER JOIN Person.Person AS p  
ON ph.BusinessEntityID = p.BusinessEntityID  
WHERE ph.PhoneNumber NOT LIKE '415%' AND p.FirstName = 'Gail'  
ORDER BY p.LastName;  
GO  

Voici le jeu de résultats obtenu.Here is the result set.

FirstName              LastName            Phone
---------------------- -------------------- -------------------
Gail                  Alexander            1 (11) 500 555-0120  
Gail                  Butler               1 (11) 500 555-0191  
Gail                  Erickson             834-555-0132  
Gail                  Erickson             849-555-0139  
Gail                  Griffin              450-555-0171  
Gail                  Moore                155-555-0169  
Gail                  Russell              334-555-0170  
Gail                  Westover             305-555-0100  
(8 row(s) affected)  

C.C. Utilisation de la clause ESCAPEUsing the ESCAPE clause

L’exemple suivant utilise la clause ESCAPE et le caractère d’échappement pour trouver la chaîne de caractères exacte 10-15% dans la colonne c1 de la table mytbl2.The following example uses the ESCAPE clause and the escape character to find the exact character string 10-15% in column c1 of the mytbl2 table.

USE tempdb;  
GO  
IF EXISTS(SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES  
      WHERE TABLE_NAME = 'mytbl2')  
   DROP TABLE mytbl2;  
GO  
USE tempdb;  
GO  
CREATE TABLE mytbl2  
(  
 c1 sysname  
);  
GO  
INSERT mytbl2 VALUES ('Discount is 10-15% off'), ('Discount is .10-.15 off');  
GO  
SELECT c1   
FROM mytbl2  
WHERE c1 LIKE '%10-15!% off%' ESCAPE '!';  
GO  

D.D. Utilisation des caractères génériques [ ]Using the [ ] wildcard characters

L’exemple suivant recherche les employés figurant dans la table Person dont le prénom est Cheryl ou Sheryl.The following example finds employees on the Person table with the first name of Cheryl or Sheryl.

-- Uses AdventureWorks  
  
SELECT BusinessEntityID, FirstName, LastName   
FROM Person.Person   
WHERE FirstName LIKE '[CS]heryl';  
GO  

L'exemple suivant recherche les lignes correspondant aux employés de la table Person dont le nom est Zheng ou Zhang.The following example finds the rows for employees in the Person table with last names of Zheng or Zhang.

-- Uses AdventureWorks  
  
SELECT LastName, FirstName  
FROM Person.Person  
WHERE LastName LIKE 'Zh[ae]ng'  
ORDER BY LastName ASC, FirstName ASC;  
GO  

Exemples : Azure Synapse Analytics (SQL Data Warehouse)Azure Synapse Analytics (SQL Data Warehouse) et Parallel Data WarehouseParallel Data WarehouseExamples: Azure Synapse Analytics (SQL Data Warehouse)Azure Synapse Analytics (SQL Data Warehouse) and Parallel Data WarehouseParallel Data Warehouse

E.E. Utilisation de LIKE avec le caractère générique %Using LIKE with the % wildcard character

L’exemple suivant recherche tous les employés figurant dans la table DimEmployee dont le numéro de téléphone commence par 612.The following example finds all employees in the DimEmployee table with telephone numbers that start with 612.

-- Uses AdventureWorks  
  
SELECT FirstName, LastName, Phone  
FROM DimEmployee  
WHERE phone LIKE '612%'  
ORDER by LastName;  

F.F. Utilisation de NOT LIKE avec le caractère générique %Using NOT LIKE with the % wildcard character

L’exemple suivant recherche tous les numéros de téléphone de la table DimEmployee qui ne commencent pas par 612.The following example finds all telephone numbers in the DimEmployee table that don't start with 612. ..

-- Uses AdventureWorks  
  
SELECT FirstName, LastName, Phone  
FROM DimEmployee  
WHERE phone NOT LIKE '612%'  
ORDER by LastName;  

G.G. Utilisation de LIKE avec le caractère générique _Using LIKE with the _ wildcard character

L’exemple suivant recherche tous les numéros de téléphone dont l’indicatif commence par 6 et se termine par 2 dans la table DimEmployee.The following example finds all telephone numbers that have an area code starting with 6 and ending in 2 in the DimEmployee table. Le caractère générique % est ajouté à la fin du modèle de recherche pour correspondre à tous les caractères suivants dans la valeur de colonne phone.The % wildcard character is included at the end of the search pattern to match all following characters in the phone column value.

-- Uses AdventureWorks  
  
SELECT FirstName, LastName, Phone  
FROM DimEmployee  
WHERE phone LIKE '6_2%'  
ORDER by LastName;   

Voir aussiSee Also

PATINDEX (Transact-SQL) PATINDEX (Transact-SQL)
Expressions (Transact-SQL) Expressions (Transact-SQL)
Fonctions intégrées (Transact-SQL) Built-in Functions (Transact-SQL)
SELECT (Transact-SQL) SELECT (Transact-SQL)
WHERE (Transact-SQL)WHERE (Transact-SQL)