Entraînement au test SQL

À quoi ressemble généralement le test réel

Il n’existe pas de test SQL unique. Chaque employeur choisit une plateforme de test ou rédige son propre test, et décide du nombre de questions, de la durée et de la base de données. L’offre d’emploi ou l’invitation au test est le meilleur guide pour savoir à quoi vous attendre. Les exemples publics montrent l’éventail possible :

• Les tests de compétences SQL de HackerRank. HackerRank indique que son test de compétences SQL (Basic) comporte 2 questions en 30 minutes et porte sur des sujets comme les requêtes simples (HackerRank), tandis que son test SQL (Intermediate) comporte 2 questions en 35 minutes et porte sur des sujets comme les jointures complexes (HackerRank). Les employeurs qui créent leurs propres tests HackerRank peuvent ajouter des questions sur les bases de données et choisir les bases de données que les candidats peuvent utiliser (support HackerRank).
• Un exercice de rédaction de requête. TestGorilla décrit son test de programmation SQLite comme un exercice de 30 minutes consistant à rédiger une requête pour un scénario réaliste, sur une base de données de complexité moyenne. Il porte sur les jointures et le filtrage, les calculs simples, le tri, l’arrondi et l’exclusion des entrées non pertinentes (TestGorilla).
• Un test de connaissances court. TestGorilla indique que son test MySQL comporte 15 questions en 10 minutes, tirées d’une banque de 101 questions (TestGorilla).

Thèmes couramment abordés dans les tests SQL :

• Filtrage et tri : SELECT, WHERE, ORDER BY et les conditions avec AND, OR, IN et BETWEEN.
• Jointures : les jointures internes et gauches, et ce qui arrive aux lignes sans correspondance.
• Regroupement : GROUP BY avec COUNT, SUM, AVG, MIN et MAX, et HAVING pour filtrer les groupes.
• Valeurs NULL : le comportement des valeurs manquantes dans les comparaisons, les comptages et les moyennes.
• Sous-requêtes : une requête à l’intérieur d’une autre, avec IN, EXISTS ou une valeur unique.
• Rédaction d’une requête à partir d’une consigne en langage courant, souvent évaluée selon qu’elle renvoie ou non exactement les lignes attendues.

Ce que couvrent nos tests blancs. Chaque test blanc complet comporte 18 questions en 45 minutes, réparties en quatre sections : concepts SQL (5), résultat renvoyé par la requête (6), correction d’une requête (4) et choix de la requête appropriée (3). Vous pouvez revenir en arrière et signaler des questions. Nous utilisons du SQL standard portable : les requêtes ont donc le même sens dans PostgreSQL, MySQL, SQL Server, SQLite et la plupart des autres bases de données. Nos tests blancs vous entraînent à lire, à suivre le déroulement et à choisir des requêtes ; ils n’exécutent pas les requêtes que vous rédigez. De nombreux vrais tests SQL vous demandent de rédiger une requête qui est vérifiée en fonction des résultats attendus. Utilisez donc nos tests blancs pour développer les compétences de lecture et de suivi qui vous seront utiles, et rédigez aussi vos propres requêtes dans une base de données gratuite comme SQLite.

Types de questions avec exemples corrigés

Un exemple détaillé pour chaque section, avec le piège dans lequel tombe la plupart des gens.

1. Concepts SQL. Quelle est la différence entre COUNT() et COUNT(email) ? COUNT() compte toutes les lignes ; COUNT(email) compte uniquement les lignes où email n'est pas NULL. Piège : supposer que chaque comptage inclut toutes les lignes. La plupart des fonctions d'agrégation ignorent les valeurs NULL.

2. Résultat de la requête. La table scores contient les valeurs 8, 5, NULL et 8. Que renvoie SELECT COUNT(DISTINCT score) ? Les valeurs distinctes non NULL sont 8 et 5, donc la réponse est 2. Piège : compter NULL comme une valeur ou compter deux fois le 8 en double. Écrivez la table et barrez les lignes comme le ferait la requête.

3. Corriger une requête. Une requête contient WHERE city = 'Austin' OR city = 'Dallas' AND active = 1 et renvoie des clients inactifs d'Austin. AND est évalué avant OR : la condition signifie donc en réalité Austin, ou Dallas avec le statut actif. La correction consiste à ajouter des parenthèses : WHERE (city = 'Austin' OR city = 'Dallas') AND active = 1. Piège : lire la condition de gauche à droite.

4. Choisir la bonne requête. Vous devez trouver les cinq commandes les plus récentes. Laquelle convient : ORDER BY order_date DESC avec une limite de 5, ou ORDER BY order_date avec une limite de 5 ? La première. Sans DESC, le tri place les plus anciennes en premier : vous obtiendriez donc les cinq plus anciennes. Piège : choisir la requête qui semble correcte sans vérifier le sens du tri. (La syntaxe de la limite varie selon les bases de données, par exemple LIMIT 5 ou FETCH FIRST 5 ROWS ONLY. Vérifiez celle utilisée dans votre test.)

5. Jointures avec conditions. Une jointure externe gauche suivie d'une condition WHERE sur une colonne de la table de droite se transforme discrètement en jointure interne, car les lignes sans correspondance y ont la valeur NULL et sont éliminées par la condition. Piège : ne pas remarquer quelles lignes disparaissent. Demandez-vous : « Que se passe-t-il pour une ligne sans correspondance ? »

Comment vous préparer

1. Lisez d'abord votre invitation. Vérifiez quelle plateforme vous utiliserez, de combien de temps vous disposerez, si vous devrez rédiger des requêtes ou répondre à des questions à choix multiple, et sur quelle base de données elle s'exécute. Les formats varient trop pour que vous puissiez le supposer.
2. Apprenez dans quel ordre une requête s'exécute. FROM et JOIN, puis WHERE, GROUP BY, HAVING, SELECT et ORDER BY. La plupart des questions du type « pourquoi est-ce incorrect ? » deviennent plus claires une fois que vous savez quelles données sont prises en compte à chaque étape.
3. Suivez à la main de petites tables. Écrivez trois ou quatre lignes, puis appliquez chaque clause dans l'ordre. C'est le moyen le plus rapide de vérifier votre réponse et de repérer les pièges liés à NULL et aux doublons.
4. Consacrez une partie de vos révisions à NULL. Entraînez-vous avec IS NULL, COUNT(column) par rapport à COUNT(*), AVG qui ignore les valeurs NULL, NOT IN avec une valeur NULL dans la liste, et les valeurs placées dans les colonnes sans correspondance par une jointure à gauche.
5. Rédigez aussi de vraies requêtes. Nos examens blancs développent votre capacité à lire et à suivre des requêtes. Rédigez aussi des requêtes dans une base de données gratuite comme SQLite, afin de vous habituer à les saisir dans un temps limité. Certains tests vérifient votre requête sur de nombreux cas, comme les plus de 10 cas de test que TestGorilla mentionne pour son test SQLite (TestGorilla).
6. Vérifiez le résultat, pas seulement la syntaxe. Une requête qui s'exécute peut tout de même renvoyer les mauvaises lignes. Avant de répondre, demandez-vous ce qui se passe en l'absence de correspondance, avec des doublons et avec des valeurs NULL.
7. Entraînez-vous au rythme réel. Un test de connaissances court comme le test MySQL de TestGorilla, 15 questions en 10 minutes, vous laisse largement moins d'une minute par question (TestGorilla). Faites des examens blancs complets et chronométrés pour vous habituer au rythme du jour de l'épreuve.

Comment la notation fonctionne généralement

La notation dépend de l'employeur et de la plateforme. Il n'existe pas de score SQL standard ni de seuil de réussite universel. Chaque employeur décide de ce qui constitue un bon résultat. Voici deux exemples publics de la façon dont les réponses aux questions de requête sont évaluées :

• Questions de base de données de HackerRank : HackerRank indique que les réponses sont notées automatiquement en comparant le résultat de votre requête au résultat attendu. Une correspondance donne le score maximal ; toute autre réponse vaut zéro, sauf si l'employeur l'examine manuellement et accorde une partie des points. L'employeur peut aussi choisir de ne pas tenir compte de l'ordre des lignes (assistance HackerRank).
• Test SQLite de TestGorilla : TestGorilla indique que les candidats sont classés à partir de plus de 10 cas de test qui vérifient les cas limites de la solution (TestGorilla).

Comme les résultats sont souvent vérifiés ligne par ligne, une requête presque correcte, par exemple si elle omet un client sans commande, peut obtenir le même score qu'une absence de réponse.

Notre score d'entraînement correspond au nombre de nos propres questions auxquelles vous avez répondu correctement, avec un détail par section pour vous aider à voir où concentrer vos efforts. Il s'agit d'un score d'entraînement : ce n'est pas un score obtenu à un test d'employeur ou de plateforme, et il ne permet pas de prédire si vous réussirez.

Erreurs fréquentes

• Comparer avec NULL à l'aide de =. Utilisez IS NULL et IS NOT NULL. Toute expression = NULL a une valeur inconnue, donc la ligne est exclue.
• Filtrer une jointure gauche dans WHERE. Un test sur les colonnes de la table de droite supprime les lignes sans correspondance. Placez ce test dans la clause ON si vous devez les conserver.
• Utiliser WHERE pour un total. Les agrégats vont dans HAVING, après GROUP BY.
• Sélectionner une colonne qui ne figure pas dans le regroupement. En SQL standard, chaque colonne sélectionnée doit être regroupée ou agrégée. Certaines bases de données exécutent la requête et choisissent une valeur à votre place, ce qui masque l'erreur.
• Oublier les doublons. Une jointure peut répéter des lignes, ce qui gonfle SUM et COUNT. Demandez-vous si chaque ligne d'un côté peut correspondre à plusieurs lignes de l'autre côté.
• S'appuyer sur les raccourcis d'une base de données. Certaines fonctions et syntaxes de limitation diffèrent d'une base de données à l'autre. Apprenez la forme standard et vérifiez quelle base de données utilise votre test.