Compte-rendu de projet de Système de gestion de base de données

Compte-rendu de projet de Système de gestion de base de données Création et utilisation d'un index de jointure LAMBERT VELLER Sylvain M1 STIC Université de Bourgogne 2010-2011 Reponsable : Mr Thierry Grison

Table des matières 1 Introduction 2 2 Le projet 3 2.A L'application réalisée.............................. 3 2.B La base de données utilisée........................... 3 2.C Interface graphique............................... 3 2.D Exemples d'utilisation............................. 5 2.D.1 Création d'un index de jointure.................... 5 2.D.2 Jointure de deux tables grâce à un index de jointure......... 6 2.D.3 lancement d'une requête........................ 7 2.E Lancement de l'application........................... 7 3 La classe JDBC 8 3.A Les diérentes fonctions............................ 8 3.B La fonction de création de la table d'index de jointure............ 8 3.C La fonction de remplissage de la table d'index................ 9 3.D La fonction de création de trigger....................... 9 3.E La fonction de vérication d'existence d'un index de jointure........ 9 3.F La fonction d'écriture de la requête de jointure................ 10 3.G La fonction d'achage d'un résultat d'une requête............. 10 4 La classe principale 11 5 Création d'un index de jointure 12 5.A L'initialisation.................................. 12 5.B La création d'une table relative à l'index de jointure............. 12 5.C Le remplissage de la table d'index de jointure................ 12 5.D La création des triggers............................. 13 6 Utilisation d'un index de jointure 14 6.A Choix des tables à joindre........................... 14 6.B Vérication de l'existence d'un index de jointure............... 14 6.C Jointure des deux tables et achage...................... 14 7 Chirement des coûts des diérents algorithmes de jointure 15

7.A Produit cartésien................................ 15 7.B Key-lookup................................... 15 7.C Hashage..................................... 15 7.D sort-merge.................................... 15 7.E Indexes de jointure............................... 16 8 Conclusion 17

1 Introduction Les algorithmes traditionnels de jointure sont au nombre de quatre : produitcartésien, key-lookup, sort-merge et hashage. Chacuns ont leurs avantages et inconvénients. Pour ce projet, il a été demandé d'implémenter un autre algorithme de jointure. Celui-ci utilise les indexes de jointure qui a été proposé par Valduriez en 1987. Un index de jointure est une structure qui contient des couples de rowids de tuples de deux relations dont on veut faciliter la jointure. On enregistre dans un index de jointure, qui sera stocké sous Oracle dans une table, les couples de rowids des tuples qui vérient un critère de jointure donné. Dans un premier temps, Je vais présenter le projet ainsi que l'utilisation de l'application. Ensuite, je vais expliquer le contenu des diérentes classes créées dans ce projet. Après cela, il vous sera expliqué le fonctionnement an de créer et utiliser les indexes de jointure. 2

2 Le projet 2.A L'application réalisée L'application qui a été réalisée permet de créer un index de jointure et implémenter un algorithme de jointure. Elle possède deux classes. Une classe principale qui est la classe mère du projet et une classe nommé JDBC qui va faire la relation avec la base de données.cette application a été réalisé avec le langage Java et les données ont été stockées sous Oracle. 2.B La base de données utilisée Cette base de données contient une table qui regroupe tous les étudiants avec leurs caractéristiques comme son nom, prénom, sexe. Elle contient également les tables sexe, sportif, ville, statut. Ces tables vont nous servir an de créer et utiliser des indexes de jointures. Voici le diagramme UML de cette base de données : 3

CHAPITRE 2. LE PROJET 4 2.C Interface graphique L'interface graphique de cette application se décompose en quatre parties : Le menu en haut à gauche qui permet de choisir si l'on veut créer un index de jointure, l'utiliser ou lancer une requete Les listes déroulantes qui permettent de choisir les tables, les attributs de tables ainsi que le critère de jointure si nécessaire Les boutons qui permettent d'eectuer certaines actions Un TextArea qui permet d'acher les résultats d'une jointure entre deux tables avec un index de jointure

CHAPITRE 2. LE PROJET 5 2.D Exemples d'utilisation 2.D.1 Création d'un index de jointure Initialisation, sélection des tables et du critère de jointure : Lancement de la création de l'index de jointure : Vérication que l'index de jointure a été créé :

CHAPITRE 2. LE PROJET 6 Résultat donné pour la création d'un index de jointure sur les tables Etudiant et ville sur le critère Numville. 2.D.2 Jointure de deux tables grâce à un index de jointure Lancement de la jointure des deux tables si un index de jointure existe : Achage si aucun index de jointure n'existe :

CHAPITRE 2. LE PROJET 7 Achage du résultat de la jointure : 2.D.3 lancement d'une requête 2.E Lancement de l'application An de pouvoir démarrer l'application, il faut se positionner dans le répertoire où se trouve le chier avec l'extension.jar et réaliser cette commande : java -jar chier.jar

3 La classe JDBC Cette classe permet de faire la relation entre notre application et la base de données Oracle que nous utilisons. C'est avec cette classe que l'on va créer et utiliser l'index de jointure. 3.A Les diérentes fonctions Voici un sommaire des fonctions que l'on trouve dans la classe JDBC 'initialisation' permet d'initialiser la connexion avec la base de données en créant une connexion et des 'statements' 'pilote' permet de charger le driver d'oracle 'creerconnexion' permet de créer une connexion avec la base de données Oracle 'fermerconnexion permet de fermer une connexion préalablement ouverte 'creationstatement' permet de créer un statement 'lancerrequete' permet de lancer une requete 'lancerrequeteupdate' permet de lancer une requete du type update 'acherres' qui permet d'acher le résultat d'une requête 'jointuretables' permet de créer et remplir une table qui stockera l'index de jointure. Elle crée également des triggers. 'verieexisteindex' permet de vérier s'il existe un index pour deux tables et un critère de jointure donné 'ecrireresrequetejointure' permet d'écrire une requête de jointure et d'acher le résultat 'remplirtableindex' permet de remplir la table qui correspond à l'index de jointure 'creertrigger' permet de créer un trigger qui réalisera la mise à jour de l'index de jointure lorsque la base de données sera modiée 3.B La fonction de création de la table d'index de jointure Cette fonction va créer une table qui va permettre de stocker l'index de jointure relatives aux tables souhaitées. Elle admet trois paramètres : les deux tables et le critère de jointure pour lequels il faut créer un index de jointure. Tout d'abord on va lancer une requête an de créer la table d'index de jointure.on utilise pour cela la commande 8

CHAPITRE 3. LA CLASSE JDBC 9 CREATE TABLE qui créera une table avec deux attributs an de stocker les 'row id' des enregistrements des deux tables à joindre dont la valeur du critère de jointure est la même. Il faut savoir que la table se nommera comme ceci : IND + le nom de la première table + le nom de la secondes tables + le nom d'un attribut( les deux attributs auront le même nom) Lorsque ceci est eectué, on remplit la table et on crée deux triggers (un pour chaque table) an que la table soit toujours à jour par rapport à la base de donnéees. 3.C La fonction de remplissage de la table d'index Cette fonction remplit la table d'index de jointure préalablement créée. La table d'index de jointure contiendra les 'row id' des enregistrements des tables dont la valeur du critère de jointure est égale. An de remplir la table, on on va lancer une requête par chaque table, qui va sélectionner le 'row id' et la valeur de l'attribut des diérentes enregistrements de la table sélectionnée. On récupère ensuite les résultats dans des variables de type ResultSet. Lorsque c'est eectué, on va comparer pour chaque résultat obtenu, les deux valeurs d'attributs et si elle sont égales on insert les 'row id' qui correspondent à cet enregistrement dans la table d'index de jointure. 3.D La fonction de création de trigger Cette fonction permet de créer un trigger an de garder à jour la table d'index de jointure que l'on a créé. Si on insert ou supprime une donnée dans une table qui possède un index de jointure, il faut que l'index de jointure se mettent à jour sinon, il n'a aucun intérêt. Pour réaliser le trigger, on crée un curseur qui va récupérer la valeur de l'attribut de la seconde table pour chaque enregistrement. Ce curseur nous servira en cas d'insertion de données. Il y a deux parties dans ce trigger : une partie pour la suppression et une autre pour l'insertion. En cas de suppression dans une table, le trigger va supprimer dans la table d'index de jointure l'enregistrement dont la valeur le champ qui correspond aux 'row id' de la table concerné est égal au 'row id' qui vient d'être supprimé. En cas d'ajout dans une table, on va comparer la valeur du critère de jointure qui vient d'être ajouté aux valeurs du critère de jointure présents dans l'autre table et s'il y a égalité, on ajoute les 'row id' correspondant dans la table d'index de jointure. 3.E La fonction de vérication d'existence d'un index de jointure Cette fonction va vérier s'il existe un index de jointure pour deux tables et un critère de jointure donné. Lors de la création de la table d'index de jointure, on donne un

CHAPITRE 3. LA CLASSE JDBC 10 nom bien spécique à la table alors pour vérier qu'il existe bien un index de jointure, il sut de lancer une requête qui va chercher s'il existe une table qui a pour nom : IND + le nom de la première table + le nom de la seconde tables + le critère de jointure S'il y a un résultat, cela signie qu'elle existe 3.F La fonction d'écriture de la requête de jointure Cette fonction permet d'eectuer une jointure entre deux tables en utilisant l'index de jointure créé auparavant et d'acher les résultats. Pour réaliser cette jointure, on va sélectionner tous les tuples de la table d'index de jointure et on va chercher quels sont les enregistrements des deux tables qui correspondent à ces 'row id' et on les ache. 3.G La fonction d'achage d'un résultat d'une requête Cette fonction est utilisée lorsqu'une requête veut être exécutée par l'utilisateur depuis notre application. Elle permet de retourner le résultat de la requête an de l'acher dans un TextArea.

4 La classe principale Cette classe va permettre de faire la relation entre la fenêtre de notre application et la classe JDBC. Les diérentes fonctions de remplissage sont : remplissage des listes déroulantes relatives aux tables remplissage de la liste déroulante relative au critère de jointure. On retrouve également dans cette classe les fonctions qui sont executées lorsqu'on clique sur un bouton dans notre application. C'est dans cette classe que sont présentes les fonctions qui remplissent les listes déroulantes. Les fonctions de la classe JDBC vont être appelées dans cette classe via des fonctions relatives à des événements qui se produisent dans l'application comme des clics sur des boutons par exemple. 11

5 Création d'un index de jointure An de pouvoir créer un index de jointure, voici les étapes nécessaires : Séléctionner 'création d'un index de jointure' dans le menu Eectuer une initialisation an de pouvoir se connecter à la base de données et remplir les listes déroulantes des tables et du critère de jointure Sélectionner les tables pour lesquelles on désire créer un index de jointure ainsi que le critère de jointure Créer une table qui servir pour stocker l'index de jointure Créer des triggers an de pouvoir eectuer des mises à jour sur l'index de jointure 5.A L'initialisation L'initialisation consiste à réaliser la connexion à la base de données Oracle et charger les listes déroulantes qui vont nous servir an de sélectionner les tables pour lesquelles on veut créer un index de jointure. Pour réaliser cette initialisation, on fait appel à la fonction initialisation de la classe JDBC et ensuite, on appelle les fonctions qui chargent les listes déroulantes relatives aux tables ainsi que celle qui contient les diérents critères de jointure. 5.B La création d'une table relative à l'index de jointure Lorsque les données ont été sélectionnées par l'utilisateur, il faut créer une table qui va permettre de stocker l'index de jointure que l'on souhaite créer. Pour créer la table on appelle la fonction jointuretables de la classe JDBC. 5.C Le remplissage de la table d'index de jointure Le remplissage de la table d'index de jointure s'eectue dans la fonction jointuretables de la classe JDBC. Dans cette fonction, on appelle la fonction remplirtableindex qui va se charger de remplir comme il faut la table que l'on vient de créer. 12

CHAPITRE 5. CRÉATION D'UN INDEX DE JOINTURE 13 5.D La création des triggers A chaque création d'un nouvel index de jointure, deux triggers seront créés an de garder l'index de jointure à jour au l des mises à jour de la base de données. Lors de la création d'une table, l'index de jointure est pour deux tables, alors un trigger sera créé pour chaque table. De ce fait, à chaque insertion, suppression ou modication d'un enregistrement dans une table, le trigger sera déclenché est l'index de jointure concerné sera mis à jour automatiquement.

6 Utilisation d'un index de jointure Après avoir créé des index de jointure, on peut utiliser ces index de jointure an de réaliser la jointure de deux tables pour lesquelles il existe un index de jointure Voici les étapes an d'eectuer une jointure de deux tables via un index de jointure choix des tables à joindre et du critère de jointure Vérication de l'existence d'un index de jointure Jointure des deux tables Achage du résultat de la jointure 6.A Choix des tables à joindre Pour pouvoir eectuer une jointure, il faut bien entendu savoir quelles sont les tables que l'on veut joindre et le critère de jointure. Pour cela, l'utilisateur doit choisir dans les listes déroulantes les deux tables à joindre et le critère de jointure possible. La vérication de l'existence des tables n'est pas nécessaire car dans la liste déroulante, on trouve seulement les tables qui sont présentes dans la base de données alors de ce fait, l'utilisateur ne peut pas choisir une autre table. 6.B Vérication de l'existence d'un index de jointure An de vérier l'existence d'un index de jointure, on va utiliser la fonction veri- eexisteindex de la classe JDBC. Cette fonction nous renverra une valeur booléenne. Si elle renvoit 'true' cela signie qu'il existe un index de jointure et que l'on peut eectuer la jointure. Si ce n'est pas le cas, cela renvoit false alors on le signale à l'utilisateur et on n'eectue pas la jointure. 6.C Jointure des deux tables et achage An d'eectuer la jointure des deux tables, on a besoin de connaître tous les enregistrement qui sont contenus dans l'index de jointure alors on écrit une requête pour les obtenir. Ensuite, on appelle la fonction ecrirereqjointure de la classe JDBC qui va rechercher les enregistrements des deux tables qui sont concerné par l'index de jointure et renvoyer une valeur de type String qui va contenir ce qu'il faut acher. Ensuite, il sut d'acher cette valeur dans le TextArea prévu à cet eet. 14

7 Chirement des coûts des diérents algorithmes de jointure An d'eectuer les calculs, je vais prendre les données suivantes : nombre d'enregistrements par bloc : 100 nombre d'enregistrements pour la table étudiant : 10000 nombre d'enregistrements pour la table ville :1000 nombre de blocs en mémoire centrale : 100 7.A Produit cartésien Coût = BV + (BV*BE)/M Coût= 10 + (10*100)/100 = 11 7.B Key-lookup Coût = BV + TV * (TE/Iville) Coût= 10 + 1000 * (10000/1000) Coût= 10 + 1000 * 10 = 10 010 7.C Hashage Coût= 3*BV+3*BE Coût= 3*10 +3*100= 330 7.D sort-merge Coût = 2BV logm BV + 2BE logm BE + BV + BE Coût=2*10 log100 10 + 2*100 log100 100 + 10 + 100 Coût= 2*10*1 + 2*100*1 + 10 + 100 Coût= 20 + 200 + 10 + 100 = 330 15

CHAPITRE 7. CHIFFREMENT DES COÛTS DES DIFFÉRENTS ALGORITHMES DE JOINTURE 1 7.E Indexes de jointure An de réaliser l'index de jointure, on parcourt les deux tables à joindre et on parcourt également la table qui va nous servir d'index an d'insérer les row id. La formule est donc celle du produit cartésien avec un parcours de table en plus ce qui donne : Coût = (BR + (BR*BS)/M ) + BV Coût = 10 + (10*100)/100 + BV = 11 + 100 = 111

8 Conclusion Ce projet a été l'occasion d'apprendre le fonctionnement de l'api JDBC et de ses principales classes. J'ai pû réaliser une application fonctionnelle qui permet de créer et utiliser un index de jointure. La performance de cet index de jointure a été calculée théoriquement car il n'est pas possible de réaliser une jointure, grâce à cet index, plus rapidement que les algorithmes existants déjà sous Oracle. Ceci est dû au fait que la jointure est réalisée à l'aide de JDBC et par conséquent, le temps d'exécution sera moins rapide. 17