diff --git a/source/dev-vitis/bdd/generic.md b/source/concept/bdd/generic.md
similarity index 100%
rename from source/dev-vitis/bdd/generic.md
rename to source/concept/bdd/generic.md
diff --git a/source/dev-vitis/bdd/images/cardinalite_vitis.png b/source/concept/bdd/images/cardinalite_vitis.png
similarity index 100%
rename from source/dev-vitis/bdd/images/cardinalite_vitis.png
rename to source/concept/bdd/images/cardinalite_vitis.png
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/dev-vitis/bdd/images/join_type.png b/source/concept/bdd/images/join_type.png
similarity index 100%
rename from source/dev-vitis/bdd/images/join_type.png
rename to source/concept/bdd/images/join_type.png
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/dev-vitis/bdd/images/postgresql_objects_tutorialdba.png b/source/concept/bdd/images/postgresql_objects_tutorialdba.png
similarity index 100%
rename from source/dev-vitis/bdd/images/postgresql_objects_tutorialdba.png
rename to source/concept/bdd/images/postgresql_objects_tutorialdba.png
diff --git a/source/dev-vitis/bdd/images/vocabulaire_bdd1.png b/source/concept/bdd/images/vocabulaire_bdd1.png
similarity index 100%
rename from source/dev-vitis/bdd/images/vocabulaire_bdd1.png
rename to source/concept/bdd/images/vocabulaire_bdd1.png
diff --git a/source/dev-vitis/bdd/images/vocabulaire_bdd2.png b/source/concept/bdd/images/vocabulaire_bdd2.png
similarity index 100%
rename from source/dev-vitis/bdd/images/vocabulaire_bdd2.png
rename to source/concept/bdd/images/vocabulaire_bdd2.png
diff --git a/source/dev-vitis/bdd/images/webapp-stack-dev.png b/source/concept/bdd/images/webapp-stack-dev.png
similarity index 100%
rename from source/dev-vitis/bdd/images/webapp-stack-dev.png
rename to source/concept/bdd/images/webapp-stack-dev.png
diff --git a/source/concept/bdd/index.rst b/source/concept/bdd/index.rst
new file mode 100644
index 0000000000000000000000000000000000000000..90558f6ba81636c8b451e0f4ea4eb98557ac409f
--- /dev/null
+++ b/source/concept/bdd/index.rst
@@ -0,0 +1,18 @@
+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
diff --git a/source/dev-vitis/bdd/postgres.md b/source/concept/bdd/postgres.md
similarity index 55%
rename from source/dev-vitis/bdd/postgres.md
rename to source/concept/bdd/postgres.md
index 2e1ee6677933646b69d215d4c7488d096ae82538..d18983f8907dc3fe8361ba0ae72fbc901d928108 100644
--- a/source/dev-vitis/bdd/postgres.md
+++ b/source/concept/bdd/postgres.md
@@ -82,14 +82,118 @@ Pour résumer en passant par les vues vous n'avez à gérer les droits que sur l
 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.
 
-   C. Sauvegarde et restauration des données
-   D. Maintenance et optimisation des performances
+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;
+```
+
+![Explain Analyze](./images/explain_analyze_result.png)
+
+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.
 
 V. Intégration et échange de données
    A. Importation et exportation de données
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
diff --git a/source/dev-vitis/bdd/sql.md b/source/dev-vitis/bdd/sql.md
deleted file mode 100644
index 8c60309b413e85fd92ca699c8df67e9e72d73cd0..0000000000000000000000000000000000000000
--- a/source/dev-vitis/bdd/sql.md
+++ /dev/null
@@ -1,245 +0,0 @@
-# Manipulation des données
-
-## Langage de requête structuré (SQL)
-
-### Syntaxe de base
-
-SQL est un langage standardisé utilisé pour communiquer avec les bases de données relationnelles. Il comprend différents types de commandes qui permettent de manipuler les données et de gérer la structure de la base de données. La syntaxe de base SQL se compose principalement des commandes suivantes :
-
-- La commande SELECT est utilisée pour récupérer des données à partir d'une ou plusieurs tables. Elle permet de spécifier les colonnes à sélectionner, les tables à interroger et les critères de recherche pour filtrer les résultats.
-
-```sql
-SELECT * FROM schema.table;
-SELECT chp1, chp2 FROM schema.table;
-SELECT * FROM schema.table WHERE ma_condition = TRUE;
-```
-
-- La commande INSERT est utilisée pour insérer de nouvelles lignes de données dans une table spécifiée. Elle permet de spécifier les valeurs à insérer pour chaque colonne ou de récupérer les valeurs à partir d'une autre table ou d'une requête SELECT.
-
-```sql
-INSERT INTO schema.table (chp1, chp2) VALUES (chp1 chp2);
-INSERT INTO schema.table (chp1, chp2) VALUES (chp1 chp2) RETURNING *;
-INSERT INTO schema.table (chp1, chp2) SELECT chp1, chp2 FROM schema.table2 WHERE ma_condition;
-```
-
-- La commande UPDATE est utilisée pour modifier les données existantes dans une table. Elle permet de spécifier les colonnes à mettre à jour, les nouvelles valeurs à assigner et les critères de recherche pour identifier les lignes à modifier.
-
-```sql
-UPDATE schema.tabe SET chp1='val1' WHERE ma_condition = TRUE;
-UPDATE schema.tabe SET chp1='val1' WHERE ma_condition = TRUE RETURNING *;
-```
-
-- Les commandes DELETE et TRUNCATE sont utilisées pour supprimer des lignes de données d'une table spécifiée. Elle permet de spécifier les critères de recherche pour identifier les lignes à supprimer. Contrairement à la commande DELETE, qui supprime les lignes une par une et peut être ralentie pour de grandes quantités de données, la commande TRUNCATE permet de vider rapidement une table en supprimant toutes les données d'un coup. Elle réinitialise également les valeurs des index et des séquences associées à la table.
-
-```sql
-DELETE FROM schema.table WHERE ma_condition;
-TRUNCATE TABLE schema.table WHERE ma_condition;
-```
-
-- La commande CREATE est utilisée pour créer de nouvelles tables, vues, index ou autres structures dans la base de données. Elle permet de spécifier les noms, les types de données et les contraintes pour chaque colonne, ainsi que d'autres options de configuration.
-
-- La commande ALTER est utilisée pour modifier la structure d'une table existante. Elle permet d'ajouter, de supprimer ou de modifier des colonnes, des contraintes, des index ou d'autres éléments de la table.
-
-- La commande DROP est utilisée pour supprimer des tables, des vues, des index ou d'autres structures de la base de données.
-
-En plus de ces commandes de base, SQL offre également des fonctionnalités avancées, telles que les clauses JOIN pour combiner des données de plusieurs tables, les fonctions d'agrégation pour effectuer des calculs sur les données, les clauses GROUP BY pour regrouper les résultats, et bien d'autres.
-
-Chaque SGBD embarque sont interpréteur de requête SQL plus ou moins fidèle au standard.
-
-
-### Clause Where et jointure
-
-Les conditions utilisables dans les clause where et dans dans les jointures doivent retourner un booléen pour fonctionner.
-
-La clause WHERE est couramment utilisée dans les requêtes SQL pour filtrer les résultats en fonction de certaines conditions spécifiées. Elle permet de restreindre les données renvoyées par une requête en utilisant des conditions logiques et des opérateurs de comparaison. Les conditions peuvent être basées sur les valeurs des colonnes, sur des expressions arithmétiques, sur des chaînes de caractères, ou sur d'autres critères.
-
-Les opérateurs de comparaison couramment utilisés dans les conditions WHERE sont les suivants :
-
-- L'opérateur d'égalité (=) permet de comparer si une valeur est égale à une autre.
-- Les opérateurs de comparaison (<, >, <=, >=) permettent de comparer si une valeur est inférieure, supérieure, inférieure ou égale, ou supérieure ou égale à une autre.
-- Les opérateurs d'inégalité (<>, !=) permettent de comparer si une valeur est différente d'une autre.
-- L'opérateur IN permet de vérifier si une valeur fait partie d'un ensemble de valeurs spécifié.
-- L'opérateur LIKE permet d'effectuer une correspondance partielle entre une valeur et un motif (pattern) spécifié à l'aide de caractères génériques (wildcards) tels que '%' et '_'.
-- L'opérateur BETWEEN permet de vérifier si une valeur se situe entre deux autres valeurs.
-
-En ce qui concerne les jointures, elles permettent de combiner des données provenant de plusieurs tables dans une seule requête. Les jointures sont généralement basées sur des relations entre les colonnes des tables, qui sont définies à l'aide de clés primaires et de clés étrangères. Les jointures les plus couramment utilisées sont les suivantes :
-
-- La jointure INNER JOIN (ou simplement JOIN) permet de récupérer les enregistrements qui ont des correspondances dans les deux tables liées.
-- La jointure LEFT JOIN (ou LEFT OUTER JOIN) permet de récupérer tous les enregistrements de la table de gauche (table de gauche dans la clause JOIN) et les enregistrements correspondants de la table de droite.
-- La jointure RIGHT JOIN (ou RIGHT OUTER JOIN) permet de récupérer tous les enregistrements de la table de droite et les enregistrements correspondants de la table de gauche.
-- La jointure FULL JOIN (ou FULL OUTER JOIN) permet de récupérer tous les enregistrements des deux tables, en incluant les enregistrements correspondants et non correspondants.
-
-Les jointures sont spécifiées dans la clause FROM d'une requête SQL, en utilisant les conditions de jointure appropriées pour relier les tables entre elles. Les conditions de jointure sont généralement basées sur des clés primaires et des clés étrangères, et peuvent être combinées avec des conditions WHERE pour affiner les résultats.
-
-![join type](./images/join_type.png)
-
-En utilisant les conditions dans la clause WHERE et les jointures, les requêtes SQL peuvent être formulées de manière précise pour récupérer les données souhaitées à partir d'une ou plusieurs tables, en tenant compte des critères de filtrage et des relations entre les données. Cela permet d'obtenir des résultats plus pertinents et cohérents lors de l'interrogation de la base de données.
-
-## Requêtes avancées
-
-### Agrégation
-
-L'agrégation de données est une fonctionnalité essentielle des requêtes SQL qui permet de regrouper et de calculer des valeurs agrégées à partir des données d'une table ou d'une requête. Elle permet d'obtenir des informations résumées et statistiques sur un ensemble de données, plutôt que sur des enregistrements individuels. Les fonctions d'agrégation les plus couramment utilisées incluent COUNT, SUM, AVG, MAX et MIN.
-
-Lorsque vous utilisez des fonctions d'agrégation, vous pouvez également combiner des clauses GROUP BY pour regrouper les résultats en fonction de certaines colonnes. Cela permet d'effectuer des calculs agrégés pour chaque groupe distinct. Par exemple, vous pouvez regrouper les ventes par catégorie de produits et calculer le montant total des ventes pour chaque catégorie.
-
-### Sous-requêtes
-
-Les sous-requêtes, également appelées requêtes imbriquées, sont une fonctionnalité puissante des requêtes SQL qui permettent d'utiliser une requête à l'intérieur d'une autre requête. Elles sont principalement utilisées pour effectuer des opérations complexes et des filtres avancés en se basant sur les résultats d'une requête interne.
-
-Une sous-requête peut être utilisée dans différentes parties d'une requête SQL, telles que la clause SELECT, la clause FROM, la clause WHERE ou la clause HAVING. Elle agit comme une requête distincte qui est exécutée en premier, puis les résultats de cette requête sont utilisés comme source de données ou de filtrage pour la requête externe.
-
-Les sous-requêtes peuvent être utilisées de différentes manières :
-
-Filtrage : Une sous-requête peut être utilisée dans la clause WHERE pour filtrer les résultats en fonction d'une condition spécifique. Par exemple, vous pouvez utiliser une sous-requête pour récupérer tous les clients qui ont effectué des achats supérieurs à une certaine valeur.
-
-Comparaison : Une sous-requête peut être utilisée pour comparer une valeur avec les résultats d'une autre requête. Par exemple, vous pouvez utiliser une sous-requête dans la clause WHERE pour vérifier si un employé a un salaire supérieur à la moyenne des salaires de l'entreprise.
-
-Valeur d'une colonne : Une sous-requête peut être utilisée pour récupérer une valeur spécifique à partir d'une autre table ou d'une autre requête. Par exemple, vous pouvez utiliser une sous-requête dans la clause SELECT pour obtenir le nombre total de commandes passées par chaque client.
-
-Il est important de noter que les sous-requêtes peuvent impacter les performances des requêtes, surtout si elles sont mal optimisées ou si elles retournent un grand nombre de résultats. Il est recommandé de bien comprendre les concepts de sous-requêtes et de les utiliser avec parcimonie et efficacité.
-
-Les sous-requêtes offrent une flexibilité et une puissance supplémentaires lors de l'écriture de requêtes SQL complexes. Elles permettent d'effectuer des opérations avancées en utilisant les résultats d'une requête interne, facilitant ainsi la manipulation et l'analyse de données dans une base de données.
-
-```sql
-SELECT Name
-FROM Customers
-WHERE CustomerID IN (
-    SELECT CustomerID
-    FROM Orders
-)
-```
-
-### Opérations sur ensembles
-
-Les opérations sur les ensembles sont une fonctionnalité importante des requêtes SQL qui permettent de manipuler des ensembles de résultats en combinant, comparant ou en effectuant des opérations logiques sur eux. Ces opérations sont généralement effectuées sur des ensembles de résultats obtenus à partir de requêtes distinctes.
-
-Les opérations sur les ensembles les plus couramment utilisées incluent l'union, l'intersection et la différence.
-
-L'opération UNION permet de combiner les résultats de deux requêtes distinctes en un seul ensemble de résultats. Elle élimine automatiquement les doublons et renvoie tous les enregistrements uniques.
-
-L'opération INTERSECT permet de trouver les enregistrements communs à deux ensembles de résultats distincts. Elle renvoie uniquement les enregistrements qui se trouvent à la fois dans le premier et le second ensemble.
-
-L'opération EXCEPT (ou MINUS dans certaines bases de données) permet de trouver les enregistrements qui se trouvent dans le premier ensemble mais qui ne sont pas présents dans le second ensemble. Elle renvoie uniquement les enregistrements du premier ensemble qui ne se trouvent pas dans le second ensemble.
-
-Ces opérations sur les ensembles peuvent être utilisées pour effectuer des tâches telles que la combinaison de résultats de requêtes, la recherche d'enregistrements communs ou la suppression de résultats indésirables.
-
-Il est important de noter que pour pouvoir effectuer ces opérations, les ensembles de résultats doivent avoir des structures de colonnes et des types de données compatibles. Les requêtes utilisées pour les opérations sur les ensembles doivent donc renvoyer des résultats avec des colonnes correspondantes.
-
-Les opérations sur les ensembles permettent d'effectuer des manipulations complexes sur les résultats des requêtes SQL, offrant ainsi une grande flexibilité dans la récupération et le traitement des données. Elles permettent de combiner, d'interagir et de comparer facilement différents ensembles de résultats, facilitant ainsi l'analyse et la manipulation de données dans une base de données.
-
-### Requêtes récursives
-
-Les requêtes récursives sont une fonctionnalité avancée des requêtes SQL qui permettent de réaliser des opérations itératives en se basant sur les résultats précédents d'une requête. Elles sont utilisées pour traiter des structures de données hiérarchiques ou pour effectuer des calculs récursifs.
-
-Une requête récursive se compose de deux parties distinctes : la partie de base et la partie récursive. La partie de base définit les résultats initiaux de la requête, tandis que la partie récursive utilise les résultats précédents pour calculer les résultats suivants.
-
-Le fonctionnement d'une requête récursive se fait en plusieurs étapes :
-
-- Définition de la partie de base : La partie de base de la requête est la première itération de la requête récursive. Elle est exécutée de manière similaire à une requête normale et renvoie les résultats initiaux.
-
-- Définition de la partie récursive : La partie récursive utilise les résultats précédents de la requête pour calculer les résultats suivants. Elle est basée sur une relation de récurrence définie par le développeur. Cette partie est exécutée répétitivement jusqu'à ce qu'une condition de terminaison soit satisfaite.
-
-- Combinaison des résultats : À chaque itération de la partie récursive, les nouveaux résultats sont combinés avec les résultats précédents pour former l'ensemble complet des résultats. Les résultats finaux sont renvoyés une fois que la condition de terminaison est atteinte.
-
-L'utilisation de requêtes récursives est courante pour manipuler des structures de données hiérarchiques telles que les arbres, les graphes ou les relations parent-enfant. Elles permettent de parcourir et de manipuler ces structures de manière itérative en utilisant les résultats précédents.
-
-Les requêtes récursives nécessitent une attention particulière lors de leur mise en œuvre, car une mauvaise utilisation peut entraîner des boucles infinies ou des performances médiocres. Il est important de définir une condition de terminaison appropriée pour éviter les boucles infinies et d'optimiser les requêtes récursives pour garantir des performances efficaces.
-
-En conclusion, les requêtes récursives offrent une fonctionnalité puissante pour effectuer des calculs itératifs ou manipuler des structures de données hiérarchiques. Elles permettent d'obtenir des résultats complexes en utilisant les résultats précédents d'une requête, offrant ainsi une flexibilité et une expressivité supplémentaires dans les requêtes SQL.
-
-```sql
-WITH RECURSIVE EmployeeHierarchy AS (
-    SELECT EmployeeID, Name, ManagerID, 0 AS Level
-    FROM Employees
-    WHERE EmployeeID = <ID_du_manager>
-
-    UNION ALL
-
-    SELECT E.EmployeeID, E.Name, E.ManagerID, EH.Level + 1
-    FROM Employees AS E
-    INNER JOIN EmployeeHierarchy AS EH ON E.ManagerID = EH.EmployeeID
-)
-SELECT EmployeeID, Name, Level
-FROM EmployeeHierarchy
-ORDER BY Level, EmployeeID;
-```
-
-### Opérateur de fenétrage
-
-L'opérateur de fenêtrage est une fonctionnalité avancée des requêtes SQL qui permet d'effectuer des calculs et des agrégations sur des ensembles de lignes définis par une fenêtre spécifique. Il permet d'appliquer des fonctions analytiques sur un groupe spécifique de lignes sans modifier la structure globale de la requête.
-
-L'opérateur de fenêtrage utilise la clause OVER suivie d'une clause de fenêtre pour définir les limites et les conditions de la fenêtre. Cette clause peut spécifier des critères de tri, des partitions et des clauses de délimitation pour définir la plage des lignes sur lesquelles les calculs seront effectués.
-
-Voici un exemple pour illustrer l'utilisation de l'opérateur de fenêtrage :
-
-Supposons que nous ayons une table "Sales" qui enregistre les ventes réalisées par différents vendeurs dans une entreprise, avec les colonnes "SalesID", "Salesperson", "Product", "Amount" et "Date". Nous voulons calculer la somme cumulative des ventes de chaque vendeur, triées par date de vente.
-
-```sql
-SELECT SalesID, Salesperson, Product, Amount, Date,
-       SUM(Amount) OVER (PARTITION BY Salesperson ORDER BY Date) AS CumulativeAmount
-FROM Sales
-```
-
-Dans cet exemple, nous utilisons l'opérateur de fenêtrage avec la fonction d'agrégation SUM pour calculer la somme cumulative des ventes (Amount) pour chaque vendeur (Salesperson), en les triant par date de vente (Date).
-
-La clause OVER spécifie la fenêtre de calcul, tandis que la clause PARTITION BY définit la partition des données par vendeur. Ainsi, la somme cumulative sera calculée séparément pour chaque vendeur.
-
-En utilisant cet opérateur de fenêtrage, la requête renverra les détails des ventes (SalesID, Salesperson, Product, Amount, Date) ainsi que la somme cumulative (CumulativeAmount) pour chaque vendeur, avec les résultats triés par date de vente.
-
-L'opérateur de fenêtrage est extrêmement utile pour effectuer des calculs analytiques avancés, tels que les sommes cumulatives, les moyennes mobiles, les rangs, les pourcentages, etc. Il permet de réaliser des analyses plus précises sur des ensembles de données spécifiques, sans avoir besoin de regrouper ou de modifier la structure de la requête principale.
-
-
-## Indexation des données
-
-L'indexation des données est une technique utilisée dans les bases de données pour améliorer les performances des requêtes, en particulier lors de l'exécution de requêtes SELECT. L'indexation consiste à créer des structures de données supplémentaires, appelées index, qui permettent un accès rapide et efficace aux données.
-
-Un index est essentiellement une copie partielle des données de la table, organisée de manière à faciliter la recherche et la récupération des enregistrements. Il peut être créé sur une ou plusieurs colonnes spécifiques de la table. Lorsqu'une requête SELECT est exécutée sur une table avec un index approprié, la base de données peut utiliser cet index pour localiser rapidement les enregistrements pertinents, plutôt que de parcourir l'ensemble de la table.
-
-L'impact de l'indexation sur une requête SELECT peut être significatif. Avec un index bien conçu, la recherche et le filtrage des données deviennent beaucoup plus rapides. Lorsqu'une condition de recherche correspond à une colonne indexée, la base de données peut utiliser l'index pour identifier rapidement les enregistrements qui satisfont la condition, réduisant ainsi le temps d'exécution de la requête.
-
-Cependant, il est important de noter que l'indexation peut également avoir des effets négatifs sur les performances. Les index occupent de l'espace de stockage supplémentaire, ce qui peut augmenter la taille de la base de données. De plus, les index doivent être maintenus et mis à jour chaque fois que des modifications sont apportées aux données, ce qui peut entraîner un léger impact sur les opérations d'insertion, de mise à jour et de suppression.
-
-Il est essentiel de concevoir et de gérer judicieusement les index pour obtenir un bon équilibre entre les avantages de performance et les coûts associés. Il est recommandé de créer des index sur les colonnes couramment utilisées dans les requêtes SELECT, en particulier celles qui sont souvent utilisées dans les clauses WHERE pour filtrer les enregistrements. Il est également important d'évaluer régulièrement les performances de la base de données et d'ajuster les index en conséquence pour maintenir une optimisation continue.
-
-En conclusion, l'indexation des données joue un rôle crucial dans l'amélioration des performances des requêtes SELECT. Elle permet d'accélérer la recherche et la récupération des données en utilisant des structures d'index optimisées. Cependant, il est important de bien concevoir et gérer les index pour éviter les impacts négatifs sur les opérations de modification des données et pour maintenir des performances optimales.
-
-PostgreSQL propose plusieurs méthodes d'indexation pour améliorer les performances des requêtes. Voici une description des principales méthodes d'indexation disponibles dans PostgreSQL :
-
-- Index B-tree : C'est la méthode d'indexation par défaut dans PostgreSQL. Les index B-tree sont efficaces pour les opérations de recherche et de tri. Ils fonctionnent bien avec des valeurs uniques ou peu répétées. Les index B-tree sont équilibrés et permettent des recherches rapides en utilisant des opérations de comparaison, telles que l'égalité ou l'inégalité.
-
-- Index Hash : Les index Hash utilisent une fonction de hachage pour stocker les valeurs d'index. Ils sont adaptés pour les recherches rapides sur des valeurs égalitaires, mais moins efficaces pour les opérations de tri ou de recherche basées sur des plages. Les index Hash fonctionnent bien lorsque les données sont uniformément réparties et que les valeurs d'index sont bien distribuées.
-
-- Index GiST (Generalized Search Tree) : Les index GiST sont polyvalents et peuvent être utilisés pour différents types de recherches, tels que les recherches basées sur des plages, les opérations de texte et les opérations spatiales. Ils permettent de créer des index personnalisés en implémentant des méthodes d'indexation spécifiques pour différents types de données.
-
-- Index GIN (Generalized Inverted Index) : Les index GIN sont utilisés pour les recherches en texte intégral et pour les opérations sur des tableaux ou des listes de valeurs. Ils sont efficaces pour les recherches de correspondance partielle, de recherche de mots-clés et d'opérations de recherche avancées.
-
-- Index BRIN (Block Range Index) : Les index BRIN sont conçus pour les tables volumineuses contenant des données ordonnées par ordre d'insertion. Ils permettent de réduire la taille de l'index en regroupant les blocs de données contigus et en conservant les informations de début et de fin pour chaque groupe de blocs. Les index BRIN sont utiles pour les requêtes d'agrégation ou les opérations de recherche basées sur des plages.
-
-Chaque méthode d'indexation a ses propres avantages et inconvénients, et la sélection de la méthode appropriée dépend du type de données, des opérations de requête fréquentes et des objectifs de performance spécifiques. PostgreSQL permet également de combiner différentes méthodes d'indexation pour optimiser les performances dans des scénarios plus complexes.
-
-## Transactions
-
-La gestion des transactions est un concept fondamental dans les systèmes de bases de données qui garantit l'intégrité et la cohérence des données. Une transaction représente une séquence d'opérations exécutées comme une unité indivisible, c'est-à-dire soit toutes les opérations sont exécutées avec succès et validées, soit aucune opération n'est exécutée du tout.
-
-Dans une base de données, une transaction est généralement définie par une combinaison d'opérations de lecture (SELECT) et d'opérations de modification (INSERT, UPDATE, DELETE). Les transactions permettent de regrouper ces opérations et d'assurer que l'ensemble des modifications apportées aux données est cohérent et durable.
-
-La gestion des transactions est basée sur le concept ACID, qui signifie Atomicité, Cohérence, Isolation et Durabilité :
-
-Atomicité : Une transaction est une unité atomique qui est exécutée dans son intégralité ou pas du tout. Si une opération échoue ou rencontre une erreur, toutes les opérations précédentes sont annulées (rollback), et les données sont restaurées à leur état précédent.
-Cohérence : Une transaction garantit que les données sont maintenues dans un état valide avant et après son exécution. Les contraintes et les règles d'intégrité sont respectées tout au long de la transaction.
-Isolation : Les transactions s'exécutent de manière isolée les unes des autres. Cela signifie que les opérations d'une transaction en cours ne sont pas visibles pour les autres transactions jusqu'à ce qu'elles soient validées. Cela préserve l'intégrité des données et évite les problèmes de concurrence.
-Durabilité : Une fois qu'une transaction est validée et confirmée, les modifications apportées aux données deviennent permanentes et survivront à d'éventuelles pannes du système.
-Voici un exemple concret pour illustrer la gestion des transactions :
-
-```sql
-BEGIN TRANSACTION;
-SELECT stock_quantity FROM Inventory WHERE product_id = <id_produit> INTO @stock_quantity;
-UPDATE Inventory SET stock_quantity = @stock_quantity - <quantite_commandee> WHERE product_id = <id_produit>;
-UPDATE Products SET stock = stock - <quantite_commandee> WHERE product_id = <id_produit>;
-
--- ROLLBACK; pour tout annuler
-COMMIT;
-```
-
-La gestion des transactions est essentielle pour garantir la cohérence et l'intégrité des données dans les systèmes de bases de données. Elle permet d'assurer que les opérations sont exécutées avec succès ou entièrement annulées en cas d'erreur, offrant ainsi une garantie de fiabilité des données.
\ No newline at end of file