Les pièges à éviter sur le langage SQL en NSI

Tu commences tout juste avec le langage SQL en NSI ? Ou tu prépares l'épreuve du bac ? Les requêtes SQL peuvent sembler simples au premier abord, mais elles cachent quelques pièges classiques qui font perdre des points. Pas de panique : je vais te montrer les erreurs les plus fréquentes et comment les éviter. Prêt à devenir un as du SQL NSI ?

Piège n°1 : Oublier le point-virgule en fin de requête

En SQL, chaque requête doit se terminer par un point-virgule (;). Sans lui, le SGBD ne sait pas que la requête est terminée et va attendre la suite. C'est l'erreur la plus basique, mais tellement fréquente !

SELECT * FROM eleves;  -- Bon
SELECT * FROM eleves   -- Erreur : point-virgule manquant

Comment l'éviter ?

Prends l'habitude d'écrire le point-virgule tout de suite après avoir tapé la requête. Avec un peu de pratique, ça deviendra automatique.

Piège n°2 : Confondre les guillemets simples et doubles

En SQL, les chaînes de caractères se mettent entre guillemets simples ('texte'). Les guillemets doubles ("texte") sont réservés aux noms de colonnes ou de tables (mais ce n'est pas standard). Beaucoup d'élèves utilisent par erreur les guillemets doubles dans les conditions WHERE.

SELECT * FROM eleves WHERE nom = 'Dupont';  -- Correct
SELECT * FROM eleves WHERE nom = "Dupont";  -- Erreur dans la plupart des SGBD

Astuce pour t'en souvenir

En français, on utilise les guillemets doubles pour les citations, mais en SQL, c'est le simple guillemet pour les valeurs textuelles. Retiens : simple pour les chaînes, double pour les identifiants (si nécessaire).

Piège n°3 : Faire une jointure sans clause de liaison

Quand tu fais un JOIN entre deux tables, il faut impérativement préciser comment elles sont reliées avec ON. Sinon, tu obtiens un produit cartésien (toutes les combinaisons possibles), ce qui n'est généralement pas ce que tu veux.

-- Correct : jointure avec condition
SELECT e.nom, c.matiere
FROM eleves e
JOIN cours c ON e.id_classe = c.id_classe;

-- Erreur : pas de condition → produit cartésien
SELECT e.nom, c.matiere
FROM eleves e, cours c;

Pourquoi est-ce un piège ?

Parfois, le produit cartésien peut donner des résultats qui semblent corrects par hasard, mais c'est un coup de chance. En bac, on te demandera toujours une jointure logique.

Piège n°4 : Oublier les guillemets autour des dates

Les dates en SQL sont considérées comme des chaînes de caractères. Il faut donc les écrire entre guillemets simples, au format 'AAAA-MM-JJ'.

SELECT * FROM inscriptions WHERE date_inscription > '2026-01-01';  -- Correct
SELECT * FROM inscriptions WHERE date_inscription > 2026-01-01;   -- Erreur

Format standard

Le format ISO YYYY-MM-DD est le seul reconnu par tous les SGBD. Entraîne-toi à l'utiliser systématiquement.

Piège n°5 : Confondre WHERE et HAVING

WHERE filtre les lignes avant les regroupements (GROUP BY), tandis que HAVING filtre après. Beaucoup d'élèves utilisent WHERE pour filtrer sur des agrégats (comme COUNT), ce qui provoque une erreur.

-- Correct : HAVING pour filtrer après GROUP BY
SELECT classe, COUNT(*) AS nb_eleves
FROM eleves
GROUP BY classe
HAVING COUNT(*) > 30;

-- Erreur : WHERE ne peut pas utiliser COUNT
SELECT classe, COUNT(*) AS nb_eleves
FROM eleves
WHERE COUNT(*) > 30
GROUP BY classe;

Règle à retenir

Si tu utilises une fonction d'agrégation (COUNT, SUM, AVG, etc.) dans une condition, c'est HAVING qu'il te faut.

Piège n°6 : Négliger l'ordre des clauses

En SQL, l'ordre des clauses est strict : SELECT, FROM, WHERE, GROUP BY, HAVING, ORDER BY, LIMIT. Si tu les mets dans le désordre, la requête échoue.

-- Ordre correct
SELECT nom, age
FROM eleves
WHERE age > 15
ORDER BY nom;

-- Ordre incorrect
SELECT nom, age
FROM eleves
ORDER BY nom
WHERE age > 15;  -- Erreur : WHERE après ORDER BY

Moyen mnémotechnique

Retiens l'ordre avec la phrase : “Sans Faire de Whisky, Gros Hérisson Oublie L'alcool” : SELECT, FROM, WHERE, GROUP BY, HAVING, ORDER BY, LIMIT.

Piège n°7 : Utiliser SELECT * dans une jointure

Quand tu fais un JOIN, SELECT * retourne toutes les colonnes des deux tables, y compris celles qui portent le même nom (comme id). Cela peut prêter à confusion et alourdir les résultats. Préfère lister les colonnes dont tu as besoin.

-- Déconseillé : colonnes en double possibles
SELECT *
FROM eleves e
JOIN notes n ON e.id = n.eleve_id;

-- Recommandé : on précise les colonnes
SELECT e.nom, n.matiere, n.note
FROM eleves e
JOIN notes n ON e.id = n.eleve_id;

Bonnes pratiques

En production et en examen, on évite SELECT *. Cela montre que tu maîtrises la sélection des données.

Piège n°8 : Oublier les alias dans les requêtes complexes

Quand une requête devient longue, les alias de table (FROM eleves e) ou de colonne (COUNT(*) AS nb) améliorent la lisibilité. Sans alias, tu risques de te tromper de colonne ou d'écrire des requêtes incompréhensibles.

-- Avec alias (plus clair)
SELECT e.nom, COUNT(n.id) AS nb_notes
FROM eleves e
LEFT JOIN notes n ON e.id = n.eleve_id
GROUP BY e.id;

-- Sans alias (plus risqué)
SELECT eleves.nom, COUNT(notes.id)
FROM eleves
LEFT JOIN notes ON eleves.id = notes.eleve_id
GROUP BY eleves.id;

Quand utiliser les alias ?

Dès que tu as plus d'une table, utilise un alias court (une lettre ou deux). Pour les colonnes calculées, un alias est obligatoire si tu veux les réutiliser.

Piège n°9 : Croire que NULL est égal à NULL

En SQL, NULL représente une valeur inconnue. On ne peut pas utiliser = pour comparer des NULL. Il faut utiliser IS NULL ou IS NOT NULL.

-- Correct
SELECT * FROM eleves WHERE email IS NULL;

-- Erreur : = NULL ne fonctionne pas
SELECT * FROM eleves WHERE email = NULL;

Pourquoi ?

Parce que NULL n'est pas une valeur, c'est l'absence de valeur. Toute comparaison avec NULL donne NULL (qui est interprété comme faux dans un WHERE).

Piège n°10 : Négliger les index et les performances

Même si ce n'est pas explicitement au programme de NSI, comprendre que les index accélèrent les recherches est un plus. Une requête mal écrite peut être très lente sur une grande base. Par exemple, utiliser LIKE '%mot' empêche l'utilisation d'un index.

-- Lent (pas d'index possible)
SELECT * FROM eleves WHERE nom LIKE '%dupont';

-- Plus rapide (index possible)
SELECT * FROM eleves WHERE nom LIKE 'dupont%';

Conseil pour le bac

On ne te demandera pas d'optimiser les performances, mais savoir que les requêtes avec LIKE en début de chaîne sont coûteuses peut faire la différence dans un oral.

Mise en pratique : un exemple complet avec Python

En NSI, tu utilises souvent Python pour interagir avec une base SQLite. Voici un exemple qui illustre plusieurs pièges.

import sqlite3

conn = sqlite3.connect('lycee.db')
cursor = conn.cursor()

# Création des tables
cursor.execute('''CREATE TABLE IF NOT EXISTS eleves (
    id INTEGER PRIMARY KEY,
    nom TEXT,
    classe TEXT
)''')

cursor.execute('''CREATE TABLE IF NOT EXISTS notes (
    id INTEGER PRIMARY KEY,
    eleve_id INTEGER,
    matiere TEXT,
    note REAL,
    FOREIGN KEY(eleve_id) REFERENCES eleves(id)
)''')

# Insertion
cursor.execute("INSERT INTO eleves (nom, classe) VALUES ('Alice', '1A')")
cursor.execute("INSERT INTO notes (eleve_id, matiere, note) VALUES (1, 'NSI', 16.0)")
conn.commit()

# Requête avec jointure (attention au point-virgule !)
req = '''
SELECT e.nom, n.matiere, n.note
FROM eleves e
JOIN notes n ON e.id = n.eleve_id
WHERE n.note > 10
ORDER BY n.note DESC
'''
cursor.execute(req)
resultats = cursor.fetchall()
print(resultats)

conn.close()

Teste ce code chez toi. Essaie de volontairement enlever le point-virgule ou utiliser WHERE n.note > 10 HAVING pour voir l'erreur.

Conseils pour le bac NSI

Lors de l'épreuve, on te demandera souvent d'écrire des requêtes SQL. Voici quelques astuces :

• Relis-toi : vérifie la syntaxe, les guillemets, le point-virgule.
• Fais un schéma : dessine les tables et leurs relations avant d'écrire la requête.
• Teste mentalement : prends un petit jeu de données et vérifie que ta requête donne le résultat attendu.
• Utilise les ressources du site : n'hésite pas à consulter notre page dédiée au SQL et les exercices pratiques pour t'entraîner.

Si tu as besoin de révisions plus générales, le cours de NSI couvre l'ensemble du programme.

Conclusion

Voilà, tu connais maintenant les principaux pièges du SQL en NSI. Le plus important est de pratiquer : plus tu écriras de requêtes, plus tu les éviteras naturellement. N'oublie pas que le SQL est un langage très logique : une fois que tu as compris les règles, tout devient plus simple. Alors, lance-toi dans les exercices et deviens incollable ! Et si tu veux approfondir, jette un œil aux ressources d'AlloBac et AlloLycée pour d'autres astuces.