Guida a SQL LIKE

LIKE verifica se un testo corrisponde a un pattern, dove % indica una sequenza qualsiasi di caratteri e _ esattamente un carattere. È il modo per trovare valori che contengono, iniziano o finiscono con un certo testo. Gli esempi funzionano in PostgreSQL, MySQL, SQLite e SQL Server.

Come usare LIKE

LIKE confronta un valore con un pattern. Il pattern deve corrispondere all'intero valore, con due caratteri jolly per riempire i vuoti: % corrisponde a un numero qualsiasi di caratteri (anche zero) e _ esattamente a uno. NOT LIKE restituisce il contrario.

expression [NOT] LIKE pattern [ESCAPE escape_character]

-- In SQL Server, LIKE only works in a condition, such as a WHERE clause
SELECT 'Joe Bloggs' LIKE 'Jo%';
-- Output: true

SELECT 'Joe Bloggs' LIKE 'J_e%';
-- Output: true

SELECT 'Joe Bloggs' LIKE 'Bloggs';
-- Output: false

L'ultimo è falso perché, senza caratteri jolly, il pattern deve essere uguale all'intero valore. In una query, LIKE va di solito nella clausola WHERE:

-- Input: customers
-- id | name
-- ---+-------------
-- 1  | Joe Bloggs
-- 2  | Jane Doe
-- 3  | Joanna Smith
-- 4  | Bob Jones

SELECT name
FROM customers
WHERE name LIKE 'Jo%';

-- Output:
-- name
-- ------------
-- Joe Bloggs
-- Joanna Smith

Regole da conoscere

• Il LIKE di PostgreSQL distingue maiuscole e minuscole. Gli altri database le ignorano di default, ma in PostgreSQL 'Smith' LIKE 'smith' è falso. Converti in minuscolo entrambi i lati, come in LOWER(name) LIKE '%smith%', quando le maiuscole non devono contare.
• NULL non corrisponde mai. NULL LIKE '%' è NULL, non vero, quindi le righe in cui la colonna è NULL vengono escluse sia da LIKE sia da NOT LIKE. Aggiungi OR column IS NULL se ti servono.

SELECT NULL LIKE '%';
-- Output: NULL

• Fai l'escape di % e _ per cercarli letteralmente. Metti un carattere di escape davanti al carattere jolly e indicalo con ESCAPE:

-- Input: discounts
-- id | description
-- ---+---------------------
-- 1  | 50% off winter coats
-- 2  | Spend 50, save 10
-- 3  | Up to 25% off shoes

-- Without escaping, the % after 50 is a wildcard
SELECT * FROM discounts
WHERE description LIKE '%50%%';

-- Output:
-- id | description
-- ---+---------------------
-- 1  | 50% off winter coats
-- 2  | Spend 50, save 10

-- With ESCAPE '\', the \% matches a real percent sign
-- (in MySQL, write ESCAPE '\\': a single backslash escapes the quote)
SELECT * FROM discounts
WHERE description LIKE '%50\%%' ESCAPE '\';

-- Output:
-- id | description
-- ---+---------------------
-- 1  | 50% off winter coats

• Un % iniziale non può usare un indice. Una ricerca per prefisso come LIKE 'INV-2026-%' può sfruttare un indice sulla colonna, ma LIKE '%widget%' deve controllare ogni riga. Per cercare parole in grandi quantità di testo, usa invece la ricerca full-text del tuo database.

Sintassi alternative

Incontrerai anche queste varianti specifiche dei vari database:

-- PostgreSQL: ILIKE ignores case
SELECT 'SMITH' ILIKE 'smith';
-- Output: true

-- SQL Server: [ ] in a LIKE pattern matches one character from a set or range
SELECT CASE WHEN 'B12' LIKE '[A-C]%' THEN 'match' ELSE 'no match' END;
-- Output: match

-- MySQL: REGEXP for regular expressions (PostgreSQL uses ~)
SELECT 'A12-345' REGEXP '^A[0-9]{2}-[0-9]{3}$';
-- Output: 1

Per verificare se un testo contiene una stringa fissa, senza pattern, cercane la posizione. Il risultato è 0 quando la stringa non c'è:

SELECT INSTR('FinTech Corp', 'Tech');
-- Output: 4

-- PostgreSQL: POSITION('Tech' IN 'FinTech Corp')
-- SQL Server: CHARINDEX('Tech', 'FinTech Corp')

CONTAINS() di SQL Server non è un test di sottostringa: è un predicato di ricerca full-text che richiede un indice full-text.

Quando usare LIKE?

Usa LIKE quando conosci solo una parte di un valore. La maggior parte degli utilizzi rientra in uno di questi quattro casi.

Trovare testo che contiene una parola

Metti % su entrambi i lati della parola. '%Tech%' trova “Tech Solutions Inc”, “FinTech Corp” e “Technology Partners”, perché corrisponde anche all'interno di parole più lunghe.

Trovare l'inizio o la fine di un valore

Metti % solo alla fine per cercare un prefisso, come 'INV-2026-%', o solo all'inizio per cercare un suffisso, come '%.pdf' o '%@gmail.com'. Le ricerche per prefisso sono quelle che un indice può velocizzare.

Trovare un formato fisso

_ indica esattamente un carattere, quindi un pattern può descrivere la forma di un valore: '___-___-____' per un numero di telefono, 'A__-___' per un codice prodotto. Con NOT LIKE, lo stesso pattern trova i valori che non rispettano il formato.

Cercare senza badare a maiuscole e minuscole

Gli utenti scrivono “smith”, nei dati c'è “Smith”. Converti in minuscolo entrambi i lati con LOWER() e la ricerca ignorerà le maiuscole, anche in PostgreSQL.

Esempi reali di LIKE

Cercare una tra più parole

Combina i pattern con OR per trovare i prodotti che corrispondono ad almeno uno di essi:

-- Input: products
-- id | name
-- ---+-----------------
-- 1  | Gaming laptop
-- 2  | Spiral notebook
-- 3  | Desk lamp
-- 4  | Desktop computer

SELECT * FROM products
WHERE name LIKE '%laptop%'
   OR name LIKE '%notebook%'
   OR name LIKE '%computer%';

-- Output:
-- id | name
-- ---+-----------------
-- 1  | Gaming laptop
-- 2  | Spiral notebook
-- 4  | Desktop computer

Trovare le fatture di quest'anno

I numeri di fattura iniziano con un tipo e un anno, quindi un pattern per prefisso seleziona le fatture del 2026 ed esclude le note di credito:

-- Input: invoices
-- invoice_no    | customer
-- --------------+----------
-- INV-2026-0012 | Northwind
-- INV-2025-0981 | Contoso
-- CN-2026-0003  | Northwind
-- INV-2026-0040 | Fabrikam

SELECT * FROM invoices
WHERE invoice_no LIKE 'INV-2026-%';

-- Output:
-- invoice_no    | customer
-- --------------+----------
-- INV-2026-0012 | Northwind
-- INV-2026-0040 | Fabrikam

Trovare numeri di telefono nel formato sbagliato

Un _ per carattere descrive il formato atteso, e NOT LIKE elenca le righe da sistemare:

-- Input: customers
-- name      | phone
-- ----------+---------------
-- Ana Lima  | 555-010-1234
-- Ben Ode   | (555) 010-9876
-- Cara Diaz | 5550104321
-- Dev Rao   | 555-010-5555

SELECT name, phone FROM customers
WHERE phone NOT LIKE '___-___-____';

-- Output:
-- name      | phone
-- ----------+---------------
-- Ben Ode   | (555) 010-9876
-- Cara Diaz | 5550104321

Trovare un cognome con qualsiasi maiuscola

I nomi scritti in maiuscolo o minuscolo vengono trovati comunque se converti in minuscolo entrambi i lati:

-- Input: customers
-- id | name
-- ---+------------
-- 1  | Anna Smith
-- 2  | BEN SMITH
-- 3  | Dana Jones
-- 4  | carla smith

SELECT * FROM customers
WHERE LOWER(name) LIKE '%smith%';

-- Output:
-- id | name
-- ---+------------
-- 1  | Anna Smith
-- 2  | BEN SMITH
-- 4  | carla smith

Approfondimenti su LIKE

Su questo blog:

• Guida a SQL SUBSTRING: estrai parte di una stringa dopo averla trovata
• Guida a SQL not equal: NOT LIKE insieme agli altri modi per escludere righe
• Guida all'istruzione SQL CASE: etichetta le righe con condizioni, anche con pattern LIKE
• Creare indici in PostgreSQL: gli indici che rendono veloci le ricerche per prefisso
• Tutorial su MySQL CREATE INDEX: lo stesso per MySQL

Documentazione ufficiale:

• PostgreSQL: LIKE
• MySQL: LIKE
• SQLite: gli operatori LIKE, GLOB, REGEXP, MATCH ed extract
• SQL Server: LIKE