Base de données
Cet article est en construction: un auteur est en train de le modifier.
En principe, le ou les auteurs en question devraient bientôt présenter une meilleure version.
Définition
En tant que machine à traiter les informations de manière automatisée, l'informatique a dès sa naissance, été confrontée à la notion de donnée. La capacité de stockage des ordinateurs permet donc l'agrégation d'une grande quantité de données informatiques.
Or, très tôt (Voir CODASYL) - relativement à l'histoire de l'informatique - la notion de structuration des données s'est faire ressentir. En effet, bien qu'il soit utile de pouvoir sauver des informations diverses, il est aussi nécessaire de les manipuler en les ordonnant, rangeant ou indexant de manière à optimiser leur sauvegarde et/ou leur recherche ultérieure.
Dès lors, des Systèmes de Gestion de Base de Données (souvent abrégé en database par la suite) informatisés ont été créés de manière à atteindre ce but. Ces derniers sont un ensemble de procédure permettant les opérations de gestion de grandes quantités de données structurée. On pense notamment aux bases de données relationnelles, qui sont très répandues dans différents domaines, mais également à d'autres types de systèmes qui sont en train d'être (ré)découvert de manière alternative ou intégrée aux bases "traditionnelles".
in extenso, une base de données n'est autre qu'un ensemble de données structurées permettant une gestion optimale de ces dernières. À noter encore, que l'on entend ici le mot 'donnée au sens d'information pouvant être stockée et traitée de manière informatisée.
Types de bases de données
Il existe plusieurs types de base de données, nous allons nous limite à illustrer brièvement, dans une analyse comparée, ces grandes "familles" de databases :
- Bases de données relationnelles
- Bases de données de type document (ou NoSQL)
- Bases de données clé-valeur (ou key-value)
- Bases de données de type Graph
Bases de données relationnelles
Les bases de données relationnelles sont le type de database le plus fréquemment utilisé à présent (2017). Leur structure est déterminée par une ou plusieurs tableaux, divisées en lignes et colonnes, comme c'est les cas des feuilles de calculs (e.g. Excel). Le terme "relationnelles" se réfère à la possibilité de faire des références croisées entre tableaux, à travers notamment des foreign keys, c'est-à-dire des colonnes dans un tableau X qui font références à un tableaux Y ou Z.
Voici un exemple de relation entre un tableau "Students" qui contient une liste d'étudiants et le tableau "Grades" qui contient une liste de notes.
Table "Students" ***** ID | Name | University | ... -------------------------------------------------------- 1 | A. B. | UNIGE | ... -------------------------------------------------------- 2 | C. D. | UNIGE | ... --------------------------------------------------------
Table "Grades" ***** ID | Student_ID | Course | Grade | ... -------------------------------------------------------- 90 | 1 | STIC I | 5.5 | ... -------------------------------------------------------- 91 | 1 | STIC II | 5.75 | ... -------------------------------------------------------- 92 | 2 | STIC I | 4.5 | ... -------------------------------------------------------- 93 | 2 | STIC I | 5.25 | ... --------------------------------------------------------
La relation entre les deux tableaux se fait grâce à la colonne Student_ID qui fait référence à la colonne ID du tableaux "Students" (on dit donc que Grades.Student_ID est une foreign key de Students.ID). Les lignes avec ID 90 et 91 de "Grades" font références à l'étudiant avec ID 1 (i.e. celui avec nom "A. B.") du tableau "Students", tandis que les lignes 92 et 93 é l'étudiant avec ID 2 (i.e. celui avec nom "C. D.").
Types de relations
Il existe trois grands types de relation entre deux tableaux :
- One-to-One : à une ligne dans le tableau X est liée seulement une ligne dans le tableau Y
- One-to-Many : à une ligne dans le tableau X sont liées une ou plusieurs lignes dans le tableau Y (c'est le cas de l'exemple Students -> Grades)
- Many-to-Many : deux tableaux X et Y sont liés par un tableau Z qui contient plusieurs références croisées entre X et Y
On peut modifier notre exemple One-to-Many Students -> Grades pour faire un exemple de Many-to-Many. Au lieu d'ajouter dans le tableau "Notes" le nom du cours à chaque ligne, on peut ajouter un troisième tableau "Courses" :
Table "Courses" ***** ID | Name | .... -------------------------------------------------------- 101 | STIC I | .... -------------------------------------------------------- 102 | STIC II | .... --------------------------------------------------------
À ce point on peut modifier notre tableau "Notes" en substituant la colonne "Grade.Course" par une foreign key Grade.Course_ID qui fait référence au tableau "Courses.ID" :
Table "Grades" revised in Many-to-Many ***** ID | Student_ID | Course_ID | Grade | ... -------------------------------------------------------- 90 | 1 | 101 | 5.5 | ... -------------------------------------------------------- 91 | 1 | 102 | 5.75 | ... -------------------------------------------------------- 92 | 2 | 101 | 4.5 | ... -------------------------------------------------------- 93 | 2 | 102 | 5.25 | ... --------------------------------------------------------
Le SQL
Le Structured Query Language (SQL) est un langage permettant la gestion et l'interrogation d'un système de base de données relationnelles. Ces dernières étant presque exclusivement utilisées aujourd'hui, on comprend mieux pourquoi nombre de produits (MySQL, SQL Server, PostgreSQL) intègrent l'acronyme dans leur dénomination. Attention cependant à ne pas confondre le langage des noms de produits commerciaux.
Le langage peut être vu sous quatre aspects distincts. En parenthèse, le nom de la catégorie en anglais.
- La gestion de la base: création et modification de la structure de données, les tables (à définir) en particulier (DDL=Data Definition Language).
- La gestion des transactions: opérations permettant de contrôler, manipuler de données (insertion, effacement, déplacement, etc) et d'éviter leur inconsistance (TCL=Transaction Control Language).
- La gestion des droits d'accès: opérations de sécurité permettant la gestion des accès aux données par les différents utilisateurs (DCL=Data Control Language).
- L'interrogation de la base: commandes permettant la récupération des données selon les besoins (DML=Data Manipulation Language).
Pour plus d'informations sur ces catégories et les commandes SQL qui les composent voir ce site
Liste de bases de données rélationnelles
Ci-après, présentés quelques noms de logiciels dédiés à la gestion de bases de données.
- Oracle Site officiel
- MySQL Site officiel (Note. MySQL est aujourd'hui propriété de Sun Microsystems, lui même racheté il y a peu par Oracle)
- Microsoft SQL Server Site Wiki
- Microsoft Access Site officel (Note. Access 2007 est basé sur une version allégée de MS SQL Server)
- PostgreSQL [www.postgresql.org Site officel]
- IBM DB2 Site officiel
- FileMaker Site officiel
- OpenOffice Base Site officiel
Bases de données de type document (NoSQL)
Les bases de données de type document, également appelées NoSQL - dans les sens "Pas SQL" ou également "Not Only SQL", c'est à dire "Pas seulement SQL" - ont été conçues, comme le nom l'indique, surtout en alternative aux databases relationnels.
Bases de données clé-valeur
Les bases de données de type clé-valuer (ou key-value databases en anglais) ont une structure beaucoup plus simple par rapport aux databases relationnels ou NoSQL: elles se composent en effet seulement de deux colonnes.
Database key-value ***** KEY | VALUE -------------------------------------------------------- key1 | value1 -------------------------------------------------------- key2 | value2, value2, value3, value4 -------------------------------------------------------- key3 | 123, 456, abcd, efgh --------------------------------------------------------
Le fonctionnement de ce type de databases est assez trivial: on associe une valeur à une clé unique. La particularité consiste dans le fait que la valeur peut être pratiquement tout type de données, de données simples (chiffres, texte, etc.) à des données composites comme des objets (comme dans le NoSQL). Comme l'exemple (fictif) le montre, de plus, la valeur associé à chaque ligne ne doit respecter aucune structure pré-déterminée.
L'association clé-unique -> valeur est une manière efficace est très performante de récupérer des données.