Données et modélisation

La mémoire secondaire n’est pas directement accessible (les programmes n’ont pas la possibilité d’aller écrire directement sur le disque). Le système d’exploitation assure ainsi l’indépendance du programme par rapport à l’emplacement des données, au travers d’instructions d’entrée/sortie spécialisées.

Pour que les programmes puissent écrire sur le disque, on introduit des objets intermédiaires : les fichiers. Un fichier est caractérisé par (nom, emplacement (volume, arborescence), droit d’accès, taille,…). Il s’agit d’une entité logique. Tout programme utilisant un fichier passe par le système d’exploitation qui, à partir des informations, détermine la localisation des données sur le support.

• La gestion des fichiers est une des fonctions essentielles des systèmes d’exploitation :
  • possibilité de traiter et conserver des quantités importantes de données
  • possibilité de partager des données entre plusieurs programmes.

Organisation hiérarchique :

• Lorsque le nombre de fichiers est élevé, les descripteurs de fichiers sont classés dans plusieurs répertoires, organisés sous une forme arborescente.
• Le répertoire de plus bas niveau hiérarchique est appelé racine → chemin d’accès (path)

FileReader f = new FileReader("/chemin/vers/mon/fichier.txt");

BufferedReader br = new BufferedReader(f);

Lorsque l’opération d’ouverture est réalisée avec succès, le flux de données devient accessible en lecture (les premières lignes du fichier sont chargées en mémoire et une tête de lecture se positionne sur le premier caractère de la première ligne). Il ne reste plus qu’à lire les données.

La consultation des données s’effectue séquentiellement à l’aide de l’opérateur de lecture readLine. Chaque appel à cet opérateur charge les nouvelles données et déplace la tête de lecture vers les données suivantes. Cette opération peut être effectuée plusieurs fois jusqu’à atteindre la fin de fichier.

try (BufferedReader br = new BufferedReader(new FileReader("/chemin/vers/mon/fichier.txt"))) {
    String ligne;
    while ((ligne = br.readLine()) != null) {
        System.out.println(ligne);
    }
} catch (IOException e) {
    e.printStackTrace();
}

Voir aussi :

• Gestion des fichiers sous Unix

Tout commence par une fiche à remplir…

Un formulaire se présente sous la forme d’un ensemble de rubriques à remplir.

• Le modèle de fiche définit le format des données à enregistrer:
  • liste des rubriques du formulaire,
  • domaine de valeurs attendues dans chaque rubrique.
• A toute fiche remplie correspond un jeu de valeurs (ou mesure) :
  • liste de valeurs correspondant au contenu d’une fiche particulière.

On peut donc générer à partir d'un modèle de formulaire un grand nombre de données obéissant au même format*

Exemple: un schéma de données décrivant des informations sur des clients avec des colonnes pour le nom, l'adresse, et le numéro de téléphone

Ces données sont généralement stockées dans des formats tabulaires (comme les tableaux ou fichiers CSV) où chaque donnée est placée dans des champs ou colonnes clairement définis.

Un tableau de données est une liste (finie et ordonnée) de tuples, chaque tuple obéissant à un même schéma $R$.

Ce type de données est facilement lisible par les machines et exploitable grâce à des langages de requête.

Les principaux formats d'échange de données sont :

• csv
• json
• xml

Dubois,Martine,"28, rue des Lilas, 45000 Orléans",45

Exemples :

• codes postaux

{"nom" : "Dubois", "prénom" : "Martine", "adresse" : "28, rue des Lilas, 45000, Orléans", "âge" : 45}

* codes postaux

Pour les données organisées de manière hiérarchique. Des balises servent à séparer les différents attributs.

<nom> Dubois </nom>
<prénom> Martine </prénom>
<adresse>
  <num> 28 </num>
  <voie> rue des Lilas </voie>
  <code postal> 45000 </code postal>
  <ville> Orléans </ville>
</adresse>
<âge> 45 </âge>

{
  "nom" : "Dubois",
  "prénom" : "Martine",
  "adresse" :
  {
    "numero" : 28,
    "voie" : "rue des Lilas",
    "code_postal" : 45000,
    "ville" : "Orléans"
  },
  "âge" : 45
}

Exemples :

• Clients
• Cours de l'Euro

• D’un point de vue informatique, un jeu de valeurs recueilli est appelé un enregistrement
  • correspondant à l’encodage des données recueillies sur un support numérique

Le Tuple est la structure de données de base servant pour le recueil, le transport et le stockage des données.

("Dubois", "Martine", 22, "29/10/1994", "Orléans")

Pour une gestion efficace des données, il est nécessaire de pouvoir identifier chaque jeu de valeurs (tuple) de façon unique.

L'indexation des données repose sur un principe simple d'étiquetage consistant à attribuer une étiquette différente à chaque enregistrement.

1. Cette étiquette peut être une suite de caractères arbitraires, un entier, ou un descripteur explicite. On parle en général de clé ou d'identifiant pour désigner cette étiquette.
2. Il existe un ordre total dans le domaine de valeurs des clés, permettant d'effectuer des opérations de tri sur les données a partie de la valeur de leur clé.

• L'indexation des données consiste à attribuer à chaque jeu de valeurs distinct un identifiant unique.
• On parle également de clé de l'enregistrement:

On peut représenter l'opération d'indexation sous la forme d'une fonction. Si $d$ est le jeu de valeurs, $k(d)$ désigne l'identifiant de ce jeu de valeurs.

L'indexation suppose l'existence d'une bijection entre l'ensemble des données et l'ensemble des clés, permettant d'assurer l'unité et la spécificité de la clé

L'identifiant doit en pratique tenir sur un nombre d'octets le plus petit possible pour que la liste $L$ puisse être manipulée en mémoire centrale. Autrement dit, il faut que :

• $|k| << |d|$

pour que :

• $|L| << |D|$

L'existence d'un identifiant unique pour chaque jeu de valeurs $d$ permet la mise en œuvre d'une recherche par identifiant (ou recherche par clé).

La recherche par identifiant repose sur une fonction d'adressage $I$ (dite "Index") qui à tout identifiant $k$ associe sa position (entrée) $i$ dans un tableau de données: $I : k \rightarrow i$. Ainsi si $k$ est l'identifiant servant à la recherche, l'extraction des informations se fait en 2 étapes:

• $i = I(k)$ (lecture de l'index des données)
• $d = D[i]$ (lecture des données elles mêmes)

Définir un ordre sur les données

La présence d'un identifiant permet de définir un ordre total sur les données :

• ordre sur les entiers (identifiant entier)
• ordre alphabétique (identifiant texte)
• ordre ASCIIbétique (chaîne de caractères quelconque)

Lier les données

Dans le cas des bases de données, l'identifiant constitue une référence vers les jeux de valeurs des tableaux de données. Une référence permet de lier les données d'une table aux données d'une autre table.

Exemple :

• Artistes
• Albums
• Pistes

• Pour chaque album de la table des albums, l'identifiant d'artiste (ici un numéro) permet de lier l'album avec l'artiste (ou groupe) correspondant.
• Pour chaque piste de la table des pistes, l'identifiant d'album permet de lier la piste à l'album correspondant (et donc à l'artiste correspondant par transitivité)

Structure d'ensemble

L'index définit l'appartenance d'une donnée à un ensemble.

Soit $\mathcal{E}$ un ensemble de données indexées : $$\mathcal{E} = \{d_1, d_2, ..., d_K\}$$ On a l'équivalence : $$d \in \mathcal{E} \Leftrightarrow k(d) \in I$$

Ainsi, il ne peut y avoir de doublon car $\forall d$ :

• $k(d)$ est unique
• $i = I(k(d))$ est unique ssi $d \in \mathcal{E}$ et indéfini sinon.

On introduit dans ce chapitre le modèle relationnel qui sert de fondation à la conception de bases de données.

Les différents modèles utiles en représentation des connaissances reposent sur des notions de base de la théorie des ensembles :

• Ensemble finis
• Éléments partiellement (ou totalement) discernables

2 approches en modélisation :

• approche ensembliste (plus général)
• modèle relationnel (plus pratique)

Rappel:

• Un enregistrement est un jeu de valeurs organisé sous forme de tuple
• A un tuple on associe en général un schéma de données.

• Définir un schéma consiste à définir :
  • une liste d'attributs (labels) associées à chacune des valeurs du tuples.
• A chaque attribut correspond :
  • un intitulé
  • un domaine de valeurs (type/format des données)

• Soit $R(A_1, ..., A_m)$ un schéma.
• On note $\text{dom}(A_i)$ le domaine associé à l'attribut $A_i$.
• On dit d'un tuple $t$ qu'il obéit au schéma $R$ si les valeurs qu'il contient correspondent aux domaines des attributs du schéma.

• Au sein d'un schéma $R$,
  • Il peut exister un ensemble de contraintes, noté $F$,
    • portant sur les attributs (plus précisément sur les valeurs prises par les attributs).
    • L'ensemble F est indépendant de R.
  • On parle de contraintes d’intégrité.
    • Ces contraintes s’expriment sous la forme de dépendances fonctionnelles.

• Il importe donc de bien réfléchir, au moment de l'étape de conception,
  • du réalisme et du caractère limitant de certaines dépendances fonctionnelles,
  • et du caractère éventuellement limitant du choix des attributs.
• Ainsi, le schéma décrivant les commandes (exemple 2)
  • ne permet pas de commander des articles de nature différente au sein d'une même commande
  • (un client, pour commander deux râteaux et une truelle, doit donc effectuer deux commandes, qui plus est à des dates différentes!).

• Soit un schéma $R(A_1, ..., A_m)$.

Soit $K$ une clé candidate. On démontre que $K \rightarrow R$ à l'aide des axiomes d'Amstrong à partir d'un ensemble de DF connues:

Tables mal construites

Les Formes normales

• Restreignent les dépendances admises dans un schéma relationnel
• Permettent d’éviter la duplication de l’information au sein des relations
• Définissent une méthode
  • de décomposition d’un schéma relationnel redondant
  • en plusieurs schémas liés entre eux:

• Lorsqu’un schéma relationnel n’est pas en deuxième forme normale, il doit être normalisé:

* Lorsqu’un schéma relationnel n’est pas en troisième forme normale, il doit être normalisé:

Une base de donnée est constituée de plusieurs ensembles d'objets et d'opérateurs participant au bon fonctionnement d'un système:

Exemple 1 :

• Ensembles d'employés
• Ensembles de commandes
• Ensembles d'articles
• Ensembles de clients

Exemple 2 :

• Ensembles d'étudiants
• Ensembles de séances
• Ensembles de cours
• Ensembles de copies

On parle plus généralement d'ensembles d'entités.

Une entité $x$

• est une représentation d'un objet du monde réel,
• appartenant au système/à l'organisation modélisée.
• Une entité est décrite par une ou plusieurs valeurs caractéristiques, appelées attributs.

Les informations conservées au sujet des entités d'un ensemble sont les attributs.

• Chaque attribut :
  • a un nom unique dans le contexte de cet ensemble d'entités : $A$, $B$, $C$, $A_1$, $A_2$, …, $A_m$, …
    • Exemples de noms concrets : couleur, nom, horaire, salaire.
  • prend ses valeurs dans un domaine bien spécifié,
    • également appelé le type de l'attribut.
    • Le domaine d'un attribut est noté $\text{dom}(Aj)= Dj$.
      • Exemples :
        • $\text{dom}(couleur)={rouge, vert, bleu, jaune}$,
        • $\text{dom}(nom) =$ensemble des chaînes de caractères,
        • $\text{dom}(salaire) =$ entiers naturels
        • etc…

Un ensemble d'entités est un ensemble fini d'éléments : $$E = \{x_1,…,x_n\}$$ Il regroupe (ou associe) plusieurs entités ayant des caractéristiques communes (descriptibles à l'aide du même ensemble d'attributs).

• Les éléments d’un ensemble d’entités sont partiellement discernables à travers les valeurs de leurs attributs :
  • les attributs $(A_1,...,A_m)$ servent à décrire les éléments de l’ensemble.
  • Le schéma $R$ de l’ensemble $E$ est une application de l'ensemble d'entités vers l'ensemble des tuples de schéma $R$
    • Soit :

$$R : \mathcal{X} \rightarrow D_1 \times ... \times D_m$$ $$x_i \mapsto (A_1(x_i),…, A_m(x_i))$$

Modéliser une base de données, c'est :

• Identifier les différents ensembles en interaction
• Identifier les liens de dépendance entre les différents ensembles

• Attribution : propriété, réservation, participation, supervision, auteur, rôle, pilote, …
• Événements : achat, vente, séance, épreuve, appel, consultation, réunion, transaction, transport …
• Aggrégation/Composition : tout/parties, contenant/contenu, supérieur/subordonné, pays/région, …
• Relations entre membres : parenté, collaboration, cercle d'amis, …
• …

Associations binaires

Associations ternaires

Associations de 1 à plusieurs (fonctionnelle)

Relation non symétrique entre les deux ensembles : […,1] d'un côté, […,N] de l'autre. Relation de type contenant/contenu, propriétaire/objet possédé, occupant/occupé, actif/passif etc… Il s'agit du type d'association le plus "courant".

Associations de plusieurs à plusieurs (croisée)

Dans une association “croisée”, les tous les lien de l’association sont de cardinalité multiple […,N]

Mesures

• Les mesures sont les données saisies sur les éléments d'un ensemble. Chaque mesure est associée à un attribut.
• Le schéma de l'ensemble est l'ensemble des attributs servant à caractériser ses éléments
• Les éléments de l'ensemble sont discernables ssi il existe un jeu de mesures différent pour chaque élément de l'ensemble
• Une clé est un ensemble d'attributs minimal (permettant de distinguer les objets) appartenant au schéma

Opérateurs

• On s’intéresse ici aux associations qui représentent une “opération” (inscription, achat, embauche, affectation…).
• Lors d’une mise à jour de la base, certains événements tels que l’emprunt ou le retour d’un ouvrage, l’affectation d’un employé à un poste, ou la liste des anciens clients disparaissent.
• Il est possible de garder une trace des événements passés en mettant un (ou plusieurs) attributs sur une association.
• Ainsi, certaines associations peuvent être "datées", c'est à dire
  • avoir lieu à une date
  • ou prendre place sur une durée précise (prêt,accès temporaire, statut temporaire…)
• On peut ainsi mémoriser :
  • "Monsieur Dupont a été employé au département logistique de tant à tant."…
  • "L'étudiant X a été élève Centrale Méditerranée de telle année à telle année"…

Exemple "Monsieur Dupont a été employé au département logistique de tant à tant."…

Exemple

• Chaque coureur est décrit par ses nom, prénom, nationalité et numéro de maillot.
• Chaque coureur appartient à une équipe qui possède un numéro, un sponsor associé.
• Chaque coureur participe à une ou plusieurs étapes. Une étape se caractérise par son numéro, son type (contre la montre/étape simple), ses points de départ et d'arrivée, sa date.
• A chaque étape est associée un classement d'arrivée pour chaque coureur, avec la durée totale de course.

Il est possible de traduire un modèle entité/association vers un modèle relationnel (en perdant quelques propriétés).

Un petit nombre de règles permettent de traduire un modèle entité/association vers un modèle relationnel.

• Selon ces règles, à la fois les ensembles d'entités et les associations sont transformés en schémas relationnels.
• Les liaisons et dépendances entre schémas de relation sont assurés par la définition des clés étrangères (attributs communs à plusieurs tables).

Exemple

Une association croisée ne contient que des contraintes de cardinalité de type [..,N]. Soit $R$ une telle association et $E_1$, …, $E_k$ les ensembles participant à l'association.

Traduction :

• Pays (nom_pays, superficie, population, PIB )
• Matière_première ( nom_matière, unité, prix )
• Exportation (nom pays, nom matière, quantité)

Traduction :

• Appareil (code_appareil, type, marque, modèle)
• Séance (date, heure, local)
• Réservation (code appareil,date, heure, local)

Soit une association fonctionnelle $R$. On suppose qu'il existe au moins un ensemble $A$ de cardinalité unique [1,1] participant l’association.

Exemple :

Remarque : lorsque l’association est valuée, les attributs de l’association sont également injectés dans la table représentant l’ensemble de gauche.

Exemple Traduction :

• Groupe_TD( num_groupe, LV1, LV2)
• Entreprise ( nom_entreprise, Adresse)
• Etudiant ( num_etudiant, Nom, Prénom, Date_naiss, num groupe, intitulé, date, durée, nom entreprise)