Cours Introduction au langage SQL en PDF (Avancé)

Introduction au langage SQL : Ce qu'il faut savoir. Le SQL (Structured Query Language) est le langage standard de communication avec les SGBDR, permettant de définir le schéma, manipuler les données et interroger des jeux de tuples stockés en tables. La maîtrise des constructions DDL/DML/DQL, des contraintes déclaratives (clé primaire, clé étrangère, NOT NULL) et des mécanismes procéduraux (procédures stockées, curseurs, triggers) est essentielle pour concevoir, interroger et maintenir des bases relationnelles en production. Le cours présente le SQL conforme au standard ISO/ANSI et met en évidence les différences de dialecte pertinentes pour Oracle, MySQL et PostgreSQL.

🎯 Ce que vous allez apprendre

• Architecture SGBDR et vocabulaire SQL — comprendre la distinction entre SGBD et SGBDR, les rôles serveur/client et les différences pratiques entre Oracle, MySQL et SQL Server. Situer les composants (catalogue, schéma, tables) et utiliser les vues d'administration (par ex. USER_CONSTRAINTS, SHOW TABLE STATUS) pour inspecter un système.
• Définition du schéma : DDL et contraintes déclaratives — créer et modifier des tables avec CREATE TABLE et ALTER TABLE, déclarer PRIMARY KEY, FOREIGN KEY, DEFAULT et NOT NULL, nommer et supprimer des contraintes. Résultat concret : modéliser l'intégrité référentielle et empêcher les insertions invalides entre tables liées.
• Manipulation et interrogation : SELECT, WHERE, ORDER BY — composer des requêtes avec projection, filtrage (conditions, NULL, BETWEEN), tri et élimination des doublons avec DISTINCT. Relier les opérations d'algèbre relationnelle (projection, sélection, jointure, produit cartésien) aux expressions SQL pour produire des rapports opérationnels et déboguer des résultats liés aux valeurs NULL.
• Jointures et produit cartésien — maîtriser le principe des jointures (INNER JOIN, LEFT JOIN, RIGHT JOIN, FULL JOIN), détecter et corriger un produit cartésien involontaire et appliquer des jointures réflexives.
• Agrégation et groupage — utiliser les fonctions d'agrégation (SUM, COUNT, AVG, MIN, MAX) conjointement avec GROUP BY pour synthétiser des jeux de données. Comprendre les règles de granularité et d'agrégation pour éviter les erreurs de regroupement.
• SQL procédural : vues, sous-requêtes, procédures, curseurs et triggers — créer des vues pour masquer la complexité, écrire sous-requêtes scalaires et corrélées, et implémenter des procédures stockées, curseurs et triggers pour des traitements côté serveur. Automatiser des tâches, gérer des flux transactionnels et mesurer l'impact des curseurs/triggers sur la performance.

📑 Sommaire du document

1. Notes de cours
2. Scripts de création de tables
3. Livraisons Sans contraintes
4. Modules et prérequis
5. Géométrie
6. Livraisons
7. Arbre généalogique
8. Comptes bancaires

💡 Pourquoi choisir ce cours ?

Le document d'Alexandre Meslé combine exposé conceptuel et exemples opérationnels tirés de cas concrets (livraisons, banque, arbre généalogique) : de la définition du schéma aux scripts de création et aux requêtes de production. L'approche privilégie la pratique avec extraits de consoles Oracle/MySQL, requêtes types et commandes d'administration pour faciliter la mise en oeuvre en environnement réel. La présence de modules procéduraux (procédures stockées, curseurs, triggers) fournit des outils adaptés aux contraintes de production.

👤 À qui s'adresse ce cours ?

• Public cible : étudiants en informatique et développeurs backend qui conçoivent ou interrogent des bases relationnelles, administrateurs de bases souhaitant formaliser les contraintes d'intégrité et développeurs produisant des rapports multi-tables.
• Prérequis : connaissance pratique de la modélisation relationnelle (tables, clés), familiarité avec les requêtes SELECT/WHERE de base et accès à un SGBDR (MySQL ou Oracle) via console ou client SQL.
• Pont théorie-pratique : le support fait le lien entre le modèle relationnel et la pratique SQL, en illustrant comment les opérateurs relationnels se traduisent en requêtes SQL avancées.

❓ Foire Aux Questions (FAQ)

Quelle est la conséquence d'un produit cartésien non voulu dans une requête ? Un produit cartésien résulte d'une jointure sans condition de liaison et multiplie le nombre de tuples, faussant les résultats et dégradant fortement les performances. La correction implique l'ajout d'une clause de jointure appropriée (ON ou WHERE) qui lie les clés primaires/étrangères ou la réécriture en jointure explicite.

Quand préférer une vue plutôt qu'une procédure stockée pour réutiliser une requête ? Une vue est adaptée pour encapsuler une projection ou un filtre réutilisable et améliorer la lisibilité des requêtes DQL, tandis qu'une procédure stockée convient pour des traitements complexes, des opérations DML ou des logiques transactionnelles côté serveur. Le choix dépend de la nécessité de paramètres, d'effets de bord et des contraintes de performance.

Lien avec l'algèbre relationnelle

Le SQL implémente concrètement le modèle relationnel d'E. F. Codd : les opérations de projection, sélection, union, différence et jointure se traduisent en constructions SQL identifiables. Comprendre ces correspondances facilite la formulation de requêtes correctes et performantes et permet d'anticiper les implications algorithmiques des plans d'exécution.

Définitions essentielles : l'union combine les tuples de deux relations compatibles en éliminant les doublons ; la différence (R − S) retourne les tuples présents dans R et pas dans S ; le produit cartésien crée toutes les paires possibles entre deux relations et sert de base aux jointures mais peut être source d'erreurs si utilisé sans condition.

Correspondance Algèbre Relationnelle

Syntaxe des jointures normalisées

Cette section détaille les principales jointures standardisées et leur usage en SQL : INNER JOIN pour l'intersection, LEFT JOIN et RIGHT JOIN pour conserver les lignes d'une table extérieure, et FULL JOIN pour l'union des ensembles. Les dialectes peuvent varier quant au support natif de FULL JOIN ; le cours précise des alternatives compatibles avec Oracle, MySQL et PostgreSQL.

-- Exemple : LEFT JOIN conservant toutes les commandes même sans client associé
SELECT c.client_id, c.nom, o.commande_id, o.montant
FROM clients c
LEFT JOIN commandes o ON c.client_id = o.client_id;

Conformité aux standards SQL ISO/ANSI

Le matériel insiste sur la conformité aux normes SQL ISO/ANSI et sur les bonnes pratiques d'écriture portable. Les différences de dialecte (types, fonctions intégrées, gestion des transactions) sont explicitement repérées et accompagnées d'alternatives compatibles pour Oracle, MySQL et PostgreSQL. Cette approche permet d'écrire des requêtes robustes, maintenables et transférables entre environnements tout en exploitant les extensions spécifiques lorsque cela est justifié.

Principes de l'algèbre relationnelle et SQL

Les principes fondamentaux de l'algèbre relationnelle fournissent une base formelle pour le langage de définition de données et les requêtes. Le cours relie les opérateurs algébriques aux constructions SQL et explique comment ces correspondances influent sur l'optimisation et le plan d'exécution. L'approche présente à la fois la théorie nécessaire pour raisonner sur la correction des requêtes et des exemples pratiques pour valider les résultats sur un SGBDR.

Différences entre les dialectes SQL (Oracle, MySQL, PostgreSQL)

• Gestion des dates et fonctions temporelles : les types et fonctions diffèrent (par ex. DATE/TIMESTAMP, formats et fonctions de parsing). Adapter les requêtes garantit la portabilité entre Oracle, MySQL et PostgreSQL.
• Auto-incrémentation / séquences : MySQL propose AUTO_INCREMENT, tandis qu'Oracle utilise des SEQUENCEs combinées à TRIGGERs ; PostgreSQL offre SERIAL ou GENERATED ... AS IDENTITY.
• Syntaxe de limitation et support de FULL JOIN : le mot-clé LIMIT est courant en MySQL/PostgreSQL, Oracle utilise FETCH FIRST ou la pseudo-colonne ROWNUM, et le support natif de FULL JOIN peut varier, avec des alternatives possibles pour assurer la compatibilité.

Installation et Environnement

Pour tester les scripts fournis, installer un environnement local minimal : soit Oracle Database Express Edition (XE) pour reproduire le comportement Oracle, soit MySQL Community Server pour un environnement léger et courant. Après installation, initialiser une instance, créer un utilisateur avec les droits nécessaires et exécuter les scripts via la console (sqlplus pour Oracle, mysql pour MySQL) ou via un client graphique. Vérifier la version du SGBDR et adapter les types/contraintes selon le standard ISO/ANSI et les extensions locales ; conserver une copie des scripts avant exécution en production.