diff --git a/source/dev-vitis/bdd/generic.md b/source/dev-vitis/bdd/generic.md
index 35a915b5922a3c47926992b52b6a888d916ebd84..fcc886cc960f1eaf248aafb17ef62fa8d993f9e8 100644
--- a/source/dev-vitis/bdd/generic.md
+++ b/source/dev-vitis/bdd/generic.md
@@ -1,3 +1,15 @@
+# Un éléphant qui trompe énormément
+
+Postgresql, PgAdmin, PgModeler, Postgis, qui fait quoi dans la meute ?
+
+**Postgresql** est un systéme de base de donnée relationnel, c'est à dire que c'est une application distribuable sur différents OS qui permet de gérer des bases de données. Il existe plein d'autres technologies similaire comme sqlite, Oracle, MySql, AWS Aurora, ...
+
+**PgAdmin** est un outil qui permet de simplifier la consultation et l'administration de vos bases postgres, ainsi que de consulter des statistiques d'utilisation facilement. C'est un otil similaire à sqlDeveloper pour Oracle, ou Dbeaver
+
+**PgModeler** est un outil de conception graphique de base de données, il permet de modéliser facilement, vos tabes, vues ... et de visualiser facilement les relations entre les entités.
+
+**Postgis** est une extension pour le moteur Postgresql qui permet la gestion de données spatiales. C'est actuellement l'extension la plus performante et complète sur les outils disponibles. Il existe des équivalences pour d'autres SGBD, comme le spatialite pour sqlite ou l'oracle Spatial.
+
 # Concepts de base des bases de données
 
 ## Qu'est-ce qu'une base de données ?
@@ -8,7 +20,17 @@ Cependant, avec l'émergence de nouvelles exigences en termes de volume de donn
 
 Le choix entre une base de données relationnelle et une base de données NoSQL dépend des besoins spécifiques de votre application. Les bases de données relationnelles sont idéales pour les applications nécessitant une structure de données rigide et une intégrité transactionnelle, comme les systèmes de gestion d'entreprise. Les bases de données NoSQL conviennent davantage aux applications nécessitant une évolutivité horizontale, une flexibilité de schéma et une gestion de données non structurées, comme les applications Web en temps réel et les plateformes d'analyse de Big Data.
 
-## Pourquoi utiliser PostgreSQL ?
+## Qu'est ce qu'un SGBD ? 
+
+Un SGBD (Système de Gestion de Base de Données) est un logiciel conçu pour gérer, stocker, organiser et manipuler de manière efficace les données dans une base de données. Il fournit une interface entre les utilisateurs et les données, permettant la création, la modification, la consultation et la suppression des données de manière sécurisée et structurée.
+
+Un SGBD offre un ensemble de fonctionnalités qui permettent de gérer les données de manière efficace. Il permet la création de schémas pour définir la structure des données, la définition de contraintes pour garantir l'intégrité des données, la manipulation des données à travers des requêtes et des opérations, et la gestion des droits d'accès pour contrôler la sécurité des données.
+
+Les SGBD prennent en charge différents modèles de données, tels que les modèles relationnels, les modèles hiérarchiques, les modèles réseau et les modèles orientés objet. Ils utilisent des langages de requête, tels que SQL (Structured Query Language), pour interagir avec les données et effectuer des opérations de recherche, d'insertion, de mise à jour et de suppression.
+
+Les SGBD offrent également des mécanismes de gestion de la concurrence et de récupération en cas de pannes, garantissant la fiabilité et la disponibilité des données. Ils peuvent prendre en charge des fonctionnalités avancées telles que la réplication, la sauvegarde et la restauration, la gestion des transactions, les index pour l'optimisation des performances, et bien plus encore.
+
+## Pourquoi utiliser PostgreSQL ?
 
 PostgreSQL est un système de gestion de base de données relationnelle open source qui offre de nombreux avantages par rapport à d'autres technologies relationnelles. L'un des points forts de PostgreSQL réside dans la diversité dans ses extensions, qui étend ses fonctionnalités pour prendre en charge les données géospatiales notamment.
 
@@ -22,6 +44,16 @@ Enfin, PostgreSQL bénéficie d'une communauté active et engagée. La communaut
 
 Dans l'ensemble, PostgreSQL se distingue par sa polyvalence, sa fiabilité, ses fonctionnalités avancées et son support géospatial avec PostGIS. Ces avantages font de PostgreSQL un choix solide pour les applications nécessitant une gestion de données relationnelle robuste et une prise en charge des données géographiques.
 
+## Utilisation des SGBD par Veremes
+
+Toutes nos applications reposent sur un socle postgres, associé au extension Postgis et PgCrypto à l'instant cette documentation est écrite.
+
+Vitis peut exploiter des bases Oracle pour renseigner des sources de données pour les listes déroulantes.
+
+Dans le cas de GTF, une base sqlite est également exploitée dans certains cas.
+
+FME permet de manipuler la quasi totalité des différent SGBDR ou noSQL.
+
 ## Terminologie courante
 
 - Table : Une table est une structure fondamentale dans une base de données relationnelle. Elle est composée de lignes et de colonnes et représente une entité ou un concept spécifique. Par exemple, une table "Utilisateurs" peut contenir des informations telles que les noms, les adresses e-mail et les identifiants des utilisateurs.
@@ -54,47 +86,99 @@ Dans l'ensemble, PostgreSQL se distingue par sa polyvalence, sa fiabilité, ses
 
 # Conception d'une base de données
 
-## Étapes de la conception
+Les étapes de conception du modèle de données comprennent l'identification des entités et de leurs attributs, la définition des relations, la normalisation, l'ajout de contraintes d'intégrité et la création du schéma physique. Une conception soigneuse du modèle de données est essentielle pour garantir une base de données bien structurée, cohérente et performante.
 
-La conception du modèle de données consiste en plusieurs étapes essentielles qui permettent de définir la structure, les relations et les contraintes de la base de données. La première étape est l'identification des entités clés et de leurs attributs. Une entité représente un objet ou un concept dans le monde réel, tandis que ses attributs décrivent les caractéristiques de cette entité. Par exemple, un client nous contacte pour réaliser une application de gestion de patrimoine, il faut lister les objet qui liste ce patrimoine, puis comprendre les relation entre les objets ...
+## Identification des entité et des relations
 
-Une fois les entités et leurs attributs identifiés, la prochaine étape est de définir les relations entre les entités. Les relations sont des associations entre les entités qui reflètent les dépendances et les liens logiques. Il existe différents types de relations, tels que les relations un-à-un (OneToOne, 1-1), un-à-plusieurs (OneToMany, 1-n) et plusieurs-à-plusieurs (ManyToMany, n-n). Par exemple, une relation 1-n peut exister entre les clients et les commandes, où un client peut passer plusieurs commandes.
+Le but de cette étape est d'identifié les différents objets nécessaire pour l'application, les différents attributs de chaque entités. Dans un second temps il faut identifier les relations qui lient chaques entités.
 
-A ce stade là on peut commencer à passer d'une représentation UML grossière, un modèle plus concret sous pgModeler.
+Le plus souvent cette étape se fait via l'analyse de documents produit par le client ou en discutant avec ce-dernier.
 
-Après avoir défini les entités et les relations, la troisième étape est de normaliser le modèle de données. La normalisation est un processus qui vise à éliminer les redondances et à garantir l'intégrité des données en les structurant de manière optimale. Cela implique de diviser les entités en tables distinctes, d'identifier les clés primaires et étrangères, et de s'assurer que les dépendances fonctionnelles entre les attributs sont correctement gérées.
+Une fois tous ces élément identifier, le plus simple reste de faire une première modélisation sommaire de ces objets via un diagramme UML par exemple, pour représenter les premières relations. Ce qui va permettre de commencer à discuter avec le reste de l'équipe et le client afin de confronter les différent point de vue et améliorer le modèle afin de répondre au plus proche au problème du client.
+Il est important de réprésenter les cardinalités sur ce diagramme ce qui simplifie les échanges et va simplifier les prochaines étape de conception.
 
-Une fois le modèle de données normalisé, la quatrième étape consiste à ajouter des contraintes d'intégrité pour garantir la cohérence et la validité des données. Les contraintes peuvent inclure des règles telles que les valeurs uniques, les valeurs obligatoires, les contraintes de plage et les contraintes de référence. Par exemple, une contrainte de clé primaire garantit que chaque enregistrement dans une table est unique et identifiable, tandis qu'une contrainte de clé étrangère assure l'intégrité des relations entre les tables.
+## Normalisation des données
+
+A ce stade on peut commencer à abstraire le modèle pour améliorer les performances, ou le volume occupé par la base finale. Le but principal est d'éliminer les redondances tout en conservant une cohérence sur le modéle de donnée.
+
+Les structures de base correspondantes aux cardinalités vont pouvoir se mettre en place sur le modèle.
 
-A ce moment là on peut commencer à développer, pour construire les vues en fonction des besoin de l'application.
+A ce stade un outil de modélisation comme pgModeler, Visual Paradigm, ... est préférable car le modèle va s'approcher de plus en plus de sa version finale
 
-Enfin, la dernière étape de la conception du modèle de données est la création du schéma physique. Le schéma physique définit la manière dont le modèle de données est implémenté dans un système de gestion de base de données spécifique. Cela implique de définir les types de données, les index, les vues et les autres structures nécessaires pour stocker et manipuler les données de manière efficace.
+Il y a quelques principe de base au niveau de la normalisation, ces principes ne sont pas des règles universelles. Il est possible de les adapter ou même de les ignorer dans certains cas.
 
-En résumé, les étapes de conception du modèle de données comprennent l'identification des entités et de leurs attributs, la définition des relations, la normalisation, l'ajout de contraintes d'intégrité et la création du schéma physique. Une conception soigneuse du modèle de données est essentielle pour garantir une base de données bien structurée, cohérente et performante.
+- Première forme normale (1NF) : La première forme normale exige que les valeurs d'un attribut soient atomiques, c'est-à-dire qu'elles ne puissent pas être divisées en parties plus petites. De plus, chaque attribut doit être unique, sans répétitions, et chaque entité doit avoir une clé primaire unique pour l'identifier de manière univoque. Le but de cette phase et de s'assurer de la non redondances des attributs et de s'assurer que chaque entité est clairement identifiable par une clé primaire unique.
 
-A aucun moment je ne parle de gestion de droit dans ces étapes, mais c'est clairement un point critique de la phase de conception. Il est primordiale d'ouvrir les droit au fur et à mesure du développement, en ouvrant au minimum les accés aux différents rolegroupe.
+- Deuxième forme normale (2NF) : La deuxième forme normale s'applique lorsque le modèle est en 1NF et exige que chaque attribut non clé dépende complètement de la clé primaire. Cela signifie que chaque attribut doit être directement lié à la clé primaire et ne pas dépendre d'autres attributs non clés.
 
+- Troisième forme normale (3NF) : La troisième forme normale s'applique lorsque le modèle est en 2NF et exige que chaque attribut non clé ne dépende que de la clé primaire et pas des autres attributs non clés. Cela permet d'éliminer les dépendances transitives entre les attributs non clés.
+
+- Forme normale de Boyce-Codd (BCNF) : La forme normale de Boyce-Codd est une extension de la 3NF qui vise à éliminer les dépendances fonctionnelles non triviales. Elle exige que chaque dépendance fonctionnelle entre les attributs non clés et la clé primaire soit une dépendance complète, c'est-à-dire que la clé primaire soit nécessaire pour déterminer tous les attributs non clés. A ce stade les cardinalité sont clairement représentées par des tables ou des attributs dans le entités.
+
+- Quatrième forme normale (4NF) : La quatrième forme normale s'applique lorsque le modèle est en BCNF et vise à éliminer les dépendances multivaluées. Elle exige que les dépendances multivaluées soient séparées en entités distinctes. On normalise les valeurs d'attribut redondantes dans des tables de référence de façon à améliorer la maintenabilité de la base de donnée.
+
+![noramlisation cardinalité](./images/cardinalite_vitis.png)
+
+## Structuration du modèle
+
+Une fois le modèle de données normalisé, la quatrième étape consiste à ajouter des contraintes d'intégrité pour garantir la cohérence et la validité des données. Les contraintes peuvent inclure des règles telles que les valeurs uniques, les valeurs obligatoires, les contraintes de plage et les contraintes de référence. Par exemple, une contrainte de clé primaire garantit que chaque enregistrement dans une table est unique et identifiable, tandis qu'une contrainte de clé étrangère assure l'intégrité des relations entre les tables.
+
+## Mise en place du modèle
+
+Cette dernière étape consiste à déployer une première version de la base afin de pouvoir commencer à développer dessus.
+
+La phase finale permettra de valider le fonctionnement de la base, de mettre en place les vues, régles, indexs, triggers et autres structures nécessaires pour stocker et manipuler les données de manière efficace. La mise en place des droits postgres se fera aussi à ce moment là en respectant le principe de moindre privilège.
+
+Dans notre cas, on génère un script SQL qui sera versionné dans un fichier XML découpé par version.
 
 ## Spécificité de Vitis par rapport à la modélisation des données
 
-Utilisation de colonnes de type timestamp with timezone pour stocker les dates.
+Utilisation de colonnes de type timestamp with timezone pour stocker les dates. Cette contrainte est lié à la fonctionnalité de gestion des fuseaux horraire coté client. En plus Le fait d'avoir un maximum de précision sur ce genre de champ n'augmente pas la compléxité ni le volume utilisé pour stocker la donnée.
 
-Favoriser les colonnes de type jsonb au type json classique.
+Utiliser le type jsonb à la place du type json classique, le jsonb facilite certaines fonctions des requêtes SQL classiques.
+
+Tous les objets défini dans le modèle devront appartenir à l'utilisateur u_vitis (spécificité lié au fonctionnement des RDS sur AWS).
+
+## Gestion des droits
+
+La gestion des droits peut se réveler trés complexe dans vos bases postgres. A savoir que des drtois bien géré sur une base de données est surement le meilleurs moyen de résister aux différentes attaques au niveau de l'application.
+
+Pour se faire il faut respecter [le principe du moindre privilèges](https://fr.wikipedia.org/wiki/Principe_de_moindre_privil%C3%A8ge) qui s'applique habituellement à la gestion des OS mais qui dans le contexte d'une base de données Postgres est tout aussi valable.
+
+La base de donnée sera la première couche du développement de vos applications et une gestion de droit bien faite dès cette première couche, fera que la gestion au niveau de vos autres couches découlera de manière naturelle. Autrement dit vous casser la tête sur ce point à ce moment là c'est vous éviter des failles et vous simplifier le travail pour la suite.
+
+![webapp stack dev](./images/webapp-stack-dev.png)
+
+Comme vous le savez tous, les droits sur la base sont géré via les rolegroupes postgres (ou privilèges Vitis), privilèges que vous retrouvez pour gérer la sécurité sur l'API ou gérer l'affichage au niveau du client.
+
+Il y a globalement quelques truc à savoir pour bien faire les choses.
+
+### Spécifités des vues et des règles
+
+Dans une base de données PostgreSQL, lorsque vous utilisez une vue, vous n'avez pas besoin d'avoir directement les droits sur la table sous-jacente à la vue pour accéder aux données via cette vue. Cela est dû à la façon dont les vues sont gérées par PostgreSQL.
+
+Une vue est une représentation virtuelle d'une ou plusieurs tables dans la base de données. Elle agit comme une couche d'abstraction qui masque la structure et les détails des tables sous-jacentes, offrant une interface simplifiée pour les utilisateurs. Lorsque vous créez une vue, vous pouvez spécifier les colonnes que vous souhaitez inclure et appliquer des conditions ou des jointures pour filtrer les données.
+
+Lorsqu'un utilisateur accède à une vue, PostgreSQL vérifie les droits de l'utilisateur sur la vue elle-même, et non sur les tables sous-jacentes. Cela signifie que si vous avez les droits nécessaires pour accéder à la vue, vous pourrez récupérer les données de la vue, même si vous n'avez pas directement les droits sur les tables concernées.
+
+Cependant, il est important de noter que les droits d'accès à la vue doivent être configurés correctement pour garantir la sécurité des données. Si un utilisateur a accès à une vue qui renvoie des données à partir d'une table, mais n'a pas les droits sur cette table, il ne pourra pas effectuer d'opérations de modification sur la vue. Les modifications doivent être effectuées directement sur les tables sous-jacentes, en respectant les droits d'accès appropriés.
+
+Lorsqu'il s'agit d'effectuer des opérations d'insertion, de mise à jour (update) ou de suppression (delete) dans une base de données PostgreSQL, il est important de prendre en compte les règles et les contraintes définies pour maintenir l'intégrité et la cohérence des données. Voici une explication des règles générales :
+
+Insertion (INSERT) : Lors de l'insertion de nouvelles données dans une table, les règles et les contraintes s'appliquent pour garantir que les données ajoutées sont conformes aux spécifications du schéma de la base de données. Cela comprend la vérification des clés primaires, des contraintes d'unicité, des contraintes de référence, etc. Si une violation de règle ou de contrainte se produit lors de l'insertion, l'opération sera rejetée et une erreur sera renvoyée.
+
+Mise à jour (UPDATE) : Lors de la mise à jour des données existantes dans une table, les règles et les contraintes veillent à ce que les modifications apportées maintiennent l'intégrité des données. Par exemple, les contraintes de clé étrangère peuvent vérifier si les modifications respectent les références entre tables. Si une mise à jour viole une règle ou une contrainte, l'opération sera rejetée et une erreur sera renvoyée.
+
+Suppression (DELETE) : Lors de la suppression de données d'une table, les règles et les contraintes garantissent que les opérations de suppression sont cohérentes avec les dépendances et les références dans la base de données. Par exemple, si une ligne est supprimée d'une table référencée par une clé étrangère dans une autre table, les contraintes de référence peuvent spécifier l'action à prendre, telle que la suppression en cascade des enregistrements correspondants dans la table référencée. Si une suppression viole une règle ou une contrainte, l'opération sera rejetée et une erreur sera renvoyée.
+
+En plus des règles et des contraintes, les opérations d'insertion, de mise à jour et de suppression peuvent également être soumises à des vérifications de sécurité, telles que les permissions d'accès des utilisateurs et les rôles définis dans la base de données. Les utilisateurs doivent disposer des autorisations appropriées pour exécuter ces opérations sur les tables concernées.
+
+Autre intéret à connaitre si une ligne n'est pas récupérable via le SELECT d'une vue pour un utilisateur, alors cet utilisateur ne pourra pas réaliser de modification/suppression sur ces lignes via des les règles de cette vue. Ce qui est un moyen simple d'améliorer la sécurité de vos applications.
+
+Pour résumer en passant par les vues vous n'avez à gérer les droits que sur les vue, l'utilisateur n'a pas besoin d'accéder aux tables, en revanche si une séquence est utilisé pour une valeur par défaut, alors il faut que l'utilisateur puisse y accéder.
+C'est une spécificité du SGBD de postgres.
 
-## Normalisation des données
 
-III. Manipulation des données
-   A. Langage de requête structuré (SQL)
-      1. Syntaxe de base
-      2. Sélection de données (SELECT)
-      3. Insertion, mise à jour et suppression de données (INSERT, UPDATE, DELETE)
-      4. Jointures de tables
-   B. Requêtes avancées
-      1. Agrégation de données
-      2. Sous-requêtes
-      3. Opérations sur ensembles (UNION, INTERSECT, EXCEPT)
-   C. Indexation des données
-   D. Transactions et contrôle de la concurrence
 
 IV. Gestion de la base de données
    A. Création de la base de données
diff --git a/source/dev-vitis/bdd/images/carinalite_vitis.png b/source/dev-vitis/bdd/images/cardinalite_vitis.png
similarity index 100%
rename from source/dev-vitis/bdd/images/carinalite_vitis.png
rename to source/dev-vitis/bdd/images/cardinalite_vitis.png
diff --git a/source/dev-vitis/bdd/images/join_type.png b/source/dev-vitis/bdd/images/join_type.png
new file mode 100644
index 0000000000000000000000000000000000000000..5c9350f14c33512e79cea59813efc8364186a60d
Binary files /dev/null and b/source/dev-vitis/bdd/images/join_type.png differ
diff --git a/source/dev-vitis/bdd/images/webapp-stack-dev.png b/source/dev-vitis/bdd/images/webapp-stack-dev.png
new file mode 100644
index 0000000000000000000000000000000000000000..f4714577e55d0242afca58836468ac25e53f682a
Binary files /dev/null and b/source/dev-vitis/bdd/images/webapp-stack-dev.png differ
diff --git a/source/dev-vitis/bdd/sql.md b/source/dev-vitis/bdd/sql.md
new file mode 100644
index 0000000000000000000000000000000000000000..8c60309b413e85fd92ca699c8df67e9e72d73cd0
--- /dev/null
+++ b/source/dev-vitis/bdd/sql.md
@@ -0,0 +1,245 @@
+# Manipulation des données
+
+## Langage de requête structuré (SQL)
+
+### Syntaxe de base
+
+SQL est un langage standardisé utilisé pour communiquer avec les bases de données relationnelles. Il comprend différents types de commandes qui permettent de manipuler les données et de gérer la structure de la base de données. La syntaxe de base SQL se compose principalement des commandes suivantes :
+
+- La commande SELECT est utilisée pour récupérer des données à partir d'une ou plusieurs tables. Elle permet de spécifier les colonnes à sélectionner, les tables à interroger et les critères de recherche pour filtrer les résultats.
+
+```sql
+SELECT * FROM schema.table;
+SELECT chp1, chp2 FROM schema.table;
+SELECT * FROM schema.table WHERE ma_condition = TRUE;
+```
+
+- La commande INSERT est utilisée pour insérer de nouvelles lignes de données dans une table spécifiée. Elle permet de spécifier les valeurs à insérer pour chaque colonne ou de récupérer les valeurs à partir d'une autre table ou d'une requête SELECT.
+
+```sql
+INSERT INTO schema.table (chp1, chp2) VALUES (chp1 chp2);
+INSERT INTO schema.table (chp1, chp2) VALUES (chp1 chp2) RETURNING *;
+INSERT INTO schema.table (chp1, chp2) SELECT chp1, chp2 FROM schema.table2 WHERE ma_condition;
+```
+
+- La commande UPDATE est utilisée pour modifier les données existantes dans une table. Elle permet de spécifier les colonnes à mettre à jour, les nouvelles valeurs à assigner et les critères de recherche pour identifier les lignes à modifier.
+
+```sql
+UPDATE schema.tabe SET chp1='val1' WHERE ma_condition = TRUE;
+UPDATE schema.tabe SET chp1='val1' WHERE ma_condition = TRUE RETURNING *;
+```
+
+- Les commandes DELETE et TRUNCATE sont utilisées pour supprimer des lignes de données d'une table spécifiée. Elle permet de spécifier les critères de recherche pour identifier les lignes à supprimer. Contrairement à la commande DELETE, qui supprime les lignes une par une et peut être ralentie pour de grandes quantités de données, la commande TRUNCATE permet de vider rapidement une table en supprimant toutes les données d'un coup. Elle réinitialise également les valeurs des index et des séquences associées à la table.
+
+```sql
+DELETE FROM schema.table WHERE ma_condition;
+TRUNCATE TABLE schema.table WHERE ma_condition;
+```
+
+- La commande CREATE est utilisée pour créer de nouvelles tables, vues, index ou autres structures dans la base de données. Elle permet de spécifier les noms, les types de données et les contraintes pour chaque colonne, ainsi que d'autres options de configuration.
+
+- La commande ALTER est utilisée pour modifier la structure d'une table existante. Elle permet d'ajouter, de supprimer ou de modifier des colonnes, des contraintes, des index ou d'autres éléments de la table.
+
+- La commande DROP est utilisée pour supprimer des tables, des vues, des index ou d'autres structures de la base de données.
+
+En plus de ces commandes de base, SQL offre également des fonctionnalités avancées, telles que les clauses JOIN pour combiner des données de plusieurs tables, les fonctions d'agrégation pour effectuer des calculs sur les données, les clauses GROUP BY pour regrouper les résultats, et bien d'autres.
+
+Chaque SGBD embarque sont interpréteur de requête SQL plus ou moins fidèle au standard.
+
+
+### Clause Where et jointure
+
+Les conditions utilisables dans les clause where et dans dans les jointures doivent retourner un booléen pour fonctionner.
+
+La clause WHERE est couramment utilisée dans les requêtes SQL pour filtrer les résultats en fonction de certaines conditions spécifiées. Elle permet de restreindre les données renvoyées par une requête en utilisant des conditions logiques et des opérateurs de comparaison. Les conditions peuvent être basées sur les valeurs des colonnes, sur des expressions arithmétiques, sur des chaînes de caractères, ou sur d'autres critères.
+
+Les opérateurs de comparaison couramment utilisés dans les conditions WHERE sont les suivants :
+
+- L'opérateur d'égalité (=) permet de comparer si une valeur est égale à une autre.
+- Les opérateurs de comparaison (<, >, <=, >=) permettent de comparer si une valeur est inférieure, supérieure, inférieure ou égale, ou supérieure ou égale à une autre.
+- Les opérateurs d'inégalité (<>, !=) permettent de comparer si une valeur est différente d'une autre.
+- L'opérateur IN permet de vérifier si une valeur fait partie d'un ensemble de valeurs spécifié.
+- L'opérateur LIKE permet d'effectuer une correspondance partielle entre une valeur et un motif (pattern) spécifié à l'aide de caractères génériques (wildcards) tels que '%' et '_'.
+- L'opérateur BETWEEN permet de vérifier si une valeur se situe entre deux autres valeurs.
+
+En ce qui concerne les jointures, elles permettent de combiner des données provenant de plusieurs tables dans une seule requête. Les jointures sont généralement basées sur des relations entre les colonnes des tables, qui sont définies à l'aide de clés primaires et de clés étrangères. Les jointures les plus couramment utilisées sont les suivantes :
+
+- La jointure INNER JOIN (ou simplement JOIN) permet de récupérer les enregistrements qui ont des correspondances dans les deux tables liées.
+- La jointure LEFT JOIN (ou LEFT OUTER JOIN) permet de récupérer tous les enregistrements de la table de gauche (table de gauche dans la clause JOIN) et les enregistrements correspondants de la table de droite.
+- La jointure RIGHT JOIN (ou RIGHT OUTER JOIN) permet de récupérer tous les enregistrements de la table de droite et les enregistrements correspondants de la table de gauche.
+- La jointure FULL JOIN (ou FULL OUTER JOIN) permet de récupérer tous les enregistrements des deux tables, en incluant les enregistrements correspondants et non correspondants.
+
+Les jointures sont spécifiées dans la clause FROM d'une requête SQL, en utilisant les conditions de jointure appropriées pour relier les tables entre elles. Les conditions de jointure sont généralement basées sur des clés primaires et des clés étrangères, et peuvent être combinées avec des conditions WHERE pour affiner les résultats.
+
+![join type](./images/join_type.png)
+
+En utilisant les conditions dans la clause WHERE et les jointures, les requêtes SQL peuvent être formulées de manière précise pour récupérer les données souhaitées à partir d'une ou plusieurs tables, en tenant compte des critères de filtrage et des relations entre les données. Cela permet d'obtenir des résultats plus pertinents et cohérents lors de l'interrogation de la base de données.
+
+## Requêtes avancées
+
+### Agrégation
+
+L'agrégation de données est une fonctionnalité essentielle des requêtes SQL qui permet de regrouper et de calculer des valeurs agrégées à partir des données d'une table ou d'une requête. Elle permet d'obtenir des informations résumées et statistiques sur un ensemble de données, plutôt que sur des enregistrements individuels. Les fonctions d'agrégation les plus couramment utilisées incluent COUNT, SUM, AVG, MAX et MIN.
+
+Lorsque vous utilisez des fonctions d'agrégation, vous pouvez également combiner des clauses GROUP BY pour regrouper les résultats en fonction de certaines colonnes. Cela permet d'effectuer des calculs agrégés pour chaque groupe distinct. Par exemple, vous pouvez regrouper les ventes par catégorie de produits et calculer le montant total des ventes pour chaque catégorie.
+
+### Sous-requêtes
+
+Les sous-requêtes, également appelées requêtes imbriquées, sont une fonctionnalité puissante des requêtes SQL qui permettent d'utiliser une requête à l'intérieur d'une autre requête. Elles sont principalement utilisées pour effectuer des opérations complexes et des filtres avancés en se basant sur les résultats d'une requête interne.
+
+Une sous-requête peut être utilisée dans différentes parties d'une requête SQL, telles que la clause SELECT, la clause FROM, la clause WHERE ou la clause HAVING. Elle agit comme une requête distincte qui est exécutée en premier, puis les résultats de cette requête sont utilisés comme source de données ou de filtrage pour la requête externe.
+
+Les sous-requêtes peuvent être utilisées de différentes manières :
+
+Filtrage : Une sous-requête peut être utilisée dans la clause WHERE pour filtrer les résultats en fonction d'une condition spécifique. Par exemple, vous pouvez utiliser une sous-requête pour récupérer tous les clients qui ont effectué des achats supérieurs à une certaine valeur.
+
+Comparaison : Une sous-requête peut être utilisée pour comparer une valeur avec les résultats d'une autre requête. Par exemple, vous pouvez utiliser une sous-requête dans la clause WHERE pour vérifier si un employé a un salaire supérieur à la moyenne des salaires de l'entreprise.
+
+Valeur d'une colonne : Une sous-requête peut être utilisée pour récupérer une valeur spécifique à partir d'une autre table ou d'une autre requête. Par exemple, vous pouvez utiliser une sous-requête dans la clause SELECT pour obtenir le nombre total de commandes passées par chaque client.
+
+Il est important de noter que les sous-requêtes peuvent impacter les performances des requêtes, surtout si elles sont mal optimisées ou si elles retournent un grand nombre de résultats. Il est recommandé de bien comprendre les concepts de sous-requêtes et de les utiliser avec parcimonie et efficacité.
+
+Les sous-requêtes offrent une flexibilité et une puissance supplémentaires lors de l'écriture de requêtes SQL complexes. Elles permettent d'effectuer des opérations avancées en utilisant les résultats d'une requête interne, facilitant ainsi la manipulation et l'analyse de données dans une base de données.
+
+```sql
+SELECT Name
+FROM Customers
+WHERE CustomerID IN (
+    SELECT CustomerID
+    FROM Orders
+)
+```
+
+### Opérations sur ensembles
+
+Les opérations sur les ensembles sont une fonctionnalité importante des requêtes SQL qui permettent de manipuler des ensembles de résultats en combinant, comparant ou en effectuant des opérations logiques sur eux. Ces opérations sont généralement effectuées sur des ensembles de résultats obtenus à partir de requêtes distinctes.
+
+Les opérations sur les ensembles les plus couramment utilisées incluent l'union, l'intersection et la différence.
+
+L'opération UNION permet de combiner les résultats de deux requêtes distinctes en un seul ensemble de résultats. Elle élimine automatiquement les doublons et renvoie tous les enregistrements uniques.
+
+L'opération INTERSECT permet de trouver les enregistrements communs à deux ensembles de résultats distincts. Elle renvoie uniquement les enregistrements qui se trouvent à la fois dans le premier et le second ensemble.
+
+L'opération EXCEPT (ou MINUS dans certaines bases de données) permet de trouver les enregistrements qui se trouvent dans le premier ensemble mais qui ne sont pas présents dans le second ensemble. Elle renvoie uniquement les enregistrements du premier ensemble qui ne se trouvent pas dans le second ensemble.
+
+Ces opérations sur les ensembles peuvent être utilisées pour effectuer des tâches telles que la combinaison de résultats de requêtes, la recherche d'enregistrements communs ou la suppression de résultats indésirables.
+
+Il est important de noter que pour pouvoir effectuer ces opérations, les ensembles de résultats doivent avoir des structures de colonnes et des types de données compatibles. Les requêtes utilisées pour les opérations sur les ensembles doivent donc renvoyer des résultats avec des colonnes correspondantes.
+
+Les opérations sur les ensembles permettent d'effectuer des manipulations complexes sur les résultats des requêtes SQL, offrant ainsi une grande flexibilité dans la récupération et le traitement des données. Elles permettent de combiner, d'interagir et de comparer facilement différents ensembles de résultats, facilitant ainsi l'analyse et la manipulation de données dans une base de données.
+
+### Requêtes récursives
+
+Les requêtes récursives sont une fonctionnalité avancée des requêtes SQL qui permettent de réaliser des opérations itératives en se basant sur les résultats précédents d'une requête. Elles sont utilisées pour traiter des structures de données hiérarchiques ou pour effectuer des calculs récursifs.
+
+Une requête récursive se compose de deux parties distinctes : la partie de base et la partie récursive. La partie de base définit les résultats initiaux de la requête, tandis que la partie récursive utilise les résultats précédents pour calculer les résultats suivants.
+
+Le fonctionnement d'une requête récursive se fait en plusieurs étapes :
+
+- Définition de la partie de base : La partie de base de la requête est la première itération de la requête récursive. Elle est exécutée de manière similaire à une requête normale et renvoie les résultats initiaux.
+
+- Définition de la partie récursive : La partie récursive utilise les résultats précédents de la requête pour calculer les résultats suivants. Elle est basée sur une relation de récurrence définie par le développeur. Cette partie est exécutée répétitivement jusqu'à ce qu'une condition de terminaison soit satisfaite.
+
+- Combinaison des résultats : À chaque itération de la partie récursive, les nouveaux résultats sont combinés avec les résultats précédents pour former l'ensemble complet des résultats. Les résultats finaux sont renvoyés une fois que la condition de terminaison est atteinte.
+
+L'utilisation de requêtes récursives est courante pour manipuler des structures de données hiérarchiques telles que les arbres, les graphes ou les relations parent-enfant. Elles permettent de parcourir et de manipuler ces structures de manière itérative en utilisant les résultats précédents.
+
+Les requêtes récursives nécessitent une attention particulière lors de leur mise en œuvre, car une mauvaise utilisation peut entraîner des boucles infinies ou des performances médiocres. Il est important de définir une condition de terminaison appropriée pour éviter les boucles infinies et d'optimiser les requêtes récursives pour garantir des performances efficaces.
+
+En conclusion, les requêtes récursives offrent une fonctionnalité puissante pour effectuer des calculs itératifs ou manipuler des structures de données hiérarchiques. Elles permettent d'obtenir des résultats complexes en utilisant les résultats précédents d'une requête, offrant ainsi une flexibilité et une expressivité supplémentaires dans les requêtes SQL.
+
+```sql
+WITH RECURSIVE EmployeeHierarchy AS (
+    SELECT EmployeeID, Name, ManagerID, 0 AS Level
+    FROM Employees
+    WHERE EmployeeID = <ID_du_manager>
+
+    UNION ALL
+
+    SELECT E.EmployeeID, E.Name, E.ManagerID, EH.Level + 1
+    FROM Employees AS E
+    INNER JOIN EmployeeHierarchy AS EH ON E.ManagerID = EH.EmployeeID
+)
+SELECT EmployeeID, Name, Level
+FROM EmployeeHierarchy
+ORDER BY Level, EmployeeID;
+```
+
+### Opérateur de fenétrage
+
+L'opérateur de fenêtrage est une fonctionnalité avancée des requêtes SQL qui permet d'effectuer des calculs et des agrégations sur des ensembles de lignes définis par une fenêtre spécifique. Il permet d'appliquer des fonctions analytiques sur un groupe spécifique de lignes sans modifier la structure globale de la requête.
+
+L'opérateur de fenêtrage utilise la clause OVER suivie d'une clause de fenêtre pour définir les limites et les conditions de la fenêtre. Cette clause peut spécifier des critères de tri, des partitions et des clauses de délimitation pour définir la plage des lignes sur lesquelles les calculs seront effectués.
+
+Voici un exemple pour illustrer l'utilisation de l'opérateur de fenêtrage :
+
+Supposons que nous ayons une table "Sales" qui enregistre les ventes réalisées par différents vendeurs dans une entreprise, avec les colonnes "SalesID", "Salesperson", "Product", "Amount" et "Date". Nous voulons calculer la somme cumulative des ventes de chaque vendeur, triées par date de vente.
+
+```sql
+SELECT SalesID, Salesperson, Product, Amount, Date,
+       SUM(Amount) OVER (PARTITION BY Salesperson ORDER BY Date) AS CumulativeAmount
+FROM Sales
+```
+
+Dans cet exemple, nous utilisons l'opérateur de fenêtrage avec la fonction d'agrégation SUM pour calculer la somme cumulative des ventes (Amount) pour chaque vendeur (Salesperson), en les triant par date de vente (Date).
+
+La clause OVER spécifie la fenêtre de calcul, tandis que la clause PARTITION BY définit la partition des données par vendeur. Ainsi, la somme cumulative sera calculée séparément pour chaque vendeur.
+
+En utilisant cet opérateur de fenêtrage, la requête renverra les détails des ventes (SalesID, Salesperson, Product, Amount, Date) ainsi que la somme cumulative (CumulativeAmount) pour chaque vendeur, avec les résultats triés par date de vente.
+
+L'opérateur de fenêtrage est extrêmement utile pour effectuer des calculs analytiques avancés, tels que les sommes cumulatives, les moyennes mobiles, les rangs, les pourcentages, etc. Il permet de réaliser des analyses plus précises sur des ensembles de données spécifiques, sans avoir besoin de regrouper ou de modifier la structure de la requête principale.
+
+
+## Indexation des données
+
+L'indexation des données est une technique utilisée dans les bases de données pour améliorer les performances des requêtes, en particulier lors de l'exécution de requêtes SELECT. L'indexation consiste à créer des structures de données supplémentaires, appelées index, qui permettent un accès rapide et efficace aux données.
+
+Un index est essentiellement une copie partielle des données de la table, organisée de manière à faciliter la recherche et la récupération des enregistrements. Il peut être créé sur une ou plusieurs colonnes spécifiques de la table. Lorsqu'une requête SELECT est exécutée sur une table avec un index approprié, la base de données peut utiliser cet index pour localiser rapidement les enregistrements pertinents, plutôt que de parcourir l'ensemble de la table.
+
+L'impact de l'indexation sur une requête SELECT peut être significatif. Avec un index bien conçu, la recherche et le filtrage des données deviennent beaucoup plus rapides. Lorsqu'une condition de recherche correspond à une colonne indexée, la base de données peut utiliser l'index pour identifier rapidement les enregistrements qui satisfont la condition, réduisant ainsi le temps d'exécution de la requête.
+
+Cependant, il est important de noter que l'indexation peut également avoir des effets négatifs sur les performances. Les index occupent de l'espace de stockage supplémentaire, ce qui peut augmenter la taille de la base de données. De plus, les index doivent être maintenus et mis à jour chaque fois que des modifications sont apportées aux données, ce qui peut entraîner un léger impact sur les opérations d'insertion, de mise à jour et de suppression.
+
+Il est essentiel de concevoir et de gérer judicieusement les index pour obtenir un bon équilibre entre les avantages de performance et les coûts associés. Il est recommandé de créer des index sur les colonnes couramment utilisées dans les requêtes SELECT, en particulier celles qui sont souvent utilisées dans les clauses WHERE pour filtrer les enregistrements. Il est également important d'évaluer régulièrement les performances de la base de données et d'ajuster les index en conséquence pour maintenir une optimisation continue.
+
+En conclusion, l'indexation des données joue un rôle crucial dans l'amélioration des performances des requêtes SELECT. Elle permet d'accélérer la recherche et la récupération des données en utilisant des structures d'index optimisées. Cependant, il est important de bien concevoir et gérer les index pour éviter les impacts négatifs sur les opérations de modification des données et pour maintenir des performances optimales.
+
+PostgreSQL propose plusieurs méthodes d'indexation pour améliorer les performances des requêtes. Voici une description des principales méthodes d'indexation disponibles dans PostgreSQL :
+
+- Index B-tree : C'est la méthode d'indexation par défaut dans PostgreSQL. Les index B-tree sont efficaces pour les opérations de recherche et de tri. Ils fonctionnent bien avec des valeurs uniques ou peu répétées. Les index B-tree sont équilibrés et permettent des recherches rapides en utilisant des opérations de comparaison, telles que l'égalité ou l'inégalité.
+
+- Index Hash : Les index Hash utilisent une fonction de hachage pour stocker les valeurs d'index. Ils sont adaptés pour les recherches rapides sur des valeurs égalitaires, mais moins efficaces pour les opérations de tri ou de recherche basées sur des plages. Les index Hash fonctionnent bien lorsque les données sont uniformément réparties et que les valeurs d'index sont bien distribuées.
+
+- Index GiST (Generalized Search Tree) : Les index GiST sont polyvalents et peuvent être utilisés pour différents types de recherches, tels que les recherches basées sur des plages, les opérations de texte et les opérations spatiales. Ils permettent de créer des index personnalisés en implémentant des méthodes d'indexation spécifiques pour différents types de données.
+
+- Index GIN (Generalized Inverted Index) : Les index GIN sont utilisés pour les recherches en texte intégral et pour les opérations sur des tableaux ou des listes de valeurs. Ils sont efficaces pour les recherches de correspondance partielle, de recherche de mots-clés et d'opérations de recherche avancées.
+
+- Index BRIN (Block Range Index) : Les index BRIN sont conçus pour les tables volumineuses contenant des données ordonnées par ordre d'insertion. Ils permettent de réduire la taille de l'index en regroupant les blocs de données contigus et en conservant les informations de début et de fin pour chaque groupe de blocs. Les index BRIN sont utiles pour les requêtes d'agrégation ou les opérations de recherche basées sur des plages.
+
+Chaque méthode d'indexation a ses propres avantages et inconvénients, et la sélection de la méthode appropriée dépend du type de données, des opérations de requête fréquentes et des objectifs de performance spécifiques. PostgreSQL permet également de combiner différentes méthodes d'indexation pour optimiser les performances dans des scénarios plus complexes.
+
+## Transactions
+
+La gestion des transactions est un concept fondamental dans les systèmes de bases de données qui garantit l'intégrité et la cohérence des données. Une transaction représente une séquence d'opérations exécutées comme une unité indivisible, c'est-à-dire soit toutes les opérations sont exécutées avec succès et validées, soit aucune opération n'est exécutée du tout.
+
+Dans une base de données, une transaction est généralement définie par une combinaison d'opérations de lecture (SELECT) et d'opérations de modification (INSERT, UPDATE, DELETE). Les transactions permettent de regrouper ces opérations et d'assurer que l'ensemble des modifications apportées aux données est cohérent et durable.
+
+La gestion des transactions est basée sur le concept ACID, qui signifie Atomicité, Cohérence, Isolation et Durabilité :
+
+Atomicité : Une transaction est une unité atomique qui est exécutée dans son intégralité ou pas du tout. Si une opération échoue ou rencontre une erreur, toutes les opérations précédentes sont annulées (rollback), et les données sont restaurées à leur état précédent.
+Cohérence : Une transaction garantit que les données sont maintenues dans un état valide avant et après son exécution. Les contraintes et les règles d'intégrité sont respectées tout au long de la transaction.
+Isolation : Les transactions s'exécutent de manière isolée les unes des autres. Cela signifie que les opérations d'une transaction en cours ne sont pas visibles pour les autres transactions jusqu'à ce qu'elles soient validées. Cela préserve l'intégrité des données et évite les problèmes de concurrence.
+Durabilité : Une fois qu'une transaction est validée et confirmée, les modifications apportées aux données deviennent permanentes et survivront à d'éventuelles pannes du système.
+Voici un exemple concret pour illustrer la gestion des transactions :
+
+```sql
+BEGIN TRANSACTION;
+SELECT stock_quantity FROM Inventory WHERE product_id = <id_produit> INTO @stock_quantity;
+UPDATE Inventory SET stock_quantity = @stock_quantity - <quantite_commandee> WHERE product_id = <id_produit>;
+UPDATE Products SET stock = stock - <quantite_commandee> WHERE product_id = <id_produit>;
+
+-- ROLLBACK; pour tout annuler
+COMMIT;
+```
+
+La gestion des transactions est essentielle pour garantir la cohérence et l'intégrité des données dans les systèmes de bases de données. Elle permet d'assurer que les opérations sont exécutées avec succès ou entièrement annulées en cas d'erreur, offrant ainsi une garantie de fiabilité des données.
\ No newline at end of file