diff --git a/content/bdd_avancees/6-SQL/index.md b/content/bdd_avancees/6-SQL/index.md
new file mode 100644
index 0000000..de5697f
--- /dev/null
+++ b/content/bdd_avancees/6-SQL/index.md
@@ -0,0 +1,260 @@
+---
+title: "Base de données avancées : Le langage SQL"
+date: 2022-02-11
+tags: ["schema", "relation", "SQL"]
+categories: ["Base de données avancées", "Cours"]
+---
+
+SQL, pour *Structured Query Langage* est un langage de programmation servant à
+interagir avec des bases de données relationelles. Il regroupe plusieurs
+fonctionnalités :
+
+ * Définition des données : créations des relations appelées ici les *tables*
+ * Manipulation des données : interrogation, insertion, supression et mise à
+   jour des données contenues dans les tables
+ * Contrôle des données : permissions, contrôle d'intégrités.
+
+L'usage veut que les mots clés du langage soit écrits en majuscule, mais ce
+n'est qu'un usage.
+
+Une requête écrite en *SQL* se termine par un point-virgule. Il est aussi
+possible d'ajouter des commentaires en commençant la ligne avec `--`.
+
+## La projection
+
+Elle s'exprime avec la command `SELECT`, Il est possible de supprimer les
+doublons avec le `DISTINCT`. il est assi possible d'afficher tous les attributs
+d'une tables avec `*`.
+
+```sql
+-- afficher les noms prénom des cyclistes 
+SELECT nom, prenom
+FROM cyclistes;
+```
+
+```sql
+-- afficher tous les attributs de la table cyclistes
+SELECT *
+FROM cyclistes
+```
+
+```sql
+-- Afficher les couleurs de vélo disponibles
+SELECT DISTINCT couleur
+FROM velos;
+```
+
+## La selection
+
+Elle s'exprime avec la clause `WHERE`. Il est possible d'utiliser des opérateurs
+de comparaison (<, >, !=, <=, >=) ou des connecteurs (`not`, `and`, `or`). Il
+est aussi possible de founir un intervale comme prédicat avec `BETWEEN`.
+
+Il est possible d'utiliser `%` pour remplacer un nombre indéfini de caractères
+et `_` pour en remplacer un seul.
+
+```sql
+-- Afficher le modèle et la taille des vélos bleus Gitanes
+SELECT modele, taille
+FROM velos
+WHERE marque = 'Gitane'
+AND couleur = 'bleu`;
+```
+
+```sql
+-- Afficher les marques, modèles et couleurs des vélos de plus de 26 pouces
+SELECT marque, couleur
+FROM velos
+WHERE taille > 26;
+```
+
+## Les operation binaires
+
+Il est bon de rapeller que les opération binaires se font que sur la base de
+relations compatibles. On en dénombre 3 en SQL :
+
+ * l'union avec `UNION`
+ * l'intersection avec `INTERSECT`
+ * la différence avec `MINUS` (Oracle) ou `EXCEPT` (PostgreSQL). Il n'y pas
+   d'opérateur de différence dans MySQL.
+
+```sql
+-- afficher le modèle des vélo de marque Gitane et Motobécane
+SELECT marque, modele
+FROM velos
+WHERE marque = 'Gitane'
+UNION
+SELECT marque, modele
+FROM velos
+WHERE marque = 'Motobécane';
+```
+
+```sql
+-- afficher les vélo rouge à 6 vitesses
+SELECT marque, modele
+FROM velos
+WHERE vitesses = 6
+INTERSECT
+SELECT marque, modele
+FROM velos
+WHERE couleur = 'rouge';
+```
+
+## Les jointures
+
+Pour acceder aux attributs commun de deux relation, il nous faut utiliser la
+notation pointée.
+
+Il existe deux syntaxe possible pour exprimer des jointures naturelles : une
+ancienne via une clause `WHERE` et une autre pus moderne via le mot clé `JOIN`.
+
+```sql
+-- nouvelle sytaxe
+SELECT date, description , marque, modele
+FROM velos
+JOIN repatation ON reparations.code_velo = velos.code_velo
+WHERE marque = 'Gitane';
+
+-- ancienne syntaxe
+SELECT date, description , marque, modele
+FROM velos, reparations
+WHERE reparations.code_velo = velos.code_velo
+AND marque = 'Gitane';
+```
+
+Pour simplifier l'écriture des clause `WHERE` et `AND`, il est possible
+d'assigner des alias pour nos tables.
+
+```sql
+
+SELECT date, description , marque, modele
+FROM velos AS v
+JOIN repatation AS r ON r.code_velo = v.code_velo
+WHERE marque = 'Gitane';
+```
+
+Cette notation est très utile dans le cadre des auto-jointures.
+
+## opérateur d'appartenance
+
+Permet de tester si un élément appartient (ou non) à un ensemble.
+
+```sql
+-- afficher les cycliste ayant un velo 6 vitesses Motobécane
+SELECT nom, prenom
+FROM cyclistes
+WHERE velo_id IN (
+  SELECT velo_id
+  FROM velos
+  WHERE vitesses = 6
+  AND marque = 'Motobécane'
+);
+```
+
+Il est posible d'exprimer la négation avec le mot clé `NOT`
+
+## opérateur d'existance
+
+La requête s'exécute si celle imbriqué dans le `EXIST` retourne une valeur.
+comme pour `IN`, il est possible d'exprimer la négation avec `NOT`.
+
+```sql
+-- trouver les marques vélos qui on servi lors des course de Trouville
+SELECT DISTINCT marques
+FROM velos
+WHERE velos_id IN (
+  SELECT velo_id
+  FROM course
+  WHERE ville = 'Trouville'
+);
+
+```
+
+## les quantificateurs
+
+Ils permettent de réaliser une comparaison entre ne attribut et un ensemble de
+valeurs. Em plus de l'opérateur de compataison, il faut indiquer si l;on compare
+sur n'importe quelle valeur (`any`) ou toutes les valeurs (`all`).
+
+```sql
+-- trouver les vélos qui ont plus de vitesse que tous les VTT
+SELECT marque, modele
+FROM velos,
+WHERE vitesse >all(
+  SELECT vitesses
+  FROM velos
+  WHERE type = 'VTT'
+);
+```
+
+## Les opérateurs arithmétiques et ensemblistes
+
+Les opérateurs arithmétiques et ensemblistes se positionnent dans les clauses
+`SELECT` ou `WHERE`. Les opérateurs arithmétiques comprennnent l'addition, la
+soustraction, la multiplication et la division. Les fonctions arithmériques
+comprennent (entre autres) la valeur absolue `ABS`, l'exponentielle `EXP`, la
+racine carré `SQRT` etc.
+
+Les fonctions ensemblistes comprennent (entre autres) le comptage `COUNT`, les
+la valeur minimale `MIN` et maximale `MAX`, la somme `SUM`, la moyenne `AVG`
+etc.
+
+```sql
+-- compter le nombre de vélos au total
+SELECT COUNT(*)
+FROM velos;
+
+-- prix moyen calculé sur l'ensemble vélos
+SELECT AVR(prix)
+FROM velos;
+```
+
+## Opérateurs de groupes
+
+Afin de partitionner les résutats d'une fonction ensembliste (aussi appelée
+fonction d'aggrégation). il est possible d'utiliser l'opérateur `GROUP BY`.
+
+```sql
+-- coumpter le nombre de modèle disponible  pour chaque marque
+SELECT marque COUNT(modele)
+FROM velo
+GROUP BY marque;
+```
+
+Il est possible d'appliquer une selection sur une fonction d'aggrégation avec la
+clause `HAVING` :
+
+```sql
+-- afficher les marque ayant plus de 3 modèles disponibles
+SELECT marque
+FROM velos
+HAVING COUNT(modele) > 3;
+```
+## classement des résultats
+
+Avec la clause `ORDER BY`, il est possible de classer les résultats d'une
+requête en fonction d'une colonne. Il est possible de définir un tri croissant
+avec `ASC` ou décroissant avec `DESC`:
+
+```sql
+SELECT modele, prix
+FROM velo
+WHERE marque = 'Gitane'
+ORDER BY prix ASC;
+```
+
+## La division en SQL
+
+Pour rappel, la division permet, par exemple, de trouver les cyclistes qui ont
+participé à toutes les courses.
+
+Il n'existe pas d'opérateur de division en SQL, mais il est poussible d'utiliser
+`HAVING` :
+
+```sql
+SELECT id_cycliste, nom, prenom
+FROM cyclistes
+JOIN courses USING(id_cycliste)
+GROUP BY id_cycliste, nom, prenom
+HAVING COUNT(id_course) = (SELECT COUNT(*) FROM courses);
+```