22 exercices pour pratiquer les commandes SQL

Vous voulez améliorer vos connaissances en SQL ? Pratiquez les commandes SQL dans ces 22 exercices réalistes !

Un vieil adage dit que "rien ne remplace l'expérience". Mais comment acquérir cette expérience quand on commence à peine à apprendre quelque chose de nouveau ? Le meilleur moyen est de pratiquer, pratiquer et encore pratiquer ! Dans cet article, nous allons vous fournir des exercices pratiques sur les commandes SQL.

Tous nos exercices pratiques sont tirés de cours dispensés sur LearnSQL.fr. Nous proposons des cours interactifs sur le langage SQL dans différents domaines. Certains cours s'adressent aux débutants ; notre cours SQL pour les débutants comprend plus de 120 exercices couvrant les commandes SQL de base. Les utilisateurs intermédiaires peuvent bénéficier de cours tels que La pratique du SQLqui comprend dix cours interactifs et plus de 100 heures de pratique ! Et pour les professionnels expérimentés, les trois cours de la piste SQL avancé (avec près de 400 exercices pratiques) aideront à maîtriser les fonctionnalités les plus approfondies de SQL.

Commençons à améliorer notre connaissance des commandes SQL !

Travailler avec une table : SELECT, WHERE, ORDER BY, GROUP BY

Dans les prochains exercices, nous allons interroger les données d'une table unique qui contient des informations sur les chats. La table s'appelle Cat et possède les colonnes suivantes :

• id - L'ID d'un chat donné. Il s'agit de la clé primaire de la table.
• name - L'identité du chat
• breed - du chat
• coloration - Le chat
• age - Le chat
• sex - Le chat
• fav_toy - Le jouet préféré du chat.

Exercice n° 1 : sélection de colonnes et filtrage de données numériques

Exercice : Sélectionner le nom, la race et la couleur de chaque chat âgé de moins de cinq ans.

Solution :

SELECT 
  name, 
  breed, 
  coloration
FROM cat
WHERE age < 5;

Explication : Énumérez les colonnes requises (name, breed, et coloration) dans la clause SELECT; séparez-les par des virgules. Faites référence au tableau Cat dans la clause FROM et utilisez la condition requise age < 5 dans la clause WHERE.

Exercice n° 2 : sélection de toutes les colonnes et filtrage des données textuelles

Exercice : Sélectionnez toutes les données pour les chats dont :

• La race commence par un "R".
• Le jouet préféré commence par le mot "balle".
• La coloration se termine par un 'm'.

Solution :

SELECT *
FROM cat
WHERE breed LIKE 'R%'
  AND fav_toy LIKE 'ball%'
  AND coloration LIKE '%m';

Explication : Comme nous voulons obtenir toutes les colonnes du tableau dans le résultat, nous utilisons le symbole * pour représenter toutes les colonnes disponibles dans le tableau. Nous référençons la table Cat dans la clause FROM et incluons les trois conditions de filtrage requises en utilisant l'opérateur LIKE et le caractère générique %. L'utilisation de l'opérateur AND signifie que chaque condition est liée à la précédente ; les trois doivent être vraies pour que la ligne soit incluse dans le résultat.

N'oubliez pas que les valeurs textuelles doivent être placées entre guillemets simples.

Exercice n° 3 : sélection de colonnes et filtrage de données NULL

Exercice : Sélectionner les noms de tous les chats mâles qui n'ont pas de jouet préféré - c'est-à-dire que la valeur du champ fav_toy est NULL pour ces chats.

Solution :

SELECT name
FROM cat
WHERE sex = 'M'
  AND fav_toy IS NULL;

Explication : N'incluez que la colonne name dans la clause SELECT. Utilisez deux conditions de filtrage avec l'opérateur AND dans la clause WHERE. La première condition consiste à faire correspondre la colonne sex avec le littéral 'M'. La deuxième condition filtre les lignes où la colonne fav_toy a une valeur NULL.

Important : vous ne pouvez pas comparer les valeurs NULL avec d'autres valeurs en utilisant des opérateurs de comparaison tels que equal ; vous devez demander si une valeur EST NULL ou N'EST PAS NULL.

Exercice n° 4 : Ordonner les données retournées par un SELECT

Exercice : Sélectionner le nom, l'âge, la race et le sexe de tous les chats, en commençant par les plus vieux.

Solution :

SELECT 
  name, 
  age, 
  breed, 
  sex
FROM cat
ORDER BY age DESC;

Explication : Listez les colonnes requises (name, age, breed, et sex) dans la clause SELECT. Faites référence au tableau Cat dans la clause FROM et ordonnez les lignes à l'aide de la clause ORDER BY< suivie de la colonne age.

Comme l'ordre par défaut est croissant, nous devons inclure le mot-clé facultatif DESC pour trier les données par ordre décroissant, c'est-à-dire en récupérant d'abord les chats les plus âgés.

Exercice n° 5 : grouper des données et les ordonner par agrégation

Exercice : Montrez le nombre de chats pour chaque type de coloration, en utilisant number_of_cats comme alias pour la fonction d'agrégation qui calcule cette information. Montrez d'abord les colorations qui ont le moins de chats.

Solution :

SELECT 
  coloration, 
  COUNT(*) AS number_of_cats
FROM cat
GROUP BY coloration
ORDER BY number_of_cats DESC;

Explication : Incluez la colonne de coloration et la fonction d'agrégation COUNT(*) dans la clause SELECT. Utilisez l'alias AS number_of_cats pour donner un nom convivial à la colonne COUNT(*).

Utilisez la clause GROUP BY suivie de la colonne coloration pour regrouper les données en fonction de la coloration. Ordonnez les résultats avec la clause ORDER BY suivie d'un nom de colonne ou d'un alias - dans ce cas, number_of_cats.

Exercice n° 6 : regroupement de données et filtrage par agrégation

Exercice : Affichez l'âge moyen des chats dans chaque race ; utilisez Average_Age comme alias pour la fonction d'agrégation. N'affichez que les races dont l'âge moyen est supérieur à cinq ans.

Solution :

SELECT 
  breed, 
  AVG(age) AS Average_Age
FROM cat
GROUP BY breed
HAVING AVG(age) > 5;

Explication : Incluez la colonne race et la fonction agrégative AVG(age) dans la clause SELECT. Utilisez un alias pour renvoyer un nom de colonne convivial pour la fonction d'agrégation. Utilisez la clause GROUP BY suivie de la colonne breed pour regrouper les données en fonction de chaque race de chat.

Comme nous devons filtrer en fonction des résultats de l'agrégation, nous ne pouvons pas utiliser la clause WHERE; elle filtre les lignes BEFORE qui sont regroupées. Au lieu de cela, nous devons utiliser la clause HAVING; elle est appliquée après que les lignes ont été regroupées.

Pour en savoir plus : Vous trouverez d'autres exemples pratiques GROUP BY dans l'article 10 GROUP BY La pratique du SQL Exercices avec solutions.

Travailler avec plusieurs tables : JOIN

Dans les prochains exercices, nous allons interroger des données provenant de plusieurs tables. Nous utiliserons un modèle très simple qui inclut les employés, les salaires et les avantages sociaux.

Voyons la employee structure de la table :

• id - l'identifiant d'un employé donné.
• first_name - Le prénom de l'employé.
• last_name - Le nom de famille de l'employé.
• salary - Le nom de l'employé
• manager_id - L'identifiant du responsable de l'employé.

Ensuite, la table salgrade contient des informations sur le niveau de salaire :

• grade - Le grade d'un salaire.
• lower_limit - La limite inférieure de la classe de salaire.
• upper_limit - Limite supérieure de la classe de salaire.

Enfin, le dernier tableau, benefitsne comporte que deux colonnes :

• benefit_name - Le nom d'un avantage donné.
• salary_req - Le salaire minimum requis pour obtenir cet avantage.

Exercice n° 7 : jointure implicite de données provenant de plusieurs tables

Exercice : Sélectionnez le prénom, le nom, le salaire et le niveau de salaire des employés dont le salaire se situe entre lower_limit et upper_limit dans le tableau. salgrade dans la table.

Solution :

SELECT 
  first_name, 
  last_name, 
  salary, 
  grade
FROM employee, salgrade
WHERE salary BETWEEN lower_limit AND upper_limit;

Explication : Dressez la liste des colonnes requises (first_name, last_name, salary, grade) dans la clause SELECT. Faites référence à la fois à la clause employee et salgrade dans la clause FROM. Nous utilisons la clause WHERE pour définir les critères de jointure entre les deux tables, en spécifiant que le salaire de l'employé doit être compris entre les limites inférieure et supérieure de la table salgrade de la table.

Exercice n° 8 : jointure explicite de données provenant de plusieurs tables

Exercice : Montrez tous les avantages dont bénéficierait l'employé sur id = 5. Sélectionnez le nom et le prénom de cet employé ainsi que les noms des avantages.

Solution :

SELECT 
  first_name, 
  last_name, 
  benefits.benefit_name
FROM employee
JOIN benefits 
ON employee.salary > benefits.salary_req
WHERE employee.id = 5;

Explication : Dressez la liste des colonnes requises (first_name, last_name, benefits.benefit_name) dans la clause SELECT. Faites référence à la table employee dans la clause FROM, puis joignez explicitement les lignes à la table des prestations à l'aide du mot-clé JOIN.

La condition qui définit la relation entre les deux tables est spécifiée après le mot-clé ON. Les conditions de relation entre les tables sont ainsi séparées des conditions de filtrage, ce qui améliore la clarté de la requête. Les conditions de filtrage sont toujours définies dans la clause WHERE; dans ce cas, nous utilisons la condition employee.id = 5.

Exercice n° 9 : jointure et regroupement de données provenant de plusieurs tables

Exercice : Pour chaque avantage, trouvez le nombre d'employés qui en bénéficient. Affichez deux colonnes : benefit_name et le nombre d'employés qui en bénéficient (nommez cette colonne employee_count). N'oubliez pas les avantages dont personne ne bénéficie.

Solution :

SELECT 
  benefits.benefit_name, 
  COUNT(employee.id) AS employee_count
FROM benefits
LEFT JOIN employee 
ON salary_req <= employee.salary
GROUP BY benefits.benefit_name;

Explication : Incluez la colonne benefit_name et la fonction d'agrégation COUNT() (appliquée à la colonne employee.id ) dans la clause SELECT. Utilisez un alias pour les résultats de la fonction d'agrégation : AS employee_count. Faites référence à la table benefits dans la clause FROM, puis joindre la table employee à l'aide d'un LEFT JOIN.

N'oubliez pas que les opérations LEFT (et RIGHT) JOIN récupèrent toutes les données du côté gauche (ou droit) des critères JOIN - même si aucune ligne correspondante n'existe dans l'autre table. Pour en savoir plus, consultez l'article SQL JOIN Types Explained (Les types de jointures SQL expliqués).

Le critère de jointure est spécifié après le mot-clé ON. Enfin, utilisez la clause GROUP BY pour agréger les données au niveau benefit_name.

Exercice n° 10 : joindre une table à elle-même (auto-jointures)

Exercice : Affichez le prénom, le nom et le salaire de chaque employé, ainsi que le prénom et le nom de son supérieur direct dans la même ligne. Pour les employés qui n'ont pas de supérieur hiérarchique (par exemple le PDG), affichez NULL comme nom et prénom du supérieur hiérarchique.

Utilisez un alias pour préfixer les colonnes de l'employé par employee_ et celles du manager par manager_ (par exemple employee_first_name).

Solution :

SELECT 
  e.first_name AS employee_first_name, 
  e.last_name AS employee_last_name, 
  e.salary AS employee_salary,
  m.first_name AS manager_first_name,
  m.last_name AS manager_last_name
FROM employee e
LEFT JOIN employee m 
ON e.manager_id = m.id;

Explication : Incluez le prénom, le nom et le salaire de l'employé en utilisant e comme alias de table. employee comme alias de table. Incluez le prénom et le nom de famille du directeur en utilisant m comme alias de table. Dans la clause FROM, utilisez la table employee avec l'alias e pour référencer les données relatives aux employés ; dans la clause LEFT JOIN, utilisez la table employee avec l'alias m pour référencer les informations relatives au manager. La condition de jointure est que la valeur manager_id de l'employé doit correspondre à la valeur id du manager.

Pour en savoir plus : La jointure d'une table à elle-même est une opération courante. Elle peut sembler délicate, mais elle est plus simple à comprendre lorsque vous utilisez les bons alias pour la table concernée ! Pour plus d'aide sur les JOIN, consultez notre cours sur les JOINTS SQL. Il contient plus de 90 exercices interactifs, dont dix exemples gratuits que vous pouvez mettre en pratique dès maintenant.

Utilisation de sous-requêtes

Dans cette section, nous allons utiliser des sous-requêtes pour interroger des données en fonction de conditions qui dépendent d'autres données stockées dans la base de données. Nous utiliserons les tables suivantes, en commençant par la table orchestras table :

• id - L'ID de l'orchestre.
• name - Le nom de l'orchestre.
• rating - L'évaluation de l'orchestre au cours des dix dernières années.
• city_origin - La ville d'origine de l'orchestre (par exemple "Berlin" pour la Philharmonie de Berlin).
• country_origin - Le pays d'origine de l'orchestre (par exemple, "Allemagne" pour la Philharmonie de Berlin).
• year - L'année de création de l'orchestre.

Le tableau concert contient des informations sur les concerts joués par les orchestres :

• id - L'ID du concert.
• city - Le nom de la ville où le concert a eu lieu. Cette ville peut être différente de la ville d'origine de l'orchestre.
• country - Le nom du pays où le concert a eu lieu.
• year - L'année où le concert a eu lieu.
• rating - La note attribuée au concert par les critiques.
• orchestra_id - Le numéro d'identification de l'orchestre qui a donné le concert.

La table members contient des informations sur chaque membre de l'orchestre :

• id - L'ID d'un membre donné.
• name - Le nom du membre.
• position - La position du membre dans l'orchestre (par exemple, deuxième flûte, premier alto).
• wage - Une rémunération mensuelle fixe versée au membre de l'orchestre.
• experience - Le nombre d'années d'expérience de ce membre de l'orchestre.
• orchestra_id - Le numéro d'identification de l'orchestre.

Exercice n° 11 : Utilisation de sous-requêtes pour filtrer les données

Exercice : Afficher les noms des orchestres qui ont été créés après l'"Orchestre de chambre" et qui ont une note supérieure à 7,5.

Solution :

SELECT name
FROM orchestras 
WHERE year > 
(SELECT year 
FROM orchestras 
WHERE name = 'Chamber Orchestra') 
  AND rating > 7.5;

Explication : Les clauses SELECT et FROM de cet exercice sont très simples, mais le point délicat est la clause WHERE. Nous avons deux conditions à évaluer, et nous en connaissons exactement une (rating > 7.5). La seconde nous est inconnue, car il ne s'agit pas d'une valeur définie comme 7,5, mais de quelque chose qui doit être obtenu à partir des données, à savoir l'année de création de l'orchestre de chambre.

Dans ces scénarios, nous utilisons une sous-requête, c'est-à-dire une requête qui s'exécute "à l'intérieur" d'une requête plus importante. Cet exercice nécessite une sous-requête qui permet d'obtenir l'année de création de l'orchestre lorsque le nom est égal à "Chamber Orchestra". Nous utilisons le résultat de cette sous-requête pour filtrer l'année de création de chaque orchestre.

Conseil de pro: Lorsque vous travaillez avec des sous-requêtes, il est conseillé de commencer par construire la sous-requête. Une fois qu'elle renvoie le résultat souhaité, intégrez-la dans la requête principale !

Exercice n° 12 : utilisation de sous-requêtes dans FROM

Exercice : Trouvez le nombre moyen de membres par orchestre.

Solution :

SELECT AVG(d.count) 
FROM (SELECT 
        orchestra_id, 
        COUNT(id) 
FROM members 
GROUP BY orchestra_id) d;

Explication : Commencez par la sous-requête obtenant le nombre de membres pour chaque orchestre et l'identifiant de l'orchestre. Placez cette sous-requête dans la clause FROM de la requête principale et donnez-lui un alias. La clause SELECT doit simplement calculer le nombre moyen de membres en utilisant la fonction d'agrégation AVG() sur les résultats de comptage de la sous-requête.

Exercice n°13 : Sous-requêtes corrélées

Exercice : Sélectionner le nom, le salaire et l'expérience des membres les mieux payés de chaque orchestre.

Solution :

SELECT 
  name, 
  wage, 
  experience
FROM members m1
WHERE wage = (SELECT MAX(wage) 
             FROM members m2 
		WHERE m1.orchestra_id = m2.orchestra_id);

Explication : Incluez les colonnes name, wage et experience dans la clause principale SELECT. Placez le tableau members dans la clause FROM et donnez-lui l'alias m1. Dans la clause WHERE, comparez la valeur du salaire (de la requête principale) avec les résultats de la sous-requête corrélée.

La sous-requête corrélée obtient le salaire maximum à l'aide de la fonction d'agrégation MAX() pour toutes les lignes de la table des membres (alias m2) dont le numéro orchestra_id correspond à celui de la requête principale.

Contrairement aux sous-requêtes ordinaires qui sont exécutées une fois avant la requête principale, les sous-requêtes corrélées sont exécutées une fois pour chaque ligne de la requête principale. Ceci est dû au fait qu'elles font référence à des valeurs de la requête principale.

Exercice n° 14 : utiliser des filtres, des jointures, des GROUP BY et des sous-requêtes

Exercice : Pour chaque orchestre, indiquez son nom, le nom de la ville où l'orchestre a reçu la meilleure note pour sa prestation, et cette note.

Solution :

SELECT 
  o.name, 
  c.city, 
  c.rating
FROM orchestras o
JOIN concerts c 
ON o.id = c.orchestra_id
WHERE c.rating IN ( SELECT MAX(con.rating)
			FROM concerts con
			WHERE con.orchestra_id = o.id) ;

Explication : Incluez le nom de l'orchestre, les colonnes concert city et rating dans la clause SELECT de la requête principale. Dans la clause FROM, incluez la table orchestras et JOIN la table concerts en utilisant les identifiants des orchestres.

Utilisez la clause WHERE pour égaler la valeur de concert rating avec la note maximale obtenue par l'orchestre lors du concert. Pour ce faire, utilisez une sous-requête corrélée qui applique la fonction MAX() à la colonne "rating". Dans la clause WHERE de la sous-requête, faites correspondre l'ID de l'orchestre de concert à l'ID de l'orchestre de la requête principale.

Commandes SQL de modification des données : INSERTION, MISE À JOUR, SUPPRESSION

Dans les sections précédentes, nous avons utilisé la commande SELECT. Dans cette section, nous allons nous entraîner à utiliser d'autres commandes SQL telles que INSERT, UPDATE, et DELETE. Nous utiliserons la table dish qui contient des informations sur les repas pris dans un restaurant. Elle comporte les colonnes suivantes :

• id - L'identifiant de chaque plat et la clé primaire de cette table.
• type - Le type de plat (par exemple, entrée, plat principal, dessert).
• name - Le nom du plat
• price - Le plat

Exercice n° 15 : insertion d'une seule ligne sans spécifier de colonnes

Exercice : Ajouter un plat appelé Cevapcici avec un ID de 9 et un prix de 27. Il s'agit d'un plat principal.

Solution :

INSERT INTO dish 
VALUES (9, 'main course', 'Cevapcici', 27);

Explication : La clause INSERT INTO, suivie du nom de la table, indique la table dans laquelle nous voulons insérer des données. Comme nous n'avons pas fourni de liste de colonnes, les valeurs de toutes les colonnes doivent être fournies dans la clause VALUES. Il convient de les énumérer dans l'ordre où elles sont définies dans la table et de mettre la liste entre parenthèses. Dans ce cas, nous insérons l'ID, le type, le nom et le prix du plat dans la table.

Exercice n° 16 : insertion d'une seule ligne et spécification des colonnes

Exercice : La cuisine des Balkans est de plus en plus populaire, nous avons donc besoin d'un autre plat des Balkans sur le menu. Nous ajoutons le Pain du Kosovo avec un ID de 10 ; c'est une entrée. Nous n'avons pas encore décidé du prix, alors ne le mentionnons pas pour l'instant.

Solution :

INSERT INTO dish (id, type, name) 
VALUES (10, 'starter', 'Kosovo Bread');

Explication : Après la clause INSERT INTO et le nom de la table, placez la liste des colonnes à insérer. (N'oubliez pas les parenthèses !) Les colonnes qui ne figurent pas dans la liste se verront attribuer une valeur NULL.

Dans la clause VALUES, les valeurs sont fournies pour chacune des colonnes spécifiées dans la liste.

Exercice n° 17 : Mise à jour de certaines lignes

Exercice : C'est l'heure de l'apéritif dans notre restaurant ! Changez le prix de tous les plats principaux à 20.

Solution :

UPDATE dish 
SET price = 20 
WHERE type = 'main course';

Explication : Utilisez la phrase UPDATE suivie du nom de la table à mettre à jour. Dans la clause SET, indiquez la colonne que vous voulez mettre à jour (dans ce cas, juste price) suivie de la nouvelle valeur à lui attribuer.

La clause WHERE fonctionne de la même manière que la phrase SELECT, mais elle identifie ici les lignes à mettre à jour au lieu des lignes à renvoyer.

Exercice n° 18 : mise à jour de plusieurs colonnes

Exercice : Les rouleaux de printemps se vendent comme des petits pains, mais la salade de crevettes (ID 1) n'intéresse plus personne. Nous devons changer son nom pour quelque chose de plus exotique - essayons le dragon vert des mers. Fixez le prix à 10 pour encourager les clients à essayer ce plat.

Solution :

UPDATE dish 
SET name = 'Green Sea Dragon', price = 10 
WHERE id = 1;

Explication : Utilisez la phrase UPDATE suivie du nom de la table que vous souhaitez mettre à jour. Dans la clause SET, indiquez les colonnes à mettre à jour (name et price) suivies des nouvelles valeurs à attribuer ; séparez chaque paire de noms et de valeurs par une virgule. La clause WHERE fonctionne de la même manière que la phrase SELECT.

Exercice n°19 : Suppression d'une seule ligne

Exercice : Les huîtres Bienville (ID 7) ne sont pas très populaires. Supprimons-les du menu.

Solution :

DELETE FROM dish 
WHERE id = 7;

Explication : Utilisez la clause DELETE FROM suivie du nom de la table pour indiquer la table dans laquelle les données seront supprimées.

La clause WHERE fonctionne de la même manière avec DELETE qu'avec SELECT. Dans ce cas, elle compare la colonne id avec une seule valeur. Ainsi, seulement une ou zéro ligne sera supprimée (selon que la ligne avec id = 7 existe ou non).

Exercice n° 20 : Suppression de plusieurs lignes

Exercice : Oups, nous n'avons plus de sucre ! Supprimez tous les desserts de notre menu.

Solution :

DELETE FROM dish 
WHERE type = 'dessert';

Explication : Utilisez la clause DELETE FROM suivie du nom de la table pour indiquer la table dans laquelle les données seront supprimées. La clause WHERE fonctionne de la même manière que la commande SELECT; dans ce cas, la commande SQL supprimera toutes les lignes contenant la valeur "dessert" dans la colonne type.

Pour en savoir plus : Jetez un coup d'œil au cours Comment modifier une base de données avec SQL pour 50+ exercices sur l'insertion, la mise à jour et la suppression de données.

Commandes CREATE TABLE et ALTER TABLE

Nous pouvons maintenant nous entraîner à utiliser deux commandes SQL supplémentaires qui nous permettent de créer et de modifier des tables.

Exercice n°21 : Créer une table simple

Exercice : Créez une table nommée result avec deux colonnes INTEGER (id et score) et une colonne DATE (score_date).

Solution :

CREATE TABLE result (
  id integer,
  score integer,
  score_date date
);

Explication : Utilisez la phrase CREATE TABLE suivie du nom de la table que vous souhaitez créer. Fournissez une liste de noms de colonnes avec le type de données approprié, séparés par des virgules. Assurez-vous que toute la liste des colonnes est entre parenthèses.

Exercice n° 22 : Ajouter une colonne NOT NULL

Exercice : Modifiez la table result en rendant la colonne id NOT NULL et en ajoutant une nouvelle colonne VARCHAR appelée name avec une limite de 32 caractères.

Solution :

ALTER TABLE result ALTER COLUMN id SET NOT NULL;
ALTER TABLE result ADD COLUMN name varchar(32);

Explication : Utilisez la commande ALTER TABLE suivie du nom de la table. Utilisez la clause ALTER COLUMN suivie du nom de la colonne que vous souhaitez modifier. Dans ce cas, vous avez défini la colonne sur NOT NULL.

Utilisez à nouveau la commande ALTER TABLE. Cette fois, utilisez la clause ADD COLUMN suivie du nom de la nouvelle colonne, de son type de données et de sa limite de caractères (varchar(32)).

Pour en savoir plus : Le cours Les bases de la création de tables en SQL comprend plus de 80 exercices et 10 heures de pratique sur la création et la modification de tables de base de données.

Prêt pour plus de pratique sur les commandes SQL ?

Nous avons abordé les commandes SQL qui vous permettent d'interroger une ou plusieurs tables, de filtrer des données, de grouper et d'ordonner des données, d'insérer et de mettre à jour des données, et de supprimer des données. Nous vous avons également montré les options de base permettant de créer et de modifier des tables de base de données.

Cependant, il reste encore beaucoup à apprendre sur les commandes SQL. Consultez Your Guide to La pratique du SQL sur LearnSQL.com pour trouver des dizaines d'articles qui vous permettront de vous entraîner à l'utilisation des commandes SQL.

Pour une formation complète, envisagez d'acheter notre package SQLTout à vie . Ce pack vous donne accès à tous les cours actuels et futurs, ce qui vous permet de disposer des ressources nécessaires pour améliorer en permanence vos compétences en SQL. Ne manquez pas cette opportunité de rester en tête !