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é: