Académique Documents
Professionnel Documents
Culture Documents
A............................................................................................................................................................................25
B............................................................................................................................................................................25
2. Exemple de boucle de type 1.......................................................................................................................26
3. Exemple de boucle de type 2.......................................................................................................................27
4. Les alias.......................................................................................................................................................28
A.............................................................................................................................................................................28
5. Les contextes...............................................................................................................................................29
6. Détection automatique des boucles.............................................................................................................31
D. Les cas particuliers........................................................................................................................................32
1. Le raccourci jointure...................................................................................................................................32
2. Les relations réflexives................................................................................................................................33
1. La fonction @Prompt..................................................................................................................................45
2. La fonction @Select....................................................................................................................................46
3. La fonction @Where...................................................................................................................................47
4. La fonction @Variable................................................................................................................................48
5. La fonction @Aggregate_aware.................................................................................................................49
6. La fonction @Script....................................................................................................................................49
F. Les conditions prédéfinies..............................................................................................................................50
G. Les indicateurs...............................................................................................................................................51
H. La navigation agrégée...................................................................................................................................53
1. Principe........................................................................................................................................................53
2. Démarche....................................................................................................................................................53
3. Réalisation...................................................................................................................................................54
4. Test..............................................................................................................................................................54
I. Les hiérarchies................................................................................................................................................55
Comme nous l’avons vu dans le module utilisateur, l’utilisation d’un univers passe par la mise
en place de la couche middleware entre l’univers et la base de données. Cette couche
middleware comporte deux éléments : la source et la connexion. La création de la connexion
ne peut s’effectuer qu’à partir de l’environnement client : Designer.
Etape 1 :
• La création d’une connexion s’effectue à partir du module Designer : Outils>Connexions...
• Cliquer sur le bouton ‘Ajouter’.
Etape 2 :
• Choisir le type de middleware (un seul possible de par l’installation de BO).
• Cliquer sur le bouton
Etape 3 :
• Donner un nom à la connexion (exemple : COURS BO)
• Choisir le moteur de SGBD/R
• Choisir la source de données dans la liste déroulante.
• Choisir le type de connexion personnelle, et tester impérativement la connexion.
• Retour sur la première fenêtre (étape 1) : terminer en cliquant sur ‘OK’
Une connexion étant maintenant créée, il convient de définir les paramètres du nouvel
univers.
Pour cela sélectionner dans le menu : Fichier >> Nouveau ou touches de raccourci CTRL +
N.
La fenêtre Paramètres de l’univers apparaît.
Si l’univers existe déjà et ouvert, cette fenêtre est accessible par le menu Fichier >>
Paramètres
B. Résumé
L’onglet résumé est très utile dans le cadre d’un déploiement à grande échelle permettant au
superviseur de visualiser par exemple des informations sur la création, les modifications et
leurs auteurs respectifs.
C. Stratégies
Les stratégies sont utilisées soit à l’importation des tables, soit à la création des objets
de l’univers.
D. Restrictions
Lorsque les utilisateurs se connectent à un Univers, vous pouvez avoir contrôlé l’accès aux
ressources en limitant :
• le nombre de lignes de résultat de la requête,
• le temps d’exécution de la requête,
• La taille maximum des objets de type long.
Vous pouvez également faire afficher un message si le temps estimé d’exécution d’une
requête dépasse le nombre de minutes spécifié.
A noter : Avec ODBC, la limite de temps n’est pas respectée car le test de durée est effectuée
au retour des premières données.
Pour le nombre de lignes limitées, si le résultat contient plus de lignes, il sera tronqué.
E. SQL
L’onglet SQL permet de paramétrer la génération du SQL lors de l’élaboration des requêtes :
• la gestion des sous-requêtes,
• l’utilisation des opérateurs ensemblistes,
• l’utilisation des opérateurs complexes,
• la génération d ’ordres SQL multiples pour chaque contexte,
• la génération d ’ordres SQL multiples pour chaque indicateur,
• la sélection de contextes multiples.
• le produit cartésien : en général, le mettre à ‘Interdire’.
F. Liens
Cliquer enfin sur le bouton’OK’ pour prendre en compte les paramètres définis.
G. Enregistrement de l’univers
Vous pouvez maintenant enregistrer l’Univers dans le dossier par défaut : Universe.
Pour cela sélectionnez le menu Fichier >> Enregistrer sous… ou touche de raccourci F12.
Le fichier créer a pour extension .unv .
La création de la structure d’un Univers est l’étape fondamentale, travail de conception par
excellence. Cette création consiste à déclarer les tables nécessaires à cet Univers, définir les
jointures utilisées par ces tables et résoudre des éventuels problèmes liés au fait que le
système va devoir générer automatiquement du SQL.
L’étape suivante consistera à convertir cette structure, dont la lecture n’est accessible qu’aux
concepteurs, en une présentation orientée vers le métier des utilisateurs : la couche
sémantique (cf. partie 4 de ce document).
Objets structure
Les tables qui font partie de la structure de l’Univers doivent être sélectionnées dans la
source. Il faut pour cela utiliser le localisateur de tables. Pour l’activer :double-cliquer dans la
fenêtre structure ou cliquer sur l’icône ou sélectionner le menu Insertion >> Tables
Il existe trois façons d’afficher les colonnes (attributs) dans une table.
• Par défaut une table affiche n colonnes maximum. Une table dont l’affichage est partiel
contient (…)
• Si on clique sur cette table , une barre de défilement apparaît .
• Double-cliquer sur la table affiche la table sans attributs .
• Double-cliquer de nouveau affiche la table avec uniquement les attributs de jointures.
(NB : ici il n’y en a pas puisque aucun n’a encore été défini, voir plus loin).
Attention : si vous le faites après avoir mis en place les relations et positionné les tables, le
shéma obtenue peut être boulversé.
Le menu contextuel de la fenêtre structure s’obtient par clic droit dans une zone libre de la
fenêtre. Il permet d’accéder à certaines options déjà vues, comme l’affichage des tables.
D’autres options, comme l’affichage du nombre de lignes (enregistrements) d’une table sont
disponibles.
Le menu contextuel d’une table s’obtient par clic droit sur une table. Il permet d’accéder à
certaines options déjà vues. D’autres options, comme l’affichage du contenu d’une table sont
disponibles.
Remarque importante : il est possible par ce menu de renommer une table. Cette option ne
doit être utilisée que si la table a été renommée au niveau physique, donc de la base de
données. Dans le cas contraire, il n’y aura plus cohérence entre l’Univers et la source de
données.
Pour supprimer des tables de la fenêtre structure, sélectionner la table et couper (menu
Edition) ou supprimez (touche Suppr)
Paramétrage graphique : cliquer sur le menu Outils >> Options pour faire apparaître la boîte
de dialogue Options. L’onglet Graphiques de cette boîte de dialogue permet de personnaliser
notamment l’apparence des jointures et des cardinalités dans la fenêtre structure.
La case à cocher Meilleur côté permet au système de dessiner les jointures de la façon la plus
courte et correcte possible (sans passer derrière une table par exemple).
Il existe par ailleurs 4 types de jointures :
• équi-jointure : égalité entre la colonne d’une table et la colonne d’une autre table.
• jointure externe : les occurrences d’une table n’ont pas de correspondance dans l’autre
table (cas des cardinalités 0,1 et 0,n).
• thêta jointure : repose sur un rapport autre que celui de l’égalité entre deux colonnes
(comparaisons, fonctions, requêtes imbriquées)
• auto-jointure : permet de définir une jointure entre attributs d’une même table.
La façon la plus élémentaire de créer une jointure est de faire glisser le pointeur de la souris
d’un attribut vers un autre.
Pour tracer manuellement une jointure depuis la colonne d’une table vers la colonne d’une
autre table :
• positionner le curseur de la souris sur la colonne de la première table (le curseur se
transforme alors en une main) , sans que la table ne soit déjà sélectionnée;
• faire glisser le curseur, qui se transforme en crayon, jusqu’à la colonne de la deuxième
table ;
• relâcher la souris.
Pour éditer une jointure, double-cliquer dessus. La fenêtre Editer la jointure s’ouvre.
• Les deux zones du haut présentent les tables et la liste de leurs attributs.
• La liste déroulante permet de définir le type de jointure (égalité, différence, comparaisons).
• La case à cocher ‘Jointure externe’ permet de définir des cardinalités minimales égales à
zéro.
• Le bouton ‘Détecter’ permet de définir automatiquement les cardinalités.
• La case à cocher ‘Raccourci jointure’permet d’optimiser une requête en créant une jointure
redondante entre une table ‘ fille ’ et une table ‘ grand-mère ’.
• Le bouton ‘Editer…’ permet de construire des requêtes complexes (cf. page suivante)
NB : l’expression SQL de la jointure apparaît dans la zone inférieure de la boîte de dialogue.
Cliquer sur le bouton permet d’afficher les jointures en mode liste dans la fenêtre
structure.
Cliquer sur le bouton pour activer la détection automatique des jointures ou sélectionner
le menu Outils >> Détecter les jointures.
La détection se fera selon la stratégie définie par la boîte de dialogue Paramètres de
l’Univers.
Remarque importante : la stratégie par défaut est fondée sur l’homonymie : BO déclare les
jointures entre attributs portant le même nom. Si vous utilisez la détection automatique,
pensez à supprimer les jointures inutiles et ajouter celles qui portent sur des attributs de noms
différents.
Rappel : pour ouvrir cette boîte de dialogue, sélectionner le menu Fichier >> Paramètres...
Il est fort probable que vous aurez des jointures inutiles, voire inexactes.
Si vous utilisez la détection automatique, il faudra impérativement vérifier les jointures une à
une.
Exemple :
Il existe deux schémas de principe et leurs dérivés dans lesquels on trouve des boucles.
• Boucle de type 1 : la table B a une grand-mère accessible par deux chemins différents. A
une occurrence de B, on associe deux occurrences de A, différentes selon le chemin emprunté.
Il y a un sommet unique : A.
• Boucle de type 2 : deux tables différentes ont des tables mères communes. Il y a deux
sommets : A et B. De façon plus générale, aux sommets A et B sont associées deux listes plus
ou moins complexes (plusieurs tables entre les sommets).
A A B
1
2
B
Le sommet de la boucle est ici la table pays, du fait que lieu de séjour (Resort) et client
(Customer) sont liés à pays (Country) , qui peut être différent.
Les sommets de la boucle sont ici client (Customer) et service (Service), dû au fait que ces
entités ont deux listes associées : celle des réservations et celle des ventes. En effet, la base de
données est en mesure de traiter deux fonctions différentes : la réservation de services par un
client et la vente de services à un client
Demi-boucle
Réservations
Demi-boucle
Ventes
4. Les alias
A A’
Pour créer un alias, sélectionner la table concernée puis sélectionner le menu Insertion >>
Alias… ou cliquer sur l’icône ou clic droit sur la table et menu Insérer un alias...
Saisir le nom de la table alias dans la fenêtre :
5. Les contextes
A B
A B
Pour créer un contexte, sélectionner le menu Insertion >> Contexte… ou cliquer sur l’icône
ou clic droit dans la fenêtre structure et menu Insérer un contexte…
Important : les contextes se définissent sur l’ensemble du schéma et non pas uniquement sur
le sous-ensemble comportant la boucle. Il faut donc d’abord sélectionner toutes les jointures
de la structure (touches de raccourci Ctrl + A ). Dans la fenêtre Nouveau contexte qui
apparaît, cliquer sur le bouton ‘Détecter’
Donner un nom au contexte (ou modifier le nom par défaut). Le système détecte
automatiquement les tables faisant partie du contexte.
Pour visualiser un contexte, passer en mode liste en cliquant sur ou sélectionner le menu
Affichage >> Mode liste
Le troisième volet affiche le nom des contextes de l’Univers.
Si un contexte est sélectionné dans ce volet, ses jointures apparaissent en inverse vidéo.
Pour supprimer un contexte, sélectionner son nom dans le volet Contextes et appuyer sur la
touche Suppr.
1. Le raccourci jointure
Dans certains cas il sera intéressant de dénormaliser le modèle afin par exemple d’améliorer
les performances du système (en diminuant le nombre de jointures).
La clé primaire de la table A deviendra alors clé étrangère dans la table C.
A1
A A1
B1 B1
B
Si vous déclarez la jointure entre A et C cela ressemble fort à une boucle. Pour éviter que le
système ne détecte cette boucle, il faut cocher la case Raccourci jointure de la fenêtre
d’édition de cette jointure (voir vue suivante).
La jointure entre la table des clients et son alias parrain permet de traduire une relation
réflexive. Un client a 0,1 parrain et un parrain 0,n clients.
Attention : la table parrain, créée après les contextes, n’appartient donc à aucun de ceux-ci. Il
faut donc l’insérer dans les contextes existants. Pour cela éditer le contexte et cliquer sur la
jointure adéquate pour la rajouter au contexte. Opérer de la sorte pour tous les contextes.
Pour éditer un contexte : passer en mode liste, clic droit sur le nom du contexte et menu
Propriétés du contexte...
L ’étape précédente à consisté à créer la structure d’un Univers. Cette création a permis de
déclarer les tables nécessaires à cet Univers, de définir les jointures utilisées par ces tables et
de résoudre des problèmes liés au fait que le système va devoir générer automatiquement du
SQL.
Ce chapitre présente l’étape suivante qui consistera à convertir cette structure, dont la lecture
n’est accessible qu’aux concepteurs, en une présentation orientée vers le métier des
utilisateurs : la couche sémantique. Cette appellation a fait l’objet d’un brevet déposé par la
société Business Objects.
(*) : par exemple l’objet date de la classe des réservations n’a pas la même signification que
l’objet date de la classe des ventes.
Classes
d’entités
Classes de
conditions
prédéfinies
La fenêtre Univers donne une représentation hiérarchique des classes et des objets de
l’Univers.
L’utilisateur visualise cette fenêtre lorsqu’il crée ses requêtes.
Les icônes en forme de dossiers représentent les classes.
A l’intérieur des classes, on trouve des objets ou des sous-classes.
Il existe trois types d ’objets :
• dimension : correspond à un attribut d’une table ou d’une requête portant sur un ou
plusieurs attributs.
• information : permet de définir un composant de dimension. Elle a les mêmes
caractéristiques que la dimension mais ne peut pas être utilisée pour l’analyse
multidimensionnelle.
• indicateur : correspond à un objet résultant d’un calcul ou d’une opération de traitement.
(Rappel important : la valeur d’un indicateur sera fonction du contexte où il se trouve et des
objets du résultat).
Classe
Dimension
Information
Indicateur
Comme pour les classes il existe plusieurs méthodes pour créer un objet. La plus simple
consiste à cliquer sur un attribut de table de la fenêtre structure et de faire glisser cet attribut
dans la classe voulue de la fenêtre Univers.
Pour créer des objets plus complexe, vous pouvez après avoir sélectionné une classe :
• cliquer sur l’icône de la barre d’outils,
• utiliser le menu Insertion >> Objet… ,
• faire un clic droit sur la classe et sélectionner le menu Insérer un objet…
Dans les trois derniers cas la fenêtre Editer les propriétés de Objet1 s’ouvre (voir shéma
suivant).
Pour ouvrir cette fenêtre après la création d’un objet, double-cliquer sur l’objet. Il est alors
possible de modifier ses propriétés.
1. Onglet Définition
2. Onglet Propriétés
Cet onglet permet de spécifier la qualification d’un objet et de lui associer une liste de valeurs
(case ‘Associer une liste de valeur’ cochée par défaut).
La qualification d’un objet est importante en vue de l ’analyse multidimensionnelle.
Ces qualifications sont :
• Dimension: élément clé pour les utilisateurs. Pour les dimensions de type Date, il sera
possible de créer une hiérarchie (voir plus loin).
• Indicateur : contient une information dérivée d’un calcul. Pour les indicateurs, une boîte de
fonctions est affichée. Le sélection d’une fonction agrégera les données relatives à cet objet en
mode analyse ascendante.
• Information : objet dépendant d’une dimension, donnant un complément d’information sur
cette dimension. Elle n’intervient pas en analyse multidimensionnelle. Un choix de dimension
associée s’affiche. Il suffit de la sélectionner dans la liste déroulante.
Dans les propriétés, il est possible d’associer une liste de valeurs à un objet (*.lov).
Cette liste est générée par une requête à partir des données de la base.
L’utilisation d’une liste de valeurs sera très utile pour les utilisateurs lorsqu’ils souhaiteront
poser des conditions dans leurs requêtes (par défaut toutes les valeurs sont prises en compte
pour l’objet en question).
Le bouton ‘Rétablir’ donne un nom par défaut, crée une requête simple.
Le bouton ‘Editer’ ouvre l’éditeur de requêtes, permettant de créer une requête plus élaborée,
avec le code et le libellé par exemple.
Ces deux fonctions sont également accessibles par le menu Outils >> Liste de valeurs...
Il est possible de donner un nom plus parlant à cette liste de valeurs. Le fichier .lov aura le
même nom.
Plusieurs objets peuvent avoir la même liste de valeur. Par exemple, les pays de séjour et pays
de résidence auront la même liste de valeur ‘Pays’.
3. Onglet ‘Avancées’
Les propriétés avancées permettent de spécifier un niveau de sécurité d’accès, les conditions
d’utilisation de l’objet dans les requêtes et pour les objets Date, le format des informations
stockées dans la base de données.
Dans le cas d’une distribution sécurisée (utilisation du référentiel Business Objects), le
designer peut attribuer un niveau de sécurité à un objet en correspondance avec un niveau de
sécurité attribué à un utilisateur (module Supervisor).
Pour chaque objet il est possible de désactiver les conditions d’utilisation de l’objet :
• Résultat,
• Condition,
• Tri.
Par défaut ces trois options sont actives.
La fonctionnalité Format de la base de données permet la saisie de valeurs au format du poste
client. Si le format date est différent de celui de la base spécifié dans la définition de l’objet,
une conversion au format base de donnée sera faite lors de la génération du SQL.
En général, les conditions ne sont pas posées sur un champ texte s’il est possible sur le code
associé, pour des raisons évidentes de performances et d’utilisation éventuelle d’index.
Il est possible d ’élaborer des objets complexes en leur donnant un sens précis. Cela revient à
renseigner l’équivalent Where de la zone de la fenêtre Editer les propriétés de Objet1.
Tout ce qui est saisi dans cette zone est introduit dans la clause WHERE du SQL généré,
derrière un AND qui suit les clauses de jointures.
Conséquence : tout ce qui est écrit dans l’équivalent WHERE doit avoir la forme générale
d’un prédicat.
EquivalentSelect1 à N sont les textes des équivalents select des objets du rapport.
EquivalentWhere1 à N sont les textes des équivalents where des objets du rapport.
Table1 à N sont déterminées automatiquement par le système en fonction de la clause
SELECT.
Les conditions de jointures respectent la définition de chaque jointure de la structure.
Lors de la création de dimensions de type Date, il est possible de créer une hiérarchie
automatique basée sur le temps.
L’équivalent SQL de ces objets est généré dynamiquement lors de l’exécution de la requête
dans le module utilisateur.
Pour compléter la définition des objets de type Date, le concepteur peut utiliser les fonctions
de transformation de dates du SGBDR choisi.
NB : cette possibilité n’est offerte que si vous accédez à une base de données Access.
E. Les fonctions @
1. La fonction @Prompt
Cette fonction permet de créer des objets interactifs. Lors de l’exécution de la requête, un
message sera soumis à l’utilisateur sous forme d’invite. Elle est utilisée dans les équivalents
Select ou Where des objets.
Sa syntaxe est la suivante :
@Prompt(‘message’,’type’,[lov],[mono/multi],[free/constrained])
Les éléments entre crochets sont facultatifs mais les virgules restent obligatoires.
- message : texte d’invite
- type : ‘A’, ‘D’, ou ‘N’ pour indiquer le format de la réponse.(‘N,NN’
pour un chiffre et deux décimales)
- lov : Permet de préciser une liste de valeurs proposées au choix de
l’utilisateur. {‘valeur1’, ‘valeur2’} ou ‘classe\objet’. Il ne peut s’agir d’un nom
d’attribut.
- mono/ multi : permet de préciser si l’invite ramènera une ou plusieurs valeurs.
- free/constrained : Permet d’imposer ou non la réponse de l’utilisateur.
2. La fonction @Select
Cette fonction permet de créer des objets dynamiques en utilisant la définition de l’équivalent
SELECT d’autres objets existants.
Sa syntaxe est la suivante :
@Select(nom de la classe\nom de l’objet)
3. La fonction @Where
Cette fonction permet de créer des objets dynamiques en utilisant la définition de l’équivalent
WHERE d’autres objets existants.
Sa syntaxe est la suivante :
@Where(nom de la classe\nom de l’objet)
Objet
dynamique
4. La fonction @Variable
Cette fonction permet de créer des objets en faisant référence à un nom ou à une variable.
Sa syntaxe est la suivante :
@Where(‘ma variable’)
Cette variable peut être :
• une variable de Business Objects : BOUSER, BOPAS…) ;
• une variable SQL BO ;
• une variable personnelle.
5. La fonction @Aggregate_aware
Cette fonction permet de créer des objets utilisés pour la navigation agrégée. D’utilisation
complexe, elle fera l’objet d’un paragraphe particulier ( H ).
6. La fonction @Script
Cette fonction permet de récupérer les résultats d’un script exécuté dans le module utilisateur.
Ces objets sont particulièrement utiles car ils permettent de retranscrire d’une part le
vocabulaire métier de l’utilisateur de l’Univers (il peut être difficile pour un utilisateur de
traduire une condition dans une requête) et d’autre part des conditions couramment utilisées.
Pour créer une condition prédéfinie :
• se positionner dans la partie Conditions de la fenêtre objets;
• sélectionner la classe dans laquelle la condition sera insérée ;
• cliquer sur l’icône de la barre d’outils ou menu Insertion >> Condition…
• saisir le nom de la condition ;
• double-cliquer sur l’objet : la fenêtre d’édition des propriétés apparaît ;
• saisir l’équivalent Where de l’objet.
G. Les indicateurs
Ces objets utilisant généralement une ou plusieurs fonctions de groupe (sum, count, avg, min ,
max…) correspondent à une règle de gestion qui prendra tout son sens en fonction de
l’association avec d’autres objets. Il s’agit de sémantique dynamique.
Ces objets, qualifiés d’indicateurs, correspondent à l’intersection ou la projection d’une règle
de gestion sur des axes d’analyse.
Il est très important d’associer une description aux indicateurs, comme par exemple la
méthode de calcul, l’unité d’expression, la règle de gestion…
Ainsi, la description qui en est faite par le concepteur au profit des utilisateurs doit être très
complète : règle de calcul, unité utilisée, objets auxquels on peut l’associer …
La fonction de projection d’un indicateur indique quel doit être le comportement de celui-ci
en cas de regroupement des occurrences du résultat.
L’indicateur est toujours de type numérique, c’est une information calculée à partir des règles
de gestion (exple : le Chiffre d’Affaire).
Il prend valeur en fonction des objets auxquels il est associé :
H. La navigation agrégée
1. Principe
Dans de nombreux cas, les bases de données contiennent des tables contenant des agrégats.
En général, il s‘agit d’informations calculées que le concepteur a choisi de mémoriser plutôt
que de les calculer à chaque fois.
Ainsi, la table Region_Sline (à inclure dans l’univers) contient le CA des ventes pour une
région et un type de service (en visualiser le contenu) et ce pour tous les couples région, type
de service. Or, cette information peut être calculée simplement par Business Object à l’aide
d’un indicateur. Mais ce calcul peut être pénalisant en temps sur des plus gros volumes de
données.
MCD MLD
Absentes du modèle 1 : créer un attribut dans une table (voir créer la
table)
Valeurs calculées : règles de gestion 2 : calculer par l’application (exple de BO via les
indicateurs)
La navigation agrégée consiste à définir un indicateur qui laissera au système le choix entre le
calcul de chaque valeur de l’indicateur ou l’utilisation d’une valeur issue d’une table
d’agrégats. Le choix sera effectué par le système en fonction des objets associés à
l’indicateur.
2. Démarche.
3. Réalisation
4. Test
Pour tester le bon fonctionnement de la navigation agrégée, nous allons comparer
plusieurs rapports.
I. Les hiérarchies