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.
Fonctions des bases de données
La plupart des systèmes de gestion de databases permettent des opérations sur les données telles que :
- CRUD, acronyme de Create, Retrieve, Update, et Delete, c'est-à-dire les opérations les plus communes effectuées sur des données ;
- Filtrer : appliquer des critères de sélection pour obtenir un sous-ensemble de données par rapport à la totalité de l'information stockée ;
- Trier (ou Sorting en anglais) : utiliser des critères pour placer les données dans un ordre précis. Le tri est une opération informatique qui nécessite d'une grande puissance computationnelle, et les bases de données sont souvent optimisés pour ce type d'opération ;
- Répliquer : créer des "clones" d'une base de données pour des raisons de sécurité (backup) ou pour balancer les ressources (e.g. utiliser deux databases "jumeaux" pour départager un nombre élevé d'interrogations).
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
- Bases de données clé-valeur (ou key-value)
- Bases de données de type Graph
SQL vs NoSQL
La différence plus marquée entre bases de données réside entre les databases de type relationnel (ou SQL) est les autres type de base de données qui sont souvent regroupés sous l'acronyme NoSQL qui peut signifier à la fois :
- No SQL dans le sens "pas de SQL"
- Not Only SQL, "pas seulement du SQL"
SQL, acronyme de Structured Query Language (voir également plus bas dans la page), représente aujourd'hui (2017) la modalité principale pour structurer et interroger des bases de données. La caractéristique principale des databases SQL concerne la structure fixe en lignes et colonnes, similaire à celle utilisé par les feuilles de calcul (e.g. Excel). L'aspect relationnel des databases SQL est déterminé par la possibilité de combiner des données sur plusieurs tableaux (voir plus bas). Les databases NoSQL, par contre, se caractérisent par des structures plus flexibles non forcément bi-dimensionnelles. Même si souvent ces bases des données peuvent être interroger avec un langage de type SQL (ou similaire), la différence fondamentale réside dans la flexibilité de la structure des données.
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
Les bases de données de type document représentent conceptuellement l'approche plus distinct par rapport aux databases relationnels (en d'autres termes, ce sont les "plus NoSQL" des databases NoSQL). Dans les bases de données de type document, les données sont organisées en collection (l'équivalente d'un tableau dans les databases relationnels). Chaque collection contient plusieurs documents, qui se différencient des lignes d'un database rélationnel par le fait qu'il n'y aucune structure en colonne pré-déterminée.
Les documents ont plutôt la structure des objets JavaScript (voir Tutoriel JavaScript de base), c'est-à-dire des associations clé-valeur ou la valeur peut être également un array (liste) ou d'autres objets emboìtés. Par exemple :
Collection "Students"
*****
{
"name" : "A. B.",
"university": "UNIGE",
"grades": [
{
"course": "STIC I",
"grade": 5.5
}, {
"course": "STIC II",
"grade": 5.75
}
]
},
{
"name" : "C. D.",
"university": "UNIGE",
"grades": [
{
"course": "STIC I",
"grade": 4.75
}, {
"course": "STIC II",
"grade": 5.25
}
]
}
La structure des documents ne doit par contre pas être forcément la même à chaque "ligne" :
Collection "Various"
*****
{
"title": "Bases de données",
"type": "Page EduTechWiki",
"url": "http://edutechwiki.unige.ch/fr/Base_de_donn%C3%A9es"
},
{
"reference" : "https://fr.wikipedia.org/wiki/Base_de_donn%C3%A9es"
}, {
"reference" : "https://en.wikipedia.org/wiki/Database",
"lang" : "English"
}
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 document: 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.