Section courante

A propos

Section administrative du site

Base de données

Une base de données se veut une façon de structurer des informations généralement sous forme de table avec des champs. En général, il y a deux manières d'écrire une base de données, soit il s'agit d'un gros fichier avec toutes les informations complètes sur les tables, les index et les données de la base de données, soit il y a un fichier par table contenant les données. Les petits systèmes comme avec dBASE III, par exemple, préconisaient l'utilisation d'un fichier par table, tandis que des SQL Server ou Oracle Database SQL préconisent l'utilisation d'un seul gros fichier et enfin MySQL offre le choix aux développeurs entre les 2 modèles.

Voici un exemple simple en Turbo Pascal illustrant le concept d'une «mini-base de données» avec un fichier par table. On va créer un programme qui stocke des informations sur des personnes avec des champs comme ID, Nom et Âge. Chaque table sera un fichier .dat :

  1. Program MiniBaseDeDonnees;
  2.  
  3. Uses Crt;
  4.  
  5. Type
  6.   { Définition d'un enregistrement représentant une "ligne" de la table }
  7.  Personne=Record
  8.   ID:Integer;
  9.   Nom:String[50];
  10.   Age:Integer;
  11.  End;
  12.  
  13. Var
  14.  F:File of Personne;
  15.  P:Personne;
  16.  Choix:Char;
  17.  
  18. Procedure AjouterPersonne;
  19. Var
  20.  FExiste:Boolean;
  21. Begin
  22.  WriteLn('--- Ajouter une personne ---');
  23.  Write('ID : '); ReadLn(P.ID);
  24.  Write('Nom : '); ReadLn(P.Nom);
  25.  Write('Âge : '); ReadLn(P.Age);
  26.  Assign(F, 'personnes.dat');  
  27.   {$I-}               { Désactive les vérifications automatiques d'erreurs }
  28.  Reset(F);            { Essaie d'ouvrir le fichier }
  29.  {$I+}
  30.  If IOResult<>0 Then Begin
  31.   Rewrite(F);         { Si le fichier n'existe pas, on le crée }
  32.  End
  33.   Else
  34.  Seek(F,FileSize(F)); { Sinon, on se place à la fin pour ajouter }
  35.  Write(F, P);         { Écrit l'enregistrement }
  36.  Close(F);
  37.  WriteLn('Personne ajoutée avec succès !');
  38. End;
  39.  
  40. Procedure ListerPersonnes;Begin
  41.  WriteLn('--- Liste des personnes ---');
  42.  Assign(F, 'personnes.dat');
  43.  {$I-} Reset(F);{$I+}
  44.  If IOResult<>0 Then Begin
  45.   WriteLn('Aucune personne enregistrée.');
  46.   Exit;
  47.  End;
  48.  While Not Eof(F)do Begin
  49.   Read(F, P);
  50.   WriteLn('ID : ', P.ID, ' | Nom : ', P.Nom, ' | Age : ', P.Age);
  51.  End;
  52.  Close(F);
  53. End;
  54.  
  55. BEGIN
  56.  ClrScr;
  57.  Repeat
  58.   WriteLn('Mini Base de Données - Table Personnes');
  59.   WriteLn('1. Ajouter une personne');
  60.   WriteLn('2. Lister les personnes');
  61.   WriteLn('Q. Quitter');
  62.   Write('Choix : '); ReadLn(Choix);
  63.   Choix := UpCase(Choix);
  64.   Case Choix of
  65.    '1': AjouterPersonne;
  66.    '2': ListerPersonnes;
  67.    Else If Choix <> 'Q'Then WriteLn('Option invalide, réessayez.');
  68.   End;
  69.   WriteLn;
  70.  Until Choix = 'Q';
  71.  WriteLn('Au revoir !');
  72. END.

Structure des fichiers

Les informations écrites dans les fichiers sont entreposées sous forme d'enregistrement pour les données contenues pour les champs des tables et contiennent des index permettant un accès rapide avec une structure de données B-arbre (ou B-Tree en anglais).

Voici un exemple simplifié en Turbo Pascal :

  1. Program FichierAvecIndex;
  2.  
  3. Type
  4.  TEnregistrement=Record
  5.   Id:Integer;
  6.   Nom:String[20];
  7.   Age:Integer;
  8.  End;
  9.  
  10.  TIndex=Record
  11.   Clef:Integer;
  12.   Position:LongInt; { position dans le fichier }
  13.  End;
  14.  
  15. Var
  16.  f:File of TEnregistrement;
  17.  index:Array[1..100] of TIndex;
  18.  rec:TEnregistrement;
  19.  i,nbEnregistrements:Integer;
  20.  
  21. { Procédure pour créer un enregistrement et l'ajouter au fichier et à l'index }
  22. Procedure AjouterEnregistrement(Id:Integer;Nom:String;Age:Integer);Begin
  23.  rec.Id:=Id;
  24.  rec.Nom:=Nom;
  25.  rec.Age:=Age;
  26.   { Se placer à la fin du fichier }
  27.  Seek(f,FileSize(f));
  28.  Write(f,Rec);
  29.   { Ajouter l'entrée dans l'index }
  30.  nbEnregistrements:=nbEnregistrements + 1;
  31.  Index[nbEnregistrements].Clef := rec.Id;
  32.  Index[nbEnregistrements].Position := filesize(f) - 1;
  33. End;
  34.  
  35.  { Procédure pour rechercher un enregistrement par clef en utilisant l'index }
  36. Function RechercherParClef(Clef:Integer):Boolean;
  37. Var
  38.  i:Integer;
  39. Begin
  40.  RechercherParClef:=False;
  41.  For i := 1 to nbEnregistrements do If index[i].Clef=clef Then Begin
  42.   Seek(f,index[i].Position);
  43.   Read(f, rec);
  44.   Writeln('Enregistrement trouvé: Id=', rec.Id, ' Nom=', rec.Nom, ' Age=', rec.Age);
  45.   RechercherParClef := true;
  46.   Exit;
  47.  End;
  48. End;
  49.  
  50. BEGIN
  51.  Assign(f, 'personnes.dat');
  52.   {$I-} reset(f); {$I+}
  53.  If IOResult<>0 then Rewrite(f);
  54.  nbEnregistrements:=0;
  55.   { Ajout d'exemples d'enregistrements }
  56.  AjouterEnregistrement(1,'Alice', 25);
  57.  AjouterEnregistrement(2,'Bob', 30);
  58.  AjouterEnregistrement(3,'Charlie', 22);
  59.  Writeln('Recherche de l''enregistrement avec Id=2');
  60.  If Not RechercherParClef(2) Then Writeln('Enregistrement non trouvé');
  61.  Close(f);
  62. END.

Demande simultanée

Bien que l'information soit écrite dans un fichier et donc pouvant être théoriquement lu par une application ayant un accès au système de fichiers, les bases de données ne donnent pas un accès direct, mais oblige les applications à passer par un analyseur de requête, généralement avec une syntaxe de SQL, offrant la possibilité de consulter l'information, d'ajouter de l'information ou de modifier de l'information. Cet analyseur est lui-même pas accessible directement, il faudra donc passer par soit un API sur la machine en local effectuant des communications directes avec la base de données ou soit un service de serveur de base de données disponible par un protocole de communication réseau. Donc, à partir de se principe, on sait qu'un utilisateur ou une application ne pourra jamais accéder directement à la base de données sans passer par un intermédiaire étant un API ou un serveur réseau. Grâce à ce principe, il est possible de gérer des utilisateurs, des sessions et des transactions simultanément afin que même si les demandes arrivent en même temps par différentes machines, le travail de l'un, ne va pas détruire le travail de l'autre.

Remarque



Dernière mise à jour : Mercredi, le 20 novembre 2019