15 minutes de SQL
Créer une table avec PRIMARY KEY et FOREIGN KEY
Créer une table avec CREATE TABLE
La commande CREATE TABLE permet de créer une nouvelle table dans une base de données.
On doit préciser :
- Le nom de la table.
- La liste des colonnes.
- Le type de chaque colonne.
- Les éventuelles contraintes (clé primaire, clé étrangère).
CREATE TABLE clients (
id_client INTEGER PRIMARY KEY,
nom TEXT,
ville TEXT
);Types usuels
INTEGER: nombre entier.REALouFLOAT: nombre décimal.TEXTouVARCHAR: texte.DATE: date.
Clés
- Une clé primaire identifie chaque ligne de manière unique.
- Une clé étrangère relie une table à une autre.
CREATE TABLE commandes (
id_commande INTEGER PRIMARY KEY,
id_client INTEGER,
date_commande DATE,
FOREIGN KEY (id_client) REFERENCES clients(id_client)
);Exemples commentés
DROP TABLE IF EXISTS auteurs;
CREATE TABLE auteurs (
id_auteur INTEGER PRIMARY KEY,
nom TEXT
);
INSERT INTO auteurs(id_auteur, nom) VALUES (1, 'Durand');
INSERT INTO auteurs(id_auteur, nom) VALUES (2, 'Martin');
SELECT * FROM auteurs ORDER BY id_auteur;On crée deux tables liées par une clé étrangère : etudiants et notes. On insère une note, puis on affiche.
DROP TABLE IF EXISTS notes;
DROP TABLE IF EXISTS etudiants;
CREATE TABLE etudiants (
id_etudiant INTEGER PRIMARY KEY,
nom TEXT,
prenom TEXT
);
CREATE TABLE notes (
id_etudiant INTEGER,
matiere TEXT,
note INTEGER,
FOREIGN KEY (id_etudiant) REFERENCES etudiants(id_etudiant)
);
INSERT INTO etudiants(id_etudiant, nom, prenom) VALUES (1, 'Dupont', 'Alice');
INSERT INTO notes(id_etudiant, matiere, note) VALUES (1, 'SQL', 14);
SELECT * FROM notes;On crée une table comptes et on teste l’insertion d’une ligne.
DROP TABLE IF EXISTS comptes;
CREATE TABLE comptes (
id_compte INTEGER PRIMARY KEY,
titulaire TEXT,
solde INTEGER
);
INSERT INTO comptes(id_compte, titulaire, solde) VALUES (1, 'Martin', 2500);
SELECT * FROM comptes;Et pour quelques minutes de plus…
Prendre en main la programmation, pas à pas.
Ces exercices sont conçus pour t’aider à maîtriser progressivement les requêtes SQL, en partant de la lecture et de la compréhension du code, jusqu’à l’écriture autonome de requêtes complètes.
L’objectif n’est pas d’aller vite, mais de construire des automatismes solides, en comprenant ce que fait chaque commande, puis en apprenant à les utiliser par toi-même.
L’ordre des exercices est volontaire : on lit, on comprend, on complète, puis on écrit seul. Prends le temps de chaque étape : c’est la clé pour progresser durablement.
Niveau 1 Lire et interpréter
Comprendre avant d’écrire.
Dans cette première série, tu observes et analyses des requêtes SQL déjà écrites.
L’objectif est de comprendre la logique et d’être capable d'expliquer ce que renvoie la requête.
Niveau 2 Compléter une requête
Écrire, mais avec un cadre.
Ici, tu passes à l’écriture sans partir de zéro.
Le squelette de la requête est fourni : il te reste à compléter certaines parties
pour que le code fonctionne correctement.
Ce format permet de se concentrer sur l’essentiel, sans se perdre dans la structure générale.
Niveau 3 Écrire une requête
Passer à l’autonomie.
Dans cette dernière série, tu écris les requêtes complètes à partir d’une consigne.
Tu dois organiser ton code, choisir les bonnes instructions et construire la logique globale.
C’est ici que tu mets en pratique tout ce que tu as appris dans les niveaux précédents.
Contenu réservé aux membres
Les exercices interactifs et le feedback IA sont réservés aux membres.
On crée une table
auteursavec une clé primaire, on insère deux lignes, puis on affiche le contenu.