diff --git a/source/dev-vitis/bdd/generic.md b/source/dev-vitis/bdd/generic.md
index fcc886cc960f1eaf248aafb17ef62fa8d993f9e8..080279e5be95aa0dc0be1f7a13954fbea0192494 100644
--- a/source/dev-vitis/bdd/generic.md
+++ b/source/dev-vitis/bdd/generic.md
@@ -60,14 +60,6 @@ FME permet de manipuler la quasi totalité des différent SGBDR ou noSQL.
 
 - Colonnes : Les colonnes, également appelées attributs ou champs, représentent les différentes caractéristiques ou propriétés d'une table. Chaque colonne a un nom unique et un type de données spécifique qui définit le type de valeurs qu'elle peut contenir. Par exemple, une table "Produits" peut avoir des colonnes telles que "Nom", "Prix" et "Quantité".
 
-- Lignes : Les lignes, également appelées enregistrements ou tuples, représentent des instances spécifiques de données dans une table. Chaque ligne contient les valeurs correspondantes pour chaque colonne de la table. Par exemple, une ligne dans la table "Utilisateurs" peut contenir les informations d'un utilisateur spécifique, telles que son nom, son adresse e-mail et son identifiant.
-
-- Clé primaire : Une clé primaire est une colonne ou un ensemble de colonnes qui identifie de manière unique chaque enregistrement dans une table. Elle garantit l'unicité des données dans la table et permet de référencer facilement un enregistrement spécifique. Par exemple, une clé primaire dans la table "Utilisateurs" peut être l'identifiant unique attribué à chaque utilisateur.
-
-- Clé étrangère : Une clé étrangère est une colonne ou un ensemble de colonnes dans une table qui fait référence à la clé primaire d'une autre table. Elle établit une relation entre les enregistrements de deux tables différentes. Par exemple, une table "Commandes" peut avoir une clé étrangère qui fait référence à la clé primaire de la table "Utilisateurs", liant ainsi les commandes à leurs utilisateurs associés.
-
-- Index : Un index est une structure de données utilisée pour accélérer la recherche et l'accès aux données dans une table. Il est créé sur une ou plusieurs colonnes spécifiques et permet de localiser rapidement les enregistrements correspondant à certaines valeurs. Les index améliorent les performances des requêtes en réduisant le temps de recherche.
-
 - Schéma : Un schéma est une collection logique d'objets de base de données, tels que des tables, des vues, des procédures stockées, etc. Il permet d'organiser et de regrouper les objets connexes au sein d'une base de données. Les schémas aident à maintenir la séparation et la cohérence des données dans un environnement de base de données complexe.
 
 - Trigger (Déclencheur) : Un trigger est un objet de base de données qui est associé à une table et est déclenché automatiquement lorsque certaines actions sont effectuées sur cette table, telles que l'insertion, la mise à jour ou la suppression de données. Les triggers permettent d'effectuer des actions spécifiques avant ou après l'exécution des opérations sur la table, offrant ainsi une flexibilité pour l'automatisation des tâches et l'application de règles métier.
@@ -84,11 +76,26 @@ FME permet de manipuler la quasi totalité des différent SGBDR ou noSQL.
 
 - Fonction : Une fonction, également appelée procédure stockée, est un bloc de code réutilisable qui effectue une tâche spécifique dans une base de données. Les fonctions sont utilisées pour encapsuler des séquences d'instructions SQL et de logique de programmation dans un seul objet. Elles peuvent être appelées à partir de requêtes SQL ou d'autres procédures stockées pour effectuer des calculs, des manipulations de données complexes ou des opérations personnalisées.
 
+![arbre postgres](./images/postgresql_objects_tutorialdba.png)
+
+- Lignes : Les lignes, également appelées enregistrements ou tuples, représentent des instances spécifiques de données dans une table. Chaque ligne contient les valeurs correspondantes pour chaque colonne de la table. Par exemple, une ligne dans la table "Utilisateurs" peut contenir les informations d'un utilisateur spécifique, telles que son nom, son adresse e-mail et son identifiant.
+
+![voc 1](./images/vocabulaire_bdd1.png)
+
+- Clé primaire : Une clé primaire est une colonne ou un ensemble de colonnes qui identifie de manière unique chaque enregistrement dans une table. Elle garantit l'unicité des données dans la table et permet de référencer facilement un enregistrement spécifique. Par exemple, une clé primaire dans la table "Utilisateurs" peut être l'identifiant unique attribué à chaque utilisateur.
+
+- Clé étrangère : Une clé étrangère est une colonne ou un ensemble de colonnes dans une table qui fait référence à la clé primaire d'une autre table. Elle établit une relation entre les enregistrements de deux tables différentes. Par exemple, une table "Commandes" peut avoir une clé étrangère qui fait référence à la clé primaire de la table "Utilisateurs", liant ainsi les commandes à leurs utilisateurs associés.
+
+- Index : Un index est une structure de données utilisée pour accélérer la recherche et l'accès aux données dans une table. Il est créé sur une ou plusieurs colonnes spécifiques et permet de localiser rapidement les enregistrements correspondant à certaines valeurs. Les index améliorent les performances des requêtes en réduisant le temps de recherche.
+
+![voc 2](./images/vocabulaire_bdd2.png)
+
+
 # Conception d'une base de données
 
 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.
 
-## Identification des entité et des relations
+## Identification des entités et des relations
 
 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.
 
@@ -139,60 +146,353 @@ Utiliser le type jsonb à la place du type json classique, le jsonb facilite cer
 
 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
+# 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.
+
+## Héritage de table
+
+Supposons que nous avons une table parente appelée "Employee" contenant des attributs communs à tous les employés, tels que "id", "name" et "salary". Nous souhaitons créer deux tables filles, "Manager" et "Staff", qui héritent des attributs de la table "Employee" mais ajoutent également des attributs spécifiques à chaque type d'employé.
+
+Voici comment cela pourrait être réalisé :
+
+```sql
+-- Création de la table parente Employee
+CREATE TABLE Employee (
+id SERIAL PRIMARY KEY,
+name VARCHAR(100) NOT NULL,
+salary DECIMAL(10, 2) NOT NULL
+);
+
+-- Création de la table fille Manager héritant de la table Employee
+CREATE TABLE Manager (
+department VARCHAR(50) NOT NULL,
+PRIMARY KEY (id),
+FOREIGN KEY (id) REFERENCES Employee (id)
+) INHERITS (Employee);
+
+-- Création de la table fille Staff héritant de la table Employee
+CREATE TABLE Staff (
+position VARCHAR(50) NOT NULL,
+PRIMARY KEY (id),
+FOREIGN KEY (id) REFERENCES Employee (id)
+) INHERITS (Employee);
+
+-- Insertion de données dans la table Manager
+INSERT INTO Manager (name, salary, department) VALUES ('John Smith', 5000.00, 'Finance');
+
+-- Insertion de données dans la table Staff
+INSERT INTO Staff (name, salary, position) VALUES ('Jane Doe', 3000.00, 'Assistant');
 
-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.
+-- Sélection des employés de toutes les tables (Employee, Manager, Staff)
+SELECT * FROM Employee;
 
-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.
+-- Sélection des employés uniquement dans la table Manager
+SELECT * FROM Manager;
 
-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.
+-- Sélection des employés uniquement dans la table Staff
+SELECT * FROM Staff;
+```
 
-![webapp stack dev](./images/webapp-stack-dev.png)
+Dans cet exemple, nous créons d'abord la table parente "Employee" avec les attributs communs à tous les employés. Ensuite, nous créons deux tables filles, "Manager" et "Staff", en utilisant la clause INHERITS pour hériter des attributs de la table parente.
 
-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.
+Nous insérons ensuite des données spécifiques dans les tables "Manager" et "Staff". Les clés primaires des tables filles sont également des clés étrangères faisant référence à la clé primaire de la table parente.
 
-Il y a globalement quelques truc à savoir pour bien faire les choses.
+Enfin, nous effectuons des sélections pour récupérer les employés de toutes les tables (Employee, Manager, Staff) ainsi que les employés spécifiques à chaque table.
 
-### Spécifités des vues et des règles
+Le mécanisme d'héritage permet de regrouper des tables liées par une relation "est-un" et de partager les attributs communs tout en permettant des attributs spécifiques à chaque table fille. Cela facilite la gestion des données et les requêtes en permettant de traiter les tables filles comme des entités distinctes tout en profitant de l'héritage des attributs et des contraintes définis dans la table parente.
 
-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.
+## JSONB
 
-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.
+Le type JSONB dans PostgreSQL offre une flexibilité et une puissance significatives pour le stockage et la manipulation de données au format JSON (JavaScript Object Notation). JSONB est une extension du type JSON qui permet un stockage efficace et une manipulation avancée des données JSON.
 
-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.
+L'utilisation du type JSONB permet de gérer des données semi-structurées et évolutives, ce qui est particulièrement utile lorsque la structure des données peut varier d'un enregistrement à un autre. Cela permet de stocker des informations diverses et complexes dans une colonne, sans avoir à définir un schéma fixe pour chaque enregistrement.
 
-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.
+Voici quelques exemples d'utilisation du type JSONB dans PostgreSQL :
 
-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 :
+Stockage de données JSON structurées :
+```sql
 
-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.
+CREATE TABLE Employee (
+  id SERIAL PRIMARY KEY,
+  name VARCHAR(100),
+  details JSONB
+);
 
-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.
+INSERT INTO Employee (name, details)
+VALUES ('John Smith', '{"age": 35, "position": "Manager", "salary": 5000}');
+```
 
-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.
+Requêtes basées sur des valeurs JSONB :
+```sql
+SELECT *
+FROM Employee
+WHERE details->>'position' = 'Manager';
+```
 
-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.
+Mise à jour de valeurs spécifiques dans une colonne JSONB :
 
-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.
+```sql
+UPDATE Employee
+SET details = jsonb_set(details, '{salary}', '5500', true)
+WHERE id = 1;
+-- OU
 
-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.
+UPDATE Employee
+SET details = details || '{"age" : 40}'
+WHERE id = 1;
 
+```
 
+Utilisation de fonctions JSONB intégrées :
 
-IV. Gestion de la base de données
-   A. Création de la base de données
-   B. Sécurité et contrôle d'accès
-   C. Sauvegarde et restauration des données
-   D. Maintenance et optimisation des performances
+```sql
+SELECT details->'age' AS age, jsonb_array_length(details->'projects') AS project_count
+FROM Employee;
+```
 
-V. Intégration et échange de données
-   A. Importation et exportation de données
-   B. Intégration avec d'autres systèmes (API, ETL, etc.)
-   C. Synchronisation des données
+Le type JSONB offre des fonctionnalités avancées pour extraire, modifier et interroger des données JSON. Les opérateurs et fonctions spécifiques permettent d'accéder aux valeurs JSONB, de les manipuler, de rechercher des clés spécifiques et d'effectuer des opérations complexes sur les données.
 
-VI. Bonnes pratiques et astuces
-   A. Optimisation des requêtes
-   B. Modélisation efficace des données
-   C. Sécurité des données
-   D. Évolutivité et extensibilité
\ No newline at end of file
+L'utilisation du type JSONB peut être particulièrement avantageuse dans les scénarios où la structure des données est flexible ou où l'on souhaite stocker des données complexes sans avoir à définir un schéma fixe. Cela permet une adaptation facile aux changements de la structure des données et facilite la manipulation des données JSON au sein de la base de données PostgreSQL.
\ No newline at end of file
diff --git a/source/dev-vitis/bdd/images/postgresql_objects_tutorialdba.png b/source/dev-vitis/bdd/images/postgresql_objects_tutorialdba.png
new file mode 100644
index 0000000000000000000000000000000000000000..d4c0935f2601eda53ca2d86909a19bbb4bb93ca8
Binary files /dev/null and b/source/dev-vitis/bdd/images/postgresql_objects_tutorialdba.png differ
diff --git a/source/dev-vitis/bdd/images/vocabulaire_bdd1.png b/source/dev-vitis/bdd/images/vocabulaire_bdd1.png
new file mode 100644
index 0000000000000000000000000000000000000000..b68051f7e83ff5f22b692640be5edfa80ecf5855
Binary files /dev/null and b/source/dev-vitis/bdd/images/vocabulaire_bdd1.png differ
diff --git a/source/dev-vitis/bdd/images/vocabulaire_bdd2.png b/source/dev-vitis/bdd/images/vocabulaire_bdd2.png
new file mode 100644
index 0000000000000000000000000000000000000000..0904daaefc57e4f568fd73cf8cd8c69759393b69
Binary files /dev/null and b/source/dev-vitis/bdd/images/vocabulaire_bdd2.png differ
diff --git a/source/dev-vitis/bdd/postgres.md b/source/dev-vitis/bdd/postgres.md
new file mode 100644
index 0000000000000000000000000000000000000000..2e1ee6677933646b69d215d4c7488d096ae82538
--- /dev/null
+++ b/source/dev-vitis/bdd/postgres.md
@@ -0,0 +1,103 @@
+# Gestion de la Base de de données
+
+## Sécurité et contrôle d'accès
+
+### Configuration du serveur
+
+Il y a deux fichiers qui vont vous permettre de verouiller l'accés à votre base, le `postgresql.conf` et le `pg_hba.conf`.
+
+Le postgresql.conf permet de jouer sur 
+
+- SSL (Secure Sockets Layer) : Vous pouvez activer et configurer SSL pour sécuriser les connexions entre le client et le serveur PostgreSQL. Cela permet de chiffrer les données transitant entre les deux et d'empêcher les interceptions non autorisées. Vous pouvez spécifier les certificats SSL, les clés privées, les méthodes d'authentification et les protocoles SSL à utiliser.
+
+- Authentification des utilisateurs : PostgreSQL prend en charge diverses méthodes d'authentification pour les utilisateurs. Vous pouvez configurer des méthodes d'authentification telles que le chiffrement des mots de passe (**password_encryption**), l'authentification par certificat client (ssl_cert_file, ssl_key_file), l'authentification GSSAPI (krb_server_keyfile), l'authentification PAM (pam configuration), etc. Vous pouvez choisir la méthode d'authentification appropriée en fonction de vos besoins de sécurité.
+
+- Règles d'accès : Bien que les règles d'accès soient généralement configurées dans le fichier pg_hba.conf, certaines options de configuration de sécurité sont disponibles dans postgresql.conf. Par exemple, vous pouvez définir l'option **listen_addresses** pour spécifier les adresses IP sur lesquelles le serveur PostgreSQL écoute les connexions entrantes. Cela permet de restreindre l'accès au serveur en spécifiant les adresses IP autorisées.
+
+- Limitation des ressources : PostgreSQL vous permet de définir des limites sur les ressources utilisées par les sessions et les requêtes. Vous pouvez configurer les paramètres tels que max_connections pour limiter le nombre de connexions simultanées, max_locks_per_transaction pour limiter le nombre de verrous pris par transaction, max_prepared_transactions pour limiter le nombre de transactions préparées, etc. Cela aide à prévenir les attaques de déni de service et à garantir une utilisation équitable des ressources du système.
+
+- Journalisation (logging) : La configuration de la journalisation dans postgresql.conf vous permet de spécifier le niveau de détail des journaux, les fichiers de destination et les formats de sortie. Vous pouvez choisir de journaliser les requêtes, les erreurs, les avertissements, les connexions, etc. La journalisation adéquate est essentielle pour l'audit, la détection des problèmes de sécurité et la conformité aux réglementations.
+
+Le fichier pg_hba.conf va permettre de faire une gestion plus fines des accés à la base de donnée.
+
+```shell
+# TYPE  DATABASE        USER            ADDRESS                 METHOD
+
+# Autoriser toutes les connexions locales en tant qu'utilisateur postgres avec une méthode d'authentification par mot de passe
+local   all             postgres                                md5
+# Autoriser les connexions provenant de l'adresse IP spécifique avec une méthode d'authentification par mot de passe
+host    all             all             192.168.1.100/32        md5
+# Autoriser les connexion sur une base spécifique depuis une ip précise par mot de passe
+host    vitis           all             192.168.1.100/32        md5
+# Spécification d'une configuration pour forcer l'utilisation du SSL
+hostssl vitis           all             127.0.0.1/32            md5
+# Autoriser les connexions provenant de l'adresse IP spécifique avec une méthode d'authentification par mot de passe chiffré
+host    mydatabase      myuser          10.0.0.5/24             scram-sha-256
+# Autoriser une méthode de connexion spécifique uniquement pour un rolegroup spécifique
+host    mydatabse       +mon_role_group 127.0.0.1/32            md5
+```
+
+A savoir que Postgres va tester chaque règle de maniére itérative tel que définir dans le fichier de haut en bas.
+Il faut donc que la règle la plus restrictive se trouve avant les règle moins restrictive dans ce fichier.
+
+Autres points : 
+
+- Sauvegardes : Mettez en place une stratégie de sauvegarde régulière pour protéger vos données. Configurez des sauvegardes automatiques, en utilisant des outils tels que pg_dump ou des solutions de sauvegarde tierces pour garantir la disponibilité des données en cas de défaillance du système.
+
+### Configuration de la base  
+
+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.
+
+#### 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.
+
+
+
+
+
+
+
+
+   C. Sauvegarde et restauration des données
+   D. Maintenance et optimisation des performances
+
+V. Intégration et échange de données
+   A. Importation et exportation de données
+   B. Intégration avec d'autres systèmes (API, ETL, etc.)
+   C. Synchronisation des données
+
+VI. Bonnes pratiques et astuces
+   A. Optimisation des requêtes
+   B. Modélisation efficace des données
+   C. Sécurité des données
+   D. Évolutivité et extensibilité
\ No newline at end of file