LIKE (Transact-SQL)
Si applica a: 
SQL Server Database SQL di Azure Istanza gestita di SQL di Azure Azure Synapse Analytics Piattaforma di strumenti analitici (PDW) Endpoint di analisi SQL in Microsoft Fabric Warehouse in Microsoft Fabric
Determina se una stringa di caratteri specifica corrisponde a un modello specificato. Il modello può contenere caratteri specifici e caratteri jolly. In una ricerca in base a un modello i normali caratteri devono corrispondere esattamente ai caratteri specificati nella stringa di caratteri del modello. I caratteri jolly tuttavia possono venire abbinati a frammenti arbitrari della stringa. L'uso dei caratteri jolly rende l'operatore LIKE più flessibile rispetto all'uso degli operatori di confronto tra = stringhe e != . Se il tipo di dati degli argomenti non è stringa di caratteri, il motore di database di SQL Server lo converte automaticamente nel tipo stringa di caratteri, se possibile.
Convenzioni relative alla sintassi Transact-SQL
Sintassi
Sintassi per SQL Server e database SQL di Azure:
match_expression [ NOT ] LIKE pattern [ ESCAPE escape_character ]
Sintassi per Azure Synapse Analytics e Parallel Data Warehouse:
match_expression [ NOT ] LIKE pattern
ESCAPE e STRING_ESCAPE non sono supportati in Azure Synapse Analytics o nel sistema della piattaforma di analisi (PDW).
Argomenti
match_expression
Qualsiasi espressione valida del tipo di dati di tipo carattere.
pattern
Stringa specifica di caratteri da cercare in match_expression e può includere caratteri jolly validi nella tabella seguente. pattern può essere composto da un massimo di 8.000 byte.
Se match_expression è un tipo di dati con precedenza maggiore rispetto a pattern e la lunghezza del criterio è maggiore di match_expression, si otterrà un errore di troncamento durante la conversione implicita del valore del criterio in match_expression tipo.
| Carattere jolly | Descrizione | Esempio |
|---|---|---|
% |
Stringa composta da zero o più caratteri. | WHERE title LIKE '%computer%' trova tutti i titoli dei libri con la parola computer ovunque nel titolo del libro. |
_ (carattere di sottolineatura) |
Carattere singolo. | WHERE au_fname LIKE '_ean' trova tutti i nomi di quattro lettere che terminano con ean (Dean, Seane così via). |
[ ] |
Qualsiasi carattere singolo all'interno dell'intervallo [a-f] specificato o impostato [abcdef]. |
WHERE au_lname LIKE '[C-P]arsen' trova i nomi dell'autore che terminano con arsen e iniziano con qualsiasi singolo carattere tra C e P, ad esempio Carsen, Larsen, Karsene così via. Nelle ricerche basate su intervalli i caratteri inclusi nell'intervallo possono variare a seconda delle regole di ordinamento delle regole di confronto. |
[^] |
Qualsiasi carattere singolo non compreso nell'intervallo [^a-f] specificato o impostato [^abcdef]. |
WHERE au_lname LIKE 'de[^l]%' trova tutti i nomi dell'autore che iniziano con de e dove la lettera seguente non lè . |
escape_character
Un carattere inserito davanti a un carattere jolly per indicare che il carattere jolly viene interpretato come un carattere normale e non come carattere jolly. escape_character è un'espressione di caratteri che non ha un valore predefinito e che deve restituire solo un carattere.
Tipo di risultato
Booleano
Valore restituito
LIKErestituisce TRUE se il match_expression corrisponde al criterio specificato.
Osservazioni:
Quando si eseguono confronti tra stringhe usando LIKE, tutti i caratteri nella stringa del criterio sono significativi. compresi gli spazi iniziali e finali. Se un confronto in una query consiste nel restituire tutte le righe con una stringa LIKE 'abc ' (abc seguita da uno spazio singolo), non viene restituita una riga in cui il valore di tale colonna è abc (abc senza uno spazio). Gli spazi vuoti finali vengono tuttavia ignorati nell'espressione corrispondente al modello. Se un confronto in una query consiste nel restituire tutte le righe con la stringa LIKE 'abc' (abc senza uno spazio), vengono restituite tutte le righe che iniziano con abc e hanno zero o più spazi vuoti finali.
Un confronto tra stringhe usando un criterio che contiene dati char e varchar potrebbe non passare un LIKE confronto a causa della modalità di archiviazione dei dati per ogni tipo di dati. Nell'esempio seguente viene passata una variabile char locale a una stored procedure e quindi viene utilizzato il criterio di ricerca per trovare tutti i dipendenti il cui cognome inizia con il set specificato di caratteri.
-- Uses AdventureWorks
CREATE PROCEDURE FindEmployee @EmpLName CHAR(20)
AS
SELECT @EmpLName = RTRIM(@EmpLName) + '%';
SELECT p.FirstName,
p.LastName,
a.City
FROM Person.Person p
INNER JOIN Person.Address a
ON p.BusinessEntityID = a.AddressID
WHERE p.LastName LIKE @EmpLName;
GO
EXEC FindEmployee @EmpLName = 'Barb';
GO
Nella procedura FindEmployee non viene restituita alcuna riga perché quando il nome è composto da meno di 20 caratteri la variabile char (@EmpLName) contiene spazi vuoti finali. Dato che la colonna LastName è di tipo varchar, non sono presenti spazi vuoti finali. Questa procedura ha esito negativo in quanto gli spazi vuoti finali sono significativi.
Nell'esempio seguente l'operazione ha invece esito positivo perché a una variabile varchar non vengono aggiunti spazi vuoti finali.
-- Uses AdventureWorks
CREATE PROCEDURE FindEmployee @EmpLName VARCHAR(20)
AS
SELECT @EmpLName = RTRIM(@EmpLName) + '%';
SELECT p.FirstName,
p.LastName,
a.City
FROM Person.Person p
INNER JOIN Person.Address a
ON p.BusinessEntityID = a.AddressID
WHERE p.LastName LIKE @EmpLName;
GO
EXEC FindEmployee @EmpLName = 'Barb';
GO
Il set di risultati è il seguente.
FirstName LastName City
---------- -------------------- ---------------
Angela Barbariol Snohomish
David Barber Snohomish
(2 row(s) affected)
Corrispondenza dei criteri con LIKE
LIKE supporta i criteri di ricerca ASCII e la corrispondenza dei criteri Unicode. Quando tutti gli argomenti (match_expression, pattern e escape_character, se presente) sono tipi di dati carattere ASCII, viene eseguita una ricerca ASCII. Se uno degli argomenti è di tipo Unicode, tutti gli argomenti vengono convertiti in Unicode e viene eseguita la corrispondenza dei criteri Unicode. Quando si usano dati Unicode (tipi di dati nchar o nvarchar ) con LIKE, gli spazi vuoti finali sono significativi. Tuttavia, per i dati non Unicode, gli spazi vuoti finali non sono significativi. Unicode LIKE è compatibile con lo standard ISO. ASCII LIKE è compatibile con le versioni precedenti di SQL Server.
La serie di esempi seguente mostra le differenze nelle righe restituite tra i criteri di ricerca ASCII e Unicode LIKE .
-- 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
Nota
LIKE i confronti sono influenzati dalle regole di confronto. Per altre informazioni, vedere COLLATE (Transact-SQL).
Usare il % carattere jolly
Se viene specificato il LIKE '5%' simbolo, il motore di database cerca il numero 5 seguito da qualsiasi stringa di zero o più caratteri.
Ad esempio, la query seguente visualizza tutte le viste a gestione dinamica nel database AdventureWorks2022 in quanto tutte iniziano con le lettere dm.
-- Uses AdventureWorks
SELECT Name
FROM sys.system_views
WHERE Name LIKE 'dm%';
GO
Per visualizzare tutti gli oggetti che non sono DMV, usare NOT LIKE 'dm%'. Se si dispone di un totale di 32 oggetti e LIKE vengono trovati 13 nomi che corrispondono al modello, NOT LIKE trova i 19 oggetti che non corrispondono al LIKE modello.
Non sempre è possibile trovare gli stessi nomi utilizzando un modello quale, ad esempio, LIKE '[^d][^m]%'. Anziché 19 nomi, è possibile trovarne solo 14, ovvero tutti i nomi che iniziano con d o hanno la lettera m in seconda posizione vengono eliminati dai risultati, nonché i nomi delle viste a gestione dinamica. Questo avviene perché le stringhe individuate tramite caratteri jolly negativi vengono valutate in fasi successive, un carattere jolly alla volta. La voce viene eliminata se la corrispondenza ha esito negativo durante una qualunque fase della valutazione.
Usare caratteri jolly come valori letterali
Nelle ricerche è possibile utilizzare i caratteri jolly come caratteri letterali racchiudendo il carattere jolly tra virgolette. La tabella seguente illustra diversi esempi di utilizzo della LIKE parola chiave e dei [ ] caratteri jolly.
| Simbolo | significato |
|---|---|
LIKE '5[%]' |
5% |
LIKE '[_]n' |
_n |
LIKE '[a-cdf]' |
a, b, c, d o f |
LIKE '[-acdf]' |
-, a, c, d o f |
LIKE '[ [ ]' |
[ |
LIKE ']' |
] |
LIKE 'abc[_]d%' |
abc_d e abc_de |
LIKE 'abc[def]' |
abcd, abce e abcf |
Corrispondenza dei criteri con la clausola ESCAPE
È possibile eseguire ricerche di stringhe di caratteri che includono uno o più caratteri speciali. Ad esempio, nella tabella discounts di un database customers è possibile archiviare i valori relativi allo sconto che includono il segno di percentuale (%). Per cercare il segno di percentuale come carattere e non come carattere jolly, è necessario specificare la parola chiave ESCAPE e il carattere di escape. Ad esempio, un database di esempio include una colonna denominata comment contenente il testo 30%. Per cercare le righe contenenti la stringa 30% all'interno della colonna dei commenti, specificare una clausola WHERE, ad esempio WHERE comment LIKE '%30!%%' ESCAPE '!'. Se non viene specificato ESCAPE e il carattere di escape, il motore di database restituisce tutte le righe con la stringa 30!.
Se dopo un carattere di escape non è presente alcun carattere nel modello LIKE, il modello non è valido e l'operatore LIKE restituisce FALSE. Se il carattere successivo al carattere di escape non è un carattere jolly, il carattere di escape viene eliminato e il carattere successivo viene considerato come un carattere normale nel modello. Questo è valido per il segno di percentuale (%), il carattere di sottolineatura (_) e la parentesi quadra aperta ([) quando questi caratteri jolly sono racchiusi tra doppie parentesi quadre ([ ]). I caratteri di escape possono essere usati all'interno di doppie parentesi quadre ([ ]), anche per eseguire l'escape di un accento circonflesso (^), un trattino (-) o una parentesi quadra chiusa (]).
0x0000 (char(0)) è un carattere non definito nelle regole di confronto di Windows e non può essere incluso in LIKE.
Esempi
R. Usare LIKE con il % carattere jolly
Nell'esempio seguente viene eseguita una ricerca di tutti i numeri telefonici con prefisso 415 nella tabella PersonPhone.
-- 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
Il set di risultati è il seguente.
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. Usare NOT LIKE con il % carattere jolly
Nell'esempio seguente viene eseguita una ricerca di tutti i numeri telefonici nella tabella PersonPhone il cui prefisso è diverso da 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
Il set di risultati è il seguente.
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. Usare la clausola ESCAPE
Nell'esempio seguente vengono usati la clausola ESCAPE e il carattere di escape per cercare la stringa di caratteri esatta 10-15% nella colonna c1 della tabella mytbl2.
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. Usare i [ ] caratteri jolly
Nell'esempio seguente viene eseguita una ricerca dei dipendenti presenti nella tabella Person con nome Cheryl o Sheryl.
-- Uses AdventureWorks
SELECT BusinessEntityID,
FirstName,
LastName
FROM Person.Person
WHERE FirstName LIKE '[CS]heryl';
GO
Nell'esempio seguente vengono restituite le righe relative ai dipendenti nella tabella Person con cognome Zheng o Zhang.
-- Uses AdventureWorks
SELECT LastName,
FirstName
FROM Person.Person
WHERE LastName LIKE 'Zh[ae]ng'
ORDER BY LastName ASC,
FirstName ASC;
GO
Esempi: Azure Synapse Analytics e Piattaforma di strumenti analitici (PDW)
E. Usare LIKE con il % carattere jolly
Nell'esempio seguente viene eseguita una ricerca di tutti i dipendenti presenti nella tabella DimEmployee con numeri telefonici che iniziano con 612.
-- Uses AdventureWorks
SELECT FirstName,
LastName,
Phone
FROM DimEmployee
WHERE phone LIKE '612%'
ORDER BY LastName;
F. Usare NOT LIKE con il % carattere jolly
Nell'esempio seguente viene eseguita una ricerca di tutti i numeri telefonici presenti nella tabella DimEmployee che non iniziano con 612.
-- Uses AdventureWorks
SELECT FirstName,
LastName,
Phone
FROM DimEmployee
WHERE phone NOT LIKE '612%'
ORDER BY LastName;
G. Usare LIKE con il _ carattere jolly
Nell'esempio seguente viene eseguita una ricerca di tutti i numeri telefonici con un prefisso che inizia con 6 e termina con 2 nella tabella DimEmployee. Alla fine del criterio di ricerca è incluso il carattere jolly % per trovare una corrispondenza con tutti i caratteri successivi nel valore della colonna del telefono.
-- Uses AdventureWorks
SELECT FirstName,
LastName,
Phone
FROM DimEmployee
WHERE phone LIKE '6_2%'
ORDER BY LastName;