Guide de SQL LIKE

LIKE vérifie si un texte correspond à un motif, où % représente n’importe quelle suite de caractères et _ exactement un caractère. C’est ce qui te permet de trouver les valeurs qui contiennent un texte, commencent ou se terminent par celui-ci. Les exemples fonctionnent avec PostgreSQL, MySQL, SQLite et SQL Server.

Comment utiliser LIKE

LIKE compare une valeur à un motif. Le motif doit correspondre à la valeur entière, avec deux jokers pour combler les trous : % correspond à n’importe quel nombre de caractères (y compris aucun) et _ à exactement un. NOT LIKE renvoie l’inverse.

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

Le dernier est faux car, sans joker, le motif doit être égal à la valeur entière. Dans une requête, LIKE se place généralement dans la clause 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

Règles à connaître

• Le LIKE de PostgreSQL est sensible à la casse. Les autres bases de données ignorent la casse par défaut, mais dans PostgreSQL 'Smith' LIKE 'smith' est faux. Passe les deux côtés en minuscules, comme dans LOWER(name) LIKE '%smith%', quand la casse ne doit pas compter.
• NULL ne correspond jamais. NULL LIKE '%' vaut NULL, pas vrai, donc les lignes où la colonne est NULL sont exclues à la fois par LIKE et par NOT LIKE. Ajoute OR column IS NULL si tu veux les garder.

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

• Échappe % et _ pour les rechercher littéralement. Place un caractère d’échappement devant le joker et déclare-le avec 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 % en début de motif ne peut pas utiliser d’index. Une recherche par préfixe comme LIKE 'INV-2026-%' peut utiliser un index sur la colonne, mais LIKE '%widget%' doit vérifier chaque ligne. Pour chercher des mots dans de gros volumes de texte, utilise plutôt la recherche plein texte de ta base de données.

Syntaxe alternative

Tu croiseras aussi ces extras propres à chaque base de données :

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

Pour vérifier si un texte contient une chaîne fixe, sans motif, cherche sa position. Le résultat vaut 0 quand la chaîne est absente :

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

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

Le CONTAINS() de SQL Server n’est pas un test de sous-chaîne : c’est un prédicat de recherche plein texte qui nécessite un index plein texte.

Quand utiliser LIKE ?

Utilise LIKE quand tu connais une partie d’une valeur, mais pas sa totalité. La plupart des usages entrent dans l’un de ces quatre cas.

Trouver un texte qui contient un mot

Mets % de chaque côté du mot. '%Tech%' correspond à « Tech Solutions Inc », « FinTech Corp » et « Technology Partners », car il trouve aussi le mot à l’intérieur de mots plus longs.

Rechercher le début ou la fin d’une valeur

Mets % uniquement à la fin pour chercher un préfixe, comme 'INV-2026-%', ou uniquement au début pour chercher un suffixe, comme '%.pdf' ou '%@gmail.com'. Ce sont les recherches par préfixe qu’un index peut accélérer.

Vérifier un format fixe

_ représente exactement un caractère, donc un motif peut décrire la forme d’une valeur : '___-___-____' pour un numéro de téléphone, 'A__-___' pour un code produit. Avec NOT LIKE, le même motif trouve les valeurs qui ne respectent pas le format.

Chercher sans se soucier de la casse

Les utilisateurs tapent « smith » ; les données disent « Smith ». Passe les deux côtés en minuscules avec LOWER() et la recherche ignore la casse, même dans PostgreSQL.

Exemples concrets de LIKE

Chercher l’un de plusieurs mots

Combine les motifs avec OR pour trouver les produits qui correspondent à l’un d’eux :

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

Trouver les factures de l’année

Les numéros de facture commencent par un type et une année, donc un motif de préfixe sélectionne les factures de 2026 et ignore les avoirs :

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

Trouver les numéros de téléphone mal formatés

Un _ par caractère décrit le format attendu, et NOT LIKE liste les lignes à nettoyer :

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

Trouver un nom de famille quelle que soit la casse

Les noms saisis en majuscules ou en minuscules ressortent quand même si les deux côtés sont passés en minuscules :

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

Pour aller plus loin avec LIKE

Sur ce blog :

• Guide de SQL SUBSTRING : extraire une partie d’une chaîne une fois trouvée
• Guide de SQL « différent de » : NOT LIKE et les autres façons d’exclure des lignes
• Guide de l’instruction SQL CASE : étiqueter des lignes selon des conditions, y compris des motifs LIKE
• Créer des index dans PostgreSQL : les index qui rendent les recherches par préfixe rapides
• Tutoriel MySQL CREATE INDEX : la même chose pour MySQL

Documentation officielle :

• PostgreSQL : LIKE
• MySQL : LIKE
• SQLite : les opérateurs LIKE, GLOB, REGEXP, MATCH et extract
• SQL Server : LIKE