sql

sql.dcl.md

@@ -0,0 +1,35 @@
+# Data Control Language
+
+Le langage de contrôle des données est le sous-langage responsable des tâches administratives de contrôle de la base de données elle-même, plus particulièrement de l'octroi et de la révocation des autorisations d'accès à la base de données pour les utilisateurs.
+
+Le DCL est utilisé principalement par les administrateurs de bases de données (DBA) pour s'assurer que seuls les utilisateurs autorisés peuvent accéder ou modifier les données, garantissant ainsi la sécurité des informations.
+
+### Grant
+
+Cette commande permet d'accorder des privilèges à des utilisateurs ou des rôles. Par exemple, elle peut autoriser un utilisateur à lire, modifier ou supprimer des données dans une table spécifique.
+
+```sql
+GRANT SELECT ON livres TO albert;
+```
+
+### Revoke
+
+Cette commande permet de retirer des privilèges précédemment accordés à un utilisateur ou un rôle
+
+```sql
+REVOKE SELECT ON livres FROM albert;
+```
+
+### Deny
+
+Cette coomande est utilisée dans certains systèmes, comme Microsoft SQL Server, pour refuser explicitement des privilèges à un utilisateur ou un rôle, même si celui-ci a reçu des permissions via la commande GRANT
+
+```sql
+DENY SELECT ON table_name TO user_name;
+```
+
+#### Pourquoi utiliser Deny ?
+
+REVOKE supprime simplement un privilège accordé, mais si l'utilisateur appartient à un groupe qui a ce privilège, il pourrait toujours l'utiliser.
+
+DENY, en revanche, a un effet prioritaire. Il bloque explicitement l'accès, et même si un utilisateur ou un rôle dispose du privilège via d'autres sources (comme des groupes), DENY prévaudra sur les autres permissions.

sql.ddl.md

@@ -0,0 +1,29 @@
+# Data Definition Language
+
+Langage de définition des données (DDL) - Le langage de définition des données est le sous-langage chargé de définir la manière dont les données sont structurées dans une base de données. En SQL, cela correspond à la manipulation des tables par l'intermédiaire de *create table*, *alter table*, et *drop table*.
+
+## Créer une table
+
+La commande CREATE TABLE permet de créer une table en SQL. Un tableau est une entité qui est contenu dans une base de données pour stocker des données ordonnées dans des colonnes. La création d’une table sert à définir les colonnes et le type de données qui seront contenus dans chacun des colonne (entier, chaîne de caractères, date, valeur binaire …).
+
+```sql
+CREATE TABLE chauffeur;
+```
+
+## Supprimer une table
+
+La commande DROP TABLE en SQL permet de supprimer définitivement une table d’une base de données. Cela supprime en même temps les éventuels index, trigger, contraintes et permissions associées à cette table.
+
+Attention : il faut utiliser cette commande avec attention car une fois supprimée, les données sont perdues. Avant de l’utiliser sur une base importante il peut être judicieux d’effectuer un backup (une sauvegarde) pour éviter les mauvaises surprises.
+
+```sql
+DROP TABLE chauffeur;
+```
+
+## Modifier une table
+
+La commande ALTER TABLE en SQL permet de modifier une table existante. Idéal pour ajouter une colonne, supprimer une colonne ou modifier une colonne existante, par exemple pour changer le type.
+
+```sql
+ALTER TABLE chauffeur;
+```

sql.dml.md

@@ -0,0 +1,43 @@
+# DML
+
+Langage de manipulation des données (DML) - Le langage de manipulation des données est le sous-langage qui permet d'ajouter, de modifier ou de supprimer des données dans une base de données. En SQL, il correspond aux langages INSERT, UPDATE et DML. DELETE
+
+## Insérer des données
+
+Lorsqu'une table est créée, elle ne contient aucune donnée. La première chose à faire avant qu’une base de données puisse être d’une grande utilité est d’insérer des données. Il n'est pas possible d'insérer quelque chose qui ne soit pas une ligne complète. Même si vous ne connaissez que quelques valeurs de colonnes, une ligne complète doit être créée.
+
+L’insertion de données dans une table s’effectue à l’aide de la commande **insert into**. Cette commande permet au choix d’inclure une seule ligne dans la table existante ou plusieurs lignes en une seule commande.
+
+Insertion d’une ligne à la fois
+Pour insérer des données dans une base, il y a 2 syntaxes principales :
+
+- Insérer une ligne en indiquant les informations pour chaque colonne existante (en respectant l’ordre)
+- Insérer une ligne en spécifiant les colonnes que vous souhaiter compléter. Il est possible d’insérer une ligne renseignant seulement une partie des colonnes
+
+Vous pouvez insérer plusieurs lignes dans une seule commande :
+
+```sql
+insert into produits (produit_no, nom, prix) values
+    (1, 'Cheese', 9.99),
+    (2, 'Bread', 1.99),
+    (3, 'Milk', 2.99);
+```
+
+## Supprimer des données
+
+La commande **delete** en SQL permet de supprimer des lignes dans une table. En utilisant cette commande associé à **where** il est possible de sélectionner les lignes concernées qui seront supprimées.
+
+Attention
+Avant d’essayer de supprimer des lignes, il est recommandé d’effectuer une sauvegarde de la base de données, ou tout du moins de la table concernée par la suppression. Ainsi, s’il y a une mauvaise manipulation il est toujours possible de restaurer les données.
+
+## Modifier des données
+
+La commande UPDATE en SQL permet de modifier des données existantes dans une table. Elle est utilisée pour mettre à jour une ou plusieurs lignes d'une table en modifiant les valeurs de colonnes spécifiques, selon des conditions données.
+
+```sql
+UPDATE nom_table
+SET colonne1 = nouvelle_valeur1, colonne2 = nouvelle_valeur2, ...
+WHERE condition;
+```
+
+Il est toujours recommandé d’utiliser une condition WHERE appropriée pour éviter des modifications involontaires.

sql.dql.md

@@ -0,0 +1,115 @@
+# Langage de requête de données
+
+DQL pour Data Query Language est le sous-langage responsable de la lecture, ou de l'interrogation, des données d'une base de données.
+
+En SQL, cela correspond principalment à la commande **select** qui permet de sélectionner et d'extraire des données spécifiques à partir d'une ou plusieurs tables.
+
+La dénomination de ce type de commande est _requête_ ou _query_ en anglais
+
+## Source
+
+Dans une commande **select** il convient de définir les colonnes que l'on veut obtenir ainsi que la source des données définie par le mot clé `from`
+
+```sql
+select FirstName, LastName, City from customers;
+```
+
+Pour sélectionner toutes les colonnes il faut utiliser le caractère joker *.
+
+## Filtre
+
+La clause `where` permet de spécifier une condition qui doit être satisfaite pour qu'une ligne soit incluse dans le résultat de la requête.
+
+```sql
+select FirstName, LastName, City
+from customers
+where Country = 'France';
+```
+
+FirstName|LastName |City
+---------|---------|---
+Camille  |Bernard  |Paris
+Dominique|Lefebvre |Paris
+Marc     |Dubois   |Lyon
+Wyatt    |Girard   |Bordeaux
+Isabelle |Mercier  |Dijon
+
+### Opérateurs
+
+Opérateur|Description
+---|---
+=|égal
+<>|différent
+>|supérieur
+>=|supérieur ou égal
+<|inférieur
+<=|inférieur ou égal
+
+#### between
+
+Détermine si une valeur se trouve entre deux limites inclusives. `between` peut être précédé du mot clé `not` pour inverser la condition.
+
+```sql
+where total between 10.0 and 20.0
+```
+
+between [lowerbound] and [upperbound]
+
+#### in
+
+détermine si une valeur est présente dans un ensemble de valeurs.
+
+```sql
+"costs"."unit_cost" in (200, 600, 'a')
+```
+
+#### like
+
+détermine si une valeur correspond à tout ou partie d'une chaîne. souvent utilisé avec caractères génériques pour indiquer toute correspondance de chaîne de caractères avec zéro ou plusieurs caractères (%) ou une correspondance à caractère unique (_).
+
+```sql
+"products"."prod_name" like 'prod%'
+```
+### Conditions multiples
+
+Les conditions peuvent être combinées avec des opérateurs booléen AND et OR.
+
+## Tri
+
+La commande ORDER BY dans une requête SELECT en SQL est utilisée pour trier les résultats retournés par la requête en fonction d'une ou plusieurs colonnes.
+
+```sql
+SELECT nom, prenom, age
+FROM utilisateurs
+ORDER BY age DESC, nom ASC;
+```
+
+## Pagination
+
+Si un nombre limite est donné, pas plus de ce nombre de lignes sera renvoyé (mais peut-être moins, si la requête elle-même génère moins de lignes). LIMIT ALL revient à omettre la clause LIMIT, tout comme LIMIT avec un argument NULL.
+
+OFFSET dit de sauter autant de lignes avant de commencer à renvoyer des lignes. OFFSET 0 revient à omettre la clause OFFSET, tout comme OFFSET avec un argument NULL.
+
+Si OFFSET et LIMIT apparaissent, les lignes OFFSET sont ignorées avant de commencer à compter les lignes LIMIT renvoyées.
+
+Lors de l'utilisation de LIMIT, il est important d'utiliser une clause ORDER BY qui contraint les lignes de résultats dans un ordre unique. Sinon, vous obtiendrez un sous-ensemble imprévisible des lignes de la requête. Vous demandez peut-être les lignes du dixième au vingtième, mais du dixième au vingtième dans quel ordre ? L'ordre est inconnu, sauf si vous avez spécifié ORDER BY.
+
+L'optimiseur de requêtes prend en compte LIMIT lors de la génération des plans de requête, vous obtiendrez donc très probablement différents plans (générant différents ordres de lignes) en fonction de ce que vous donnez pour LIMIT et OFFSET. Ainsi, l'utilisation de différentes valeurs LIMIT/OFFSET pour sélectionner différents sous-ensembles d'un résultat de requête donnera des résultats incohérents à moins que vous n'appliquiez un classement prévisible des résultats avec ORDER BY. Ce n'est pas un bug; c'est une conséquence inhérente du fait que SQL ne promet pas de fournir les résultats d'une requête dans un ordre particulier à moins que ORDER BY ne soit utilisé pour contraindre l'ordre.
+
+Les lignes ignorées par une clause OFFSET doivent toujours être calculées à l'intérieur du serveur ; par conséquent, un OFFSET important pourrait être inefficace.
+
+## Agrégation
+
+[Agrégation](../agrégation)
+
+
+
+## Regoupement
+
+Les fonctions d'agrégation deviennent particulièrement puissantes lorsqu'elles sont utilisées avec GROUP BY, qui regroupe les lignes partageant une valeur commune dans une ou plusieurs colonnes avant d'appliquer l'agrégation.
+
+```sql
+SELECT departement, AVG(salaire)
+FROM employes
+GROUP BY departement;
+```

sql.md

@@ -0,0 +1,17 @@
+---
+title: Structured Query Language
+---
+
+SQL, acronyme de Structured Query Language (Langage de Requête Structuré), est un langage de programmation spécialement conçu pour la gestion des bases de données relationnelles. Il permet de manipuler, interroger et gérer les données stockées dans une base de données de manière structurée et cohérente.
+
+SQL est largement utilisé dans le domaine des bases de données et joue un rôle essentiel dans le développement et la gestion de systèmes de gestion de bases de données relationnelles (SGBDR).
+
+Tous les SGBDR implément le langage SQL mais chacun l'a agrémenté d'extensions et de modifications non standard pour se démarquer des concurents.
+
+Le langage SQL est décomposé en 4 sous ensembles de commandes
+
+- [DATA DEFINITION LANGAGE](ddl) (DDL)
+- [DATA QUERY LANGAGE](dql) (DQL)
+- [DATA MANIPULATION LANGAGE](dml) (DML)
+- [DATA CONTROL LANGAGE](dcl) (DCL)
+- [TRANSACTION CONTROL LANGAGE](tcl) (TCL)

sql.tcl.md

@@ -0,0 +1,29 @@
+# Transaction Control Language
+
+Le TCL (Transaction Control Language) est utilisé pour gérer les transactions dans la base de données. Les transactions sont un ensemble d'instructions SQL qui sont exécutées comme une seule unité logique. Si une partie de la transaction échoue, tout l'ensemble peut être annulé pour garantir l'intégrité des données.
+
+Les commandes principales de TCL sont :
+
+- BEGIN TRANSACTION : Démarre une transaction.
+- COMMIT : Valide la transaction, enregistrant toutes les modifications apportées.
+- ROLLBACK : Annule la transaction, rétablissant la base de données à son état précédent, avant la transaction.
+
+### SAVEPOINTS
+
+La commande SAVEPOINT dans le langage SQL (et plus spécifiquement dans SQLite) est utilisée pour marquer un point intermédiaire au sein d'une transaction en cours. Cela permet de créer des points de contrôle où l'on peut revenir en cas d'erreur, sans avoir à annuler toute la transaction. C'est très utile pour gérer les transactions complexes où plusieurs étapes doivent être validées ou annulées séparément.
+
+Les SAVEPOINTS permettent de diviser une transaction en plusieurs étapes plus petites et réversibles. Si une partie d'une transaction échoue, on peut annuler uniquement cette partie sans avoir à revenir en arrière sur l'ensemble de la transaction. Cela est particulièrement utile dans des scénarios complexes où des sous-opérations doivent être validées ou annulées de manière indépendante.
+
+- SAVEPOINT savepoint_name : Crée un point de sauvegarde avec un nom spécifique.
+- ROLLBACK TO savepoint_name : Annule toutes les modifications effectuées après le point de sauvegarde désigné, mais ne termine pas la transaction complète.
+- RELEASE savepoint_name : Supprime le point de sauvegarde et valide toutes les modifications effectuées depuis ce point.
+
+#### RELEASE
+
+La commande RELEASE permet de libérer un point de sauvegarde une fois que vous êtes sûr que vous n'avez plus besoin de revenir à ce point. Quand vous libérez un SAVEPOINT, les modifications effectuées depuis ce point sont confirmées, mais la transaction reste ouverte jusqu'à ce qu'un COMMIT soit exécuté. Si vous n'utilisez pas RELEASE, un ROLLBACK complet de la transaction pourra toujours revenir à ce point de sauvegarde.
+
+##### Différence entre ROLLBACK et ROLLBACK TO SAVEPOINT
+
+ROLLBACK : Si vous utilisez cette commande sans spécifier de SAVEPOINT, elle annule toute la transaction depuis le début.
+
+ROLLBACK TO SAVEPOINT : Permet d'annuler les changements seulement jusqu'au point de sauvegarde désigné, en maintenant les modifications précédentes intactes. Cela est particulièrement utile pour éviter de refaire complètement une transaction complexe.