Correction exercices bd objet modélisation odl oql requêtes

Télécharger PDF

Correction Exercice N°1 : Modélisation et Requêtes ODL

a. Diagramme de classes

Le diagramme de classes est une représentation graphique des classes, de leurs attributs et de leurs relations. Il sert de base fondamentale pour la modélisation des données dans une approche orientée objet.

b. ODL (Object Definition Language)

L'ODL (Object Definition Language) est un langage de définition d'objets utilisé pour spécifier la structure des schémas de bases de données orientées objet. Voici la définition des classes pour le module PÉDAGOGIE :

Module PEDAGOGIE {
    Class Etudiant extents Etudiants {
        Key(Mat)
        Attribute Number Mat;
        Attribute String Nom;
        Attribute String Prenom;
        Attribute Number AnneeBac;
        Attribute Date DateNaiss;
        Attribute Structure {String Rue, Number Num, String Ville} Adresse;
        Relationship Set<Cours> CoursSuivis Inverse Set<Etudiant> EtudiantsInscrits;
        Function Number GetAge();
    }

    Class Cours extents Courss {
        Key(Code)
        Attribute Number Code;
        Attribute String Nom;
        Attribute Number Coeff;
        Relationship Set<Etudiant> EtudiantsInscrits Inverse Set<Cours> CoursSuivis;
        Relationship Set<Cours> EstPrerequis Inverse Set<Cours> A_Prerequis;
        Relationship Enseignant EstEnseignePar Inverse Set<Cours> CoursEnseignes;
    }

    Class Enseignant extents Enseignants {
        Key(NUM)
        Attribute Number NUM;
        Attribute String Nom;
        Attribute Date DateRecrutement;
        Relationship Set<Cours> CoursEnseignes Inverse Enseignant EstEnseignePar;
        Function Number GetExp();
    }
}

Note : Les mots-clés "extents", "Attribute", "Relationship", "Inverse" et "Function" sont des éléments syntaxiques spécifiques au langage ODL et ne sont pas modifiés. Les noms de relations ont été clarifiés pour une meilleure lisibilité (par exemple, "EtudiantsInscrits" au lieu de "Etud-Inscris").

c. Requêtes ODL

Voici les requêtes exprimées en ODL, basées sur le schéma de classes défini précédemment :

Sélectionner les noms des cours auxquels participe l'étudiant Karim Salim :

select C.Nom from Cours C, C.EtudiantsInscrits e where e.Nom = "Karim" and e.Prenom = "Salim"

Sélectionner les noms des cours enseignés par M. Bouchama et auxquels participe l'étudiant Karim Salim :

select C.Nom from Cours C, C.EtudiantsInscrits e, C.EstEnseignePar E where E.Nom = "Bouchama" and e.Nom = "Karim" and e.Prenom = "Salim"

(Une autre solution possible :)

select C.Nom from Cours C, C.EtudiantsInscrits e where C.EstEnseignePar.Nom = "Bouchama" and e.Nom = "Karim" and e.Prenom = "Salim"

Sélectionner les noms des étudiants qui suivent le cours "BDA" :
```
select E.Nom from Etudiant E, E.CoursSuivis C where C.Nom = "BDA"
```

Calculer l'âge moyen des étudiants qui suivent le cours "Compilation" :

select avg(E.GetAge()) from Etudiant E, E.CoursSuivis C where C.Nom = "Compilation"

Sélectionner les noms des cours pour lesquels "BDA" est un prérequis :
```
select C.Nom from Cours C, C.EstPrerequis cp where cp.Nom = "BDA"
```

Sélectionner les noms des cours où tous les participants ont plus de 20 ans :

select C.Nom from Cours C where for all E in C.EtudiantsInscrits : E.GetAge() > 20

Exercice N°2 : Stratégies de Traitement et Fragmentation

a. Requête Initiale

La requête à optimiser est la suivante :

select C.Ville, AVG(V.Montant) From Voyage V, Client C where C.Age > 18 AND C.Age < 26 group by Ville;

b. Stratégies de Traitement pour la Requête

Ces stratégies décrivent différentes manières d'exécuter la requête sur un système distribué, en considérant que la table Client est localisée à Oran et la table Voyage à Alger.

Stratégie 1 : Effectuer la sélection des clients à Oran, puis envoyer le résultat filtré à Alger pour le joindre avec la table Voyage et calculer la moyenne.
Stratégie 2 : Envoyer l'intégralité de la table Client à Alger, puis exécuter la requête complète (filtrage, jointure, agrégation) à Alger.
Stratégie 3 : Envoyer l'intégralité de la table Voyage à Oran, exécuter la requête complète (filtrage, jointure, agrégation) à Oran, et renvoyer le résultat final à Alger.
Stratégie 4 : Envoyer les tuples de la table Voyage un par un à Oran. Pour chaque tuple Voyage, vérifier s'il correspond à un client dont l'âge est compris entre 18 et 26. Ensuite, renvoyer les résultats partiels pour agrégation à Alger. Cette stratégie minimise les transferts de données si peu de voyages correspondent aux critères.

c. Fragmentation Horizontale de la Table Client

La fragmentation horizontale divise une table en plusieurs fragments, chacun contenant un sous-ensemble des lignes de la table d'origine, basé sur des critères spécifiques. Cela permet d'optimiser les performances en distribuant les données.

Fragmentation du premier niveau par âge :

Client_Moins18 = Σ_{âge < 18}(Client)
Client18_26 = Σ_{âge entre 18 et 26}(Client)
Client26_60 = Σ_{âge entre 26 et 60}(Client)
ClientSup60 = Σ_{âge > 60}(Client)

Fragmentation du deuxième niveau par ville (pour chaque fragment d'âge pertinent) :

Client_18_26_TT = Σ_{Ville = {'Tamenrasset', 'Tindouf'}}(Client18_26)
Client_18_26_OG = Σ_{Ville = {'Ouargla', 'Ghardaia'}}(Client18_26)
Client_18_26_Autres = Σ_{Ville = autre}(Client18_26)
Client_Sup60_TT = Σ_{Ville = {'Tamenrasset', 'Tindouf'}}(Client_Sup60)
Client_Sup60_Autres = Σ_{Ville = autre}(Client_Sup60)
Client_Moins18_TT = Σ_{Ville = {'Tamenrasset', 'Tindouf'}}(Client_Moins18)
Client_Moins18_Autres = Σ_{Ville = autre}(Client_Moins18)
Client_26_60_TT = Σ_{Ville = {'Tamenrasset', 'Tindouf'}}(Client_26_60)
Client_26_60_Autres = Σ_{Ville = autre}(Client_26_60)

Le mode composite Range-List pour la création de la table Client :

Ce type de partitionnement combine une partition par plage (Range) sur l'âge et une sous-partition par liste (List) sur la ville, offrant une grande flexibilité pour la distribution des données et l'optimisation des requêtes ciblées.

Create Table Client (
    NumC Number PRIMARY KEY,
    NomC varchar(20),
    Age Number(3),
    Ville varchar(20)
)
Partition by Range (Age) (
    Partition Client_Moins18 VALUES LESS THAN (18) (
        SubPartition by List (Ville) (
            SubPartition Client_Moins_18_TT VALUES ('Tamenrasset','Tindouf'),
            SubPartition Client_Moins_18_Autres VALUES (DEFAULT)
        )
    ),
    Partition Client_18_26 VALUES LESS THAN (26) (
        SubPartition by List (Ville) (
            SubPartition Client_18_26_TT VALUES ('Tamenrasset','Tindouf'),
            SubPartition Client_18_26_OG VALUES ('Ouargla','Ghardaia'),
            SubPartition Client_18_26_Autres VALUES (DEFAULT)
        )
    ),
    Partition Client_26_60 VALUES LESS THAN (60) (
        SubPartition by List (Ville) (
            SubPartition Client_26_60_TT VALUES ('Tamenrasset','Tindouf'),
            SubPartition Client_26_60_Autres VALUES (DEFAULT)
        )
    ),
    Partition Client_Sup_60 VALUES LESS THAN (MAXVALUE) (
        SubPartition by List (Ville) (
            SubPartition Client_Sup_60_TT VALUES ('Tamenrasset','Tindouf'),
            SubPartition Client_Sup_60_Autres VALUES (DEFAULT)
        )
    )
);

Note : L'utilisation de DEFAULT dans une sous-partition LIST permet de gérer toutes les valeurs de la colonne de sous-partitionnement qui ne sont pas explicitement listées dans les autres sous-partitions de ce niveau.

Réécriture des Requêtes après Fragmentation

Après l'implémentation de la fragmentation, certaines requêtes peuvent être réécrites pour cibler directement les fragments pertinents, améliorant ainsi les performances en évitant de scanner l'intégralité de la table.

Requête combinant des clients d'âge supérieur à 30 ans dans les fragments Client_26_60_TT et Client_Sup_60 :
```
Select * from Client_26_60_TT where Age > 30
UNION ALL
Select * from Client_Sup_60_TT
UNION ALL
Select * from Client_Sup_60_Autres;
```
(La répétition de la première clause UNION dans l'original a été corrigée. L'utilisation de UNION ALL est souvent préférée pour des raisons de performance, car elle inclut tous les enregistrements sans éliminer les doublons, ce qui est généralement plus rapide.)
Sélectionner les clients de la ville de Tindouf dans le fragment Client_Sup60_TT :
```
Select * from Client_Sup60_TT where Ville = 'Tindouf';
```
Requête générique applicable à tous les fragments :

Cette requête est valide sur tous les fragments. L'union de tous les fragments est nécessaire pour obtenir un résultat complet si la requête ne peut pas être ciblée sur un ou plusieurs fragments spécifiques. Sa forme sur un fragment Client_i est la suivante :
```
Select NumC, Ville, Age from Client_i
```
où Client_i représente chacun des fragments de la table Client (par exemple : Client_Moins_18_TT, Client_18_26_OG, etc.).

Schéma de Fragmentation de la Table Voyage

La fragmentation de la table Voyage est basée sur une jointure semi-externe (Semi-Join) avec les fragments correspondants de la table Client. Chaque fragment Voyage_i est défini par une jointure avec son fragment Client_i correspondant, ce qui permet de localiser les voyages et les clients associés sur la même partition physique ou logique.

Voyage_18_26_TT = Voyage Semi-Join Client_18_26_TT
Voyage_18_26_OG = Voyage Semi-Join Client_18_26_OG
Voyage_18_26_Autres = Voyage Semi-Join Client_18_26_Autres
Voyage_Sup60_TT = Voyage Semi-Join Client_Sup60_TT
Voyage_Sup60_Autres = Voyage Semi-Join Client_Sup60_Autres
Voyage_Moins18_TT = Voyage Semi-Join Client_Moins18_TT
Voyage_Moins18_Autres = Voyage Semi-Join Client_Moins18_Autres
Voyage_26_60_TT = Voyage Semi-Join Client_26_60_TT
Voyage_26_60_Autres = Voyage Semi-Join Client_26_60_Autres

Foire Aux Questions (FAQ)

Qu'est-ce que l'ODL (Object Definition Language) ?: L'ODL est un langage utilisé pour décrire les schémas de bases de données orientées objet. Il permet de définir les classes, leurs attributs, leurs relations et leurs méthodes, constituant ainsi un plan pour la structure des données et facilitant l'interopérabilité entre différents systèmes de gestion de bases de données objet (SGBDO).
Quel est l'intérêt principal de la fragmentation horizontale des tables ?: La fragmentation horizontale vise à améliorer les performances des bases de données distribuées et l'évolutivité. Elle divise une table en plusieurs sous-ensembles de lignes (fragments) basés sur des critères spécifiques. Cela permet de distribuer les données sur différents nœuds physiques, de réduire la quantité de données à scanner pour certaines requêtes, d'optimiser les accès locaux et d'améliorer la parallélisation du traitement des requêtes, en particulier dans les environnements OLAP ou de data warehousing.
Comment fonctionne le partitionnement composite Range-List ?: Le partitionnement composite Range-List est une technique avancée qui combine deux méthodes de partitionnement pour organiser les données. Une table est d'abord partitionnée par plage (Range) sur une colonne (par exemple, l'âge, divisant la table en tranches d'âge). Ensuite, chaque partition de plage est sous-partitionnée par liste (List) sur une autre colonne (par exemple, la ville, divisant chaque tranche d'âge par des groupes de villes spécifiques). Cette approche offre une grande flexibilité pour organiser et isoler les données, améliorant ainsi les performances des requêtes ciblées et la gestion des données.