Projet Bibliographique Guides

MASTER MIAGE Spécialité ACSI
Projet bibliographique :
guides d’utilisations des
outils décisionnels
Professeur : Odile THIERY
Elias Ohayon | Adrien Gabriel

Année 2007 - 2008
Projet Bibliographique : guides d’utilisation Ohayon | Gabriel
Sommaire
Introduction ..................................................................................................................................................... 3
Business Objects 5.1 ......................................................................................................................................... 4

1. Principes de base ....................................................................................................................................... 4
2. Que contient un univers ? .......................................................................................................................... 4
3. Procédures d’installation ........................................................................................................................... 5
4. Utilisation de Designer ............................................................................................................................... 6
a. Paramètrage .......................................................................................................................................... 6
b. Création d’un schéma : .......................................................................................................................... 7
c. Création des classes et objets :.............................................................................................................. 9
5. Reporting ................................................................................................................................................. 11
Cognos V7 ...................................................................................................................................................... 14
1. Installation ............................................................................................................................................... 14
2. Transformer, création du cube ................................................................................................................ 14
3. Powerplay, exploitation du cube ............................................................................................................. 15
SQL Server 7.0 ................................................................................................................................................ 16

1. Installation ............................................................................................................................................... 16
2. Création du cube ...................................................................................................................................... 17
3. Exploration du cube ................................................................................................................................. 26
La suite Pentaho et ses satellites .................................................................................................................... 28

1. Installation ............................................................................................................................................... 28
a. Les différentes solutions ...................................................................................................................... 28
b. Démarrage de la plateforme Pentaho ................................................................................................. 28
c. Démarrage des autres outils composant la suite Pentaho .................................................................. 29
2. Fonctionnalités......................................................................................................................................... 30
a. La création du cube avec CubeDesigner .............................................................................................. 31
b. L’analyse avec la plateforme BI Pentaho et son module JPivot .......................................................... 38
c. L’édition de rapports avec le Pentaho Report Design Wizard ............................................................. 41
La plateforme SpagoBI ................................................................................................................................... 47

1. Installation ............................................................................................................................................... 47
a. Pré-requis ............................................................................................................................................ 47
b. Installation de la plateforme ............................................................................................................... 47
c. Démarrage de la suite SpagoBI ............................................................................................................ 51
2. Fonctionnalités......................................................................................................................................... 53
a. Importation du cube ............................................................................................................................ 53
b. Création d’un dossier de travail........................................................................................................... 54
c. L’analyse OLAP du cube ProjetBiblio ................................................................................................... 54
d. L’édition de rapport ............................................................................................................................. 57
Kettle, ou plutôt Pentaho Data Integration .................................................................................................... 61

1. Exemple de création d’une transformation ............................................................................................. 61
Talend Open Studio ........................................................................................................................................ 68

1. Exemple de création d’une transformation ............................................................................................. 68
MASTER MIAGE Spécialité ACSI | Année 2007 - 2008
Page 2/ 76
Introduction
Dans le cadre de nos derniers mois de formation en Master 2 ACSI, nous avons choisi de faire le point
sur quelques outils d’analyses décisionnelles commerciaux ou open-source. En effet, avec l’explosion
de l’Intelligence Economique dans de nombreux domaines de services ou industriels, le
développement de solutions informatiques de datamining a évolué de manière significative.
Les grands acteurs de la Business Intelligence que sont Business Objects, Cognos ou bien SQL Server
ont désormais des adversaires open-source qui commencent à se faire connaître dans les milieux
spécialisés : Pentaho, SpagoBI et OpenI par exemple.
Nous avons souhaité scinder notre rapport en deux parties afin de bien dissocier les guides
d’installation et d’utilisation et l’analyse des logiciels.
Nous n’avons pas la prétention de fournir des tutoriaux d’utilisation exhaustifs pour plusieurs
raisons :
- Ca n’est pas notre objectif

- Nous n’avons pas le niveau adapté en BI
- Nous souhaitons plutôt proposer un guide pour éviter de perdre du temps à chercher dans
les manuels.
Ainsi, nous allons étudier comment installer et utiliser de façon simple Business Objects et SQL
Server. Pour Cognos, nous survolerons rapidement le processus car nous l’avons étudié plus en
profondeur en Master 1.
Au niveau des logiciels open-source, ce qui était encore un embryon d’approche il y a quelques
années s’est considérablement développé. S’il ne représente pas une solution envisageable pour le
moment pour les grosses sociétés, pour les petites PME qui souhaitent s’approcher de la fouille
décisionnelle, c’est à considérer, notamment en raison du prix des licences des logiciels commerciaux
qui s’élèvent à plusieurs milliers d’euros.
Page 3/ 76
Business Objects 5.1

La version de Business Objects que nous présentons est la 5.1, elle est assez ancienne puisque
l’actuelle est la V11. Malheureusement nous n’avons pas réussi pas à trouver celle-ci.
Avant de nous intéresser à l’installation nous devons présenter le fonctionnement de Designer, le

software permettant la création de l’univers qui sera exploité par Business Objects.
1. Principes de base
Un univers est un fichier qui contient les éléments suivants :
- Des paramètres de connexion pour un ou plusieurs middlewares de base de données

- Des structures SQL appelées « objets » qui correspondent à de vraies structures SQL de la
base de données, par exemple des colonnes, des tables et des fonctions de base de données.
Les objets sont regroupés en classes.
- Un schéma des tables et des jointures utilisées dans la base de données. Les objets sont
créés à partir des structures de la base de données que l'on inclut dans le schéma.
Un univers offre une interface simple à utiliser et compréhensible permettant à des utilisateurs non
spécialistes des logiciels de reporting, comme Business Objects, d'exécuter des requêtes dans une
base de données afin d'effectuer des analyses et de créer des rapports.
2. Que contient un univers ?

Un univers est composé de 2 types de structures : les classes et les objets.
- Classe : une classe est un regroupement logique d'objets dans un univers. Elle représente
une catégorie d'objets. Pour des raisons évidentes de clarté, le nom de la classe doit indiquer
la catégorie des objets qu'elle contient.
- Objets : un objet est un composant qui représente des données de la BDD. Nous disposons
de 3 types d'objets sous ce logiciel :
o Dimension : qui constitue une hiérarchie d'analyse.

o Information : permet de décrire une dimension mais ne constitue pas l'objectif
o Indicateur : fournit des informations utilisées pour quantifier un objet de type
dimension.
Figure 1 : Fonctionnement de Business Object
Page 4/ 76
3. Procédures d’installation
Lancer le panneau de configuration puis choisir « Sources de données (ODBC) ». Cliquer sur l'onglet
« Sources de données système » puis sur « Ajouter », une liste déroulante apparaît.
Figure 2 : Choisir le driver Access
Une nouvelle fenêtre est affichée avec différentes informations sur la base de données que nous
allons utiliser :
Figure 3 : Informations sur la BDD
Normalement le nom de la base apparaît dans la liste principale comme affiché ci-après :
Figure 4 : Vérifier que la BDD est bien dans la liste
La partie la plus délicate est maintenant réalisée. Il suffit alors d'installer le logiciel grâce à
l’exécutable. Ensuite, on lance « Designer ».
Page 5/ 76
4. Utilisation de Designer
a. Paramètrage
Figure 5 : Informations sur l'univers
On nomme l'univers, on peut également le décrire de façon succinte afin de faciliter le travail lors
d'échange de fichiers dans une équipe. On doit alors préparer la connexion. On choisit dans la liste
déroulante la valeur « New connection ». On va paramétrer cette connexion en l'éditant (bouton
edit).
Figure 6 : Connexion à la BDD
Dans « Data source name », on choisit la base créée précédemment (« Eid »). Un clic de souris sur le
bouton « Test » permet de s'assurer que la connexion fonctionne.
On valide les réglages, on peut aller commencer la création de l'univers qui permettra d'utiliser le
reporting.
Page 6/ 76
b. Création d’un schéma :

Un schéma est une représentation graphique d'une partie de la base de données que nous allons
utiliser pour créer notre univers. C'est donc un faux schéma E/A que nous avons car il y a des
redondances d'informations. En effet, puisque le schéma est créé à partir des tables contenus dans la
base de données, nous en avons fusionné certaines (cardinalité 1,1 : 1,1 ; 1,1 : 1,n) ou créer de
nouvelles (cardinalité 1,n : 1,n).
Les attributs des tables sont donc les objets qui seront utilisés pour l'analyse des besoins des
utilisateurs.
Pour créer notre schéma, nous allons partir de la requête SQL que nous avons créée en Master 1
pour le projet d'EID et exploité sous Cognos :
SELECT
e.idEleve, u.idUnite, s.moyenne, fp.moyenneJanvier, fp.moyenneJuin,
fp.moyenneGenJuin, a.annee, ec.semestre, p.idPromo, d.idDomaine
FROM
Annee a, estComposeePU ec, promo p, unite u, domaine d, suitEU s, seRapporteUD r,
eleve e, faitPartieEP fp
WHERE
fp.idEleve = e.idEleve AND
s.idEleve = e.idEleve AND
fp.annee = a.annee AND
ec.annee = a.annee AND
s.annee = a.annee AND
fp.idPromo = p.idPromo AND
ec.idPromo = p.idPromo AND
ec.idUnite = u.idUnite AND
s.idUnite = u.idUnite AND
r.idUnite = u.idUnite AND
d.idDomaine = r.idDomaine
Nous pouvons donc recréer le schéma qui correspond à cette requête. Pour se faire, dans la grande
fenêtre, nous faisons « clic-droit », « insert-table » et nous choisissons d'insérer les tables suivantes
pour débuter :
faitPartieEP, annee, promo, eleve
Ensuite, nous créons les jointures entre ces tables : clic-droit, insert join. Le fonctionnement est très
simple comme illustré ci-après :
Page 7/ 76
Figure 7 : Edition des jointures
On choisit les clés entre les deux tables puis la cardinalité. Afin d'aider le créateur, le programme
résume clairement le rapport entre les tables. Par exemple, ici, nous faisons le lien entre la table
« annee » qui contient un champ « année » et la table « faitPartieEP ». La cardinalité est « 1,N » ce
qui signifie selon le programme « each annee has one or more faitPartieEP and Each faitPartieEP has
one and only one annee »
Le schéma est donc le suivant :
Figure 8 : Schéma, première étape
Ensuite, nous ajoutons les tables :
domaine, unite, estComposeePU, seRapporteUD et suitEU.
Il faut faire les jointures pour obtenir le schéma final de notre univers.
Page 8/ 76
Figure 9 : Schéma final de l'univers
La première partie de la création de l'univers est maintenant réalisée. Nous pouvons entamer la
seconde qui consiste en la création de « classes » et de leurs « objets » associés.
c. Création des classes et objets :

Nous allons créer 4 classes dans notre univers : Temps, Enseignements, Elèves et Mesures
Pour ajouter une classe, il faut cliquer sur cet icône
On nomme alors les dimensions et on peut les décrire si on le souhaite, ca facilite la compréhension
lors du travail en équipe.
Classe Temps :
Pour celle-ci nous utiliserons deux objets : Année et Semestre.
Pour créer un objet et l'associer à une classe il faut commencer par double-cliquer sur la classe qui
nous intéresse afin de « l'ouvrir ». Ensuite, il faut cliquer sur l'icône suivant :
On peut alors rentrer les différentes informations nécessaires à la caractérisation de l'objet. Il ne faut
pas se tromper avec le type de l'objet qui doit correspondre à celui utilisé dans la base de données.
Ensuite, nous allons définir le contenu de l'objet grâce à l'assistant requêteur qui s'ouvre en cliquant
sur « >> » au niveau de la boîte texte « Select ». Une nouvelle fenêtre nous permet donc d'aller
chercher les informations pour construire la requête qui amènera la valeur de l'objet.
Pour la valeur de l'année, il nous faut juste utiliser la valeur de table « année ». On clique sur celle-ci
et elle apparaît dans la boîte texte. On remarque également qu'il existe un certain nombre de
fonctions mathématiques, de chaînes de caractères.
Enfin, on peut également appliquer sur cette requête une clause « WHERE » qui nous permet si on le
souhaite d'effectuer un tri des résultats.
Page 9/ 76
- Objet année : annee.annee

- Objet semestre : estComposeePU.semestre
Classe Enseignements :
Nous souhaitons utiliser 3 objets :
- Promotions
- Domaines
- Unités
Sous Cognos, nous utilisions le niveau « spécialisation » afin de pouvoir facilement dissocier la
spécialité « SID » et « ACSI ». Malheureusement, il est impossible ici de créer de tel niveau
manuellement car la valeur d'un objet fait référence à une donnée contenue dans la base. On doit
donc supprimer ce niveau.
Nous ne descendons pas au niveau des matières car celles-ci sont remaniées à peu près chaque
année que ca soit dans leur programe, dans leur niveau etc... Nous préférons donc en rester aux
unités.
- Objet promotions : promo.nomPromo

- Objet domaines : domaine.nomDomaine
- Objet unités : unité.nomUnite
Classe Elèves :
Pour la dimension élève, nous prenons seulement l'identité de l'élève.
- Objet nom : eleve.nomEleve

- Objet prénom : eleve.prenomEleve
Classe Mesures :
La classe mesure en contiendra plusieurs ce qui permettra une analyse des résultats des élèves ou
des promos. Les données à utiliser sont présentes dans la table « suitEU » qui permet notamment de
connaître la moyenne d'un élève pour une unité lors de la première session et, si besoin, en
septembre. Les données sont aussi présentes dans la table « faitPartieEP » qui elle, regroupe les
moyennes des semestres de Janvier, de Juin, ainsi que les moyennes générales de Juin et de
Septembre.
Pour définir une mesure, il faut créer un objet comme on l'a vu précédemment mais dans l'onglet
« Properties », il faut passer de « dimension » à « measure » et choisir si besoin une des cinq
fonctions d'aggrégations : moyenne, compte, max, min et somme.
Les mesures que nous utiliserons dans notre univers ne concernent que les résultats de la première
session, nous occulterons donc ceux de Septembre.
Nous pouvons commencer par la création de trois mesures qui représenteront la meilleure moyenne,
la moins bonne moyenne et la moyenne générale d'une unité. Pour se faire, nous utilisons le champ
« moyenne » de la table « suitEU ».
Page 10/ 76
Ensuite, nous faisons la même chose pour les moyennes de Janvier, de Juin et la moyenne générale
de Juin en utilisant les champs « moyenneJanvier », « moyenneJuin » et « moyenneGenJuin » de la
table « faitPartieEP ».
Les mesures sont donc les suivantes :
Figure 10 : Listing des mesures
5. Reporting
Le logiciel « Business Objects » pourrait être assimilé à « Impromptu » de Cognos.
Pour créer un rapport, c'est très simple, il faut lancer le logiciel puis choisir l'univers que l'on a créé
précédemment.
Le « Query Panel » apparaît. Cette interface est divisée en trois parties, à gauche les classes et objets
définis dans l'univers. A droite, se trouvent les résultats, les objets, que l'on souhaite afficher dans le
rapport. Sous ceux-ci, on a un cadre réservé aux conditions.
Ci-dessous, nous illustrons un exemple d'utilisation en affichant l'évolution des moyennes générales
de la session de Juin pour les différentes promotions.
Les objets seront donc : les promotions (classe Enseignements), les années (classe Temps) et la
moyenne des moyennes générales de la session de Juin (mesure « Moyenne générale Session Juin »,
classe Mesures). On ajoute des conditions qui élaguent un peu les résultats car nous avons quelques
données incomplètes, ainsi nous n'afficherons pas les moyennes « vides » ou égales à 0.
L'outil qui crée les conditions est bien conçu, comment fonctionne t'il ?
On choisit l'objet ou la mesure sur lequel on souhaite poser une condition et on le glisse dans le
cadre « conditions ». Apparaît alors dans la partie gauche une liste d'opérateurs :
Page 11/ 76
Figure 11 : Liste d'opérateurs
On clique sur celui qui nous intéresse, ici, « Different from ». La liste d'opérateurs laisse place à une
liste de méthodes de récupérations de valeurs :
Figure 12 : Liste de méthodes
Nous avons le choix entre « type a new constant » et dans ce cas on met 0, ou « Show list of values »
qui nous affichera la liste des valeurs de la base de données, on cliquera sur la première valeur de 0.
Figure 13 : Editeur
En cliquant sur « Run » on lance l'édition du rapport :
Page 12/ 76
Figure 14 : Evolution des moyennes corrigées
Page 13/ 76
Cognos V7
Nous allons étudier Cognos en relation avec une base de données Access. Toutefois, par rapport à BO
ou SQL Server, nous ne rentrerons pas dans les détails. En effet, nous avons estimé que ca n’était pas
utile de réécrire les TP réalisés en Master 1.
1. Installation
Nous considérons que nous disposons d’une base Access prête à être utilisée. A notre niveau,
l'installation se fait simplement grâce à un exécutable, toutefois, les administrateurs spécialisés en BI
apprécieront le fait que les options sont grandement paramétrables.
2. Transformer, création du cube

Transformer est l’outil qui, à partir d’une requête SQL ramenant les éléments que l’on souhaite
utiliser dans notre cube, nous permettra de créer les dimensions et les mesures avant de l’exploiter
avec « Powerplay ».
La requête Access est la même celle utilisée dans la présentation BO, toutefois, à la place des clés
primaires, nous ramenons les attributs :
- Nom et prénom de l’élève

- Nom de l’unité
- Nom du domaine
- Nom de la promo
Les dimensions et sous-dimensions que nous utiliserons sont les suivantes :
TEMPS PROMOTIONS ENSEIGNEMENTS ELEVES

Année Promotions Domaines Nom
Semestre Spécialisation (*) Unités Prénom
Domaines
Unités
(*) la sous-dimension « spécialisation » a été crée manuellement, elle permet de distinguer les
différents types de Master 2. L'arbre des dimensions a été modifié pour que cette couche n'existe
que lorsque l'on observe les résultats du M2.
Une fois le cube déterminé, nous pouvons définir une série de mesures mathématiques afin
d'observer et d'exploiter les résultats d'une façon plus complète. Par exemple :
- moyenne des moyennes de Janvier

- moyenne des moyennes de Juin
- taux de non-régularité, permet de connaître la différence en pourcentage entre la moins
bonne moyenne et la meilleure dans un domaine pour un élève entre deux semestres : par
exemple 50% de différences entre les domaines mathématiques de L3 signifiera que l'élève a
été très bon au premier semestre et moins au second.
Page 14/ 76
Il ne reste maintenant qu'à générer l'hypercube et lancer PowerPlay.
3. Powerplay, exploitation du cube

Sous PowerPlay, grâce à des différents onglets, il est très aisé de naviguer dans les différentes
dimensions. Il apparaît clairement que les développeurs ont cherché à rendre l'interface la plus
conviviale possible pour les utilisateurs n'ayant aucune connaissance en informatique. On distingue
bien la frontière entre « Transformer » qui demande quelques notions (et encore, c'est à débattre) et
PowerPlay où n'importe quelle personne qui est un tant soi peu familiarisée avec un ordinateur
pourra utiliser.
Nous n'allons pas détailler plus en détails le fonctionnement de « PowerPlay » car nous ne ferions
que de la redite avec les cours de M1, toutefois, voici quelques illustrations des tableaux que l'on
peut obtenir :
Figure 15 : Exploitation PowerPlay
Figure 16 : Génération de graphique
Page 15/ 76
SQL Server 7.0

1. Installation
Nous avons réussi à récupérer la version 7.0 de SQL Server, ca n'est pas la plus récente mais elle
dispose tout de même des outils d'analyse qui nous intéressent. Toutefois, nous espérons qu'ils ont
été mis à jour correctement car nous allons le voir ce ne sont pas des foudres de guerre.
L'installation à partir du CD se déroule sans problèmes, le seul point sur lequel il ne faut pas se
tromper c'est la sélection des composants, notamment ceux nécessaires aux services OLAP.
Ensuite, nous devons, si cela n'a pas déjà été fait, créer une connexion OBDC avec la base de données
EID (explications déjà données dans la partie BO).
Nous pouvons maintenant réaliser les quelques derniers réglages sur la partie OLAP. Il faut lancer
l'outil OLAP Manager : Menu « Démarrer », « Microsoft SQL Server 7.0 », « OLAP Services ».
Cet outil nous permet de créer les cubes et de les explorer.
Il faut commencer par choisir « New Database » puis rentrer les informations demandées (nom et
description)
Figure 17 : Création d'une nouvelle base
La base s’est ajoutée à la liste courante :
Figure 18 : Validation
Page 16/ 76
Puis, il faut créer la source de données pour le cube :
Figure 19 : Création d'une source de données
Dans la fenêtre « Propriétés des liaisons de données », onglet « Connexion », choisir la base :
Figure 20 : Liaison avec la source ODBC
On valide, on peut maintenant commencer à réaliser le cube en faisant « clic-droit », « new cube »,
« Wizard ».
2. Création du cube
Nous terminons ici notre troisième analyse d'outil de réalisation d'hypercube, mais nous avons choisi
de réaliser un cube plus simple que les deux précédents car le fonctionnement des mesures est
particulier. Le logiciel nous oblige à utiliser une fonction d'agrégat ce qui peut entraîner des résultats
fantaisistes. Nous ne créerons que deux mesures : la moyenne générale à la session de Juin et la
moyenne des unités
Nous demandons au logiciel la création d'un nouveau cube, il faut commencer par sélectionner ce
que le logiciel appelle la « table de faits », cette table regroupe les mesures que nous souhaiterons
utiliser, il faut alors sélectionner la requête précédemment créée pour BO.
Page 17/ 76
Figure 21 : Sélection table de faits
On peut également imaginer, lors de la création de la BDD, de mettre en place une table spécifique
pour contenir ces données plutôt que d'utiliser une requête, cela peut faciliter le transfert entre
différents SGBD.
Il faut sélectionner ensuite les mesures :
Figure 22 : Sélection des mesures
Ensuite, nous passons à la création des différentes dimensions, cliquer sur « new dimension » :
Page 18/ 76
Figure 23 : Création des mesures
Le logiciel nous demande alors si la dimension utilise une seule table ou plusieurs tables, dans notre
cas, il s'agit de la deuxième solution :
Figure 24 : Sélection de la source de la dimension
Choisir ensuite les tables nécessaires à la dimension :
Figure 25 : Choix des tables pour la dimension
Page 19/ 76
On obtient un schéma où l'on effectue les jointures...
Figure 26 : Schéma de la dimension
... puis on choisit les différents niveaux de la dimension :
Figure 27 : Niveaux de la dimension
Il faut ensuite valider et la dimension apparaît dans la liste, on crée ensuite les deux autres
dimensions :
- Temps : annee.annee et estComposeePU.semestre

- Eleve : eleve.nomEleve et eleve.prenomEleve
La liste des dimensions est donc la suivante :
Figure 28 : Liste des dimensions
Page 20/ 76
Il faut encore nommer le cube pour terminer la première partie :
Figure 29 : Nommage du cube
Nous obtenons ensuite le schéma suivant. Toutefois, il est très important de remarquer que ce
schéma est simple. Pourquoi ? Car en ajoutant des tables et des jointures supplémentaires nous
n'avons vu aucune différence dans la navigation du cube. Ainsi, nous n'avons pas réussi à faire en
sorte qu'en choisissant une année et une promo nous n'ayons que les unités correspondantes...
Peut-être est-ce dû à un problème de conception de la base de données ou alors c'est le logiciel en
lui-même qui pose problème... Quoi qu'il en soit, le schéma ci-dessous illustre clairement la table des
faits et les données qui y sont rattachées.
Figure 30 : Schéma du cube
Page 21/ 76
Création des mesures :
Dans le menu de gauche, nous avons deux répertoires : « Measures » et « Calculated members ». Le
premier contient les mesures que nous avons sélectionnés lors de la création du cube, le second les
mesures que nous pouvons créer.
Figure 31 : Mesure du cube
Nous l'avons souligné un peu avant, le gros problème de SQL Server par rapport à Cognos est qu'il
oblige à utiliser une fonction d'agrégat pour les mesures sélectionnées. Ainsi, dans la navigation on
obtient des moyennes pouvant être « 540 » ou bien « 1 995 560 », ca n'a absolument aucun sens.
Pour corriger ce problème, nous allons créer des mesures.
Commençons par renommer les deux déjà existantes (clic-droit => rename) :
- moyenne > Sum moyennes unités

- moyenneGenJuin > Sum moyennes Session Juin
Nous pouvons maintenant créer deux nouvelles mesures (clic-droit => new measure) :
Sélectionner « moyenne » et valider, renommer la mesure en « Count moyennes unités ».
Sélectionner « moyenneGenJuin » et valider, renommer la mesure en « Count moyennes Session

Juin »
Pour modifier les propriétés des mesures, il faut cliquer sur l'onglet « Properties » en bas du menu
gauche. Cela paraît évident mais il nous a fallu pratiquement deux jours pour nous rendre compte
qu'il y avait un onglet... (merci à l'interface Microsoft).
Figure 32 : Onglet Properties pour les mesures
Nous allons changer la propriété d'agrégation en « count » pour ces deux mesures :
Figure 33 : Modification de la propriété Agrégation
Page 22/ 76
Enfin, pour les 4 mesures, onglet « advanced », changer la propriété « is Internal » en « Yes ». Cela
permettra de ne pas les afficher dans le cube.
Figure 34 : Liste des mesures
Maintenant, il faut définir les mesures grâce à l'éditeur (clic-droit sur « calculated members »). Nous
devons l'avouer, nous n'avons pas réussi à exploiter vraiment l'éditeur et ses fonctions. Nous savons
qu'il permet d'utiliser des requêtes MDX mais malgré quelques exemples trouvés sur internet, nous
n'avons pas obtenu de résultats probants.
Pour créer les formules, il faut simplement choisir les mesures qui nous intéressent et cliquer sur
« insert » :
Figure 35 : Editeur de mesures
Grâce à cette formule, nous avons créé la moyenne des unités. Ainsi pour un élève nous pourrons
avoir ses moyennes aux différentes unités. Nous faisons la même chose pour la moyenne générale à
la session de Juin.
Figure 36 : Liste des mesures créées
Page 23/ 76
Enfin, nous devons générer le cube (« Tools », « Design Storage »). Le programme offre 3 différentes
méthodes de gestion du cube :
- MOLAP : Le M-OLAP est un OLAP optimisé pour l'analyse multidimensionnelle. C'est une
forme d'hypercube multidimensionnel qui permet de représenter les données sous la forme
d'un croisement de n dimensions, ces dimensions pouvant être plus ou moins denses,
caractérisant ainsi la densité ou sparsité du cube.
- ROLAP : le R-OLAP est une technique de modélisation et de stockage des données basée sur
une structure relationnelle. Elle tire parti des ressources déjà existantes (licences, ressources
matérielles...) et, à ce titre, ne requiert pas l'investissement complémentaire d'une base
multidimensionnelle.
- HOLAP : Le H-OLAP est un Hybride entre le M-OLAP et le R-OLAP. La structure
multidimensionnelle d'un hypercube est utilisée pour les données agrégées. Lorsque l'accès à
un niveau de détail élémentaire plus fin est nécessaire, des tables relationnelles classiques
sont utilisées : c'est le mécanisme du drill through.
Nous allons utiliser le « MOLAP » ici :
Figure 37 : Selection du type de cube
Dans la fenêtre suivante, nous pouvons effectuer quelques réglages pour l'agrégation afin de gérer
au mieux la performance par rapport à la taille des données (cliquer sur « start »).
Figure 38 : Amélioration de la performance du cube
Page 24/ 76
Figure 39 : Résultat de l'agrégation
Comme on peut le voir sur le schéma, nous avons un très bon modèle mais le nombre de données
n'est pas énorme dans la base, il ne faut pas l'oublier.
On peut maintenant générer le cube :
Figure 40 : Génération du cube
Le programme nous informe du bon déroulement de la création du cube :
Figure 41 : Processus de création du cube
Page 25/ 76
3. Exploration du cube
Cette vue nous offre un résumé de la constitution du cube, les méta-données :
Figure 42 : Constitution du cube
L'onglet « Data » représente l'hypercube. Ses options sont très sommaires, on ne peut pas changer
l'affichage, cacher des colonnes. Bref , l'interface est on ne peut plus sommaire.
Ci-dessous se trouve une vue du cube, la même que pour BO et Cognos : moyenne générale de la
session de Juin pour toutes les promos et les années. Les résultats sont similaires à ceux que nous
ont donnés les deux autres logiciels.
Figure 43 : Exploration du cube
Page 26/ 76
Ci-dessous nous avons une seconde analyse, les résultats de GABRIEL Adrien pour la première année
et selon les domaines d'enseignements. Le logiciel n'offre même pas un agrandissement de la
colonne « Nom Domaine » ni d’outils de mise en page.
Figure 44 : Le cube
Page 27/ 76
La suite Pentaho et ses satellites

1. Installation
a. Les différentes solutions
La suite Pentaho est donc composée de plusieurs briques qu’il convient de télécharger séparément
sur le site d’hébergement des projets Open Source SourceForge.net. Parmi ces briques, seule la
plateforme Pentaho pour la publication de rapports peut être installée de plusieurs façons. Nous
vous proposons donc de passer en revue les différents cas envisageables.
Installer la plateforme Pentaho n’est pas difficile en soit, car plusieurs solutions s’offrent à
l’utilisateur / développeur.
Afin de simplifier au maximum l’installation de la plateforme, il est possible de récupérer sur le site
de téléchargement un guide au format PDF qui décrit en détail les différentes options d’installation.
De plus, différents guides expliquant en détail le fonctionnement de la plateforme sont disponibles

sur le site SourceForge.net. Ceux-ci sont en anglais et très complets.
Dans le cadre de cette étude, nous avons choisi d’utiliser la distribution prête à l’emploi, avec une
base de données MySQL qu’il convient d’installer séparément, avec EasyPHP par exemple. Le jeu de
données est un fichier data/SampleDataDump_MySql.sql (fourni avec la plateforme) qu’il suffira de
fournir à la base de données pour que l’utilisation de la plateforme soit optimale. La configuration de
la base de données est déjà prête, et requiert que cette dernière soit présente sur la même machine
et utilise le port par défaut 3306.
En ce qui concerne les autres briques indispensables au bon fonctionnement des opérations, il suffit
de télécharger sur le site les dernières versions de chacune d’entre elles, puis de les dézipper où bon
vous semble sur le disque dur. Voyons comment démarrer un composant essentiel de la suite : la
plateforme de publication Pentaho.
b. Démarrage de la plateforme Pentaho

Avant de démarrer la plateforme Pentaho, il ne faut jamais oublier de démarrer la base de données
MySQL sans quoi il ne sera pas possible de se logger sur la plateforme.
Etant donné que nous avons choisi une solution prête à l’emploi, la mise en service de la plateforme
Pentaho est d’une extrême simplicité. Il suffit juste de double-cliquer sur l’icône start-pentaho.bat,
dans le dossier décompressé qui contient l’ensemble de l’application. Le serveur JBoss se met alors
en route, et il suffit maintenant d’ouvrir un navigateur Web (Internet Explorer, Mozilla Firefox) et de
taper l’adresse suivante :
http://localhost:8080/pentaho
Le navigateur sera redirigé automatiquement vers l’interface d’accueil de la plateforme Pentaho.
Page 28/ 76
Figure 45 : Ecran d'accueil
Il faut toutefois noter que la première utilisation de l’application implique un temps de réponse assez
long. Ceci est dû à la technologie Java, qui impose la compilation des pages jsp (Java Server Page,
technologie conceptuellement proche du PHP), ce qui met sensiblement plus de temps que
l’interprétation du PHP. Par contre, une fois compilées, les pages jsp ont un temps de réponse
inférieur à celui d’une page PHP. Le temps de réponse n’est donc pas un problème à terme.
c. Démarrage des autres outils composant la suite Pentaho

Tous les outils proposés sont des outils développés à partir du langage Java, et c’est la raison pour
laquelle ces composants de la suite Pentaho ne nécessitent aucune installation sur un poste de
travail. En effet, une icône start<application>.bat est présente dans la quasi-totalité des cas et le
démarrage sera effectif lors d’un double click.
La seule exception vient du composant Pentaho Data Mining, qui requiert une installation
traditionnelle et somme toute très simple.
Page 29/ 76
2. Fonctionnalités
La suite Pentaho est un ensemble d’applications rassemblées afin de fournir une solution dans
chaque domaine de la Business Intelligence.
Figure 46 : Fonctionnement de la suite Pentaho
On constate donc sur ce schéma quelles sont les interactions possibles entre les différentes briques
de la suite, et qui permettent de donner naissance à des rapports et des analyses à partir
d’hypercubes de données.
La création de l’entrepôt de données est assurée grâce au logiciel Pentaho Data Integration,
anciennement appelé Kettle. L’exploration de ce logiciel est présentée dans la partie III. Nous
passerons donc tout de suite à la création du cube.
La plateforme BI Pentaho permet la gestion des comptes d’accès. Pour les besoins de la
démonstration, le logiciel est fourni avec divers profils utilisables. Nous avons donc choisi d’utiliser le
profil de Joe, administrateur. Toutefois, il est possible de configurer d’autres comptes.
Page 30/ 76
a. La création du cube avec CubeDesigner

CubeDesigner est l’outil de création de cubes dans la suite Pentaho. Cet outil propose la création de
cubes utilisables par la suite avec le serveur OLAP Mondrian (supporté par Pentaho, SpagoBi et
OpenI), basés sur le formalisme XML et les requêtes MDX.
Une fois téléchargé, il suffit de décompresser le fichier sur le disque dur et s’assurer de la présence
d’une JVM version 5 pour pouvoir utiliser le logiciel.
Toutefois, certaines manipulations doivent être effectuées avant de pouvoir exporter correctement
son travail sur la plateforme Pentaho. En tout premier lieu, il est impératif de vérifier que la
plateforme peut se connecter à la base de données que l’on souhaite utiliser. Pour vérifier si c’est
bien le cas, il faut éditer le fichier ...\pentaho-demo\pentaho-solutions\system\simple-
jndi\jdbc.properties. Dans notre champ d’application, nous désirons utiliser une base de données
MySQL qui se trouve sur le serveur localhost. Il est donc impératif de rajouter a la fin du fichier les
lignes suivantes :
projet_biblio/type=javax.sql.DataSource
projet_biblio/driver=com.mysql.jdbc.Driver
projet_biblio/url=jdbc:mysql://localhost:3306/movedb
projet_biblio/user=root
projet_biblio/password=
De plus, il est impératif de modifier le fichier ...\pentaho-demo\pentaho-

solutions\system\publisher_config.xml, afin de fournir un mot de passe de publication. Choisissons
admin comme mot de passe.
<publisher-config>
<publisher-password>admin</publisher-password>
</publisher-config>
Ces manipulations, indispensables pour le bon fonctionnement de CubeDesigner, ne figurent

bizarrement pas dans le guide officiel de démarrage rapide édité par Pentaho…
Pendant toute la manipulation de CubeDesigner, il est indispensable que la plateforme BI Pentaho

soit en route. En effet, le moteur OLAP de la plateforme sera utilisé pour effectuer la publication et la
prévisualisation. Basé sur l’IDE Eclipse, CubeDesigner propose un assistant de création de cubes
fonctionnel et pratique, reposant sur une interface graphique pratique à utiliser. Voici l’écran
d’accueil.
Figure 47 : Poste de travail Cube Designer
Page 31/ 76
Une fois le logiciel lancé, il suffit de démarrer la création d’un nouveau cube en sélectionnant File ->
New Cube Schema. L’assistant démarre alors.
Figure 48 : Cube Designer : étape 1
La création d’un cube demande un nom, qui doit impérativement être saisi sans espaces, sans quoi la
plateforme Pentaho sur laquelle sera déployée le cube ne le reconnaitra peut être pas. Une fois le
nom spécifié, il est possible de fournir une description du cube que l’on souhaite créer.
Avant de passer à l’étape suivante, il est nécessaire de configurer la source des données que l’on
souhaite utiliser. En choisissant l’ajout d’une connexion, une fenêtre pop-up s’ouvre pour permettre
la configuration.
Figure 49 : Formulaire de connexion à l'entrepôt de données
Le premier champ est le nom avec laquelle la connexion sera identifiée par la suite. Le driver choisi
est le driver MySQL simple. Le « connect string » est
« jdbc:mysql://localhost:PORT/DATABASE_NAME », où PORT et DATABASE_NAME devront être
modifiés afin de permettre la connexion à la base de données. La base de données est « movedb » et
le port est celui fourni par défaut : 3306. L’utilisateur et le mot de passe s doivent être ceux qui
régissent la base de données.
Page 32/ 76
Comme nous l’avons vu au début de ce paragraphe sur CubeDesigner, il est impératif de respecter les
données de connexions fournies à la plateforme, sans quoi la connexion et la publication du cube ne
pourra pas avoir lieu.
L’étape suivante consiste à créer la requête qui va alimenter l’entrepôt de données. Pour cela, une
interface nous propose une solution graphique, avec la création de jointures de façon directe.
Figure 50 : Mapping des tables pour la requête
On constate en bas à gauche la liste des tables de la base de données. En double cliquant sur l’une
d’elles, sa représentation graphique apparaît dans l’espace de travail bleu à droite.
Figure 51 : Une table
En cochant l’une des checkboxs, on remarque une mise à jour de la requête générée
automatiquement en haut à gauche. Cette solution propose une grande souplesse qui permettra
sans aucun doute à un utilisateur peu expérimenté en SQL de tirer son épingle du jeu. La création de
jointure peut se faire de façon graphique, en effectuant un glisser-déposer entre 2 colonnes (clés
primaires), ou en faisant un clic droit sur la colonne de son choix. Toutefois, on regrettera qu’il ne
soit pas possible d’éditer une requête SQL complète. En effet, nous n’avons pas pu fournir une
requête préparée au préalable au système. Voici un aperçu de cette opération :
Page 33/ 76
Figure 52 : Maping des tables
Nous avons choisi ici de récupérer les notes obtenues en Janvier et en Juin par les élèves de toutes
les promotions. Une fois la requête traduite, on accède à l’étape de définition des mesures. Cette
étape est indispensable pour accéder à la création des dimensions.
Nous allons donc définir la mesure « Moyenne des moyennes générales de Juin ».
Figure 53 : Définition des mesures
Page 34/ 76
Afin de créer une mesure, il faut :
• Dans un premier temps, choisir la table qui contient les données ;

• Ensuite choisir le champ qui correspond à nos besoins ;
• Puis cliquer sur le bouton fléché vers la droite afin de créer la mesure.
A partir de là, il est possible de modifier l’agrégat, le format de présentation des données et le nom
de la mesure. Une fois les mesures enregistrées, nous pouvons accéder à l’interface de création des
dimensions.
Figure 54 : Définition des dimensions
Afin de créer une nouvelle dimension, il convient de sélectionner tout d’abord le conteneur des
données qui vont servir de base pour la dimension, puis de cliquer sur le bouton « Add new
dimension ». C’est ainsi que nous procédons afin de créer la dimension Elèves, en sélectionnant le
nom de l’élève comme premier niveau de cette dimension. Afin d’ajouter le prénom de l’élève
comme sous niveau, il suffit de sélectionner le prénom dans l’onglet de gauche, puis de cliquer sur le
bouton fléché vers la droite. On obtient donc la représentation suivante :
Figure 55 : les dimensions utilisées
Page 35/ 76
On fait donc de même pour les dimensions Promotions et Temps. ATTENTION, il faut être vigilant sur
le fait que les niveaux hiérarchiques de chaque dimension doivent appartenir à la même source de
données, c’est-à-dire la même table.
La dernière étape permet la publication et la sauvegarde du cube.
Figure 56 : Publication
Trois étapes nous sont ici proposées. Dans un premier temps, le logiciel nous propose d’avoir une
vue sur le code XML qui constitue le cube. Ensuite, il est possible de publier le cube vers la
plateforme Pentaho, afin qu’une analyse via le module JPivot, intégré à la plateforme, soit possible.
Voici une capture d’écran du formulaire de publication :
Figure 57 : Formulaire de publication
Page 36/ 76
Il convient de noter que le mot de passe de publication doit être le même que celui fourni en début
de paragraphe, à savoir dans notre cas « admin ». De même, le login et mot de passe utilisateur
doivent OBLIGATOIREMENT être « joe » et « password ». Ces paramètres sont des valeurs fournies
par défaut dans la plateforme Pentaho, c’est donc la raison pour laquelle nous préférons les utiliser.
Enfin, une prévisualisation du cube est possible.
Pour terminer, en cliquant sur Finish, le logiciel propose de sauvegarder le cube sur le disque dur.
Afin de vérifier si le cube a bien été pris en compte par la plateforme BI, il suffit, depuis la page
d’accueil et après s’être enregistré en tant que Joe, d’aller dans Solutions ->Exemples d’analyses.
Normalement, le nom du cube devrait apparaître dans la liste des analyses possibles. Si ce n’est pas
le cas, mieux vaut essayer de redémarrer le serveur.
Figure 58 : Résultat de la publication sur la plateforme BI
Page 37/ 76
b. L’analyse avec la plateforme BI Pentaho et son module JPivot

Le module d’analyse JPivot intégré à la plateforme BI Pentaho est un module assez rudimentaire et
peu confortable d’utilisation, dans la mesure où le cube créé sous CubeDesigner n’est JAMAIS
correctement représenté. Nous avons réalisés divers tests afin d’inclure plusieurs mesures pour le
cube. Le résultat est un bug graphique qui duplique les valeurs de la première mesure. De même, ces
valeurs sont tronquées avant la virgule, ce qui ne correspond pas au format spécifié lors de la
création du cube.
Voici une représentation de l’écran d’analyse.
Figure 59 : Analyse du cube
Ici, on a à faire avec une interface désuète et qui manque cruellement d’inspiration. De plus son
utilisation est relativement lourde et ne bénéficie pas des dernières technologies du Web telles
qu’AJAX, qui allègeraient de façon efficace l’interface.
En cliquant sur la petite croix à coté des variables, on commande l’affichage des éléments sous
jacents.
Page 38/ 76
Figure 60 : Utilisation de JPivot : déroulement des données
On peut constater que les valeurs, malgré le fait qu’elles soient tronquées, semblent correctes, sauf
pour la dernière ligne.
Il est ainsi possible de créer des graphiques et de configurer les options.
Figure 61 : Options pour la génération de graphiques
Il est assez simple de créer des graphiques pertinents, par exemple la répartition des moyennes de
fin d’années par promotions, toutes années confondues :
Page 39/ 76
Figure 62 : Exemple de génération de graphique
Il est aussi possible de configurer les valeurs que l’on souhaite utiliser dans le cube via la troisième
icône en partant de la gauche. Un menu apparaît alors pour permettre la customisation du cube.
Figure 63 : Paramétrage du cube
En sus, il est également possible de définir des requêtes MDX qui permettront la customisation du
cube de façon plus directe.
Une des fonctionnalités qui suscite un intérêt réel est l’export du cube vers un fichier Excel. En effet,
en cliquant sur la dernière icône à droite, le navigateur va pouvoir télécharger le fichier Excel
préconfiguré. Cette option fonctionne de manière très convenable.
Page 40/ 76
c. L’édition de rapports avec le Pentaho Report Design Wizard

Le Pentaho Report Design Wizard est un assistant de création de rapport, qui permet, à l’instar de
CubeDesigner pour la création des cubes, de créer des rapports de façon assistée et au travers de
plusieurs étapes.
Figure 64 : PRDW : première étape
En premier lieu, il est nécessaire de fournir un titre au rapport, puis une rapide description. Ensuite
l’assistant nous propose de choisir quel modèle de rapport nous souhaitons utiliser.
L’écran suivant propose à l’utilisateur de sélectionner la source des données qu’il souhaite utiliser.
Ainsi, lors de la première utilisation du logiciel, il est impératif de définir les modalités de connexions
exactement comme nous l’avons fait avec CubeDesigner.
Il est possible d’utiliser, au lieu des connexions à une base de données, un fichier XML adapté à
Mondrian, et contenant un cube. Ce type de fichiers est créé lors de la publication du cube avec
CubeDesigner.
Sur la droite, un grand champ texte attend de l’utilisateur une requête, au format SQL ou MDX en
fonction du type de données sources choisies. Un assistant de création de requête (semblable en
tous points avec le créateur de requêtes sous CubeDesigner) est également utilisable. A noter que
cet assistant n’est disponible que pour les requêtes SQL.
Page 41/ 76
Figure 65 : Séléction des données
L’étape suivante propose la customisation des en têtes et pieds de pages du rapport et de chaque
page.
Figure 66 : Customisation du rapport
Simple à utiliser, cette interface permet la customisation libre ou l’utilisation des éléments de la
requête effectuée au préalable.
Page 42/ 76
L’interface suivante permet l’organisation des données récupérées en groupes et contenus de ces
groupes. Simple à utiliser, cette interface permet de regrouper comme bon nous semble les données
pour une mise en page rapide.
Figure 67 : Organisation et composition du rapport
Les prochains écrans sont des interfaces de customisation avec lesquels l’utilisateur prendra plaisir à
jouer afin de régler des détails comme la couleur des titres de groupes, la taille et la police utilisée, la
configuration de la page (portrait, paysage), les marges etc.
Figure 68 : paramétrage du format
Page 43/ 76
Figure 69 : Paramétrage de la page
Figure 70 : Customisation avancée
Il est tout à fait possible de publier le rapport à n’importe quel moment, en cliquant sur le bouton
« publish ». Une fenêtre pop-up apparaît alors.
Page 44/ 76
Figure 71 : Publication sur le poste local
Figure 72 : Publication sur la plateforme BI
En fonction du choix de l’utilisateur au niveau du type de publication, la fenêtre s’en trouve modifiée
(à gauche la publication sur le serveur, à droite la publication sur l’ordinateur).
La seule différence notable est la présence d’un nom d’utilisateur et d’un mot de passe pour la
publication sur le serveur Pentaho, et l’emplacement d’enregistrement du fichier pour la publication
en local.
Testons la publication sur le serveur. Après avoir fourni les mêmes valeurs que celles que nous avons
utilisés pour la publication du cube sous CubeDesigner, nous sommes informés de la réussite de
notre requête.
Direction la plateforme, dans la page Solutions -> Exemples de rapports. Nous constatons avec joie
que le rapport voulu a bien été publié.
Page 45/ 76
Figure 73 : Exemple de publication
En sélectionnant notre rapport, le navigateur ouvre ce dernier qui est format PDF dans un onglet. Et
nous pouvons alors constater que le rapport a été efficacement créé, et que ce dernier est conforme
à ce que nous avions voulu créer.
Figure 74 : Affichage du rapport
Page 46/ 76
La plateforme SpagoBI
1. Installation
a. Pré-requis
L’installation de la plateforme SpagoBI requiert tout d’abord la présence d’une Java Virtual Machine
5.x sur le poste hôte, ainsi que la présence du logiciel Open Source Open Office (version 2.x) pour la
constitution de rapports. Les variables d’environnement PATH pour la JVM et OFFICE_HOME pour
Open Office devront être introduites, chacune pointant vers le dossier d’installation desdits logiciels.
Un interpréteur du langage PERL est aussi nécessaire, pour l’exécution des processus perl avec
SpagoBITalendEngine (qui est le moteur de l’outil d’ETL de SpagoBI). Cette dernière spécification est
tout à fait optionnelle, comme nous le verrons plus loin avec l’étude du logiciel Talend Open Studio.
Afin de pouvoir utiliser correctement la plateforme, il est nécessaire d’utiliser un serveur

d’applications J2EE qui pourra déployer l’application. La liste des serveurs est restreinte et il convient
donc de choisir avec parcimonie le logiciel à installer. Voici cette liste (les liens pour les obtenir sont
disponibles dans le guide d’installation) :
− Tomcat 5.0.28 avec eXo-Portal 1.1.4

− JBoss 4.0.3SP1 avec eXo-Portal 1.1.2
− JOnAS 4.7.4 avec eXo-Portal 1.1.3
Leur installation est d’une simplicité déconcertante : il suffit de dézipper le fichier téléchargé sur
notre disque dur et le tour est joué !
Etant donné que l’installation de SpagoBI entraîne l’écrasement de certains fichiers existants sur le
serveur, il est recommandé de se servir d’une installation serveur propre.
b. Installation de la plateforme
Comme tout bon projet qui se respecte, le projet SpagoBI est accompagné d’une documentation (en
anglais) qui à l’avantage d’être extrêmement concise et efficace, ce qui permet une utilisation
optimale. Cette documentation peut être récupérée au format PDF comme au format Word, sur le
site de présentation de la plateforme.
Il est vivement recommandé d’utiliser la documentation pour réaliser une installation propre, car la
plateforme SpagoBI n’est pas facile à installer, même pour un utilisateur initié, ceci en regard des
possibilités offertes par le logiciel.
NB : Il est aussi possible de choisir une version de la plateforme que l’on pourrait déployer sur un
serveur J2EE déjà fonctionnel. Nous n’avons pas retenu cette option, afin d’utiliser l’installateur qui
permettra à un utilisateur lambda de mieux exploiter la plateforme.
La première étape consiste à choisir le serveur qui va héberger l’application. Dans notre exemple,
nous avons choisi d’utiliser le serveur tomcat 5.0.28. Ce dernier a été téléchargé à partir du lien
fourni par le guide d’installation.
Page 47/ 76
Figure 75 : Sélection du serveur d'application
Ensuite, il est nécessaire de choisir les composants qui vont constituer l’application. Ces composants
sont des moteurs d’exécution des différents composants. Nous choisissons de laisser la sélection par
défaut de ces composants.
Figure 76 : Sélection des outils
Nous avons choisi de décocher les exemples de démonstration afin de pouvoir configurer aisément la
base de données MySQL que nous souhaitions utiliser. En effet, et pour l’avoir essayé, l’ajout d’un
entrepôt de données à la plateforme est une opération longue et fastidieuse, avec des résultats plus
qu’incertains (nous n’avons jamais réussi…). Mieux vaut donc configurer immédiatement la base de
données dont nous avons besoin.
Page 48/ 76
L’étape suivante est la connexion à l’entrepôt de données. Les entrepôts disponibles sont :
• Hsqldb,
• Oracle,
• Postgres
• MySql
Les paramètres de connexions seront également à fournir. Cette étape est facultative dans la mesure
où l’on choisit d’utiliser les exemples de démonstration. Etant donné que ce n’est pas le cas pour
notre installation, nous avons fourni les paramètres suivants :
• Driver : driver MySQL

• Connexion : jdbc:mysql://localhost:3306/movedb
• User : root
• Password : aucun mot de passe
Comme nous l’avons précisé plus tôt, la plateforme SpagoBI possède des outils basés sur le langage
Perl. Si l’utilisateur désire utiliser ces outils, un interpréteur Perl soit être installé sur le poste de
travail. Etant donné le caractère uniquement complémentaire de ces outils (des alternatives existant
en java), nous avons décidé de faire l’impasse sur eux.
Figure 77 : Sélection de l'interpréteur Perl (optionnel)
Il est ensuite nécessaire de fournir l’adresse à laquelle est installé le serveur d’application sur le
disque dur. Dans notre cas, l’installation du serveur Tomcat avec Exo portal consiste à décompresser
un dossier n’importe où. Il nous suffit donc d’indiquer à quel endroit nous avons choisi de le stocker.
Page 49/ 76
Figure 78 : Recherche de l'emplacement du serveur
L’action suivante consiste à désigner le dossier dans lequel le programme d’installation va

télécharger la plateforme. Une fois ce dernier sélectionné, le téléchargement commence.
Figure 79 : Emplacement du dépôt des sources
La fin de l’installation est assez banale : le programme propose des raccourcis sur le bureau et dans le
menu de lancement rapide ; puis un récapitulatif est proposé avant de fermer.
Page 50/ 76
c. Démarrage de la suite SpagoBI

Le lancement de la suite SpagoBI se fait de façon analogue au lancement de la plateforme Pentaho.
En utilisant le raccourci sur le bureau pour accéder au répertoire source du projet, ou en utilisant le
lancement rapide a partir du menu démarrer, on accède à l’icône « Start Spago BI platform »
Figure 80 : Démarrage
En cliquant sur l’icône correspondante, le serveur d’application se met en marche. Légèrement plus
long que la plateforme Pentaho, il faudra attendre le démarrage complet du serveur avant d’ouvrir
un navigateur web pour y saisir l’adresse suivante :
http://localhost:8080/sbiportal
On accède ainsi au portail de la plateforme SpagoBI.
Page 51/ 76
Figure 81 : Ecran d'accueil de la plateforme SpagoBI (avec jeu de démonstration)
Page 52/ 76
2. Fonctionnalités
a. Importation du cube
SpagoBI fait référence à un schéma quant il s’agit d’un fichier XML pouvant contenir un ou plusieurs
cubes. Ainsi, le fichier XML créé via CubeDesigner est un schéma contenant un seul cube. Afin de
pouvoir être utilisé par le module JPivot / Mondrian, il faut déposer ce fichier dans le répertoire
suivant : exo-portal-1.1.4\webapps\SpagoBIJPivotEngine\WEB-INF\queries, puis redémarrer la
plateforme si celle-ci était en état de marche.
Voici un aperçu du dossier après l’importation :
Figure 82 : Importation du cube
De plus, il faut impérativement déclarer le schéma importé dans le fichier exo-portal-

1.1.4\webapps\SpagoBIJPivotEngine\WEB-INF\classes\engine-config.xml, comme suit :
Figure 83 : Modification du fichier engine-config.xml
Cette démarche permettra à la plateforme d’identifier le cube et ainsi nous pourrons l’utiliser dans
notre démarche d’analyse OLAP.
Page 53/ 76
b. Création d’un dossier de travail

A partir de maintenant, il est possible de démarrer la plateforme SpagoBI. Une fois sur l’écran
d’accueil, s’identifier en tant qu’administrateur en saisissant comme login et mot de passe biadmin.
Ce faisant, nous accédons au portail d’accueil consacré à l’administration de la plateforme.
Dans un premier temps, nous allons définir un dossier de travail pour notre étude. Pour cela, il faut
se rendre dans l’onglet Development and Tree Management -> Functionnality Management. Nous
accédons ainsi à l’arborescence des dossiers existants. En cliquant sur le dossier racine, nous avons la
possibilité d’insérer un nouveau dossier. C’est ce que nous allons faire.
Figure 84 : Arborescence des fichiers
Afin de créer un nouveau dossier, il faut remplir le formulaire ci-dessous, et définir les droits.
Figure 85 : Formulaire de création d'un nouveau dossier
Pour enregistrer le dossier, il faut cliquer sur l’icône en forme de disquette en haut à droite. Notre
dossier de travail est donc prêt à l’emploi, nous pourrons donc nous en servir pour conserver les
analyses OLAP et les rapports que nous allons éditer.
c. L’analyse OLAP du cube ProjetBiblio

Nous entrons enfin dans le vif du sujet. Pour pouvoir effectuer une analyse OLAP sur la plateforme
SpagoBI, il faut au préalable définir un document au format « analyse OLAP ». Pour cela, il faut se
rendre dans l’onglet Development environment, où sont listés tous les documents que peuvent
utiliser les utilisateurs finaux de la plateforme (tels que les dirigeants par exemple).
Page 54/ 76
En haut à droite, une icône en forme de loupe avec une croix verte nous permet d’accéder au
formulaire de création d’un document.
Figure 86 : Formulaire de création d'un document
Les champs marqués d’un astérisque doivent être obligatoirement remplis. Le type de document
peut donc être un rapport, une analyse OLAP, ou bien d’autres choses. Choisissons l’analyse OLAP.
Sur la droite, nous apercevons l’arborescence des dossiers de travail. En cochant notre dossier, nous
indiquons l’emplacement de sauvegarde de notre document.
Le template à fournir n’est pas obligatoire. De fait, il s’agit d’un fichier XML qui configure le cube de
données. Ce fichier peut être réalisé manuellement puis importé, ou dynamiquement via la
plateforme. C’est la deuxième option que nous avons retenu. Laissons donc vide ce champ et
sauvegardons le document, en cliquant comme précédemment sur l’icône en forme de disquette.
Une fois la sauvegarde effectuée, nous allons définir le template qui accompagnera notre cube. Ce
template va permettre de définir une représentation du cube selon certains critères (données filtrées
ou pas, mesures à afficher…). Pour créer un template de façon dynamique, il faut cliquer sur l’icône à
droite de Template build, à la fin du formulaire de création de document. Ceci nous amène donc au
formulaire suivant :
Figure 87 : Création d'un template pour le cube
La connexion est laissée par défaut car c’est celle-là que nous avons configuré lors de l’installation de
la plateforme. Ensuite, dans chacune des listes déroulantes, nous choisissons l’élément ProjetBiblio.
Comme nous l’avons précisé précédemment, le schéma correspond au fichier XML qui contient la
définition du cube (il pourrait en contenir plusieurs), et le cube est le cube qui nous intéresse.
Une fois le cube sélectionné, nous obtenons une interface JPivot qui va nous permettre de configurer
les dimensions que nous souhaitons utiliser.
Page 55/ 76
Figure 88 : Configuration dynamique du template
On remarque d’emblée que les bugs graphiques qui étaient présents sur la plateforme Pentaho sont
ici aussi de la partie, ce qui nous permet de confirmer que l’outil CubeDesigner souffre de légères
lacunes qu’il serait bon de modifier. Toutefois, nos données sont correctes, et prêtes à être
analysées.
Une fois le cube configuré, nous pouvons le sauvegarder, à l’aide de du bouton orné d’une disquette.
Il suffira ensuite de fournir un nom au template.
De retour à la liste des documents existants au sein de la plateforme, nous pouvons maintenant
cliquer sur l’icône en forme de rouage afin de lancer l’exécution de notre analyse.
Figure 89 : Aperçu de l'interface de travail
Ce faisant, la plateforme nous demandera de choisir parmi les profils d’utilisateurs possibles celui
que nous voudrions utiliser. Nous choisissons celui de l’utilisateur final, afin d’avoir un aperçu des
possibilités (pour valider le choix, il suffit de cliquer sur l’icône en forme de rouage à droite).
Figure 90 : Sélection du rôle
Et celles-ci ne sont pas en reste, car nous nous retrouvons avec un module d’exploitation JPivot
semblable à celui de Pentaho. Son utilisation est donc simple et agréable.
Page 56/ 76
Figure 91 : Analyse du cube avec JPivot
Les mêmes fonctionnalités sont donc présentes. Pour plus d’informations sur l’utilisation de cette
interface, veuillez vous reporter à la section analogue pour la suite Pentaho : L’analyse avec la
plateforme BI Pentaho et son module JPivot.
d. L’édition de rapport
De la même façon que pour l’analyse OLAP, la création d’un rapport nécessite la création au
préalable d’un template, qui devra être fourni à la plateforme pour la publication. Ce template peut
être configuré à l’aide de deux logiciels externes : Ireport et Birt. Nous avons choisi (de façon
arbitraire) d’utiliser IReport. Le guide de démarrage rapide indique l’adresse à laquelle le logiciel,
basé sur JasperReport, est disponible.
Plusieurs formats de distributions sont envisageables, mais dans un souci de confort d’utilisation,
nous avons choisi la version pourvue d’un installateur Windows. Cette installation est simplissime, et
ne posera aucun problème quelque soit le degré de maitrise de l’utilisateur.
Ainsi, une fois après avoir lancé le logiciel, allons dans Fichier -> Assistant de génération de rapports.
Cette action aura pour conséquence l’ouverture d’une fenêtre pop-up.
Page 57/ 76
Figure 92 : Assistant de génération de rapports dans IReport
Aucun modèle n’étant disponible, nous allons nous concentrer sur la création de la connexion a la
base de données. Cliquons donc sur Nouveau. Une nouvelle fenêtre s’ouvre alors, dans laquelle nous
fournissons les coordonnées de notre base de données, puis nous validons.
Une fois la connexion crée, le logiciel nous invite à saisir la requête au format SQL qui va récupérer
les données nécessaires à la génération du rapport. Une fois la requête enregistrée, nous devons
choisir quels seront les champs qui seront introduits dans le rapport.
Figure 93 : Sélection des champs
Il faut ensuite définir les groupes de données via des listes déroulantes.
Page 58/ 76
Figure 94 : Configuration du rapport
La dernière étape propose de sélectionner sa mise en page parmi plusieurs prédéfinies.
Figure 95 : Définition de la mise en page
Une fois le rapport configuré, il est possible de le customiser dans les détails depuis l’espace de
travail. Une fois sauvegardé, retour à la plateforme SpagoBI.
La démarche de création d’un document rapport est sensiblement équivalente à celle d’un document
analyse OLAP, la seule différence provenant du type de document, forcément. Ainsi, une fois le
document créé, on obtient à l’exécution un résultat probant :
Page 59/ 76
Figure 96 : Publication sous SpagoBI
Le rapport est donc conforme à ce à quoi nous nous attendions. Toutefois, la mise en page définie
avec l’assistant de génération de rapport (au niveau du look and feel, pas au niveau organisationnel)
sous IReport n’a pas été appliquée sur la plateforme.
Page 60/ 76
Kettle, ou plutôt Pentaho Data Integration

1. Exemple de création d’une transformation
Voici l’écran de démarrage de Kettle.
Figure 97 : Accueil
Afin d’accéder directement à l’interface de travail, nous choisissons de cliquer sur le bouton Pas de
référentiel.
L’espace de travail s’ouvre alors, avec un écran de bienvenue et l’astuce du jour.
Figure 98 : Espace de travail
Page 61/ 76
Afin de démarrer un nouveau traitement, choisissons d’effectuer une nouvelle transformation, en

allant cliquant en haut à gauche sur le bouton Nouveau -> Transformation.
Une fois la transformation créée, il est nécessaire de configurer la connexion à la base de données
qui va remplir l’entrepôt. Pour cela, nous allons utiliser l’assistant de création de connexion, en
appuyant sur F3, ou en allant dans Assistant -> Assistant de création de connexion.
Figure 99 : Sélection de la base de données
Voici la première étape de la création d’une connexion. Il est tout d’abord demandé de fournir un
nom pour la connexion. Choisissons « projet_biblio ». Puis, il nous est demandé d’indiquer le type de
base de données et le type d’accès. Etant donné que nous utilisons une base de données MySQL,
nous pouvons laisser ces paramètres par défaut.
Il nous est ensuite demandé d’indiquer le nom du serveur qui héberge la base de données, le port et
le nom de la base de données concernée.
Figure 100 : Définition des paramètres JDBC
Page 62/ 76
Etant donné que la base de données est hébergée sur le même poste de travail, « localhost » est une
valeur suffisante. Le port peut être laissé tel quel, et le nom de la base de données sera en fonction
de la base de données avec laquelle on souhaite travailler.
Ceci fait, nous voila de retour à l’espace de travail. Maintenant, à partir des onglets situés à gauche,
nous allons pouvoir schématiser les différentes opérations qui vont composer la construction de
l’entrepôt de données.
Tout d’abord, il est nécessaire d’extraire les données de la source. Pour cela, nous choisissons
d’ouvrir l’onglet Arborescence principale de la façon suivante :
Figure 101 : Arborescence principale
Ainsi, en utilisant le drag and drop, il est possible de sélectionner l’icône projet_biblio et de la
déposer dans l’espace de travail associé à la transformation en cours. Un utilitaire s’ouvre alors pour
configurer l’extraction de données :
Figure 102 : Configuration de l'extraction de données
A partir de cet utilitaire, il est possible de configurer à nouveau la connexion, et d’utiliser un assistant
de création de requêtes SQL, en cliquant sur le bouton « Obtenir script SQL select… ».
Une nouvelle fenêtre s’ouvre alors, dans laquelle l’utilisateur peut agir et sélectionner les tables et
les champs qu’il veut utiliser. Attention, même si Kettle fournit une aide pour la création des
Page 63/ 76
requêtes, une bonne connaissance du langage SQL reste indispensable pour pouvoir utiliser cet
assistant.
Figure 103 : Assistant de requêtes SQL
L’utilité première de cette fenêtre est de permettre une sélection rapide des éléments requis sans
avoir à utiliser des outils tels que PhpMyAdmin pour l’administration de la base de données.
Admettons que l’on souhaite sélectionner l’intégralité de la table offices. Il suffit donc de la
sélectionner puis de cliquer sur OK. Une fenêtre d’avertissement viendra sanctionner notre
démarche en nous proposant de détailler les champs de la table dans la requête. Nous choisissons de
répondre oui pour une meilleure lisibilité.
Il ne nous reste qu’à valider la fenêtre précédente, en laissant les autres choix par défaut faute
d’information à leur sujet.
On constate alors la présence d’un icône sur l’espace de travail indiquant l’extraction depuis une
base de données. Ceci fait, choisissons d’appliquer une transformation à l’aide du deuxième onglet
sur la gauche : « Arborescence ».
On constate ici que l’opération d’extraction que nous avons choisi aurait put être diligentée depuis
cet onglet. Toutefois, attardons nous sur le sous-onglet « Transformation ». Nous allons transformer
nos données en fournissant la valeur Nul si la valeur d’un champ vaut une certaine constante. Pour
configurer cette étape, il suffit de double cliquer sur l’icône dans l’espace de travail.
Page 64/ 76
Figure 104 : Aperçu de l'espace de travail
Nous allons maintenant établir un lien entre les deux actions. Pour cela, il suffit de se positionner
dans l’onglet de gauche « Arborescence principale, et de double cliquer sur l’icône « Liens » pour voir
apparaître la fenêtre suivante :
Figure 105 : Définition d'un lien
En sélectionnant la source et la destination, nous obtenons un lien entre les deux étapes.
Figure 106 : Apreçu d'une liaison
Nous allons maintenant fournir l’étape finale de notre démarche : la création d’un fichier XML. Pour
cela, rendez-vous dans l’onglet « Arborescence » et dans le sous onglet « Alimentation », pour choisir
l’étape Alimentation Fichier Excel. Une fois importé sur l’espace de travail, on double clique dessus
pour configurer l’emplacement de sauvegarde.
Page 65/ 76
Figure 107 : Configuration de l'étape de chargement
Une fois le fichier Excel configuré, il convient de créer le lien entre les étapes.
Figure 108 : Résultat de l'opération
En cliquant sur le bouton Exécuter, le programme ouvre une nouvelle fenêtre pour configurer les
options d’exécution.
Figure 109 : Ecran d'exécution
Page 66/ 76
Chacune des options est laissée dans la configuration par défaut. En cliquant sur le bouton démarrer,
le programme vous incite à sauvegarder votre transformation. Il est impératif de le faire, sans quoi le
programme refusera de continuer… qu’à cela ne tienne ! Une fois terminé le traitement, un bref
récapitulatif vous sera proposé.
Figure 110 : Ecran bilan de l'opération
On constate également que le fichier Excel a bien été créé à l’emplacement spécifié.
Cette introduction nous aura donc permis d’envisager les possibilités qu’offre Kettle en matière de
traitement des données.
Page 67/ 76
Talend Open Studio

1. Exemple de création d’une transformation
Afin d’illustrer le potentiel des Job design, nous allons essayer de réaliser la même opération que
celle que nous avons faite avec l’ETL concurrent Kettle, c’est-à-dire extraire des données d’une base
de données, puis appliquer la valeur nulle en fonction de la présence d’une valeur constante, puis le
chargement dans un fichier Excel.
Une fois téléchargé le fichier compressé depuis le site officiel de Talend (www.talend.com) il suffit de
le décompresser dans un dossier sur le poste de travail. Pour démarrer l’application, il est nécessaire
de double cliquer sur l’icône « TalendOpenStudio-win32-x86.exe ». Ceci fait, l’écran suivant s’affiche.
Figure 111 : Accueil de TOS
Lors de la première connexion, il est nécessaire de configurer l’email et le mot de passe de

l’utilisateur, en définissant ou en modifiant un profil de connexion (ici « Local »). Pour ce faire, il faut
cliquer sur le bouton estampillé « … ».
Page 68/ 76
Figure 112 : Définition d'une connexion à une BDD
Sans modifier la valeur de la liste déroulante « Repository », ni avec les champs « Name » et
« Description », nous choisissons de fournir un email valide et un mot de passe. Il convient toutefois
de noter quelques remarques :
• L’email n’est utilisé que pour la connexion, aucun message ne sera envoyé à cette adresse ;
• Le mot de passe est facultatif, mais pour des raisons évidentes de sécurité il est préférable
d’en définir un.
Une fois l’email et le mot de passe fournis, on valide le formulaire en cliquant sur OK, pour basculer
vers la fenêtre de connexion. Sur cette dernière, il suffit alors de fournir email et mot de passe tels
que nous les avons définis auparavant.
Un projet doit impérativement être choisi pour pouvoir continuer. Lors de la première connexion, il
est nécessaire de créer un projet, en cliquant sur le bouton correspondant. Une fenêtre s’ouvre
alors :
Page 69/ 76
Figure 113 : Définition d'un projet
En déclarant un nom de projet, et ensuite en choisissant le langage Java comme langage de

génération (la description du projet étant facultative), nous procédons donc à la création d’un projet.
Une fois créé le projet est sélectionné par défaut sur la fenêtre des connexions. Nous pouvons donc
enfin lancer l’application.
Talend Open Studio est basé sur le très connu IDE Eclipse, nous retrouvons donc une interface
connue qui facilitera la prise en main du logiciel. Au premier lancement de ce dernier, une
proposition d’enregistrement auprès de Talend. Cette étape est totalement facultative ; pour refuser
l’enregistrement, il suffit de cliquer sur le bouton « Cancel ». On accède ainsi, après l’écran de
bienvenue, à l’interface suivante.
Figure 114 : Espace de travail
Page 70/ 76
Pour créer un nouveau Job, il faut faire un clic droit dans le menu de gauche sur le lien Job Designs,
et choisir « Create Job ». Une fenêtre de création d’ouvre alors.
Figure 115 : Définition d'un nouveau "Job"
Le nom du job est la seule information requise pour la création dudit job. Ainsi, nous nommons notre
job « test_projet_biblio » et nous validons la création du job. Toutes les autres informations peuvent
être fournies et ne semblent qu’avoir un but descriptif.
La validation du job entraine la création d’un espace de travail dans l’IDE. C’est dans cet espace de
travail que nous allons modéliser notre traitement.
Tout à fait à droite sur l’IDE se trouve un onglet nommé « Palette ». Cet onglet répertorie l’ensemble
des actions réalisables, triés en fonction de leurs champs d’actions.
Pour commencer, il est nécessaire d’extraire les données de la base de données MySQL que nous
utilisons. Pour ce faire, nous utiliserons une action prédéfinie dans l’onglet Databases, puis dans le
sous onglet MySQL : tMysqlInput.
Page 71/ 76
Figure 116 : Onglet des possibilités
Il suffit ensuite de cliquer dans l’espace de travail à l’endroit précis où l’on souhaite déposer le
traitement. Sous l’espace de travail, se trouve les propriétés de l’objet sélectionné. Pour ce
traitement, on peut fournir les informations relatives à la base de données dans cette fenêtre.
Figure 117 : Exemple de configuration d'un évènement
Nous souhaitons attirer l’attention sur le niveau nommé « Schema ». Afin de faire fonctionner
efficacement le traitement d’extraction des données, il est impératif de définir une sorte de vue
correspondant trait pour trait aux champs de la table de données que l’on souhaite traiter.
Définir un schéma peut se faire de deux façons :
• Soit de façon directe pour ce traitement (Built-In), en créant le schéma associé à ce

traitement,
• Soit de façon indirecte (Repository), ce qui permet d’utiliser un schéma préalablement défini
pour ce traitement.
Page 72/ 76
L’édition de traitement se fait via une fenêtre pop-up.
Figure 118 : Edition de traitement
L’ajout de données est extrêmement simple et se fait via le bouton de type croix. Une fois le schéma
créé, la configuration du traitement est terminée.
Afin de continuer le traitement tel que nous l’avions initialement prévu, il faut se servir d’une action
tMap, disponible dans l’onglet Processing. Avant de procéder à sa configuration, nous allons aussi
récupérer le traitement de chargement des données sur une feuille Excel : tFileOutput Excel. Ce
dernier se trouve dans l’onglet File -> Output. Les données fournies par défaut précisent que le
fichier sera enregistré dans le répertoire d’installation de TOS.
Ceci fait, il est possible de relier les étapes du traitement entres elles. Pour cela, il faut sélectionner
une étape, puis faire un clic droit sur l’icône, puis aller dans Row -> Main, et enfin sélectionner l’icône
qui représentera l’étape suivante. Pour la liaison tMap – TfileOutputExcel, il faut préciser un nom
pour le lien, nous le nommons donc « test ».
Voici une illustration du traitement final :
Figure 119 : Schéma de l'opération
Dernière étape : configurer la transformation. Pour ce faire, il est nécessaire d’accéder à la fenêtre de
configuration de l’étape tMap. Voici la fenêtre en question :
Figure 120 : Configuration de l'étape tMap
Page 73/ 76
En cliquant sur le bouton estampillé « … », une fenêtre supplémentaire s’ouvre pour permettre la
configuration de la transformation.
Figure 121 : Configuration de la transformation
La première opération consiste à fournir le mapping du schéma sortant. On procède donc de façon
similaire à la création du schéma pendant la configuration de l’étape d’extraction. Une fois le schéma
sortant effectué, il suffit de cliquer sur le bouton « AutoMap » en haut à droite pour que le
programme relie automatiquement les champs entre eux.
Figure 122 : Mapping des tables
Afin de créer la transformation requise (si la valeur d’un champ est une constante prédéfinie, on
affecte la valeur nulle), il convient de créer une expression filtre au niveau de la variable concernée.
Choisissons la variable lastname. En cliquant sur la cellule du schéma de droite estampillée
row1.lastname, nous avons accès à l’Expression Builder en cliquant sur le petit bouton « … » qui
apparaît dans la cellule.
Page 74/ 76
Figure 123 : Expression Builder
Dans l’encart Category, il y a des fonctions réparties par catégories et prêtes à l’emploi. Pour
effectuer le traitement que nous recherchons, nous cliquons dans la catégorie StringHandling pour
obtenir la liste des fonctions disponibles dans l’encart Functions. Nous choisissons la fonction
EREPLACE en double cliquant dessus et nous modifions les valeurs par défaut pour obtenir la
fonction suivante :
StringHandling.EREPLACE(row1.lastname, « Ohayon », « NULL »)
On valide cette formule en cliquant sur OK pour fermer la fenêtre, puis on peut aussi fermer la
fenêtre de configuration du tMap. Une demande de confirmation de propagation des données nous
sera présentée, il est impératif de répondre par l’affirmative pour terminer la configuration de
l’étape.
La mise en place du traitement est maintenant terminée, nous allons donc lancer le traitement afin
de vérifier si tout s’est bien passé. Pour cela, il suffit de cliquer sur l’icône de lecture en haut à
gauche de l’IDE.
Figure 124 : Exécution du traitement
Page 75/ 76
L’exécution s’est bien passée, on récupère les informations suivantes dans le fichier Excel généré :
1002 Murphy dmurphy@classicmodelcars.com

1056 Patterson mpatterso@classicmodelcars.com
1076 NULL jfirrelli@classicmodelcars.com
1088 Patterson wpatterson@classicmodelcars.com
1102 Bondur athompson@classicmodelcars.com
1143 Bow bhoward@classicmodelcars.com
1165 Jennings ljennings@classicmodelcars.com
Où l’on constate que dans le troisième enregistrement, on a effectivement la valeur « Ohayon » qui a
été remplacée par NULL.
• Configurer la connexion avec la plateforme SpagoBI et déploiement
Talend Open Studio est directement lié à la plateforme décisionnelle SpagoBI. Il est possible de
paramétrer les conditions de connexion de la façon suivante :
1. Sélectionnez « Préférences » depuis le menu « Windows »

2. Ouvrez le menu « Talend » dans la fenêtre des préférences (sur la gauche).
3. Sélectionnez le sous-menu « SpagoBI Servers ».
4. Appuyez sur le bouton « New... » pour ajouter une nouvelle connexion vers une instance de
la SpagoBITalendEngine.
5. Renseignez correctement les paramètres de connexion, et en particulier :
• Host : l’hôte surlequel SpagoBITalendEngine est installé ;
• Port : le port d’écoute du serveur ;
• Login : « spagobi » ;
• Password : « spagobi » ;
• Engine name : le nom du moteur. Rôle purement descriptif.
Pour déployer un Job design sur SpagoBI, il suffit de faire un clic droit sur l’intitulé du Job dans le
menu de gauche et de choisir Deploy on SpagoBI. Il suffira ensuite de choisir la connexion appropriée
et cliquer sur Finish.
Page 76/ 76

Projet Bibliographique Guides

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Projet Bibliographique Guides

Uploaded by

Copyright:

Available Formats

MASTER MIAGE Spécialité ACSI

Elias Ohayon | Adrien Gabriel

Business Objects 5.1 ......................................................................................................................................... 4

SQL Server 7.0 ................................................................................................................................................ 16

La suite Pentaho et ses satellites .................................................................................................................... 28

La plateforme SpagoBI ................................................................................................................................... 47

Kettle, ou plutôt Pentaho Data Integration .................................................................................................... 61

Talend Open Studio ........................................................................................................................................ 68

MASTER MIAGE Spécialité ACSI | Année 2007 - 2008

- Ca n’est pas notre objectif

MASTER MIAGE Spécialité ACSI | Année 2007 - 2008

Business Objects 5.1

Avant de nous intéresser à l’installation nous devons présenter le fonctionnement de Designer, le

- Des paramètres de connexion pour un ou plusieurs middlewares de base de données

2. Que contient un univers ?

o Dimension : qui constitue une hiérarchie d'analyse.

Figure 1 : Fonctionnement de Business Object

MASTER MIAGE Spécialité ACSI | Année 2007 - 2008

Figure 2 : Choisir le driver Access

Figure 3 : Informations sur la BDD

Figure 4 : Vérifier que la BDD est bien dans la liste

MASTER MIAGE Spécialité ACSI | Année 2007 - 2008

Figure 5 : Informations sur l'univers

Figure 6 : Connexion à la BDD

MASTER MIAGE Spécialité ACSI | Année 2007 - 2008

b. Création d’un schéma :

faitPartieEP, annee, promo, eleve

MASTER MIAGE Spécialité ACSI | Année 2007 - 2008

Figure 7 : Edition des jointures

Le schéma est donc le suivant :

Figure 8 : Schéma, première étape

Ensuite, nous ajoutons les tables :

domaine, unite, estComposeePU, seRapporteUD et suitEU.

MASTER MIAGE Spécialité ACSI | Année 2007 - 2008

Figure 9 : Schéma final de l'univers

c. Création des classes et objets :

Pour ajouter une classe, il faut cliquer sur cet icône

Pour celle-ci nous utiliserons deux objets : Année et Semestre.

MASTER MIAGE Spécialité ACSI | Année 2007 - 2008

- Objet année : annee.annee

Nous souhaitons utiliser 3 objets :

- Objet promotions : promo.nomPromo

Pour la dimension élève, nous prenons seulement l'identité de l'élève.

- Objet nom : eleve.nomEleve

MASTER MIAGE Spécialité ACSI | Année 2007 - 2008

Les mesures sont donc les suivantes :

Figure 10 : Listing des mesures

MASTER MIAGE Spécialité ACSI | Année 2007 - 2008

Figure 11 : Liste d'opérateurs

Figure 12 : Liste de méthodes

En cliquant sur « Run » on lance l'édition du rapport :

MASTER MIAGE Spécialité ACSI | Année 2007 - 2008

Figure 14 : Evolution des moyennes corrigées

MASTER MIAGE Spécialité ACSI | Année 2007 - 2008

2. Transformer, création du cube

- Nom et prénom de l’élève

Les dimensions et sous-dimensions que nous utiliserons sont les suivantes :

TEMPS PROMOTIONS ENSEIGNEMENTS ELEVES

- moyenne des moyennes de Janvier

MASTER MIAGE Spécialité ACSI | Année 2007 - 2008

Il ne reste maintenant qu'à générer l'hypercube et lancer PowerPlay.

3. Powerplay, exploitation du cube

Figure 15 : Exploitation PowerPlay

Figure 16 : Génération de graphique