menu
languageFrançais
save_alt Télécharger

Aide-mémoire du langage SQL

Les commandes SQL essentielles et la syntaxe de référence pour interroger tes bases de données

🔍 Les bases de SELECT

Récupère les données des tables en précisant les colonnes à renvoyer. Utilise DISTINCT pour supprimer les doublons et AS pour les alias de colonnes.
SELECT customer_id, name, email
FROM customers;

-- With alias and DISTINCT
SELECT DISTINCT country AS customer_country
FROM customers;

Points clés :

  • Indique des colonnes précises plutôt que * pour de meilleures performances
  • DISTINCT supprime les lignes en double
  • Le mot-clé AS crée des alias de colonnes
  • L'ordre des colonnes dans SELECT détermine celui du résultat

⚡ Clause WHERE

Filtre les lignes selon des conditions avec des opérateurs de comparaison. Combine plusieurs conditions avec AND/OR pour des filtres complexes.
SELECT name, price
FROM products
WHERE price > 100;

-- Multiple conditions
SELECT name, category
FROM products
WHERE category = 'Electronics'
  AND price <= 500;

Points clés :

  • Filtre les lignes avant de renvoyer les résultats
  • Permet de combiner plusieurs conditions avec AND/OR
  • Les chaînes de caractères nécessitent des guillemets simples
  • Opérateurs : =, !=, <>, <, >, <=, >=

⚙️ Opérateurs logiques

Combine plusieurs conditions avec AND (toutes doivent être vraies), OR (au moins une doit être vraie) et NOT (inverse la condition).
-- AND operator
SELECT * FROM orders
WHERE status = 'shipped' AND total > 100;

-- OR operator
SELECT * FROM customers
WHERE country = 'USA' OR country = 'Canada';

-- NOT operator
SELECT * FROM products
WHERE NOT category = 'Discontinued';

Points clés :

  • AND est prioritaire sur OR
  • Utilise des parenthèses pour contrôler l'ordre d'évaluation
  • NOT équivaut à != ou <>
  • Combine les opérateurs pour une logique complexe

↕️ ORDER BY

Trie les résultats par ordre croissant (ASC) ou décroissant (DESC). Trie sur plusieurs colonnes pour un ordre plus fin.
-- Single column sort
SELECT name, price
FROM products
ORDER BY price DESC;

-- Multiple columns
SELECT name, category, price
FROM products
ORDER BY category ASC, price DESC;

Points clés :

  • ASC est la valeur par défaut si rien n'est précisé
  • Tri sur plusieurs colonnes (priorité de gauche à droite)
  • Tu peux trier sur une colonne absente du SELECT
  • Les valeurs NULL sont triées en premier ou en dernier (selon la base)

✂️ LIMIT / OFFSET

Limite le nombre de lignes renvoyées et saute des lignes avec OFFSET. Indispensable pour la pagination et les gros jeux de résultats.
-- First 10 rows
SELECT name, price
FROM products
ORDER BY price DESC
LIMIT 10;

-- Pagination (skip first 20, get next 10)
SELECT name, price
FROM products
ORDER BY price DESC
LIMIT 10 OFFSET 20;

Points clés :

  • Indispensable pour la pagination
  • À combiner avec ORDER BY pour des résultats cohérents
  • OFFSET commence à 0 (première ligne)
  • Remarque : SQL Server utilise TOP au lieu de LIMIT

*️⃣ Recherche de motifs (LIKE)

Recherche des motifs de texte avec des jokers : % correspond à n'importe quelle suite de caractères, _ à un seul caractère.
-- Starts with 'John'
SELECT name, email
FROM customers
WHERE name LIKE 'John%';

-- Contains 'smith'
SELECT name FROM customers
WHERE name LIKE '%smith%';

-- Exact pattern (5 characters starting with 'A')
SELECT code FROM products
WHERE code LIKE 'A____';

Points clés :

  • % correspond à zéro caractère ou plus
  • _ correspond à exactement un caractère
  • La sensibilité à la casse dépend de la collation de la base
  • Utilise NOT LIKE pour exclure

↔️ Plages et ensembles (BETWEEN, IN)

Filtre par plage avec BETWEEN (bornes incluses) ou compare à une liste de valeurs avec IN. Plus efficace que plusieurs conditions OR.
-- BETWEEN (inclusive)
SELECT name, price
FROM products
WHERE price BETWEEN 50 AND 100;

-- IN operator
SELECT name, country
FROM customers
WHERE country IN ('USA', 'Canada', 'Mexico');

-- NOT IN
SELECT name FROM products
WHERE category NOT IN ('Discontinued', 'Draft');

Points clés :

  • BETWEEN inclut les deux bornes
  • IN est plus lisible que plusieurs conditions OR
  • IN fonctionne aussi avec des sous-requêtes
  • BETWEEN fonctionne avec les dates et les chaînes

❓ Gestion des NULL

Manipule les valeurs NULL avec IS NULL et IS NOT NULL. Utilise COALESCE pour fournir des valeurs par défaut aux colonnes NULL.
-- Find NULL values
SELECT name, phone
FROM customers
WHERE phone IS NULL;

-- Exclude NULL values
SELECT name, email
FROM customers
WHERE email IS NOT NULL;

-- Provide default value
SELECT name, COALESCE(phone, 'No phone') AS contact
FROM customers;

Points clés :

  • Impossible d'utiliser = ou != avec NULL
  • Il faut utiliser IS NULL ou IS NOT NULL
  • COALESCE renvoie le premier argument non NULL
  • NULL dans un calcul donne NULL

Σ Fonctions d'agrégation

Effectue des calculs sur des ensembles de lignes : COUNT, SUM, AVG, MIN, MAX. Les agrégats ignorent les valeurs NULL (sauf COUNT(*)).
-- Basic aggregates
SELECT
  COUNT(*) AS total_orders,
  SUM(amount) AS total_revenue,
  AVG(amount) AS avg_order_value,
  MIN(amount) AS smallest_order,
  MAX(amount) AS largest_order
FROM orders;

-- COUNT variations
SELECT COUNT(*) AS all_rows,
       COUNT(email) AS rows_with_email,
       COUNT(DISTINCT country) AS unique_countries
FROM customers;

Points clés :

  • COUNT(*) compte toutes les lignes (même avec NULL)
  • COUNT(column) exclut les valeurs NULL
  • COUNT(DISTINCT column) compte les valeurs uniques
  • SUM/AVG ne fonctionnent qu'avec des types numériques

▦ GROUP BY / HAVING

Regroupe les lignes selon les valeurs des colonnes et applique des fonctions d'agrégation. Utilise HAVING pour filtrer les groupes (comme WHERE, mais pour les groupes).
-- Group by single column
SELECT country, COUNT(*) AS customer_count
FROM customers
GROUP BY country
ORDER BY customer_count DESC;

-- Group by multiple columns with HAVING
SELECT category, status, AVG(price) AS avg_price
FROM products
GROUP BY category, status
HAVING AVG(price) > 50;

Points clés :

  • Toutes les colonnes non agrégées du SELECT doivent figurer dans GROUP BY
  • WHERE filtre les lignes avant le regroupement
  • HAVING filtre les groupes après l'agrégation
  • Les fonctions d'agrégation sont utilisables dans HAVING

🔗 Jointures (référence rapide) VOIR LE GUIDE DÉTAILLÉ

Combine les données de plusieurs tables à partir de colonnes liées. INNER JOIN ne renvoie que les correspondances, LEFT/RIGHT conservent un côté entier.
-- INNER JOIN (most common)
SELECT orders.id, customers.name, orders.amount
FROM orders
INNER JOIN customers
  ON orders.customer_id = customers.id;

-- LEFT JOIN (all orders, even without customer)
SELECT orders.id, customers.name
FROM orders
LEFT JOIN customers
  ON orders.customer_id = customers.id;

Points clés :

  • INNER JOIN est la plus courante (peut s'écrire simplement JOIN)
  • LEFT/RIGHT JOIN conservent toutes les lignes d'une table
  • Utilise la clause ON pour définir la condition de jointure

⬚ Sous-requêtes

Des requêtes dans des requêtes pour des filtres et calculs complexes. À utiliser avec IN, EXISTS ou comme valeurs scalaires.
-- Subquery with IN
SELECT name, price
FROM products
WHERE category_id IN (
  SELECT id FROM categories
  WHERE name = 'Electronics'
);

-- Subquery with EXISTS
SELECT name FROM customers c
WHERE EXISTS (
  SELECT 1 FROM orders o
  WHERE o.customer_id = c.id
);

-- Scalar subquery
SELECT name, price,
  price - (SELECT AVG(price) FROM products) AS price_diff
FROM products;

Points clés :

  • Une sous-requête IN renvoie plusieurs valeurs
  • EXISTS vérifie l'existence (efficace)
  • Une sous-requête scalaire renvoie une seule valeur
  • Une sous-requête corrélée fait référence à la requête externe

✂️ Fonctions de chaînes

Extrais, transforme et formate du texte. SUBSTRING extrait selon la position ; LEFT/RIGHT prennent depuis l'une ou l'autre extrémité.
-- Extract characters by position
SELECT SUBSTRING(name, 1, 3) AS prefix FROM products;

-- First / last N characters
SELECT LEFT(email, 5), RIGHT(phone, 4) FROM users;

-- Dynamic position (find @ then extract domain)
SELECT SUBSTRING(email, INSTR(email, '@') + 1) AS domain
FROM users;

-- Common string helpers
SELECT
  UPPER(name), LOWER(name),
  TRIM(name),
  LENGTH(name)
FROM users;

Points clés :

  • En SQL, les positions commencent à 1 (premier caractère = position 1)
  • LEFT/RIGHT pour le début/la fin ; SUBSTRING pour le milieu
  • SQLite ne gère pas LEFT/RIGHT — utilise SUBSTRING
  • Oracle utilise SUBSTR(), pas SUBSTRING()

Envie d'une meilleure façon d'écrire du SQL ?

Beekeeper Studio est un éditeur SQL moderne et intuitif, avec autocomplétion, historique des requêtes et prise en charge de plus de 15 bases de données.

Essaie Beekeeper Studio gratuitement