SQL Server
Erreurs SQL courantes chez les débutants et comment les éviter
Repérez les erreurs SQL courantes sur les filtres, NULL, les jointures, le tri et les modifications de données, puis adoptez de meilleurs réflexes.
Dans cet article
SQL est suffisamment lisible pour qu’une personne débutante écrive une requête avant d’en comprendre toutes les conséquences. Une instruction peut s’exécuter sans erreur et pourtant répondre à la mauvaise question, renvoyer un nombre inattendu de lignes ou modifier davantage de données que prévu. La meilleure protection repose sur quelques habitudes répétables : vérifier le contexte, préciser les colonnes et les lignes recherchées, examiner les relations et contrôler le résultat.
Cette leçon sert de guide de diagnostic ; elle ne remplace pas les leçons précédentes. Utilisez-la lorsqu’un résultat vous surprend ou avant d’intégrer une requête à un script. Les exemples s’appuient sur la base synthétique JaviBuildsLab et les tables dbo.Customers et dbo.Orders. Commencez par votre première requête SELECT, puis consultez au besoin les leçons sur le filtrage avec WHERE, le tri avec ORDER BY, NULL, les jointures, les lignes répétées après une jointure et les pratiques sûres pour UPDATE et DELETE.
Erreur : exécuter une requête dans la mauvaise base
Une fenêtre de requête SSMS est connectée à un serveur et possède un contexte de base de données. Il est possible de choisir la mauvaise base dans la barre d’outils, d’ouvrir une fenêtre depuis un autre contexte ou de supposer que le nom visible dans un onglet est toujours sélectionné. Une requête sur une table homonyme d’une autre base peut réussir et afficher des lignes plausibles, mais sans rapport avec le besoin. Une table absente provoquera plutôt une erreur d’objet introuvable.
Avant d’explorer ou de modifier des données, interrogez la session :
SELECT DB_NAME() AS CurrentDatabase;Comparez le résultat avec la base attendue. S’il ne s’agit pas de JaviBuildsLab, arrêtez-vous et sélectionnez la bonne base. Une instruction USE change le contexte de la connexion, mais ne crée pas une base et ne prouve pas que son contenu est celui attendu. Dans un environnement partagé ou de production, suivez la procédure de connexion approuvée par l’équipe.
Meilleur réflexe : vérifiez le serveur et la base avant un script qui dépend de ces deux éléments. Ajoutez un contrôle de contexte lorsqu’une exécution dans la mauvaise base aurait des conséquences importantes.
Erreur : utiliser SELECT * partout
SELECT * est pratique pour découvrir une table, mais demande toutes ses colonnes. Il peut inclure des champs inutiles pour un rapport, rendre le résultat difficile à lire et créer une dépendance à des colonnes qui ne faisaient pas partie du besoin. Si une colonne est ajoutée plus tard, la forme du résultat peut changer sans modification de la requête.
Préférez une liste explicite :
SELECT CustomerId, FirstName, LastName, City
FROM dbo.Customers;La sortie est plus facile à examiner et l’intention est plus claire. Pendant une exploration, SELECT TOP (10) * peut aider à découvrir les données ; ajoutez un ORDER BY si vous avez besoin d’un échantillon reproductible. Ne recopiez pas automatiquement ce raccourci dans du code applicatif, un export ou un rapport enregistré.
Meilleur réflexe : nommez les colonnes qui répondent à la question. Donnez des alias utiles aux expressions et qualifiez une colonne avec son alias de table lorsque plusieurs sources possèdent le même nom.
Erreur : oublier WHERE
Un UPDATE ou un DELETE sans condition WHERE peut toucher toutes les lignes de la table. Un SELECT sans le filtre attendu peut renvoyer beaucoup plus de données que prévu. SQL Server exécute l’instruction écrite ; il ne peut pas deviner le sous-ensemble recherché.
Pour une modification, commencez par une prévisualisation :
SELECT CustomerId, FirstName, State
FROM dbo.Customers
WHERE CustomerId = 11;Vérifiez que le résultat contient exactement les lignes visées. Réutilisez la même table et la même condition dans la modification, puis contrôlez le résultat. Un filtre apparemment précis peut correspondre à plusieurs enregistrements : inspectez les données et comptez les lignes au lieu de vous fier à son apparence.
Meilleur réflexe : écrivez et exécutez le SELECT d’abord. Pour modifier des données, suivez le parcours qui commence par SELECT et entraînez-vous uniquement dans une base de test connue. Ne supprimez jamais un WHERE simplement pour faire fonctionner une requête.
Erreur : supposer que les lignes sont triées
Une table ne garantit aucun ordre d’affichage. Une requête peut sembler renvoyer les lignes dans l’ordre d’insertion ou de clé primaire pendant un essai, mais ce n’est pas une promesse. Un autre plan, un index, une version du serveur ou une modification des données peut produire un autre ordre.
Lorsque l’ordre compte, indiquez-le :
SELECT TOP (5) OrderId, OrderDate, Amount
FROM dbo.Orders
ORDER BY OrderDate DESC, OrderId DESC;La seconde colonne de tri rend les égalités déterministes. TOP sans ORDER BY limite la sortie, mais ne signifie pas « les plus récents », « les premiers » ni aucun autre sous-ensemble précis. La leçon sur le tri avec ORDER BY montre comment définir l’ordre souhaité.
Meilleur réflexe : considérez l’ordre comme indéterminé sans ORDER BY. Avec TOP, définissez les lignes recherchées avant de les limiter.
Erreur : comparer NULL avec le signe égal
NULL représente une information absente ou inconnue. Ce n’est pas une valeur ordinaire ; Email = NULL ne recherche donc pas les adresses manquantes. La comparaison produit une valeur inconnue et ne sélectionne pas les lignes attendues. Une chaîne vide ('') est une valeur ; NULL est différent.
Utilisez les prédicats adaptés :
SELECT CustomerId, Email
FROM dbo.Customers
WHERE Email IS NULL;Utilisez IS NOT NULL pour trouver les lignes qui possèdent une valeur. Ne remplacez pas les données manquantes par une chaîne vide uniquement pour simplifier une comparaison : vous changeriez leur sens. Consultez Comprendre NULL dans SQL Server pour voir comment l’inconnu intervient dans les conditions et les agrégats.
Meilleur réflexe : utilisez IS NULL ou IS NOT NULL et décidez explicitement comment l’application doit présenter une information manquante.
Erreur : confondre WHERE et HAVING
WHERE filtre les lignes source avant la création des groupes. HAVING filtre les groupes après l’agrégation. Placer COUNT(*) dans WHERE est invalide, car les groupes n’existent pas encore à cette étape. Mettre une condition sur une ligne dans HAVING peut parfois fonctionner, mais masque l’ordre logique et risque d’effectuer un travail inutile.
Ici, on sélectionne d’abord les commandes terminées, puis les clients ayant au moins deux commandes répondant au filtre :
SELECT CustomerId, COUNT(*) AS OrderCount
FROM dbo.Orders
WHERE Status = N'Complete'
GROUP BY CustomerId
HAVING COUNT(*) >= 2;Le statut concerne chaque commande ; le nombre concerne chaque groupe de clients. La leçon WHERE ou HAVING explique cette différence.
Meilleur réflexe : demandez-vous si une condition décrit une ligne source ou un groupe agrégé. Placez les premières dans WHERE, les secondes dans HAVING.
Erreur : attendre d’une jointure un-à-plusieurs qu’elle conserve une ligne par client
Un client peut passer plusieurs commandes. Une jointure de Customers et Orders sur CustomerId renvoie une ligne pour chaque paire client-commande correspondante. Un client avec trois commandes apparaît donc sur trois lignes. Ce ne sont pas nécessairement des doublons ; chaque ligne représente une relation.
Décidez ce que doit représenter une ligne avant d’écrire la jointure. Si vous souhaitez une ligne par commande, la répétition des informations client est normale. Si vous voulez une ligne par client, agrégez les commandes ou choisissez une autre forme de requête. Une LEFT JOIN conserve également les clients sans commande, avec des valeurs NULL dans les colonnes de commande. Consultez la leçon sur les jointures et le guide sur les lignes répétées après une jointure.
Meilleur réflexe : décrivez le grain en langage simple, par exemple « une ligne par commande ». Faites ensuite correspondre la jointure et le regroupement à cette promesse.
Erreur : ajouter DISTINCT pour masquer une mauvaise jointure
DISTINCT élimine les lignes identiques parmi les colonnes sélectionnées. Il ne corrige pas une condition de jointure manquante et ne prouve pas que deux tables sont correctement liées. Une jointure qui associe par erreur tous les clients à toutes les commandes reste incorrecte, même si DISTINCT masque certaines répétitions. Il peut également effacer des valeurs répétées légitimes lorsque les colonnes choisies n’identifient pas l’événement métier.
Vérifiez la condition ON, comparez les nombres de lignes avant et après la jointure et examinez quelques clés. Si le résultat doit contenir une ligne par entité, utilisez un regroupement ou un test d’existence qui exprime vraiment ce besoin.
Meilleur réflexe : comprenez pourquoi les lignes se répètent avant d’utiliser DISTINCT. Réservez-le aux résultats pour lesquels l’unicité fait partie du besoin.
Erreur : ne pas qualifier les colonnes portant le même nom
Customers et Orders peuvent toutes deux contenir CustomerId. Après avoir ajouté les deux tables à une requête, ce nom seul peut être ambigu. SQL Server renvoie une erreur plutôt que de deviner. Même lorsqu’un nom n’est pas encore ambigu, le qualifier rend sa provenance plus claire.
SELECT c.CustomerId, c.FirstName, o.OrderId, o.Amount
FROM dbo.Customers AS c
INNER JOIN dbo.Orders AS o
ON o.CustomerId = c.CustomerId;c et o sont des alias de table valables dans cette instruction. Ils ne renomment pas les tables dans la base. La leçon sur les alias de tables et de colonnes précise cette différence.
Meilleur réflexe : qualifiez les colonnes partagées et choisissez des alias qui éclairent la lecture d’une requête à plusieurs tables.
Erreur : lancer UPDATE ou DELETE sans vérifier la cible
Une instruction syntaxiquement correcte peut rester dangereuse. Un filtre mal saisi, trop large ou une mauvaise base peut modifier les mauvais enregistrements. Le message « lignes affectées » ne prouve pas que la modification était correcte ; il indique seulement le nombre de lignes touchées.
Utilisez le même filtre pour une prévisualisation et pour la modification. Vérifiez les enregistrements et leur nombre, travaillez dans un environnement adapté et confirmez le résultat. Pour vous entraîner, utilisez une transaction et annulez-la, sauf si vous voulez réellement conserver le changement de test. En production, suivez les procédures de revue et de sauvegarde de l’organisation.
Meilleur réflexe : prévisualisez, comptez, modifiez et vérifiez, puis décidez. Suivez les pratiques sûres pour UPDATE et DELETE.
Erreur : traiter NULL comme une chaîne vide
Une chaîne vide indique qu’une valeur texte existe et contient zéro caractère. NULL signifie qu’aucune valeur n’est connue ou enregistrée. Le sens peut différer : une personne peut ne pas vouloir fournir d’adresse e-mail (NULL), tandis qu’un système source a peut-être importé un texte vide. Les comparaisons, les comptages et l’affichage ne les traitent pas toujours de la même façon.
Par exemple, COUNT(Email) ignore les valeurs NULL, alors que COUNT(*) compte les lignes. Remplacer NULL par '' modifie les données et peut rendre une analyse moins juste. À l’inverse, la couche de présentation peut afficher une étiquette conviviale sans altérer la valeur stockée.
Meilleur réflexe : demandez-vous ce que signifie « manquant » dans le domaine. Gardez un stockage cohérent et n’utilisez COALESCE ou le formatage de l’application que si la sortie doit afficher une valeur de remplacement.
Erreur : penser qu’un alias renomme un objet du schéma
SELECT Amount AS OrderTotal change l’étiquette dans le résultat de cette requête. FROM dbo.Orders AS o donne un nom court à la table pendant l’exécution de l’instruction. Aucun des deux ne renomme une colonne ni une table dans la base. Une autre requête doit toujours référencer l’objet stocké, tel que dbo.Orders.
La modification des objets de base est une tâche administrative distincte qui peut toucher les applications, les autorisations et les dépendances. Un alias ne prouve donc pas qu’une modification du schéma a eu lieu.
Meilleur réflexe : distinguez les étiquettes de résultat et les alias limités à une instruction des définitions permanentes. Gérez les changements de schéma au moyen de migrations examinées.
Erreur : copier du SQL sans comprendre ses hypothèses
Un exemple trouvé sur un forum, dans un ancien script ou généré automatiquement peut supposer d’autres noms de tables, d’autres clés ou un autre moteur SQL. Il peut omettre un filtre parce que son auteur travaillait sur un jeu de données jetable. Sa syntaxe peut même être valide dans un autre produit, mais pas dans SQL Server.
Avant d’adapter le code, identifiez le moteur, les tables et colonnes attendues, les lignes susceptibles d’être touchées et le résultat prévu. Dans la mesure du possible, commencez par une version en lecture seule. Comparez le résultat avec un exemple connu et lisez chaque clause au lieu de coller toute l’instruction dans une fenêtre de production.
Meilleur réflexe : soyez capable d’expliquer chaque clause. Si vous ne pouvez pas prévoir le résultat, testez l’idée sur des données sûres et consultez la leçon correspondante ou la documentation officielle.
Une routine de diagnostic rapide
Lorsqu’un résultat semble faux, faites une pause et vérifiez les bases dans l’ordre. Confirmez le serveur et DB_NAME(). Relisez les colonnes, les tables et les filtres. Vérifiez la logique de NULL. Déterminez si une jointure peut produire plusieurs lignes par entité et choisissez ce que signifie une ligne. Ajoutez ORDER BY si le tri compte. Avant toute modification, prévisualisez et comptez les lignes cibles. Enfin, comparez le résultat réel à la question initiale.
- Erreur repérée
- Vérifier contexte et grain
- Choisir un meilleur réflexe
- Prévisualiser et vérifier
Ces contrôles deviennent plus rapides avec la pratique. Gardez cette liste à portée de main pendant l’apprentissage, puis faites-en une partie normale de la relecture. La prochaine leçon présente un objet de base de données qui permet de réutiliser une requête sous un nom stable : les vues dans SQL Server. Vous pouvez aussi revenir à la feuille de route SQL Server Foundations.
Vérifiez ce que vous avez retenu
2 questions rapides
Fondamentaux de SQL Server
Leçon 20 sur 25
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Continuer à apprendre
- Aide-mémoireVérifier l’utilisation des indexExaminez l’activité de lecture et d’écriture des index SQL Server, repérez les index à faible valeur et déterminez lesquels méritent une analyse approfondie avant toute suppression.Ouvrir l’aide-mémoire
- Feuille de routeSQL Server FoundationsRepérez les erreurs SQL courantes sur les filtres, NULL, les jointures, le tri et les modifications de données, puis adoptez de meilleurs réflexes.Voir la feuille de route
Que devrais-je créer ensuite ?
Je développe Javi Builds autour des problèmes concrets rencontrés par les data engineers. Dites-moi quel sujet vous aimeriez voir ensuite.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.