Accueil › Outils d’étude › Aide aux devoirs SQL
Comprenez le schéma. Expliquez la requête. Vérifiez le résultat.

Aide aux devoirs SQL avec AI
Construisez des requêtes que vous pouvez expliquer

Vous bloquez sur une requête, un résultat inattendu ou les exigences du devoir ? Apportez le schéma, les lignes d’exemple, votre tentative et la version de la base. Utilisez l’aide au codage académique de Verla pour parcourir la logique, repérer les hypothèses et préparer une solution que vous pourrez tester et expliquer.

✦ Travaillez sur votre devoir SQLSchéma · Requête · Résultat attendu
Travailler sur mon devoir SQL ↗
Ouvre le Tableau de bord. Saisissez de nouveau les entrées et importez-y les supports autorisés ; cette page ne les transfère pas, ne se connecte pas à une base et n’exécute pas de SQL.
REQUÊTE ILLUSTRATIVE · DONNÉES D’EXERCICE PARTAGÉES

Compter les apprenants par équipe

SELECT team_id, COUNT(*) AS n
FROM learners
GROUP BY team_id
ORDER BY team_id;
team_idn
12
22
Sortie attendue pour le jeu de quatre lignes ci-dessous.
Exemple statique – pas d’exécuteur SQL en direct. Les résultats dépendent du schéma exact et des lignes d’exemple.
Trois étapes pratiques

Comment travailler sur un devoir SQL avec Verla

Rendez la tâche reproductible, examinez la logique et vérifiez la réponse dans la base requise.

Une question SQL reproductible
📄 Brief + version de la baseExigences
▤ Schéma + lignes d’exempleEntrées
✎ Tentative + sortie attendueProblème
01 / FOURNIR

Ajoutez la tâche, le schéma et votre tentative

Incluez les définitions de tables, de petites lignes représentatives, la base et sa version, l’erreur exacte et le résultat attendu. Supprimez les identifiants et utilisez uniquement des données que vous êtes autorisé à partager.

Une requête expliquée
01 Granularité de ligne requiseDéfinir
02 Jointures et conditionsRaisonner
03 Sortie et cas limitesVérifier
02 / AFFINER

Examinez la logique avant de faire confiance à la syntaxe

Demandez une explication des jointures, filtres, groupes ou fenêtres et une correction minimale si possible. Rendez explicites les colonnes supposées et les exigences manquantes au lieu de considérer un SQL plausible comme une solution vérifiée.

Un résultat vérifié localement
Lignes attendues ↔ Lignes réelles
Vérifier les égalités, les valeurs NULL et les lignes sans correspondance
Exécuter localement · Comparer · Expliquer
03 / VÉRIFIER

Exécutez et examinez dans l’environnement de votre cours

Testez le SQL vérifié avec le jeu de test fourni dans une base d’exercice appropriée. Comparez les valeurs et le nombre de lignes, incluez les cas limites et gardez l’explication conforme aux règles d’aide de votre cours.

Comprenez d’abord le devoir

Qu’est-ce qu’un devoir SQL et comment l’aborder ?

Un devoir SQL vous demande de récupérer, d’organiser ou de définir des données relationnelles selon une spécification. Les devoirs SQL peuvent porter sur des requêtes, des jointures, des agrégations, des fonctions de fenêtre, des clés ou la conception d’un schéma. Une réponse correcte doit respecter le sens et la structure de lignes demandés, et pas seulement s’exécuter sans erreur de syntaxe.

Lisez le schéma et déterminez ce que doit représenter une ligne de sortie avant d’écrire la requête. Créez un petit cas de test, expliquez chaque clause et comparez la sortie réelle à l’exigence. L’explication de Verla sur la séparation entre les environnements d’analyse et l’aide à l’explication et à la révision est pertinente ici : vérifiez l’exécution dans la base requise au lieu de supposer qu’une réponse générée a été exécutée. Indiquez toujours le dialecte et la version, car la syntaxe et le comportement peuvent différer.

Passer d’un SQL plausible à un raisonnement vérifié

Six façons de travailler sur des devoirs SQL

Utilisez une aide au codage pour comprendre la tâche tout en vérifiant le comportement dans la base exigée par le cours.

🧩

Traduire l’exigence en lignes de sortie

Identifiez les colonnes, les filtres et ce que représente une ligne de résultat. Clarifiez si les enregistrements sans correspondance, les doublons et les groupes vides doivent apparaître avant de choisir une structure de requête.

🔗

Raisonner sur les jointures et l’agrégation

Suivez la façon dont les clés relient les tables et dont une jointure modifie le nombre de lignes. Examinez les regroupements et les filtres pour éviter que des lignes répétées n’augmentent silencieusement les comptes ou les totaux.

🔎

Déboguer avec un exemple minimal reproductible

Utilisez l’erreur exacte, le schéma et un petit jeu de données pour isoler un problème de syntaxe ou de logique. Demandez si possible une correction minimale et expliquez pourquoi elle change le résultat au lieu de remplacer toute la tentative sans raisonnement.

🏅

Choisir délibérément le classement et la logique de fenêtre

Décidez si les égalités doivent partager un rang, si des écarts sont souhaités et si les lignes ont besoin d’une séquence déterministe. Distinguez RANK, DENSE_RANK et ROW_NUMBER avant d’interpréter la sortie.

🔑

Vérifier les clés, contraintes et hypothèses de dialecte

Reliez l’unicité, les exigences de non-NULL et les relations au schéma. Signalez la syntaxe propre à la base ; une déclaration de variable SQL Server n’est pas portable dans une requête PostgreSQL simple.

✅

Concevoir des tests et expliquer le résultat

Comparez les valeurs et le nombre de lignes attendus à la sortie réelle. Ajoutez des cas pertinents comme les égalités, les valeurs NULL, les entrées vides et les lignes sans correspondance, puis documentez le raisonnement et ce qui reste non testé.

Devoirs SQL pour s’exercer

Six devoirs SQL avec solutions et explications

Petits exemples pédagogiques, pas des réponses à une tâche de cours cachée. Les quatre premiers utilisent un jeu de test partagé : learners(id, name, team_id, score) = (1, Ana, 1, 90), (2, Bo, 1, 90), (3, Cy, 2, 80), (4, Dee, 2, 70) ; teams(team_id, label) = (1, Alpha), (2, Beta).

Filtrer et trier
SELECT name, score
FROM learners
WHERE score >= 85
ORDER BY id;
Comportement attendu
Attendu : Ana 90 ; Bo 90. ORDER BY id définit l’ordre d’affichage.
REQUÊTE / FILTRE

Filtrer et trier

Requête pédagogique portable ; testée sur le jeu de test partagé.

Ouvrir le Tableau de bord ↗
Associer les tables liées
SELECT l.name, t.label
FROM learners AS l
JOIN teams AS t
  ON t.team_id = l.team_id
ORDER BY l.id;
Comportement attendu
Attendu : Ana–Alpha, Bo–Alpha, Cy–Beta, Dee–Beta. Les apprenants sans correspondance seraient exclus.
REQUÊTE / JOINTURE

Associer les tables liées

Jointure interne sur la relation d’équipe déclarée.

Ouvrir le Tableau de bord ↗
Calculer une ligne par équipe
SELECT team_id, AVG(score) AS mean_score
FROM learners
GROUP BY team_id
ORDER BY team_id;
Comportement attendu
Attendu : équipe 1 = 90,0 ; équipe 2 = 75,0. AVG ignore les scores NULL.
REQUÊTE / GROUPE

Calculer une ligne par équipe

Clarifiez le niveau de résultat avant de regrouper.

Ouvrir le Tableau de bord ↗
Classer les scores avec égalités
SELECT name, score,
  RANK() OVER (ORDER BY score DESC) AS r
FROM learners
ORDER BY score DESC, id;
Comportement attendu
Rangs attendus : Ana 1, Bo 1, Cy 3, Dee 4. L’ordre externe par id départage l’affichage sans modifier le rang.
FENÊTRE / ÉGALITÉS

Classer les scores avec égalités

Syntaxe standard de fenêtre de style PostgreSQL ; le test du sous-ensemble partagé est décrit dans la livraison.

Ouvrir le Tableau de bord ↗
Définir une clé primaire
CREATE TABLE practice_teams (
  team_id INT NOT NULL PRIMARY KEY,
  label VARCHAR(40) NOT NULL
);
Comportement attendu
team_id est unique et non NULL. Le NOT NULL explicite rend également le test de contrainte de démonstration clair entre les moteurs.
DDL / CONTRAINTE

Définir une clé primaire

Déclaration compatible PostgreSQL ; utilisez un schéma d’exercice jetable.

Ouvrir le Tableau de bord ↗
Utiliser une variable locale
DECLARE @min_score int = 85;
SELECT name, score
FROM learners
WHERE score >= @min_score
ORDER BY id;
Comportement attendu
Pour le même jeu de test, l’attente logique est Ana 90 et Bo 90. Vérifiez sur la version SQL Server indiquée.
SQL SERVER / T-SQL

Utiliser une variable locale

T-SQL uniquement ; revu dans la documentation, non exécuté ici sur SQL Server.

Ouvrir le Tableau de bord ↗

Les vérifications du jeu de test ont été effectuées hors ligne avec SQLite pour le sous-ensemble de requêtes partagé, pas par cette page ni dans un environnement Verla authentifié. La compatibilité PostgreSQL a été revue dans la documentation ; les variables T-SQL n’ont pas été exécutées sur SQL Server. La configuration complète et les sorties attendues figurent dans sample-fixture.sql et sql-verification.json dans la livraison.

Difficultés SQL variées

Utilisez l’aide SQL là où le raisonnement doit être travaillé

Apportez la tâche réelle et un exemple reproductible plutôt qu’une requête sans schéma.

🔁

Une jointure produit trop de lignes

La requête s’exécute mais le total est gonflé. Vérifiez la relation et le niveau de résultat requis avant d’ajouter DISTINCT ou de modifier l’agrégation.

🧮

Une agrégation renvoie les mauvais groupes

Votre requête mélange les filtres de lignes et les conditions de groupe. Suivez les lignes qui entrent dans le groupe et ce que l’exigence vous demande de conserver.

🏅

Les résultats classés gèrent mal les égalités

Deux scores sont égaux mais la sortie attendue partage les rangs. Choisissez la fonction de fenêtre appropriée et distinguez l’ordre du classement de l’ordre d’affichage final.

🔑

Un schéma ne possède pas de clé fiable

La tâche nécessite un identifiant unique ou une relation. Vérifiez les valeurs existantes et les contraintes requises avant de proposer une déclaration de clé ou une migration.

🛠️

Une requête utilise la mauvaise syntaxe de base

Un tutoriel utilise des @variables, mais votre cours utilise PostgreSQL. Identifiez le dialecte et le contexte d’exécution avant d’adapter l’approche.

📚

Vous avez besoin de pratique, pas d’une réponse inexpliquée

Travaillez sur le petit jeu de test, prévoyez la sortie puis testez-la. Modifiez une entrée à la fois et expliquez comment le comportement de la requête découle des données.

Questions fréquentes

FAQ sur les devoirs SQL

Réponses sur les entrées, les solutions guidées, le classement, les clés et la syntaxe des variables.

Que dois-je fournir pour obtenir de l’aide sur un devoir SQL ?

Indiquez la tâche exacte, la base de données et sa version, les instructions CREATE TABLE, des lignes INSERT représentatives, votre requête actuelle et la sortie attendue. Ajoutez le message d’erreur complet s’il y en a un. Utilisez des données synthétiques ou autorisées et supprimez les identifiants ; une capture d’écran seule peut omettre des détails nécessaires pour reproduire le problème.

Comment vérifier la solution d’un devoir de requête SQL ?

Définissez les colonnes, les valeurs et le nombre de lignes attendus avant de l’exécuter. Utilisez un petit jeu de test et comparez la sortie réelle, en incluant si nécessaire les égalités, les valeurs NULL, les doublons ou les enregistrements sans correspondance. Une requête qui s’exécute correctement peut tout de même répondre à la mauvaise question. Conservez une explication de la nécessité de chaque clause.

Comment attribuer un rang en SQL ?

Utilisez une fonction de fenêtre prise en charge avec l’ordre prévu. RANK donne le même rang aux lignes à égalité et laisse des écarts ; DENSE_RANK supprime ces écarts ; ROW_NUMBER produit une séquence et nécessite un critère de départage approprié pour une numérotation déterministe. Consultez la documentation des fonctions de fenêtre de PostgreSQL. L’exemple regroupe les scores égaux au même rang et utilise un ordre externe distinct pour l’affichage.

Comment attribuer une clé primaire en SQL ?

Déclarez une PRIMARY KEY lors de la création d’une table, ou utilisez la syntaxe de modification de table prise en charge par le dialecte requis. Une clé primaire peut contenir une ou plusieurs colonnes et identifie les lignes par des valeurs uniques et non NULL ; elle ne signifie pas automatiquement qu’un nombre sera généré. Vérifiez les données existantes avant d’ajouter une contrainte. Consultez les recommandations de PostgreSQL sur les contraintes et vérifiez la syntaxe de la base de votre cours.

Pourquoi l’affectation de variables en SQL dépend-elle de la base de données ?

SQL Server utilise des déclarations locales T-SQL telles que DECLARE @min_score int = 85 ; les variables utilisateur de session de MySQL suivent un autre modèle, et un simple SELECT PostgreSQL n’accepte pas de bloc DECLARE T-SQL. Distinguez les paramètres de requête, les variables de session et les variables du langage procédural. Utilisez la documentation pertinente de SQL Server ou de MySQL plutôt que de mélanger les dialectes.

Les solutions d’exercice sont-elles vérifiées pour chaque base de données ?

Non. Le sous-ensemble de requêtes portable et les contraintes explicites de clé de démonstration ont été vérifiés hors ligne avec SQLite ; il ne s’agit pas d’un test d’exécution PostgreSQL, MySQL ou SQL Server. La déclaration T-SQL a été comparée à la documentation officielle de syntaxe, mais n’a pas été exécutée sur SQL Server. Exécutez le jeu de test fourni dans la base et la version exigées par votre cours avant de vous fier au résultat.

Verla se connecte-t-il à ma base de données ou exécute-t-il la requête ici ?

Cette page est un aperçu statique avec des briefs d’exercice copiables. Elle ne se connecte pas à une base de données, ne lit pas les fichiers importés, n’exécute pas de SQL et ne vérifie pas les résultats en direct. Verla répertorie publiquement les devoirs SQL, mais aucun environnement d’exécution SQL authentifié n’a été testé ou établi. Faites l’exécution et la vérification des résultats dans l’environnement d’exercice approprié du cours.

Comment utiliser les exemples guidés pour un travail de cours ?

Utilisez-les pour prévoir les sorties, comprendre les clauses et concevoir des tests, puis appliquez ce raisonnement à votre tâche réelle. Ne présentez pas une réponse générée non vérifiée comme un travail exécuté. Suivez les règles du cours concernant l’aide extérieure ou l’aide de l’AI et expliquez la solution avec votre propre compréhension, y compris les hypothèses et les limites de validation.

Comprenez la requête.
Vérifiez le résultat. Expliquez la logique.

Apportez votre devoir, la version de la base de données, le schéma et votre tentative. Travaillez sur une solution dont vous pouvez tester les hypothèses et le comportement.

Commencer mon aide aux devoirs SQL ↗
Aide aux devoirs SQL avec AI – Exemples de requêtes et pratique | Verla