Bases de données

Une base de données (BDD) est une collection structurée et organisée d'informations (données) qui sont stockées électroniquement dans un système informatique. Imaginez une bibliothèque très bien rangée où chaque livre est classé, indexé et facile à retrouver. C'est un peu le rôle d'une base de données pour les informations numériques.

Son rôle principal est de permettre un stockage persistant des données. Cela signifie que les informations ne disparaissent pas lorsque l'ordinateur est éteint. Elles sont destinées à être conservées et accessibles sur le long terme.

Les bases de données sont gérées par un Système de Gestion de Bases de Données (SGBD). C'est un logiciel qui permet de :

• Créer la structure de la base de données.
• Insérer de nouvelles données.
• Modifier les données existantes.
• Supprimer des données.
• Interroger les données pour en extraire des informations pertinentes.

En résumé, une base de données est un système d'information centralisé et organisé, conçu pour faciliter l'accès, la gestion et la mise à jour d'un grand volume de données.

Les bases de données sont partout ! Voici quelques exemples pour illustrer leur importance :

• Sites web : Quand vous vous connectez à un site comme Amazon, votre profil, votre historique de commandes, les descriptions des produits, les avis clients... tout cela est stocké dans une base de données.
• Applications mobiles : Votre liste de contacts, vos messages, les données de votre application de fitness, les paramètres de vos jeux, sont souvent gérés par des bases de données locales ou distantes.
• Gestion commerciale : Les entreprises utilisent des bases de données pour stocker les informations sur leurs clients, leurs produits, leurs employés, leurs factures, leurs stocks. C'est essentiel pour la comptabilité, la logistique et la relation client.
• Réseaux sociaux : Facebook, Instagram, Twitter... stockent des milliards de données : profils utilisateurs, publications, photos, vidéos, commentaires, relations entre amis. C'est un exemple massif d'utilisation de bases de données distribuées.
• Banques : Les informations sur les comptes clients, les transactions, les soldes, sont stockées dans des bases de données hautement sécurisées et performantes.

Ces exemples montrent que les bases de données sont fondamentales pour la persistance et l'accessibilité des informations dans notre monde numérique.

Les bases de données offrent de nombreux avantages, mais présentent aussi quelques défis.

Avantages :

• Cohérence des données : Elles garantissent que les données sont exactes et fiables. Par exemple, un numéro de client ne peut pas exister deux fois.
• Réduction de la redondance : Les informations sont stockées une seule fois, ce qui évite les duplications inutiles et les incohérences.
• Sécurité des données : Les SGBD permettent de définir des droits d'accès précis, pour que seules les personnes autorisées puissent consulter ou modifier certaines informations.
• Partage des données : Plusieurs utilisateurs ou applications peuvent accéder simultanément aux mêmes données.
• Indépendance des données : La manière dont les données sont stockées physiquement est séparée de la manière dont les applications y accèdent. Cela facilite les modifications sans impacter les programmes.
• Accès rapide et efficace : Les SGBD sont optimisés pour retrouver rapidement des informations même dans de très grands volumes de données.

Inconvénients :

• Complexité de mise en œuvre : Concevoir et mettre en place une base de données, surtout pour de grands projets, peut être complexe et nécessite des compétences spécialisées.
• Coût : Les SGBD professionnels peuvent être chers, et la maintenance demande des ressources.
• Taille : Une base de données peut devenir très volumineuse et nécessiter beaucoup d'espace de stockage.
• Vulnérabilité : Une mauvaise configuration ou une attaque peut entraîner la perte ou la compromission de toutes les données. La sauvegarde régulière est cruciale.
• Performance : Mal conçue ou mal gérée, une base de données peut devenir lente et affecter les performances des applications qui l'utilisent.

Malgré ces inconvénients, les avantages des bases de données sont tels qu'elles sont devenues indispensables dans le développement logiciel moderne.

Le modèle Entité-Association (EA), aussi appelé Entité-Relation (ER), est le plus courant pour le MCD. Il permet de représenter les informations à l'aide de trois concepts fondamentaux :

1. L'Entité : Représente un objet d'intérêt, concret ou abstrait, dont on veut stocker des informations. C'est une catégorie de choses. Exemples : Client, Produit, Commande, Livre.
2. L'Association : Représente un lien sémantique entre une ou plusieurs entités. Elle décrit comment les entités interagissent ou sont liées. Exemples : Un Client passe une Commande, un Auteur écrit un Livre.
3. La Propriété / Attribut : C'est une caractéristique ou une information descriptive d'une entité ou d'une association. Exemples : Pour l'entité Client, les attributs pourraient être nom, prénom, adresse, email. Pour l'entité Produit, libellé, prix, quantité_stock.

Le modèle Entité-Association est une représentation abstraite et graphique des données.

Pour identifier les entités, posez-vous la question : "De quoi ai-je besoin de stocker des informations ?" Les noms communs et les concepts clés dans la description d'un problème sont souvent de bonnes entités.

Une fois les entités identifiées, il faut lister leurs attributs. Ce sont les informations spécifiques que l'on souhaite conserver pour chaque occurrence de l'entité.

• Entité : Livre
  • Attributs : ISBN (identifiant unique), Titre, Année_publication, Nombre_pages.
• Entité : Auteur
  • Attributs : ID_Auteur (identifiant unique), Nom, Prénom, Date_naissance.
• Entité : Adhérent
  • Attributs : ID_Adhérent (identifiant unique), Nom, Prénom, Adresse, Date_adhésion.

Chaque entité doit avoir au moins un attribut qui l'identifie de manière unique. C'est l'identifiant unique ou la clé primaire conceptuelle. Pour Livre, c'est ISBN. Pour Auteur, c'est ID_Auteur.

Les attributs ont souvent un type de données implicite (texte, nombre entier, date, etc.).

Les associations décrivent les liens entre les entités. Pour chaque association, on définit des cardinalités. Les cardinalités indiquent le nombre minimum et maximum de fois qu'une occurrence d'une entité peut être liée à des occurrences de l'autre entité via cette association.

Elles s'écrivent sous la forme (min, max).

Types de cardinalités courantes :

• (0,1) : Zéro ou une fois (optionnel)
• (1,1) : Exactement une fois (obligatoire et unique)
• (0,N) : Zéro ou plusieurs fois (optionnel et multiple)
• (1,N) : Une ou plusieurs fois (obligatoire et multiple)

• Association entre Auteur et Livre : "Écrit"

  • Un Auteur peut écrire (0,N) Livres (un auteur peut n'avoir encore rien écrit, ou plusieurs livres).
  • Un Livre est écrit par (1,N) Auteurs (un livre doit avoir au moins un auteur, et peut en avoir plusieurs).
  • Ce type d'association est appelé "plusieurs-à-plusieurs" (N-M).

• Association entre Adhérent et Emprunt : "Effectue"

  • Un Adhérent effectue (0,N) Emprunts.
  • Un Emprunt est effectué par (1,1) Adhérent.
  • Ce type d'association est appelé "un-à-plusieurs" (1-N).

• Association entre Emprunt et Livre : "Concerne"

  • Un Emprunt concerne (1,1) Livre (un emprunt est toujours pour un seul livre).
  • Un Livre est concerné par (0,N) Emprunts (un livre peut n'avoir jamais été emprunté, ou l'avoir été plusieurs fois).
  • C'est aussi un "un-à-plusieurs" (1-N).

Les associations peuvent elles-mêmes avoir des attributs, par exemple, l'association "Emprunt" pourrait avoir les attributs Date_emprunt et Date_retour_prévue.

Un diagramme Entité-Association (DEA) est une représentation graphique du MCD. Il utilise des symboles spécifiques :

• Rectangle pour les entités.
• Ovale pour les attributs (liés aux entités par une ligne). L'identifiant unique est souvent souligné.
• Losange pour les associations (liées aux entités par des lignes, avec les cardinalités notées à chaque extrémité).

Voici un exemple simple de DEA pour notre bibliothèque :

+-----------+       (0,N) Écrit (1,N)       +-------+
|  Auteur   |-------------------------------| Livre |
+-----------+                               +-------+
| ID_Auteur (PK) <---- Clé primaire         | ISBN (PK)
| Nom                                       | Titre
| Prénom                                    | Année_publication
| Date_naissance                            | Nombre_pages
+-----------+                               +-------+
      |
      | (1,1) Est_auteur_de (0,N)
      |
+-------------------------------------------------+
|                                                 |
| +-----------+       (0,N) Effectue (1,1)       |
| | Adhérent  |-------------------------------| Emprunt |
| +-----------+                               +---------+
| | ID_Adhérent (PK)                          | ID_Emprunt (PK)
| | Nom                                       | Date_emprunt
| | Prénom                                    | Date_retour_prévue
| | Adresse                                   |
| | Date_adhésion                             |
| +-----------+                               +---------+
|                                                 |
|                                                 | (1,1) Concerne (0,N)
|                                                 |
|                                         +-------+
|                                         | Livre |  (Ce Livre est le même que celui ci-dessus)
|                                         +-------+

Note : Les lignes ici sont simplifiées, en réalité le lien "Concerne" irait vers l'entité Livre déjà définie.

Un diagramme EA est un outil de communication puissant pour comprendre la structure des données. Il sert de base pour la prochaine étape : le modèle relationnel.

Le passage du MCD (conceptuel) au modèle relationnel (logique) est une étape de transformation. Chaque entité et chaque association du MCD sont transformées en une ou plusieurs tables (aussi appelées relations).

• Entité → Table : Chaque entité du MCD devient une table dans le modèle relationnel.
  • Les attributs de l'entité deviennent les colonnes (ou champs) de la table.
  • Chaque occurrence de l'entité devient une ligne (ou enregistrement, ou tuple) dans la table.
  • L'identifiant unique de l'entité devient la clé primaire de la table.

L'entité Livre (ISBN, Titre, Année_publication, Nombre_pages) devient la table LIVRE :

Ces deux concepts sont fondamentaux pour l'intégrité et la structuration du modèle relationnel.

• Clé Primaire (Primary Key - PK) :

  • C'est un attribut (ou un ensemble d'attributs) qui identifie de manière unique chaque ligne d'une table.
  • Elle ne peut pas contenir de valeurs dupliquées.
  • Elle ne peut pas contenir de valeur NULL (vide).
  • Elle garantit l'unicité de chaque enregistrement.
  • Exemple : ISBN pour la table LIVRE, ID_Auteur pour la table AUTEUR.

• Clé Étrangère (Foreign Key - FK) :

  • C'est un attribut (ou un ensemble d'attributs) dans une table qui fait référence à la clé primaire d'une autre table.
  • Elle établit une relation entre deux tables.
  • Elle assure l'intégrité référentielle : elle garantit que si une valeur existe dans une clé étrangère, elle doit exister en tant que clé primaire dans la table référencée. Cela évite les "liens cassés".
  • Exemple : Dans une table COMMANDE, un attribut ID_Client serait une clé étrangère qui ferait référence à ID_Client de la table CLIENT.

La manière dont les associations du MCD sont transformées en tables dépend de leurs cardinalités.

• Relation "Un-à-Plusieurs" (1-N) :

  • C'est le cas le plus simple. L'identifiant de la table "côté 1" est ajouté comme clé étrangère dans la table "côté N".
  • Exemple : Adhérent (1,1) <-- Effectue --> (0,N) Emprunt
    • Table ADHERENT : ID_Adhérent (PK), Nom, Prénom, ...
    • Table EMPRUNT : ID_Emprunt (PK), Date_emprunt, Date_retour_prévue, ID_Adhérent (FK)
    • Ici, ID_Adhérent dans EMPRUNT fait référence à ID_Adhérent dans ADHERENT.

• Relation "Plusieurs-à-Plusieurs" (N-M) :

  • Ce type de relation ne peut pas être représenté directement avec une clé étrangère simple. Il faut créer une table d'association (ou table de jointure) spécifique.
  • Cette nouvelle table aura comme clé primaire une combinaison des clés primaires des deux tables qu'elle relie. Elle contiendra également ces clés primaires comme clés étrangères.
  • Exemple : Auteur (0,N) <-- Écrit --> (1,N) Livre
    • Table AUTEUR : ID_Auteur (PK), Nom, Prénom, ...
    • Table LIVRE : ISBN (PK), Titre, Année_publication, ...
    • Table d'association ECRIRE :
      • ID_Auteur (FK vers AUTEUR)
      • ISBN (FK vers LIVRE)
      • La clé primaire de ECRIRE est la combinaison (ID_Auteur, ISBN).

La création d'une table d'association est la solution standard pour les relations N-M.

SQL est utilisé pour :

• Définir la structure des bases de données (création de tables, de vues, etc.). C'est le DDL (Data Definition Language).
• Manipuler les données (insertion, modification, suppression). C'est le DML (Data Manipulation Language).
• Interroger les données (sélectionner des informations). C'est la partie la plus utilisée du DML.
• Contrôler l'accès aux données (permissions). C'est le DCL (Data Control Language).

Le SQL est un langage puissant et universellement reconnu. Apprendre SQL est essentiel pour quiconque souhaite travailler avec des bases de données.

La commande CREATE TABLE est utilisée pour définir la structure d'une nouvelle table dans la base de données. Il faut spécifier le nom de la table, le nom de chaque colonne, leur type de données et d'éventuelles contraintes.

Syntaxe de base :

CREATE TABLE NomDeLaTable (
    NomColonne1 TypeDeDonnee1 [CONTRAINTE],
    NomColonne2 TypeDeDonnee2 [CONTRAINTE],
    ...
    [CONSTRAINT NomContrainte PRIMARY KEY (NomColonnePK)],
    [CONSTRAINT NomContrainte FOREIGN KEY (NomColonneFK) REFERENCES TableReferencee(ColonnePKReferencee)]
);

Exemple : Création des tables ADHERENT et LIVRE

CREATE TABLE ADHERENT (
    ID_Adherent INT PRIMARY KEY,
    Nom VARCHAR(50) NOT NULL,
    Prenom VARCHAR(50) NOT NULL,
    Adresse VARCHAR(100),
    Date_Adhesion DATE
);

CREATE TABLE LIVRE (
    ISBN VARCHAR(13) PRIMARY KEY,
    Titre VARCHAR(255) NOT NULL,
    Annee_Publication INT,
    Nb_Pages INT
);

• INT : pour les nombres entiers.
• VARCHAR(n) : pour les chaînes de caractères de longueur variable, avec un maximum de n caractères.
• DATE : pour les dates.
• PRIMARY KEY : désigne la colonne comme clé primaire.
• NOT NULL : indique que la colonne ne peut pas être vide.

La commande INSERT INTO permet d'ajouter de nouvelles lignes (enregistrements) dans une table.

Syntaxe de base :

INSERT INTO NomDeLaTable (Colonne1, Colonne2, ...)
VALUES (Valeur1, Valeur2, ...);

Ou, si vous insérez des valeurs pour toutes les colonnes dans l'ordre de leur définition :

INSERT INTO NomDeLaTable VALUES (Valeur1, Valeur2, ...);

Exemple : Insertion dans ADHERENT et LIVRE

INSERT INTO ADHERENT (ID_Adherent, Nom, Prenom, Adresse, Date_Adhesion)
VALUES (1, 'Dupont', 'Jean', '12 Rue de la Paix, Paris', '2023-01-15');

INSERT INTO ADHERENT VALUES (2, 'Martin', 'Sophie', '3 Av. des Champs, Lyon', '2022-11-20');

INSERT INTO LIVRE (ISBN, Titre, Annee_Publication, Nb_Pages)
VALUES ('978-2070360344', '1984', 1949, 384);

INSERT INTO LIVRE VALUES ('978-0743273565', 'The Great Gatsby', 1925, 180);

Les chaînes de caractères et les dates doivent être encadrées par des guillemets simples ''.

La commande SELECT est la plus utilisée en SQL. Elle permet de récupérer des informations à partir d'une ou plusieurs tables.

Syntaxe de base :

SELECT Colonne1, Colonne2, ...      -- Quelles colonnes je veux voir
FROM NomDeLaTable                   -- De quelle table
WHERE Condition                     -- Quelles lignes je veux (filtrage optionnel)
ORDER BY ColonneTri ASC/DESC;       -- Comment je veux trier les résultats (optionnel)

• SELECT * : pour sélectionner toutes les colonnes.
• WHERE : permet de filtrer les résultats selon une condition.
• ORDER BY : permet de trier les résultats. ASC pour ascendant (par défaut), DESC pour descendant.

• Sélectionner tous les adhérents :

  SELECT *
  FROM ADHERENT;
  

• Sélectionner le nom et le prénom des adhérents :

  SELECT Nom, Prenom
  FROM ADHERENT;
  

• Sélectionner les livres publiés après 1900 :

  SELECT Titre, Annee_Publication
  FROM LIVRE
  WHERE Annee_Publication > 1900;
  

• Sélectionner les adhérents triés par nom, puis par prénom :

  SELECT ID_Adherent, Nom, Prenom
  FROM ADHERENT
  ORDER BY Nom ASC, Prenom ASC;
  

  (Ou ORDER BY Nom, Prenom car ASC est la valeur par défaut).

La commande UPDATE permet de modifier des données existantes dans une ou plusieurs lignes d'une table.

Syntaxe de base :

UPDATE NomDeLaTable
SET Colonne1 = NouvelleValeur1,
    Colonne2 = NouvelleValeur2,
    ...
WHERE Condition; -- CRITIQUE : sans WHERE, TOUTES les lignes seront modifiées !

• Mettre à jour l'adresse d'un adhérent :

  UPDATE ADHERENT
  SET Adresse = 'Nouvelle Adresse, Paris'
  WHERE ID_Adherent = 1;
  

• Augmenter le nombre de pages d'un livre (si une erreur a été faite) :

  UPDATE LIVRE
  SET Nb_Pages = Nb_Pages + 10
  WHERE ISBN = '978-2070360344';
  

  Soyez extrêmement prudent avec la clause WHERE dans une commande UPDATE. Une erreur ici peut corrompre une grande partie de votre base de données.

La commande DELETE FROM permet de supprimer une ou plusieurs lignes d'une table.

Syntaxe de base :

DELETE FROM NomDeLaTable
WHERE Condition; -- CRITIQUE : sans WHERE, TOUTES les lignes seront supprimées !

• Supprimer l'adhérent avec l'ID 2 :

  DELETE FROM ADHERENT
  WHERE ID_Adherent = 2;
  

• Supprimer tous les livres publiés avant 1900 :

  DELETE FROM LIVRE
  WHERE Annee_Publication < 1900;
  

  Comme pour UPDATE, la clause WHERE est vitale pour DELETE. Sans elle, vous videz votre table !

Les jointures sont utilisées pour combiner des lignes de deux tables ou plus, basées sur une colonne liée entre elles (généralement une clé primaire et une clé étrangère).

Le type de jointure le plus courant est l'INNER JOIN. Il ne retourne que les lignes ayant des correspondances dans les deux tables.

Syntaxe de base (INNER JOIN) :

SELECT ColonnesQueJeVeux
FROM Table1
INNER JOIN Table2 ON Table1.ColonneCommune = Table2.ColonneCommune;

EMPRUNT (ID_Emprunt (PK), ID_Adherent (FK), ISBN (FK), Date_Emprunt)

• Afficher le nom de l'adhérent et le titre du livre pour chaque emprunt :

  SELECT A.Nom, A.Prenom, L.Titre, E.Date_Emprunt
  FROM ADHERENT AS A
  INNER JOIN EMPRUNT AS E ON A.ID_Adherent = E.ID_Adherent
  INNER JOIN LIVRE AS L ON E.ISBN = L.ISBN;
  

  Ici, AS A, AS E, AS L sont des alias pour les tables, ce qui rend la requête plus lisible. Cette requête combine ADHERENT et EMPRUNT sur ID_Adherent, puis le résultat est combiné avec LIVRE sur ISBN.

Les fonctions d'agrégation effectuent des calculs sur un ensemble de lignes et retournent une seule valeur.

• COUNT() : Compte le nombre de lignes.
• SUM() : Calcule la somme des valeurs d'une colonne numérique.
• AVG() : Calcule la moyenne des valeurs d'une colonne numérique.
• MIN() : Retourne la valeur minimale d'une colonne.
• MAX() : Retourne la valeur maximale d'une colonne.

Elles sont souvent utilisées avec la clause GROUP BY pour regrouper les résultats par une ou plusieurs colonnes.

• Nombre total d'adhérents :

  SELECT COUNT(ID_Adherent) AS TotalAdherents
  FROM ADHERENT;
  

• Nombre de livres par année de publication :

  SELECT Annee_Publication, COUNT(ISBN) AS NombreDeLivres
  FROM LIVRE
  GROUP BY Annee_Publication
  ORDER BY Annee_Publication DESC;
  

• Âge moyen des livres (en années depuis publication) :

  SELECT AVG(2024 - Annee_Publication) AS AgeMoyenLivres
  FROM LIVRE;
  

  (Note : 2024 - Annee_Publication est un calcul simple fait directement dans la requête).

• Nombre d'emprunts par adhérent (avec le nom de l'adhérent) :

  SELECT A.Nom, A.Prenom, COUNT(E.ID_Emprunt) AS NbEmprunts
  FROM ADHERENT AS A
  INNER JOIN EMPRUNT AS E ON A.ID_Adherent = E.ID_Adherent
  GROUP BY A.ID_Adherent, A.Nom, A.Prenom -- Important de grouper par toutes les colonnes SELECT non agrégées
  HAVING COUNT(E.ID_Emprunt) > 1; -- Filtrer les groupes (ici, seulement les adhérents avec plus d'un emprunt)
  

  La clause HAVING est utilisée pour filtrer les résultats après l'agrégation, tandis que WHERE filtre avant.