diff --git a/source/concept/bdd/generic.md b/source/concept/bdd/generic.md
new file mode 100644
index 0000000000000000000000000000000000000000..66f907e5b2c6da31191af74b54941f32055de071
--- /dev/null
+++ b/source/concept/bdd/generic.md
@@ -0,0 +1,500 @@
+# 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 ?
+
+Une base de données est une collection organisée de données interdépendantes, stockées de manière structurée et accessible. Elle permet de stocker, gérer, organiser et récupérer efficacement des informations. Une base de données est composée de tables qui regroupent des enregistrements contenant des données spécifiques. Chaque table est constituée de colonnes (aussi appelées champs) qui définissent les types de données stockées, et chaque enregistrement est représenté par une ligne. Les bases de données relationnelles, telles que MySQL, Oracle et PostgreSQL, utilisent le modèle relationnel, dans lequel les données sont organisées en tables interconnectées par des relations basées sur des clés. Ce modèle offre une structure solide pour la gestion des données, garantissant l'intégrité et la cohérence.
+
+Cependant, avec l'émergence de nouvelles exigences en termes de volume de données, de flexibilité et de performances, les bases de données NoSQL (Not Only SQL) ont gagné en popularité. Contrairement aux bases de données relationnelles, les bases de données NoSQL, telles que MongoDB, Cassandra et Redis, adoptent des modèles de données non relationnels et évolutifs. Elles offrent une grande flexibilité pour stocker et traiter des données non structurées, semi-structurées et en constante évolution, comme les données JSON ou les données provenant de capteurs IoT. Les bases de données NoSQL sont conçues pour gérer des charges de travail distribuées à grande échelle, offrant une évolutivité horizontale et une haute disponibilité.
+
+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.
+
+## 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.
+
+PostgreSQL présente plusieurs autres avantages significatifs. Tout d'abord, sa grande conformité aux normes SQL garantit une compatibilité élevée avec les applications existantes et facilite l'interchangeabilité avec d'autres SGBDR. Cela permet aux utilisateurs de migrer facilement depuis d'autres systèmes ou de développer des applications multiplateformes sans rencontrer de problèmes majeurs de compatibilité, via l'utilisation d'une couche d'abstraction comme DBAL en PHP par exemple.
+
+De plus, PostgreSQL se distingue par sa robustesse et sa fiabilité. Il est réputé pour sa capacité à gérer des charges de travail intensives et de grandes quantités de données, tout en maintenant des performances élevées. Sa conception modulaire permet une extensibilité facile, ce qui signifie que de nouvelles fonctionnalités peuvent être ajoutées à la base de données sans compromettre sa stabilité.
+
+Un autre avantage clé de PostgreSQL est sa riche gamme de fonctionnalités avancées. Outre la prise en charge des données géospatiales avec PostGIS, PostgreSQL offre des fonctionnalités telles que les transactions ACID (Atomicité, Cohérence, Isolation, Durabilité), les vues matérialisées, les déclencheurs, les procédures stockées et les index avancés. Ces fonctionnalités permettent aux développeurs de créer des applications sophistiquées et d'optimiser les performances de leurs requêtes.
+
+Enfin, PostgreSQL bénéficie d'une communauté active et engagée. La communauté PostgreSQL travaille constamment à l'amélioration du système, à la correction des bogues, à l'ajout de nouvelles fonctionnalités et à la fourniture d'un support solide. Cette communauté dynamique offre un accès à une vaste base de connaissances, des forums d'entraide et une documentation complète, ce qui facilite l'apprentissage et le développement avec PostgreSQL.
+
+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.
+
+- 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é".
+
+- 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.
+
+- Séquence : Une séquence est un objet de base de données qui génère automatiquement une série de valeurs numériques dans un ordre croissant ou décroissant. Les séquences sont souvent utilisées pour générer des identifiants uniques pour les tables, garantissant ainsi l'unicité des valeurs dans une colonne spécifique. Elles sont couramment utilisées dans les bases de données relationnelles pour gérer les valeurs d'auto-incrémentation.
+
+- Vue : Une vue est une représentation virtuelle d'une ou plusieurs tables dans une base de données. Elle permet de sélectionner et de présenter un sous-ensemble des données d'origine selon des critères spécifiques, sans modifier les données réelles. Les vues offrent une couche d'abstraction et facilitent la simplification des requêtes complexes en fournissant des vues pré-définies et filtrées des données.
+
+- Vue matérialisée : Une vue matérialisée est une vue qui est physiquement stockée en tant que table dans la base de données. Contrairement aux vues classiques, qui sont générées à la volée lors de l'exécution des requêtes, les vues matérialisées sont précalculées et mises à jour périodiquement pour refléter les modifications des données sous-jacentes. Cela permet d'améliorer les performances des requêtes répétitives et de réduire la charge sur la base de données.
+
+- Rôle de connexion : Un rôle de connexion, également appelé utilisateur, est un compte qui permet à un utilisateur d'accéder à une base de données et d'effectuer des opérations sur les objets de cette base de données. Les rôles de connexion ont des privilèges et des autorisations qui définissent ce que l'utilisateur peut faire dans la base de données, tels que la lecture, l'écriture, la création ou la suppression de données.
+
+- Rôlegroup : Un rôlegroup est un groupe de rôles de connexion qui permet de regrouper plusieurs rôles en une seule entité logique. Les rôlegroups facilitent la gestion des autorisations en attribuant des privilèges communs à un groupe de rôles, plutôt que de les définir individuellement pour chaque rôle de connexion. Cela simplifie la gestion des autorisations et facilite les modifications globales des privilèges pour un ensemble de rôles.
+
+- 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.
+
+
+
+- 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.
+
+
+
+
+# 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é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.
+
+Le plus souvent cette étape se fait via l'analyse de documents produit par le client ou en discutant avec ce-dernier.
+
+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.
+
+## 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 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
+
+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.
+
+- 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.
+
+- 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.
+
+
+
+## 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. 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.
+
+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).
+
+# 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.
+
+
+
+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');
+
+-- Sélection des employés de toutes les tables (Employee, Manager, Staff)
+SELECT * FROM Employee;
+
+-- Sélection des employés uniquement dans la table Manager
+SELECT * FROM Manager;
+
+-- Sélection des employés uniquement dans la table Staff
+SELECT * FROM Staff;
+```
+
+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.
+
+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.
+
+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.
+
+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.
+
+## JSONB
+
+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.
+
+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.
+
+Voici quelques exemples d'utilisation du type JSONB dans PostgreSQL :
+
+Stockage de données JSON structurées :
+```sql
+
+CREATE TABLE Employee (
+ id SERIAL PRIMARY KEY,
+ name VARCHAR(100),
+ details JSONB
+);
+
+INSERT INTO Employee (name, details)
+VALUES ('John Smith', '{"age": 35, "position": "Manager", "salary": 5000}');
+```
+
+Requêtes basées sur des valeurs JSONB :
+```sql
+SELECT *
+FROM Employee
+WHERE details->>'position' = 'Manager';
+```
+
+Mise à jour de valeurs spécifiques dans une colonne JSONB :
+
+```sql
+UPDATE Employee
+SET details = jsonb_set(details, '{salary}', '5500', true)
+WHERE id = 1;
+-- OU
+
+UPDATE Employee
+SET details = details || '{"age" : 40}'
+WHERE id = 1;
+
+```
+
+Utilisation de fonctions JSONB intégrées :
+
+```sql
+SELECT details->'age' AS age, jsonb_array_length(details->'projects') AS project_count
+FROM Employee;
+```
+
+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.
+
+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/concept/bdd/images/cardinalite_vitis.png b/source/concept/bdd/images/cardinalite_vitis.png
new file mode 100644
index 0000000000000000000000000000000000000000..d5f3074ca9c6ccf9b70cc0a9a1a6cc07e5e69a44
Binary files /dev/null and b/source/concept/bdd/images/cardinalite_vitis.png differ
diff --git a/source/concept/bdd/images/explain_analyze_result.png b/source/concept/bdd/images/explain_analyze_result.png
new file mode 100644
index 0000000000000000000000000000000000000000..6fbc35d849b373c931dadc8ceccadca4e44fb5ac
Binary files /dev/null and b/source/concept/bdd/images/explain_analyze_result.png differ
diff --git a/source/concept/bdd/images/join_type.png b/source/concept/bdd/images/join_type.png
new file mode 100644
index 0000000000000000000000000000000000000000..5c9350f14c33512e79cea59813efc8364186a60d
Binary files /dev/null and b/source/concept/bdd/images/join_type.png differ
diff --git a/source/concept/bdd/images/pg_logos.png b/source/concept/bdd/images/pg_logos.png
new file mode 100644
index 0000000000000000000000000000000000000000..654b8bf44c0ff3380a9759b1165420698b910cc5
Binary files /dev/null and b/source/concept/bdd/images/pg_logos.png differ
diff --git a/source/concept/bdd/images/pgadmin4_logo.png b/source/concept/bdd/images/pgadmin4_logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..dc1beca38c054565a9a992592e84afb41861d298
Binary files /dev/null and b/source/concept/bdd/images/pgadmin4_logo.png differ
diff --git a/source/concept/bdd/images/pgmodeler_logo.png b/source/concept/bdd/images/pgmodeler_logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..924ea21fb72af321963296e0100a3067856172e7
Binary files /dev/null and b/source/concept/bdd/images/pgmodeler_logo.png differ
diff --git a/source/concept/bdd/images/postgis-logo.png b/source/concept/bdd/images/postgis-logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..8bdb3a00ff13ac8410913bf0a454d3c533d1ee16
Binary files /dev/null and b/source/concept/bdd/images/postgis-logo.png differ
diff --git a/source/concept/bdd/images/postgres_logo.png b/source/concept/bdd/images/postgres_logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..a72f37e824698bd2cb22177679715cbb1b49cdb8
Binary files /dev/null and b/source/concept/bdd/images/postgres_logo.png differ
diff --git a/source/concept/bdd/images/postgresql_objects_tutorialdba.png b/source/concept/bdd/images/postgresql_objects_tutorialdba.png
new file mode 100644
index 0000000000000000000000000000000000000000..d4c0935f2601eda53ca2d86909a19bbb4bb93ca8
Binary files /dev/null and b/source/concept/bdd/images/postgresql_objects_tutorialdba.png differ
diff --git a/source/concept/bdd/images/vocabulaire_bdd1.png b/source/concept/bdd/images/vocabulaire_bdd1.png
new file mode 100644
index 0000000000000000000000000000000000000000..b68051f7e83ff5f22b692640be5edfa80ecf5855
Binary files /dev/null and b/source/concept/bdd/images/vocabulaire_bdd1.png differ
diff --git a/source/concept/bdd/images/vocabulaire_bdd2.png b/source/concept/bdd/images/vocabulaire_bdd2.png
new file mode 100644
index 0000000000000000000000000000000000000000..0904daaefc57e4f568fd73cf8cd8c69759393b69
Binary files /dev/null and b/source/concept/bdd/images/vocabulaire_bdd2.png differ
diff --git a/source/concept/bdd/images/webapp-stack-dev.png b/source/concept/bdd/images/webapp-stack-dev.png
new file mode 100644
index 0000000000000000000000000000000000000000..f4714577e55d0242afca58836468ac25e53f682a
Binary files /dev/null and b/source/concept/bdd/images/webapp-stack-dev.png differ
diff --git a/source/concept/bdd/index.rst b/source/concept/bdd/index.rst
new file mode 100644
index 0000000000000000000000000000000000000000..2cb37cc739902c32a838acf8d4bffddb31241e0a
--- /dev/null
+++ b/source/concept/bdd/index.rst
@@ -0,0 +1,19 @@
+Modélisation base de donnée et Postgres
+============================================
+
+.. image:: ./images/postgres_logo.png
+ :width: 250 px
+ :align: center
+ :target: #
+
+
+Postgres est le SGBD choisi par Veremes pour les application basées sur Vitis.
+
+============================================
+
+.. toctree::
+ :maxdepth: 2
+
+ generic.md
+ postgres.md
+ postgis.md
diff --git a/source/concept/bdd/postgis.md b/source/concept/bdd/postgis.md
new file mode 100644
index 0000000000000000000000000000000000000000..72079eaf8d5628425ce7e66d604b1720984e0d58
--- /dev/null
+++ b/source/concept/bdd/postgis.md
@@ -0,0 +1,250 @@
+# Présentation de PostGIS
+
+PostGIS est une extension open source pour la base de données PostgreSQL, qui permet de gérer des données géospatiales. Il fournit des fonctionnalités avancées pour le stockage, l'interrogation et l'analyse de données géographiques, en permettant aux utilisateurs de traiter des informations géographiques complexes et de réaliser des opérations spatiales puissantes.
+
+PostGIS ajoute des types de données géospatiales à PostgreSQL, tels que les points, les lignes, les polygones, les multipoints, les multilignes et les multipolygones. Ces types de données permettent de représenter des objets géographiques du monde réel avec leurs coordonnées et leurs attributs associés.
+
+Avec PostGIS, vous pouvez effectuer des requêtes spatiales avancées, telles que l'intersection, l'union, la différence, le tampon, le tampon multiple, la recherche de plus proches voisins, etc. Ces opérations spatiales vous permettent de répondre à des questions complexes liées à la géographie et d'effectuer des analyses spatiales approfondies.
+
+PostGIS offre également des fonctionnalités d'indexation spatiale, ce qui permet d'accélérer les requêtes spatiales en utilisant des indexes spécifiques. Cela garantit des performances optimales lors de l'interrogation de grandes quantités de données géospatiales.
+
+En outre, PostGIS prend en charge l'intégration avec d'autres outils et librairies géospatiales, tels que QGIS, GDAL, GEOS, etc. Cela facilite l'échange de données et la collaboration avec d'autres systèmes géographiques.
+
+Les cas d'utilisation de PostGIS sont nombreux et variés. Il est largement utilisé dans des domaines tels que l'aménagement du territoire, la gestion des ressources naturelles, la cartographie, la planification urbaine, l'analyse de données géospatiales, etc. Sa flexibilité et sa puissance en font un outil essentiel pour toute personne travaillant avec des données géographiques.
+
+## Principales fonctionnalités de PostGIS
+
+PostGIS offre un large éventail de fonctionnalités pour la gestion et l'analyse de données géospatiales. Voici quelques-unes des fonctionnalités clés de PostGIS :
+
+- Types de données géospatiales : PostGIS étend PostgreSQL en ajoutant des types de données géospatiales, tels que les points, les lignes, les polygones, les multipoints, les multilignes et les multipolygones. Ces types de données permettent de stocker et de manipuler des objets géographiques réels avec leurs coordonnées et leurs attributs associés.
+
+- Opérations spatiales : PostGIS offre un large éventail d'opérations spatiales permettant de réaliser des requêtes complexes sur les données géospatiales. Parmi les opérations les plus couramment utilisées, on trouve l'intersection, l'union, la différence, le tampon, le tampon multiple, la recherche de plus proches voisins, le découpage, la simplification, etc. Ces opérations permettent de répondre à des questions spécifiques liées à la géographie et de réaliser des analyses spatiales avancées.
+
+- Indexation spatiale : PostGIS propose des techniques d'indexation spatiale pour optimiser les performances des requêtes spatiales. L'utilisation d'indexes spatiaux tels que les indexes R-tree permet d'accélérer les opérations de recherche spatiale et d'améliorer les temps de réponse des requêtes sur les données géospatiales.
+
+- Transformation de coordonnées : PostGIS fournit des fonctions permettant de convertir les coordonnées d'un système de référence spatial à un autre. Cela facilite l'intégration et l'interopérabilité des données géospatiales provenant de différentes sources, qui peuvent utiliser des systèmes de référence spatiale différents.
+
+- Analyse spatiale avancée : PostGIS offre des fonctionnalités avancées d'analyse spatiale telles que le calcul de distances, de longueurs, d'aires, d'angles, etc. Ces fonctions permettent d'effectuer des mesures précises et de réaliser des analyses détaillées sur les données géospatiales.
+
+- Importation et exportation de données : PostGIS prend en charge l'importation et l'exportation de données à partir de différents formats de fichiers géospatiaux, tels que Shapefile, GeoJSON, KML, etc. Cela facilite l'intégration des données géospatiales provenant de différentes sources et leur utilisation dans l'environnement PostGIS. Même si dans notre cas nous préférerons utiliser FME pour réaliser ce genre d'opération.
+
+- Intégration avec d'autres outils géospatiaux : PostGIS s'intègre facilement avec d'autres outils et librairies géospatiales populaires, tels que QGIS, GDAL, GEOS, etc. Cette intégration permet d'échanger des données, d'effectuer des analyses avancées et de bénéficier de fonctionnalités supplémentaires offertes par ces outils.
+
+Ces fonctionnalités font de PostGIS un outil puissant pour la gestion, l'analyse et la manipulation de données géospatiales. Que vous travailliez dans des domaines tels que la planification urbaine, la gestion des ressources naturelles, la cartographie ou l'analyse de données géospatiales, l'utilisation de PostGIS vous permettra d'exploiter pleinement le potentiel de
+
+# Création et gestion de bases de données spatiales
+
+Pour transformer une base de donnée classique en base de donnée spatiale il suffit d'ajouter l'extension postgis dessus.
+
+```sql
+CREATE EXTENSION IF NOT EXISTS postgis;
+```
+
+## Utilisation des types de données géospatiales
+
+PostGIS ajoute plusieurs types de colonnes spécifiques pour gérer les données géospatiales de manière efficace. Voici quelques-uns des types de colonnes les plus couramment utilisés dans PostGIS :
+
+- Géométrie (Geometry) : Le type de colonne "geometry" est utilisé pour stocker des objets géospatiaux de tous types, tels que des points, des lignes, des polygones, etc. Ce type de colonne est polyvalent car il peut contenir différents types d'objets géométriques.
+
+- Géographie (Geography) : Le type de colonne "geography" est spécifiquement conçu pour stocker des données géographiques, telles que des coordonnées de latitude et de longitude. Ce type de colonne utilise une représentation sphérique de la Terre et offre des fonctions géographiques avancées pour les calculs de distance, les conversions de coordonnées, etc.
+
+- Point (Point) : Le type de colonne "point" est utilisé pour stocker des coordonnées de points spécifiques dans l'espace. Il est utile pour représenter des emplacements ponctuels précis, tels que des adresses, des sites d'intérêt, etc.
+
+- Ligne (LineString) : Le type de colonne "linestring" est utilisé pour stocker des segments de lignes ou des courbes continues. Il peut représenter des routes, des rivières, des chemins, etc.
+
+- Polygone (Polygon) : Le type de colonne "polygon" est utilisé pour stocker des régions fermées délimitées par des segments de ligne. Il peut représenter des limites administratives, des lacs, des parcelles de terrain, etc.
+
+- MultiPoint, MultiLineString, MultiPolygon : Ces types de colonnes permettent de stocker plusieurs points, lignes ou polygones, respectivement. Ils sont utilisés lorsque plusieurs objets de même type doivent être regroupés.
+
+Ces types de colonnes spécifiques de PostGIS permettent de stocker et de manipuler des données géospatiales de manière optimisée. Ils offrent des fonctionnalités avancées pour effectuer des opérations spatiales et analyser les données géographiques de manière précise et efficace.
+
+Exemple de déclaration d'une colonne de type Point dont les coordonnée utilise le SRID 4326 WGS84 Long/lat :
+
+```sql
+CREATE TABLE my_table (
+ id SERIAL PRIMARY KEY,
+ name VARCHAR(50),
+ geom GEOMETRY(Point, 4326)
+);
+```
+
+## Importation et exportation de données spatiales
+
+La colonne de type géométrie utilise le format WKB qui est la variante binaire du WKT, ce qui la rend difficilement exploitable directement.
+
+Postgis offre différentes fonction permettant d'utiliser des formats textuelles, plus faciles à utiliser via vMap, ...
+
+Par exemple pour passer du wkb à d'autre format pour les requêtes SELECT vous pouvez utiliser
+- [ST_AsText](https://postgis.net/docs/ST_AsText.html) qui permet de récupérer du WKT
+- [ST_AsEWKT](https://postgis.net/docs/ST_AsEWKT.html) pour récupérer de l'EWKT
+- [ST_AsGeoJSON](https://postgis.net/docs/ST_AsGeoJSON.html) pour obtenir un GéoJSON
+
+A l'inverse pour les requête INSERT et UPDATE il est possibke d'utiliser des fonctions pour passer d'un format texte au WKB :
+- [ST_GeomFromText](https://postgis.net/docs/ST_GeomFromText.html) qui transformera une géométrie WKT
+- [ST_GeomFromEWKT](https://postgis.net/docs/ST_GeomFromEWKT.html) qui transformera une géométrie EWKT
+- [ST_GeomFromGeoJSON](https://postgis.net/docs/ST_GeomFromGeoJSON.html) qui transformera une géométrie GeoJson
+
+Postgis embarque aussi des binaires permettant l'import export de données dans des formats SIG spécifiques comme shp2pgsl et pgsl2shp, mais dans notre cas nous utiliserons le plus souvent FME.
+
+## Manipulation des données géospatiales avec les fonctions PostGIS
+
+Il existe beaucoup de fonction permettant d'extraire de la données à partir de la Géométrie d'une entité en voici quelques exemple :
+- [ST_Distance](https://postgis.net/docs/ST_Distance.html) : permet d'extraire la distance entre deux géométries
+- [ST_SRID](https://postgis.net/docs/ST_SRID.html) : Extrait la le code EPSG de la projection de la géométrie (pas fiable à 100%)
+- [ST_Area](https://postgis.net/docs/ST_Area.html) : Calcule la surface occupé par un polygone
+
+## Requêtes spatiales basiques
+
+Les requêtes spatiales dans PostGIS permettent d'effectuer des opérations courantes sur les données géospatiales, telles que la recherche de points à l'intérieur d'une zone, l'identification des intersections entre des objets géométriques, ou encore le calcul des distances entre des entités spatiales. Voici quelques exemples de requêtes spatiales basiques :
+
+Recherche des points à l'intérieur d'une zone :
+
+```sql
+SELECT *
+FROM points
+WHERE ST_Within(geom, ST_GeomFromText('POLYGON((x1 y1, x2 y2, x3 y3, x4 y4, x1 y1))'));
+Cette requête sélectionne tous les points de la table "points" qui se trouvent à l'intérieur du polygone défini par les coordonnées (x1, y1), (x2, y2), (x3, y3), (x4, y4).
+```
+
+Identification des intersections entre des objets géométriques :
+
+```sql
+SELECT *
+FROM roads
+WHERE ST_Intersects(geom, ST_GeomFromText('LINESTRING(x1 y1, x2 y2)'));
+```
+
+Cette requête sélectionne toutes les routes de la table "roads" qui intersectent la ligne définie par les coordonnées (x1, y1) et (x2, y2).
+
+Calcul des distances entre des entités spatiales :
+
+```sql
+SELECT ST_Distance(a.geom, b.geom) AS distance
+FROM points a, points b
+WHERE a.id = 1 AND b.id = 2;
+```
+
+Cette requête calcule la distance entre les points ayant les identifiants 1 et 2 de la table "points".
+
+Fusionner plusieurs polygones en un seul :
+
+```sql
+SELECT ST_Union(geom) AS merged_polygon
+FROM polygons;
+```
+
+Ces exemples illustrent quelques requêtes spatiales de base dans PostGIS. Vous pouvez combiner ces opérations avec d'autres clauses SQL, tels que les filtres WHERE, les agrégations ou les jointures, pour réaliser des analyses spatiales plus complexes et répondre à des besoins spécifiques de votre application.
+
+Il y a plus d'information sur ce genre d'usage dans [la documentation de Postgis](http://postgis.fr/chrome/site/docs/workshop-foss4g/doc/spatial_relationships.html).
+
+## Requêtes spatiales avancées
+
+Il est rare que les données stockées en base soit parfaite ou que l'intersection des géométries pures soient satisfaisantes.
+
+Pour améliorer les résultat ils existe plusieurs techniques comme l'utilisation des tampons par exemple.
+
+```sql
+SELECT *
+FROM roads
+WHERE ST_Intersects(geom, ST_Buffer(ST_GeomFromText('LINESTRING(x1 y1, x2 y2)'), 50));
+```
+
+Dans cette exemple, on applique un buffer sur la géométrie à intersecter de 50 unité de projections.
+
+Sur ce genre de fonction il faut toujours se méfier de l'unité lié à la Projection, par exemple si la géométrie est en WGS84 (4326) alors l'unité est en radian alors qu'en utilisant des projection comme le Lambert 93 (2154) alors l'unité est le mètre.
+
+Du coup pour palier à ce problème il faut parfois convertir la géométrie dans une projection métrique pour simplifier l'utilisation de ce genre de fonction.
+
+```sql
+SELECT *
+FROM roads
+WHERE ST_Intersects(geom, ST_Trasnform(ST_Buffer(ST_Transform(ST_GeomFromText('LINESTRING(x1 y1, x2 y2)'), 2154), 50), 4326));
+```
+
+Ce genre d'opération peut déclencher une erreur en cas de violation de l'étendue de la projection, par exemple une donnée situé aux état-unis projeté en Lambert 93 sera incohérente ou provoquera l'apparition d'une erreur car le Lambert 93 ne couvre pas cette zone.
+
+Autre point important sur ce genre d'opération, ces transformations sont trés coûteuse en terme de performance, il est donc important d'appliquer ces modification à l'ensemble le plus petit.
+
+Par exemple si vous intersectez les géométries d'une table par une géométrie commune (en dur dans votre clause where) alors il vaut mieux appliquer les fonction de transformation à cette dernière géométrie. Exemple je fait une requête de ce type sur une table contenant une cinquantaine de ligne par une géométrie statique. Si j'applique la transformation à la géométrie statique je fais 1 transfromation suivi de 50 intersections alors qu'en faisant l'inverse postgres va réaliser 50 transformations suivi de 50 intersections.
+
+## Optimisation des requêtes spatiales avec les indexes
+
+L'utilisation des index spatiaux est essentielle pour améliorer les performances des requêtes géospatiales dans PostGIS. Les index spatiaux sont des structures de données spécifiquement conçues pour accélérer les opérations de recherche et de récupération de données spatiales en utilisant des techniques d'indexation spéciales adaptées aux données géométriques.
+
+Dans PostGIS, il existe différents types d'index spatiaux disponibles :
+
+- Index GIST (Generalized Search Tree) : L'index GIST est l'index spatial par défaut dans PostGIS. Il utilise une structure d'arbre généralisée pour organiser les données géométriques et permet une recherche efficace sur les requêtes spatiales. L'index GIST prend en charge divers types de données géométriques, tels que les points, les lignes et les polygones, ainsi que les opérations spatiales correspondantes.
+
+```sql
+CREATE INDEX idx_geom ON ma_table USING GIST (geom);
+```
+
+- Index GiST (Generalized Search Tree) : L'index GiST est une extension de l'index GIST qui offre des fonctionnalités supplémentaires pour les opérations spatiales avancées. Il permet de créer des index spatiaux pour des types de données spécifiques, tels que les géométries 3D, les géométries géodésiques ou les géométries temporelles. L'index GiST permet une recherche efficace même pour des données spatiales complexes et multidimensionnelles.
+
+```sql
+CREATE INDEX idx_geom_3d ON ma_table USING GIST (geom3d gist_geometry_ops);
+```
+
+- Index SP-GiST (Space-Partitioned Generalized Search Tree) : L'index SP-GiST est un type d'index spatiale qui divise l'espace en partitions pour organiser les données géométriques. Il est particulièrement adapté aux données spatiales qui peuvent être partitionnées de manière efficace, comme les données en grille ou en quadrillage. L'index SP-GiST offre des performances améliorées pour les requêtes spatiales dans ces types de données.
+
+```sql
+CREATE INDEX idx_geog ON ma_table USING SPGIST (geog);
+```
+
+L'utilisation des index spatiaux dans PostGIS permet d'accélérer considérablement les requêtes de recherche, de filtrage et d'analyse sur les données géospatiales. Lors de la conception de votre schéma de base de données et de vos requêtes, il est recommandé de prendre en compte l'ajout d'index spatiaux appropriés pour les colonnes géométriques utilisées fréquemment dans les opérations spatiales. Cela permettra d'optimiser les performances et de réduire le temps d'exécution des requêtes géospatiales, en tirant parti des capacités avancées d'indexation spatiale offertes par PostGIS.
+
+## Analyse de proximité et recherche de plus proches voisins
+
+
+L'analyse de proximité et la recherche de plus proches voisins sont des opérations courantes dans le domaine des données géospatiales. Dans PostGIS, vous pouvez effectuer ces types d'opérations à l'aide des fonctions fournies par l'extension.
+
+Pour effectuer une recherche de plus proches voisins, vous pouvez utiliser la fonction ST_Distance combinée avec la fonction ORDER BY dans une requête SELECT. Voici un exemple :
+
+```sql
+-- Recherche des 5 points les plus proches d'un point donné
+SELECT *
+FROM points
+ORDER BY geom <-> ST_SetSRID(ST_MakePoint(12.345, 67.890), 4326)
+LIMIT 5;
+```
+Dans cet exemple, nous utilisons la fonction <-> pour calculer la distance entre les points et les ordonner par ordre croissant. La fonction ST_SetSRID est utilisée pour définir le système de coordonnées de référence du point. Vous pouvez ajuster les coordonnées et le nombre de voisins que vous souhaitez récupérer en modifiant les valeurs dans la requête.
+
+Pour l'analyse de proximité, vous pouvez utiliser des fonctions telles que ST_DWithin ou ST_Intersects. Par exemple :
+
+```sql
+-- Recherche de tous les points situés à moins de 500 mètres d'un point donné
+SELECT *
+FROM points
+WHERE ST_DWithin(geom, ST_SetSRID(ST_MakePoint(12.345, 67.890), 4326), 500);
+```
+
+Cette requête retournera tous les points qui se trouvent à moins de 500 mètres du point spécifié. Vous pouvez ajuster la distance et les autres critères selon vos besoins.
+
+En utilisant ces fonctions de recherche de plus proches voisins et d'analyse de proximité, vous pouvez effectuer des opérations avancées sur les données géospatiales dans PostGIS. Veillez à prendre en compte les performances et à utiliser des index spatiaux appropriés pour optimiser vos requêtes.
+
+## Analyse de cluster et de densité spatiale
+
+L'analyse de cluster et de densité spatiale est une méthode couramment utilisée pour identifier des motifs et des regroupements dans les données géospatiales. Dans PostGIS, vous pouvez réaliser ces types d'analyses en utilisant les fonctionnalités et les requêtes disponibles.
+
+Pour effectuer une analyse de cluster, vous pouvez utiliser la fonction ST_ClusterDBSCAN qui implémente l'algorithme DBSCAN (Density-Based Spatial Clustering of Applications with Noise). Voici un exemple :
+
+```sql
+-- Analyse de cluster en utilisant l'algorithme DBSCAN
+SELECT ST_ClusterDBSCAN(geom, eps := 100, minpoints := 5) OVER () AS cluster_id, *
+FROM points;
+```
+
+Dans cet exemple, nous appliquons l'algorithme DBSCAN à une table de points en spécifiant un rayon de voisinage (eps) de 100 unités et un nombre minimum de points (minpoints) de 5 pour qu'un point soit considéré comme un noyau de cluster. La fonction ST_ClusterDBSCAN renvoie un identifiant de cluster pour chaque point.
+
+Pour l'analyse de densité spatiale, vous pouvez utiliser la fonction ST_Density qui calcule la densité de points dans une région donnée. Voici un exemple :
+
+```sql
+-- Calcul de la densité spatiale des points dans une zone rectangulaire
+SELECT ST_Density(geom, 100) AS density
+FROM points
+WHERE ST_Intersects(geom, ST_MakeEnvelope(10, 20, 30, 40, 4326));
+```
+
+Dans cet exemple, nous calculons la densité des points en utilisant une fenêtre rectangulaire définie par les coordonnées de son coin supérieur gauche et de son coin inférieur droit. La valeur 100 représente la taille de la grille utilisée pour estimer la densité.
+
+En utilisant ces fonctions et d'autres fonctionnalités de PostGIS, vous pouvez réaliser des analyses avancées de cluster et de densité spatiale sur vos données géospatiales. Il est recommandé d'adapter les paramètres des algorithmes et des fonctions en fonction de vos données et de vos objectifs d'analyse.
\ No newline at end of file
diff --git a/source/concept/bdd/postgres.md b/source/concept/bdd/postgres.md
new file mode 100644
index 0000000000000000000000000000000000000000..a18c41f04d1de3f9c04e4fa9d1d9f39950a3a3dc
--- /dev/null
+++ b/source/concept/bdd/postgres.md
@@ -0,0 +1,196 @@
+# 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.
+
+
+
+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.
+
+
+## Sauvegarde et restauration des données
+
+Il existe trois outils spécifiques à postgres
+
+- [pg_dump](https://docs.postgresql.fr/15/app-pgdump.html) : permet de créer un fichier de backup contenant la structure et/ou les données d'une base de donnée ou d'un de ses sous-objets.
+- [pg_restore](https://docs.postgresql.fr/15/app-pgrestore.html) : permet de restaurer une backup réalisée avec pg_dump ou pg_dumpall
+- [pg_dumpall](https://docs.postgresql.fr/15/app-pg-dumpall.html) : permet de créer un fichier contenant toutes les infos d'une base de donnée ou d'un cluster y compris les éléments partagés par tout le cluster.
+
+## Maintenance et optimisation des performances
+
+### Utilisation des vue matérialisées
+
+Une vue matérialisée fonctionne comme une vue, à la différence que le résultat de la requete SELECT va être stocké, ce qui permet un accés à la donnée bien plus rapide vu que toutes les étapes de construction du retour de la requête ne sera pas à refaire.
+
+La mise à jour de se retour est à demander explicitement via une requête SQL.
+
+```sql
+CREATE TABLE Customers (
+ customer_id SERIAL PRIMARY KEY,
+ customer_name VARCHAR(100)
+);
+
+CREATE TABLE Orders (
+ order_id SERIAL PRIMARY KEY,
+ order_date DATE,
+ customer_id INTEGER REFERENCES Customers(customer_id)
+);
+
+INSERT INTO Customers (customer_name) VALUES ('John Doe');
+INSERT INTO Customers (customer_name) VALUES ('Jane Smith');
+INSERT INTO Customers (customer_name) VALUES ('Robert Johnson');
+
+INSERT INTO Orders (order_date, customer_id) VALUES ('2022-01-01', 1);
+INSERT INTO Orders (order_date, customer_id) VALUES ('2022-02-01', 1);
+INSERT INTO Orders (order_date, customer_id) VALUES ('2022-03-01', 2);
+INSERT INTO Orders (order_date, customer_id) VALUES ('2022-04-01', 3);
+
+CREATE MATERIALIZED VIEW OrderCounts AS
+SELECT c.customer_id, c.customer_name, COUNT(o.order_id) AS order_count
+FROM Customers c
+LEFT JOIN Orders o ON c.customer_id = o.customer_id
+GROUP BY c.customer_id, c.customer_name;
+
+REFRESH MATERIALIZED VIEW OrderCounts;
+
+SELECT customer_name, order_count
+FROM OrderCounts;
+```
+
+Danc ce cas là le count n'aura un impact de performance que lors de la mise à jour de la vue matérialisée, la requête qui sera faite sur la vue matérialisée répondra aussi vite que si on interrogait une simple table.
+
+Cependant cette mise à jour statique présente un défaut, en cas d'utilisation d'une clause where, limitant le retour de données en fonction de l'utilisateur (comme la restrcition communal de vmap), la vue matérialisée contiendra les données de l'utilisateur ayant lancé le REFRESH.
+Autrement dit dans ce cas là, il vaut mieux lancer une vue matérialisée, sans utilisé de condition ou uniquement ce qui ne va pas dépendre du role qui interroge la donnée ou des circonstances d'interrogation, en revanche il est pertinent de continuer à utiliser ces restriction lors de l'interrogation de la vue matérialisée.
+
+Si la donnée change énormément et régulièrement, la vue matérialisée deviendra un handicape pour votre application.
+
+
+### Importance des index
+
+Il faut savoir que les colonnes soumis à des contraintes de type clés primaire ou unicité sont automatiquement indéxés avec un index de type B-TREE.
+
+Il est préférable d'indexer les colonnes qui seront régulièrement soumis à des utilisation dans des jointure ou des clause where, cependant attention une surutilisation des index fera grossir le l'espace disque occupé par votre base et pourra avoir un effet néfaste sur l'utilisation de votre base de donnée voir même ralentir vos requêtes.
+
+### Utilisation du VACUUM et automatisation
+
+Dans PostgreSQL, la commande VACUUM est utilisée pour récupérer l'espace disque occupé par les tables et les index. Elle permet également de mettre à jour les statistiques internes utilisées par l'optimiseur de requêtes pour prendre des décisions efficaces lors de l'exécution des requêtes.
+
+Voici ce que fait la commande VACUUM :
+
+- Récupération de l'espace disque : Lorsqu'une transaction est effectuée dans PostgreSQL, les données modifiées sont marquées comme "supprimées" mais ne sont pas immédiatement supprimées physiquement de l'espace disque. Au fil du temps, ces données supprimées s'accumulent et peuvent entraîner une fragmentation de l'espace disque. Le VACUUM récupère cet espace disque en supprimant physiquement les données marquées comme supprimées.
+
+- Mise à jour des statistiques : PostgreSQL utilise des statistiques internes sur les tables et les index pour prendre des décisions d'optimisation lors de l'exécution des requêtes. Ces statistiques incluent le nombre de lignes, la distribution des valeurs, etc. Le VACUUM met à jour ces statistiques pour refléter les modifications apportées aux données depuis la dernière exécution du VACUUM.
+
+Il existe différentes variantes de la commande VACUUM qui peuvent être utilisées en fonction des besoins spécifiques :
+
+- VACUUM : Cette commande effectue une récupération de l'espace et met à jour les statistiques pour toutes les tables et les index de la base de données.
+
+- VACUUM FULL : Cette commande effectue une récupération de l'espace plus agressive en réorganisant physiquement les données et les index. Elle peut nécessiter davantage de temps et de ressources, mais elle peut récupérer plus d'espace disque.
+
+- VACUUM ANALYZE : Cette commande effectue à la fois la récupération de l'espace et la mise à jour des statistiques. Elle est souvent utilisée pour maintenir les performances optimales de la base de données.
+
+Il est recommandé d'exécuter régulièrement la commande VACUUM sur votre base de données pour maintenir l'intégrité des données, prévenir la fragmentation de l'espace disque et garantir des performances de requête optimales.
+
+Il convient de noter que dans les versions plus récentes de PostgreSQL, le VACUUM est automatiquement planifié et exécuté en arrière-plan pour maintenir la base de données en bon état. Cependant, il est toujours recommandé de connaître et de comprendre l'utilisation de la commande VACUUM pour pouvoir l'exécuter manuellement si nécessaire.
+
+### Utilisation d'EXPLAIN et ANALYZE
+
+Dans PostgreSQL, les commandes EXPLAIN et ANALYZE sont utilisées pour analyser et optimiser les requêtes. Elles fournissent des informations détaillées sur la façon dont le moteur de base de données exécute une requête et permettent d'identifier les éventuels goulots d'étranglement ou problèmes de performance.
+
+La commande EXPLAIN permet d'obtenir le plan d'exécution d'une requête sans exécuter réellement la requête. Elle affiche des informations telles que les types d'opérations effectuées, l'ordre d'exécution des opérations, l'utilisation des indexes, les jointures, etc. Voici un exemple d'utilisation de la commande EXPLAIN :
+
+```sql
+EXPLAIN SELECT * FROM Customers WHERE age > 30;
+```
+
+La commande ANALYZE, quant à elle, est utilisée pour collecter et mettre à jour les statistiques sur les tables et les indexes. Ces statistiques sont utilisées par l'optimiseur de requêtes pour évaluer le coût des différentes stratégies d'exécution et choisir le plan d'exécution le plus efficace. Voici un exemple d'utilisation de la commande ANALYZE :
+
+```sql
+ANALYZE Customers;
+```
+
+Lorsqu'elles sont utilisées ensemble, les commandes EXPLAIN ANALYZE exécutent réellement la requête en plus de fournir le plan d'exécution et les statistiques détaillées. Cela permet d'obtenir des informations précises sur le temps d'exécution de la requête, le nombre de lignes traitées, les temps d'accès aux données, etc. Voici un exemple d'utilisation de la commande EXPLAIN ANALYZE :
+
+```sql
+EXPLAIN ANALYZE SELECT * FROM Customers WHERE age > 30;
+```
+
+
+
+L'analyse des résultats de EXPLAIN ANALYZE permet d'identifier les éventuels problèmes de performance dans une requête et de prendre des mesures pour les résoudre. Par exemple, vous pouvez ajuster les indexes, réorganiser les jointures, ajouter des clauses WHERE supplémentaires, etc.
+
+En résumé, l'utilisation des commandes EXPLAIN et ANALYZE dans PostgreSQL est essentielle pour comprendre et optimiser les performances des requêtes. Elles fournissent des informations précieuses sur le plan d'exécution et les statistiques des requêtes, ce qui permet d'identifier les problèmes de performance et de prendre des mesures pour les résoudre.
\ No newline at end of file
diff --git a/source/concept/index.rst b/source/concept/index.rst
index 7aeaa39d79281cc104ba8c98e13fb13ff7a4f197..ded59d64fea4678a70a5fa5d91605c9c2f2df229 100644
--- a/source/concept/index.rst
+++ b/source/concept/index.rst
@@ -13,4 +13,5 @@ Documentation Veremes sur les notions théoriques
:maxdepth: 2
:glob:
- system/index.rst
\ No newline at end of file
+ system/index.rst
+ bdd/index.rst
\ No newline at end of file