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

GILT FÜR: jaSQL Server jaAzure SQL-DatenbankjaAzure SQL Data Warehouse jaParallel Data WarehouseAPPLIES TO: yesSQL Server yesAzure SQL Database yesAzure SQL Data Warehouse yesParallel Data Warehouse

Bestimmt, ob eine bestimmte Zeichenfolge mit einem angegebenen Muster übereinstimmt.Determines whether a specific character string matches a specified pattern. Ein Muster kann normale Zeichen und Platzhalterzeichen einschließen.A pattern can include regular characters and wildcard characters. Bei einem Mustervergleich müssen normale Zeichen exakt mit den angegebenen Zeichen in der Zeichenfolge übereinstimmen.During pattern matching, regular characters must exactly match the characters specified in the character string. Platzhalterzeichen können jedoch mit beliebigen Teilen der Zeichenfolge übereinstimmen.However, wildcard characters can be matched with arbitrary fragments of the character string. Das Verwenden der Vergleichsoperatoren für Zeichenfolgen = und != ist nicht so flexibel wie das Verwenden von Platzhalterzeichen mit dem LIKE-Operator.Using wildcard characters makes the LIKE operator more flexible than using the = and != string comparison operators. Wenn eins der Argumente kein Zeichenfolgen-Datentyp ist, wird es von SQL Server-Datenbank-EngineSQL Server Database Engine in einen Zeichenfolgen-Datentyp konvertiert, sofern dies möglich ist.If any one of the arguments isn't of character string data type, the SQL Server-Datenbank-EngineSQL Server Database Engine converts it to character string data type, if it's possible.

Artikellinksymbol Transact-SQL Syntax Conventions (Transact-SQL-Syntaxkonventionen)Article link icon Transact-SQL Syntax Conventions

SyntaxSyntax

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

ArgumenteArguments

match_expressionmatch_expression
Ein gültiger Ausdruck eines Zeichendatentyps.Is any valid expression of character data type.

patternpattern
Ist die bestimmte Zeichenfolge, nach der in match_expression gesucht werden soll, und kann die folgenden gültigen Platzhalterzeichen enthalten.Is the specific string of characters to search for in match_expression, and can include the following valid wildcard characters. pattern darf maximal 8.000 Bytes umfassen.pattern can be a maximum of 8,000 bytes.

PlatzhalterWildcard character und BeschreibungDescription BeispielExample
% Eine Zeichenfolge aus null oder mehr ZeichenAny string of zero or more characters. WHERE title LIKE '%Computer%' findet alle Buchtitel, die das Wort 'Computer' enthalten.WHERE title LIKE '%computer%' finds all book titles with the word 'computer' anywhere in the book title.
_ (Unterstrich)_ (underscore) Ein einzelnes Zeichen.Any single character. WHERE au_fname LIKE '_ean' findet alle Vornamen mit vier Buchstaben, die auf ean enden (Dean, Sean usw.).WHERE au_fname LIKE '_ean' finds all four-letter first names that end with ean (Dean, Sean, and so on).
[ ][ ] Beliebiges einzelnes Zeichen im angegebenen Bereich ([a-f]) oder in der angegebenen Menge ([abcdef]).Any single character within the specified range ([a-f]) or set ([abcdef]). WHERE au_lname LIKE '[C-P]arsen' findet alle Autorennachnamen, die auf 'arsen' enden und mit einem einzelnen Zeichen zwischen C und P beginnen, z. B. Carsen, Larsen, Karsen usw.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. In Bereichssuchvorgängen unterscheiden sich die im Bereich enthaltenen Zeichen möglicherweise je nach den Sortierungsregeln für die Sortierung.In range searches, the characters included in the range may vary depending on the sorting rules of the collation.
[^][^] Beliebiges einzelnes Zeichen, das sich nicht im angegebenen Bereich ([^a-f]) oder in der angegebenen Menge ([^abcdef]) befindet.Any single character not within the specified range ([^a-f]) or set ([^abcdef]). WHERE au_lname LIKE 'de[^l]%' findet alle Autorennachnamen, die mit 'de' beginnen und deren dritter Buchstabe nicht l ist.WHERE au_lname LIKE 'de[^l]%' all author last names starting with de and where the following letter isn't l.

escape_characterescape_character
Ist ein Zeichen, das vor einem Platzhalterzeichen eingefügt wird, um anzuzeigen, dass der Platzhalter als reguläres Zeichen und nicht als Platzhalter interpretiert wird.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. excape_character ist ein Zeichenausdruck ohne Standard und muss zu einem einzelnen Zeichen ausgewertet werden.escape_character is a character expression that has no default and must evaluate to only one character.

ErgebnistypenResult Types

BooleanBoolean

ErgebniswertResult Value

LIKE gibt TRUE zurück, wenn match_expression dem angegebenen pattern entspricht.LIKE returns TRUE if the match_expression matches the specified pattern.

RemarksRemarks

Bei Zeichenfolgenvergleichen mithilfe von LIKE werden alle Zeichen in der Musterzeichenfolge berücksichtigt.When you do string comparisons by using LIKE, all characters in the pattern string are significant. Die zu berücksichtigenden Zeichen umfassen alle führenden oder nachfolgenden Leerzeichen.Significant characters include any leading or trailing spaces. Wenn in einer Vergleichsabfrage LIKE 'abc ' (abc, gefolgt von einem Leerzeichen) verwendet wird, um Zeilen zurückzugeben, die dem Muster abc ähnlich sind, werden keine Zeilen zurückgegeben, die den Wert abc (abc ohne Leerzeichen) enthalten.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. Nachfolgende Leerzeichen in dem Ausdruck, der mit dem Muster verglichen wird, werden jedoch ignoriert.However, trailing blanks, in the expression to which the pattern is matched, are ignored. Wenn in einer Abfrage LIKE 'abc' (abc ohne Leerzeichen) verwendet wird, um Zeilen zurückzugeben, die dem Muster abc ähnlich sind, werden alle Zeilen zurückgegeben, die mit abc anfangen und null oder mehr nachfolgende Leerzeichen enthalten.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.

Ein Zeichenfolgenvergleich mithilfe eines Musters, das Daten der Typen char und varchar enthält, ist bei Verwendung des LIKE-Operators möglicherweise aufgrund der Art und Weise, in der die Daten für jeden Datentyp gespeichert werden, nicht erfolgreich.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. Im folgenden Beispiel wird eine lokale char-Variable an eine gespeicherte Prozedur übergeben. Mit einem Mustervergleich sollen dann alle Mitarbeiter gefunden werden, deren Nachnamen mit den angegebenen Zeichen beginnen.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  

Die FindEmployee-Prozedur gibt keine Zeilen zurück, da die char-Variable (@EmpLName) immer dann nachfolgende Leerzeichen enthält, wenn der Name weniger als 20 Zeichen enthält.In the FindEmployee procedure, no rows are returned because the char variable (@EmpLName) contains trailing blanks whenever the name contains fewer than 20 characters. Da die LastName-Spalte vom Typ varchar ist, sind keine nachfolgenden Leerzeichen vorhanden.Because the LastName column is varchar, there are no trailing blanks. Diese Prozedur schlägt fehl, da die nachfolgenden Leerzeichen von Bedeutung sind.This procedure fails because the trailing blanks are significant.

Das folgende Beispiel ist jedoch erfolgreich, da der varchar-Variablen keine nachfolgenden Leerzeichen hinzugefügt werden.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';  

Im Folgenden finden Sie das Resultset.Here is the result set.

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

Mustervergleich mithilfe von LIKEPattern Matching by Using LIKE

LIKE unterstützt Mustervergleiche im ASCII- und Unicode-Format.LIKE supports ASCII pattern matching and Unicode pattern matching. Sind alle Argumente (match_expression, pattern und ggf. escape_character) ASCII-Zeichen, wird ein ASCII-Mustervergleich durchgeführt.When all arguments (match_expression, pattern, and escape_character, if present) are ASCII character data types, ASCII pattern matching is performed. Wenn eines der Argumente von einem Unicode-Datentyp ist, werden alle Argumente in Unicode konvertiert und ein Unicode-Mustervergleich durchgeführt.If any one of the arguments are of Unicode data type, all arguments are converted to Unicode and Unicode pattern matching is performed. Wenn Sie beim LIKE-Operator Unicode-Daten (nchar- oder nvarchar-Datentypen) verwenden, werden nachfolgende Leerzeichen berücksichtigt. Bei Daten, die nicht vom Typ Unicode sind, werden nachfolgende Leerzeichen ignoriert.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. Der Unicode-LIKE-Operator ist mit dem ISO-Standard kompatibel.Unicode LIKE is compatible with the ISO standard. Der ASCII-LIKE-Operator ist mit früheren Versionen von SQL ServerSQL Server kompatibel.ASCII LIKE is compatible with earlier versions of SQL ServerSQL Server.

Die folgenden Beispiele verdeutlichen die Unterschiede der zurückgegebenen Zeilen beim Durchführen von Mustervergleichen mit ASCII- und Unicode-LIKE-Operatoren.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  

Hinweis

LIKE-Vergleiche werden von der Sortierung beeinflusst.LIKE comparisons are affected by collation. Weitere Informationen finden Sie unter COLLATE (Transact-SQL).For more information, see COLLATE (Transact-SQL).

Verwenden des %-PlatzhalterzeichensUsing the % Wildcard Character

Wird bei LIKE beispielsweise '5%' angegeben, sucht Datenbank-EngineDatabase Engine nach der Zahl 5, gefolgt von einer beliebigen Zeichenfolge mit 0 oder mehr Zeichen.If the LIKE '5%' symbol is specified, the Datenbank-EngineDatabase Engine searches for the number 5 followed by any string of zero or more characters.

Mit der folgenden Abfrage werden beispielsweise alle dynamischen Verwaltungssichten in der AdventureWorks2012AdventureWorks2012-Datenbank angezeigt, da sie alle mit den Buchstaben dm beginnen.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  

Wenn Objekte angezeigt werden sollen, bei denen es sich nicht um dynamische Verwaltungssichten handelt, verwenden Sie NOT LIKE 'dm%'.To see all objects that aren't dynamic management views, use NOT LIKE 'dm%'. Sind insgesamt 32 Objekte vorhanden und LIKE findet 13 Namen, die dem Muster entsprechen, findet NOT LIKE die 19 Objekte, die dem Muster nicht entsprechen.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.

Mit einem Muster wie LIKE '[^d][^m]%' werden möglicherweise nicht immer die gleichen Namen gefunden.You may not always find the same names with a pattern such as LIKE '[^d][^m]%'. Statt 19 Namen werden möglicherweise nur 14 angezeigt, da Namen, die mit d beginnen oder deren zweiter Buchstabe m ist, aus dem Resultset ebenso entfernt werden wie die Namen der dynamischen Verwaltungssichten.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. Grund für dieses Verhalten ist die sequentielle Auswertung von Musterzeichenfolgen mit negativen Platzhalterzeichen, es wird also ein Platzhalter nach dem anderen ausgewertet.This behavior is because match strings with negative wildcard characters are evaluated in steps, one wildcard at a time. Wenn der Vergleich an einem beliebigen Punkt der Auswertung fehlschlägt, wird das entsprechende Objekt entfernt.If the match fails at any point in the evaluation, it's eliminated.

Verwenden von Platzhalterzeichen als LiteraleUsing Wildcard Characters As Literals

Platzhalterzeichen können auch als Literalzeichen verwendet werden.You can use the wildcard pattern matching characters as literal characters. Um ein Platzhalterzeichen als Literalzeichen zu verwenden, schließen Sie das Platzhalterzeichen in Klammern ein.To use a wildcard character as a literal character, enclose the wildcard character in brackets. Die folgende Tabelle enthält einige Beispiele für die Verwendung des LIKE-Schlüsselworts und der [ ]-Platzhalterzeichen.The following table shows several examples of using the LIKE keyword and the [ ] wildcard characters.

SymbolSymbol BedeutungMeaning
LIKE '5[%]'LIKE '5[%]' 5%5%
LIKE '[]n'LIKE '[]n' _n_n
LIKE '[a-cdf]'LIKE '[a-cdf]' a, b, c, d oder fa, b, c, d, or f
LIKE '[-acdf]'LIKE '[-acdf]' -, a, c, d oder f-, a, c, d, or f
LIKE '[ [ ]'LIKE '[ [ ]' [[
LIKE ']'LIKE ']' ]]
LIKE 'abc[]d%'LIKE 'abc[]d%' abc_d und abc_deabc_d and abc_de
LIKE 'abc[def]'LIKE 'abc[def]' abcd, abce und abcfabcd, abce, and abcf

Mustervergleich mit der ESCAPE-KlauselPattern Matching with the ESCAPE Clause

Sie können nach Zeichenfolgen suchen, die ein oder mehrere Platzhalterzeichen enthalten.You can search for character strings that include one or more of the special wildcard characters. Die discounts-Tabelle in der customers-Datenbank kann beispielsweise Rabattwerte mit einem Prozentzeichen (%) speichern.For example, the discounts table in a customers database may store discount values that include a percent sign (%). Um nach dem Prozentzeichen als Zeichen und nicht als Platzhalterzeichen zu suchen, müssen das ESCAPE-Schlüsselwort und das Escapezeichen angegeben werden.To search for the percent sign as a character instead of as a wildcard character, the ESCAPE keyword and escape character must be provided. Eine Beispieldatenbank enthält beispielsweise eine comment-Spalte, die den Text 30% enthält.For example, a sample database contains a column named comment that contains the text 30%. Wenn Sie in den Zeilen der comment-Spalte nach der Zeichenfolge "30%" suchen, geben Sie eine WHERE-Klausel wie WHERE comment LIKE '%30!%%' ESCAPE '!' an.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 '!'. Werden ESCAPE und das Escapezeichen nicht angegeben, gibt Datenbank-EngineDatabase Engine alle Zeilen zurück, die die Zeichenfolge 30 enthalten.If ESCAPE and the escape character aren't specified, the Datenbank-EngineDatabase Engine returns any rows with the string 30.

Wenn im LIKE-Muster auf ein Escapezeichen kein Zeichen folgt, ist das Muster nicht gültig, und das LIKE-Muster gibt FALSE zurück.If there is no character after an escape character in the LIKE pattern, the pattern isn't valid and the LIKE returns FALSE. Wenn es sich beim Zeichen nach einem Escapezeichen nicht um ein Platzhalterzeichen handelt, wird das Escapezeichen verworfen und das folgende Zeichen als reguläres Zeichen im Muster behandelt.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. Zu diesen Platzhalterzeichen gehören das Prozentzeichen (%), der Unterstrich () und die linke eckige Klammer ([), wenn sie in doppelte eckige Klammern ([ ]) eingeschlossen sind.These characters include the percent sign (%), underscore (), and left bracket ([) wildcard characters when they are enclosed in double brackets ([ ]). Innerhalb doppelter eckiger Klammern ([ ]) können Escapezeichen verwendet werden; dem Caretzeichen (^), dem Bindestrich (-) sowie der rechten eckigen Klammer (]) kann ein Escapezeichen vorangestellt werden.Escape characters can be used within the double bracket characters ([ ]), including to escape a caret (^), hyphen (-), or right bracket (]).

0x0000 (char(0) ) ist ein nicht definiertes Zeichen in Windows-Sortierungen und darf in LIKE nicht enthalten sein.0x0000 (char(0)) is an undefined character in Windows collations and can't be included in LIKE.

BeispieleExamples

A.A. Verwenden von NOT LIKE mit dem Platzhalterzeichen %Using LIKE with the % wildcard character

Im folgenden Beispiel werden alle Telefonnummern gefunden, die die Vorwahl 415 in der PersonPhone-Tabelle enthalten.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  

Im Folgenden finden Sie das Resultset.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. Using NOT LIKE with the % wildcard character  
The following example finds all telephone numbers in the `PersonPhone` table that have area codes other than `415`.  
 
```sql  
-- 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  

Im Folgenden finden Sie das Resultset.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. Using the ESCAPE clause  
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.  
 
```sql
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. Verwenden des []-PlatzhalterzeichensUsing the [ ] wildcard characters

Im folgenden Beispiel werden Mitarbeiter in der Person-Tabelle mit dem Vornamen Cheryl oder Sheryl gesucht.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  

Im folgenden Beispiel werden in der Person-Tabelle Zeilen für Mitarbeiter mit den Nachnamen Zheng oder Zhang gesucht.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  

Beispiele: Azure SQL Data WarehouseAzure SQL Data Warehouse und Parallel Data WarehouseParallel Data Warehouse.Examples: Azure SQL Data WarehouseAzure SQL Data Warehouse and Parallel Data WarehouseParallel Data Warehouse

E.E. Verwenden von NOT LIKE mit dem Platzhalterzeichen %Using LIKE with the % wildcard character

Im folgenden Beispiel werden alle Mitarbeiter in der DimEmployee-Tabelle mit Telefonnummern gefunden, die mit 612 beginnen.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. Verwenden von NOT LIKE mit dem Platzhalterzeichen %Using NOT LIKE with the % wildcard character

Das folgende Beispiel findet alle Telefonnummern in der DimEmployee-Tabelle, die nicht mit 612 beginnen.The following example finds all telephone numbers in the DimEmployee table that don't start with 612. erforderlich..

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

G.G. Verwenden von LIKE mit dem Platzhalterzeichen _Using LIKE with the _ wildcard character

Im folgenden Beispiel werden alle Telefonnummern in der DimEmployee-Tabelle gefunden, die eine Vorwahl aufweisen, die mit 6 beginnt und mit 2 endet.The following example finds all telephone numbers that have an area code starting with 6 and ending in 2 in the DimEmployee table. Das Platzhalterzeichen % wird am Ende des Suchmusters eingefügt, um alle folgenden Zeichen im Spaltenwert für Telefonnummern abzugleichen.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;   

Weitere InformationenSee Also

PATINDEX (Transact-SQL) PATINDEX (Transact-SQL)
Ausdrücke (Transact-SQL) Expressions (Transact-SQL)
Integrierte Funktionen (Transact-SQL) Built-in Functions (Transact-SQL)
SELECT (Transact-SQL) SELECT (Transact-SQL)
WHERE (Transact-SQL)WHERE (Transact-SQL)