Developpez.com - Oracle
X

Choisissez d'abord la catégorieensuite la rubrique :


Optimisation des temps de réponse d'un datawarehouse sous Oracle basée sur la ré-écriture de requêtes en utilisant des vues matérialisées

Date de publication : 13 avril 2009

Par Nicolas Stefaniuk
 

Cet article présente, explique et forme à la fonctionnalité de ré-écriture de requêtes d'Oracle, utilisant des vues matérialisées pré-calculant les valeurs.

               Version hors-ligne (Miroir)

I. Introduction
II. Résumé
II-A. Qu'est-ce qu'une Vue Matérialisée ?
II-B. Ben qu'est-ce qu'elle a ma requête ?
III. Méthode
III-A. Environnement
III-B. My tailor is rich
III-C. Espace de travail
III-D. Le modèle
III-E. La structure
III-F. Le jeu de données
III-G. Fast and furious
III-H. Les statistiques boudiou !
III-I. Choisir ses VM
III-J. Le compromis des VM
III-K. La technique du bouclier
III-L. Les combinaisons
III-M. Les index sur VM
III-N. Activer / désactiver la ré-écriture
III-O. Pause-café
III-P. Benchmarks
III-P-1. Requêtes basiques
III-P-2. Requêtes d'analyses
III-P-3. Requêtes d'analyse à travers les axes
IV. A venir :


I. Introduction

Le but de cet article est de présenter la ré-écriture de requêtes basée sur l'utilisation de vues matérialisées pré-calculées sous Oracle. Ce genre de techniques s'applique particulièrement sur les datawarehouses où les données changent peu mais où les requêtes aggrégées sont fréquentes et coûteuses. Je souhaite donner au lecteur tous les éléments possibles pour le rendre efficace et autonome sur le sujet, dans la limite de mes propres connaissances. Pour cette raison, cet article fourni aussi des astuces, des logs de mes manipulations et une liste des erreurs qui peuvent survenir, avec leur cause et leur correction que je nommerai troubleshooting, n'ayant pas trouvé de traduction adéquate.

Après un résumé rapide, l'article se compose de 3 parties, chacune comportant des explications, les références aux scripts, les logs, astuces et troubleshooting.

Le point absolument essentiel de cet article est que je le livre tel quel, sans aucune garantie d'aucune sorte. Je ne m'engage à aucun résultat ni au fait que je ne dise pas des énormités parfois (bien qu'en principe je préfère ne pas m'étendre sur un sujet plutôt que de raconter doctement une sottise). J'ai essayé d'écrire un guide de qualité, compréhensible, pas complet mais contenant tout ce qu'il faut pour pouvoir appliquer les principes décrits ici sur des cas réels, mais ce n'est qu'un article écrit sur mon temps libre avec ma fille sur les genoux. Il n'a donc pas la qualité d'une production professionnelle réalisée par un expert. D'ailleurs si un lecteur a des corrections / améliorations / conseils / idées à apporter je lui en serais reconnaissant.


II. Résumé

Les temps de réponses sont le premier problème d'un datawarehouse, et les solutions pour les réduire se trouvent à de nombreux niveaux :

L'optimisation de la base englobe toutes les actions permettant d'améliorer les performances d'une manière transparente pour la modélisation et l'utilisateur (excepté le gain de performances bien entendu). On peut la séparer en 2 grandes parties :

C'est l'optimisation locale qui nous intéresse ici, et plus particulièrement le fait de pré-calculer des informations pour éviter de faire le même travail plusieurs fois. Dans cette définition, on peut bien évidemment placer les Index, qui permettent d'indexer les données pour pouvoir les retrouver plus vite et plus efficacement, mais ce n'est encore une fois pas le sujet de l'article. L'élement qui nous intéresse ici c'est la ré-écriture de requêtes basée sur l'utilisation de vues matérialisées pré-calculées.


II-A. Qu'est-ce qu'une Vue Matérialisée ?

Une Vue Matérialisée (VM) est une table d'un type particulier contenant le résultat d'une requête. Sa caractéristique est donc que son contenu représente le résultat à l'instant de sa création de la requête sur laquelle elle est basée. Contrairement à une vue, une VM contient donc des données, ce qui implique que :

La construction d'une VM accepte les mêmes paramètres qu'une table (à peut-être quelques exceptions que je ne connais pas) et finalement on peut se dire qu'il n'y a pas de grande différence à utiliser une VM ou à alimenter une table aggrégée à l'aide d'un script SQL ou d'un ETL (à part les possibilités avancées dont on ne parlera que dans la 3e partie telles que le refresh on commit).

C'est vrai sauf si on souhaite utiliser la ré-écriture de requête.


II-B. Ben qu'est-ce qu'elle a ma requête ?

Sous certaines conditions, Oracle peut décider de ré-écrire une requête pour améliorer les performances, et ceci de manière transparente pour l'utilisateur. Oracle va estimer le coût de la requête qui lui est soumise, puis la ré-écrire en utilisant un algorithme et les éléments à sa disposition. Puis il va comparer le coût estimé de cette requête ré-écrite avec celle d'origine. Si le coût est moindre, il utilisera la requête ré-écrite. Finalement on retrouve là le comportement des index, où Oracle choisi d'utiliser un index ou un autre en fonction de ce qu'il estime le plus performant. Qui ne s'est jamais exclamé "Mais pourquoi il fait un full scan cet abruti ! Y a un index !" ? Les voies du CBO (Cost Based Optimizer) sont impénétrables...

De la même manière que pour bien utiliser les index Oracle a besoin de statistiques à jour, un certain nombre de conditions sont nécessaires pour utiliser la ré-écriture de requêtes et tous les problèmes de performance ne pourront pas être résolus de cette manière. De plus, la ré-écriture de requête nécessite qu'Oracle comprenne la requête d'origine, ce qui implique qu'elle ne soit pas trop compliquée.


III. Méthode


III-A. Environnement

La version d'Oracle utilisée pour cet exemple est une 10.2.0.1 avec options partitionning et OLAP sur une machine virtuelle de 600 Mo de RAM et 1 seul CPU. Si vous installez vous même votre base il me semble que les options sont à choisir à l'installation, je n'ai pas vu l'intérêt de monter une documentation d'installation. Attention je pense que ces options n'existent pas sur une XE. Je ne peux rien garantir sur le fonctionnement de cet article pour des versions antérieures.


III-B. My tailor is rich

Les scripts et la structure des tables sont en Anglais, pas parce que j'aime particulièrement l'Anglais ni pour rendre le script portable mais parce que les commandes sont en Anglais (CREATE, ALTER, etc.) et que je n'aime pas avoir plusieurs langues mélangées dans mes scripts. Les messages oracle des logs et troubleshooting sont en Français par contre, pour donner la possibilité de faire une recherche sur les messages dans l'article.


III-C. Espace de travail

Pour commencer, nous allons initialiser notre espace de travail. La base s'appelle orcl.

Tout l'article sera basé sur un utilisateur nommé DEMO_USR. Tous les scripts seront volontairement préfixés avec cet utilisateur. Pour les jouer sur un autre utilisateur il faut donc procéder à un rechercher / remplacer dans tous les scripts / exemples. J'ai préféré faire ce choix car cet article nécessite de travailler énormément sur l'utilisateur (gestion des droits, trace des sessions, etc.), donc il aurait de toute façon fallu adapter le nom de l'utilisateur à un moment ou à un autre.

La première chose à faire est bien sûr de créer l'utilisateur. Soit vous créez un utilisateur qui s'appelle DEMO_USR en utilisant le script 001 - Create_User_DEMO_USR.sql, soit vous vous débrouillez... Dans ce cas, n'oubliez pas de bien attribuer les droits. Je n'aime pas donner des roles sans savoir pourquoi (surtout le role DBA) donc à chaque étape j'ai essayé de ne donner que les droits minimum pour l'étape. De plus je ne me suis pas encombré de considérations sur le tablespace par défaut, les quotas, etc. Si vous n'avez pas les droits suffisants pour gérer ce genre de choses, adressez-vous à votre DBA pour initialiser l'espace de travail.

Pour créer l'utilisateur, connectez-vous donc avec un utilisateur qui a assez de droits et lancez le script suivant : 001 - Create_User_DEMO_USR.sql. Une fois l'utilisateur DEMO_USR créé, ouvrez une session avec lui avec DEMO_USR comme mot de passe.

Si votre DBA est du genre à se faire désirer, demandez-lui d'exécuter ce script aussi : 005 - Grant_BI_Rights_DEMO_USR.sql, ça sera du temps gagné pour plus tard (qui sera utilisé à ce point de l'article)


III-D. Le modèle

Pour notre exemple nous allons nous baser sur un modèle en flocon constitué de:

Le modèle
Le modèle
Note : les notions de dimensions et de faits sont connues de tous, la notion d'attribut peut-être moins. La définition d'un attribut utilisée ici est : information n'étant ni un fait, ni une dimension, et par conséquent n'étant pas destinée à être utilisée dans l'analyse. Par exemple ici l'attribut est "la date et l'heure de la vente". Alors que la date est un élément de la dimension Temps, l'heure n'a aucune importance pour l'analyse. C'est ainsi qu'est conçu le modèle. Si l'heure de vente était importante pour mener des analyses par exemple sur les meilleures heures de vente par périodes, l'heure aurait été modélisée comme une dimension, avec des clés de regroupement (8h, 9h, 10h, etc. puis un niveau au dessus MATIN, APRES-MIDI etc.). Cela implique aussi que si les utilisateurs souhaitent utiliser l'heure dans leurs analyses, ils sortent du périmètre défini, et donc il est très probable que l'optimisation que nous avons prévue devienne inefficace.

Les tables et leurs champs sont les suivants:

Faits

F_SALE

SAL_ID
SAL_AMOUNT
SAL_DISCOUNT_AMOUNT
SAL_DATETIME
SAL_DATE
SAL_PRODUCT
SAL_VENDOR
SAL_CUSTOMER
Dimension Temps

D_CALENDAR

CAL_DATE
CAL_DAY_OF_WEEK
CAL_YEARMONTH
CAL_MONTH_OF_YEAR
CAL_MONTH_DESC
CAL_YEAR
CAL_YEAR_DESC
Dimension Produit

D_PRODUCT

PRO_ID
PRO_SUB_FAMILY
PRO_DESC
D_PRODUCT_SUB_FAMILY

PSF_ID
PSF_FAMILY
PSF_DESC
D_PRODUCT_FAMILY

PFM_ID
PFM_DESC
Dimension Vendeur

D_VENDOR

VDR_ID
VDR_AGENCY
VDR_NAME
D_AGENCY

AGC_ID
AGC_REGION
AGC_NAME
D_REGION

REG_ID
REG_COUNTRY
REG_NAME
D_COUNTRY

CTR_ID
CTR_NAME
Dimension Client

D_CUSTOMER

CUS_ID
CUS_SUB_GROUP
CUS_NAME
D_CUSTOMER_SUB_GROUP

CSB_ID
CSB_GROUP
CSB_DESC
D_CUSTOMER_GROUP

CGR_ID
CGR_DESC
Ce modèle permet de valider les cas suivants :


III-E. La structure

Pour créer la structure de base de données il faut lancer le script 002 - Create_Database_Structure.sql. Note: les erreurs lors des DROP sont normales à la première exécution du script.

Des options avancées d'organisation telles que le partitionnement, la compression, l'utilisation d'index particuliers (bitmap), l'option nologging ou l'organisation en index des tables de dimensions ont été volontairement ignorées pour cet article, vu que ça n'apporte pas grand chose au sujet de la ré-écriture de requêtes. Pour une application sur cas réel, il faudrait bien entendu en tenir compte.


III-F. Le jeu de données

Nous allons maintenant alimenter nos tables de manière automatisée pour 2 raisons :

1 000 000 de lignes devraient suffire à la démonstration. Pour générer ces 1 000 000 lignes, nous allons utiliser la table ALL_OBJECTS qui contient environ 40 000 lignes. En faisant un produit cartésien avec elle même, on peut monter jusqu'à 1 600 000 000 lignes (mais nous allons la limiter à 1 000 000). Un code PL/SQL est aussi disponible mais il est plus lent à générer les lignes.

Notez que nous allons d'abord alimenter la table de fait, puis nous allons alimenter les tables de dimension à partir des données de la table de fait. Enfin nous activerons les clés étrangères. Ceci permet de garantir la cohérence des données crées automatiquement.

Exécutez le script 003 - Create_Source_Data.sql. Ce script s'occupe de désactiver les contraintes et d'effacer les tables (au cas où vous l'ayez déjà lancé) puis génére 1 000 000 lignes dans la table de fait. Ensuite il peuple les tables de dimensions à partir des données de la table de fait. Il dure moins de 10mn sur mon environnement.

En exécutant le script 004 - Stats on Source Data.sql, vous obtenez des statistiques sur les données de notre modèle, qui vont nous être bien utiles pour valider le comportement de nos tables aggrégées. De plus il est temps de faire quelques requêtes pour valider qu'il y a un problème de performances.

Les données doivent ressembler à ça:


III-G. Fast and furious

Si les durées des requêtes sont déjà assez longues sur cet exemple on peut imaginer les dérives avec 100 fois plus de lignes et des lignes 100 fois plus lourdes. Nous allons donc nous attacher à essayer de réduire les délais des requêtes en utilisant la ré-écriture de requête. Ce qui est intéressant c'est que ce modèle pourrait servir à démontrer les bénéfices d'autres techniques, que j'évoquerai à la fin de cet article.

Comme expliqué auparavant, la ré-écriture de requête fonctionne de la façon suivante:

Notons que cela implique que pour toutes les requêtes il va donc faire une ré-écriture et 2 parsing (au moins, je ne suis pas sûr qu'il ne tente pas plusieurs ré-écritures possibles), ce qui peut s'avérer plus coûteux en temps que la requête elle même. La ré-écriture n'a vraiment de l'intérêt que pour les requêtes coûteuses. Oracle utilise peut-être des critères non documentés pour décider de tenter de ré-écrire ou non une requête, du genre s'il sait que les tables en jeu contiennent peu de lignes. Ceci implique donc que pour faire de la ré-écriture de requêtes il faut l'avoir choisi, et chez Oracle ça se traduit par le fait d'avoir les droits.

Nous allons faire un 2e lot d'attribution de droits. Vous avez besoin de droits pour créer les objets suivants:

Il vous faut les droits suivants pour pouvoir procéder à de la ré-écriture de requêtes:

Faites exécuter le script 005 - Grant_BI_Rights_DEMO_USR.sql pour obtenir les droits décrits au-dessus. Aucun droit supplémentaire ne sera nécessaire pour la suite.


III-H. Les statistiques boudiou !

Comme dit auparavant, il est important de respecter un certain nombre de conditions pour utiliser correctement la ré-écriture de requêtes. Une de ces conditions est le calcul des statistiques. Les statistiques doivent être à jour sur vos objets, et ce encore plus que d'habitude car c'est grace aux statistiques qu'Oracle va estimer si la ré-écriture est intéressante par rapport à la requête initiale. Pour calculer les statistiques, utilisez le package DBMS_STATS.

Par exemple pour calculer les statistiques sur la table DEMO_USR.F_SALE, il faut lancer la commande suivante :

exec DBMS_STATS.GATHER_TABLE_STATS('DEMO_USR', 'F_SALE');
Il existe de nombreuses options que je ne détaillerai pas, parlez-en avec votre DBA.


III-I. Choisir ses VM

Il faut bien comprendre, comme dit au début du document, que la ré-écriture de requêtes basée sur des VM est une forme de tuning, et qu'elle doit être adaptée à l'évolution du modèle, des données et des besoins. Comme les index, de nouvelles VM peuvent devenir nécessaires à posteriori, alors que d'autres deviennent obsolètes. Un exemple classique est un changement de clé fonctionnelle dans le modèle : hier la clé fonctionnelle unique était obtenue par nom+prénom+agence et aujourd'hui on a introduit un nouveau champ qui contient un identifiant unique, disons matricule. Dans ce cas tous les index seront sûrement à reprendre, et les VM aussi.

Il n'y a donc pas de règle évidente pour choisir les VM à créer, et il faudra des analyses et des tests pour déterminer ce qu'il est judicieux de créer ou pas. On peut toutefois poser les 3 principes suivants :


III-J. Le compromis des VM

Le compromis avec lequel il faut composer se situe entre [espace disque utilisé par les VM, temps de calcul des VM ] et [ressources économisées lors des requêtes, fréquence d'utilisation des VM par les requêtes]. Ceci implique qu'une VM qui est longue à calculer et qui occupe de l'espace et qui n'est que très rarement utilisée n'est pas intéressante à utiliser. Par contre une VM qui permet de répondre à 50% des demandes et qui les améliore grandement vaudra le coup d'être calculée, même si elle demande beaucoup de temps de calcul et utilise de l'espace disque.


III-K. La technique du bouclier

Le bouclier consiste en une VM peu aggrégée, calculée seulement sur la table de fait (donc sans lier les tables de dimension) qui contient le niveau le plus fin de toutes les dimensions et les indicateurs aggrégés. Ainsi cela permet d'assurer les points suivants:

Encore une fois, le principe du bouclier c'est de dire : j'ai tout ce dont j'ai besoin pour faire toutes mes analyses. Si j'ai besoin d'un élément qui n'est pas dans mon bouclier (un attribut), alors je devrais aller attaquer ma table de faits mais c'est normal car je sors du cadre de l'analyse dimensionnelle. Le bouclier protège donc la table de faits en prenant sur lui toutes les requêtes qui voudraient l'attaquer (toujours en considérant que les requêtes restent sur le périmètre d'analyse).

Dans notre modèle le bouclier est donc constitué des 4 dimensions, des 2 indicateurs sommés et d'un compteur du nombre de lignes:

Note: SAL_DATETIME est un attribut et est donc exclu du périmètre d'analyse et donc du bouclier.

On remarquera que l'utilisation d'un bouclier est presque inutile si toutes les dimensions forment une clé unique ou, du moins, très discriminante, car dans ce cas le seul intérêt du bouclier sera d'avoir une VM sans les attributs de la table de faits (il y aura donc moins de données inutiles pour l'analyse à ramener dans les blocs). Par contre le bouclier garde de l'intérêt même s'il n'y a aucun attribut, car dans ce cas le bouclier permet quand même de réduire le nombre de lignes, réduction qui peut-être très importante.


III-L. Les combinaisons

A partir de notre bouclier, nous allons pouvoir construire toutes les VM dont on a besoin pour répondre à nos besoins. Pour l'illustration de cet article, et comme il n'y a que 4 dimensions, nous allons faire toutes les possibilités. Dans la réalité il faudrait analyser les VM les plus pertinentes.

Nous allons créer n VM sur m niveaux différents. m est égal au nombre de dimensions du bouclier, cad le nombre MAXIMAL de dimensions de notre modèle, ici m = 4, n vaut donc 16.

Illustration :

Au niveau 4 nous avons notre bouclier à 4 dimensions:

Niveau VM Dimensions
4 4-1 SAL_DATE - SAL_PRODUCT - SAL_VENDOR - SAL_CUSTOMER
Il n'y a qu'une seule combinaison avec 4 dimensions, on a donc une seule VM pour le niveau 4, qu'on appelera VM_LVL4_001.

Le niveau en dessous est constitué de 3 dimensions. On prends donc 3 dimensions sur les 4 disponibles, ce qui donne C(3,4) combinaisons possibles. Pour rappel C(3,4) = 4!/(3! * (4-3)!) = 24/(6 * 1) = 4.

Niveau VM Dimensions
4 4-1 SAL_DATE - SAL_PRODUCT - SAL_VENDOR - SAL_CUSTOMER
3 3-1 SAL_DATE - SAL_PRODUCT - SAL_VENDOR -
3 3-2 SAL_DATE - SAL_PRODUCT - - SAL_CUSTOMER
3 3-3 SAL_DATE - - SAL_VENDOR - SAL_CUSTOMER
3 3-4 - SAL_PRODUCT - SAL_VENDOR - SAL_CUSTOMER
Ce niveau 3 devrait nous permettre de répondre à toutes les analyses qui nécessitent 3 axes d'analyse.

Le niveau en dessous est constitué de 2 dimensions. On prends donc 2 dimensions sur les 4 disponibles, ce qui donne C(2,4) combinaisons possibles. Pour rappel C(2,4) = 4!/(2! * (4-2)!) = 24/(2 * 2) = 6.

Niveau VM Dimensions
4 4-1 SAL_DATE - SAL_PRODUCT - SAL_VENDOR - SAL_CUSTOMER
3 3-1 SAL_DATE - SAL_PRODUCT - SAL_VENDOR -
3 3-2 SAL_DATE - SAL_PRODUCT - - SAL_CUSTOMER
3 3-3 SAL_DATE - - SAL_VENDOR - SAL_CUSTOMER
3 3-4 - SAL_PRODUCT - SAL_VENDOR - SAL_CUSTOMER
2 2-1 SAL_DATE - SAL_PRODUCT - -
2 2-2 SAL_DATE - - SAL_VENDOR -
2 2-3 - SAL_PRODUCT - SAL_VENDOR -
2 2-4 SAL_DATE - - - SAL_CUSTOMER
2 2-5 - SAL_PRODUCT - - SAL_CUSTOMER
2 2-6 - - SAL_VENDOR - SAL_CUSTOMER
Ce niveau 2 devrait nous permettre de répondre à toutes les analyses qui nécessitent 2 axes d'analyse.

Le niveau en dessous est constitué de 1 dimension. On prends donc 1 dimension sur les 4 disponibles, ce qui donne C(1,4) combinaisons possibles. Pour rappel C(1,4) = 4!/(1! * (4-1)!) = 24/(1 * 6) = 4.

Niveau VM Dimensions
4 4-1 SAL_DATE - SAL_PRODUCT - SAL_VENDOR - SAL_CUSTOMER
3 3-1 SAL_DATE - SAL_PRODUCT - SAL_VENDOR -
3 3-2 SAL_DATE - SAL_PRODUCT - - SAL_CUSTOMER
3 3-3 SAL_DATE - - SAL_VENDOR - SAL_CUSTOMER
3 3-4 - SAL_PRODUCT - SAL_VENDOR - SAL_CUSTOMER
2 2-1 SAL_DATE - SAL_PRODUCT - -
2 2-2 SAL_DATE - - SAL_VENDOR -
2 2-3 - SAL_PRODUCT - SAL_VENDOR -
2 2-4 SAL_DATE - - - SAL_CUSTOMER
2 2-5 - SAL_PRODUCT - - SAL_CUSTOMER
2 2-6 - - SAL_VENDOR - SAL_CUSTOMER
1 1-1 SAL_DATE - - -
1 1-2 - SAL_PRODUCT - -
1 1-3 - - SAL_VENDOR -
1 1-4 - - - SAL_CUSTOMER
Ce niveau 1 devrait nous permettre de répondre à toutes les analyses qui nécessitent 1 axe d'analyse.

Le dernier niveau est constitué de 0 dimension. On prends donc 0 dimension sur les 4 disponibles, ce qui donne C(0,4) combinaisons possibles. Pour rappel C(0,4) = 4!/(0! * (4-0)!) = 24/(1 * 24) = 1.

Niveau VM Dimensions
4 4-1 SAL_DATE - SAL_PRODUCT - SAL_VENDOR - SAL_CUSTOMER
3 3-1 SAL_DATE - SAL_PRODUCT - SAL_VENDOR -
3 3-2 SAL_DATE - SAL_PRODUCT - - SAL_CUSTOMER
3 3-3 SAL_DATE - - SAL_VENDOR - SAL_CUSTOMER
3 3-4 - SAL_PRODUCT - SAL_VENDOR - SAL_CUSTOMER
2 2-1 SAL_DATE - SAL_PRODUCT - -
2 2-2 SAL_DATE - - SAL_VENDOR -
2 2-3 - SAL_PRODUCT - SAL_VENDOR -
2 2-4 SAL_DATE - - - SAL_CUSTOMER
2 2-5 - SAL_PRODUCT - - SAL_CUSTOMER
2 2-6 - - SAL_VENDOR - SAL_CUSTOMER
1 1-1 SAL_DATE - - -
1 1-2 - SAL_PRODUCT - -
1 1-3 - - SAL_VENDOR -
1 1-4 - - - SAL_CUSTOMER
0 0-1 - - -
Ce niveau 0 devrait nous permettre de répondre à toutes les analyses qui nécessitent 0 axe d'analyse. Autant dire qu'il est plus là pour la cohérence de l'ensemble que pour l'utilité lors d'analyses.

Nous obtenons donc 16 tables, un résultat que nous pouvions prévoir ainsi : Sommei=0..1( C(i,4) ) = C(0,4) + C(1,4) + C(2,4) + C(3,4) + C(4,4) = 1 + 4 + 6 + 4 + 1 = 16.

Imaginons que nous décidions de rajouter une 5e dimension, la notion de solde / pas solde par exemple. Nous n'aurions pas besoin de changer nos 16 tables, nous aurions juste à en rajouter de nouvelles. Nous créerions la table VM_LVL5_001 basée sur les 5 dimensions, qui deviendrait notre nouveau bouclier, et l'ancien bouclier VM_LVL4_001 deviendrait juste la première des 5 VM du niveau 4. Car au niveau 4 on aurait C(4,5) = 5!/(4! * (5-4)!) = 120 / (24 * 1) = 5 VM différentes. Au final nous aurions S(i=0..1) C(i,5) = C(0,5) + C(1,5) + C(2,5) + C(3,5) + C(4,5) + C(5,5) = 1 + 5 + 10 + 10 + 5 + 1 = 32. Soit 16 tables de plus, ce qui double le nombre de tables.

On remarquera que le nombre total de tables = 2^(le nombre max de dimensions) ce qui était prévisible sachant que le nombre de sous-ensembles d'un ensemble à n éléments est 2^n. Ceci implique qu'à chaque dimension supplémentaire on double le nombre de tables si on veut couvrir toutes les possibilités.


III-M. Les index sur VM

Le principe d'un index est d'accéder rapidement à de l'information. Si consulter l'index PUIS aller chercher l'information à l'endroit indiqué par l'index est plus long que chercher directement l'information en parcourant toute les données, l'index est inutile.

Imaginons la VM bouclier LVL4-001, elle contient les 4 dimensions : SAL_DATE - SAL_PRODUCT - SAL_VENDOR - SAL_CUSTOMER

Je pourrais me dire : tiens, je vais faire un index sur SAL_CUSTOMER et SAL_VENDOR. Comme ça si j'ai une analyse à faire sur SAL_CUSTOMER et SAL_VENDOR, la requête passe par l'index, c'est plus rapide. Erreur ! Car si je cherche à faire une analyse sur SAL_CUSTOMER et SAL_VENDOR, c'est en fait la VM LVL2-006 qui sera utilisée et l'index sur LVL4-001 sera inutile. Evidemment il se trouvera bien quelqu'un pour me sortir un contre-exemple, par exemple le fait qu'Oracle préfère parfois passer par une VM d'un périmètre plus large plutôt qu'utiliser la VM qui a exactement le périmètre qui va bien, sûrement parce que la VM d'un périmètre plus large est déjà montée en cache.

A noter toutefois qu'Oracle créé de manière transparente au moins un index sur la Vue Matérialisée. [CREATE MATERIALIZED VIEW [Oracle 10g release 2] chez Oracle]

Cas particulier : si je veux analyser mes données sur SAL_DATE, SAL_PRODUCT, SAL_VENDOR en filtrant sur SAL_CUSTOMER = 'x'. Dans ce cas effectivement, et parce que SAL_CUSTOMER a une grosse sélectivité, un index sur la VM peut être intéressant. Cette possibilité n'est donc pas à écarter sans analyse, mais ce n'est pas la première chose sur laquelle travailler.


III-N. Activer / désactiver la ré-écriture

La ré-écriture de requête peut être activée / désactivée à volonté par une modification de la session:

ALTER SESSION SET QUERY_REWRITE_ENABLED = 'true';
ALTER SESSION SET QUERY_REWRITE_ENABLED = 'false';
Le niveau d'intégrité que respecte Oracle lors de la ré-écriture de requête peut lui aussi être réglé:


ALTER SESSION set query_rewrite_integrity = ENFORCED;
ALTER SESSION set query_rewrite_integrity = TRUSTED;
ALTER SESSION set query_rewrite_integrity = STALE_TOLERATED;




III-O. Pause-café

Lancez le script 006 - Create Materialized Views.sql et allez boire un café.

Ce script :


III-P. Benchmarks


III-P-1. Requêtes basiques

Nous allons lancer les mêmes requêtes que celles qui ont servi à créer les VM une fois en désactivant la ré-écriture puis en l'activant et afficher le plan d'exécution. La requête non ré-écrite sera basée sur la table de faits alors que la requête ré-écrite sera basée sur la VM qui convient le mieux. Le but est seulement de tester le fonctionnement de nos requêtes.

Le principe est simple:

Notez que le cache risque de venir fausser les résultats, dans ce cas il faut utiliser la commande suivante:

alter system flush buffer_cache;
Le script à exécuter est 007 - Basic Benchmarks.sql


III-P-2. Requêtes d'analyses

Nous allons lancer des requêtes plus compliquées, intégrant notamment des clauses where pour valider que les VM permettent de répondre aux besoins d'analyse.

On peut constater 4 cas :

Le but n'est pas de montrer que les VM sont inutiles, mais plutôt de confirmer que le périmètre d'analyse doit être bien défini pour éviter les surprises.



III-P-3. Requêtes d'analyse à travers les axes

Nous allons maintenant explorer nos données en utilisant la totalité de notre modèle, ce qui implique de joindre la table de faits avec les tables dimensions.

En naviguant dans les axes en partant du niveau le plus fin, celui de la table de faits, et en remontant le long de l'axe d'analyse jusqu'au niveau le plus aggrégé, on rajoute des tables dans les requêtes, mais Oracle arrive toujours à les ré-écrire. En effet, vu que nos VM sont basées sur les champs de la table F_SALE, Oracle sait qu'il arrivera toujours à ré-écrire les requêtes en utilisant la logique suivante : rechercher une vue matérialisée utilisable dans les ré-écritures de requêtes (query rewrite enable) qui contienne tous les éléments dont la requête a besoin.

Ainsi, même en rajoutant plusieurs tables de dimensions normalisées, Oracle n'a aucun problème à ré-écrire correctement la requête : il détermine la VM à utiliser en fonction des dimensions utilisées puis il la joint aux tables de dimensions, voire à la hierarchie de tables de dimensions, et finalement procède au groupement. Oracle est aussi à l'aise pour grouper les données sur des identifiant (le code du vendeur ou du pays par exemple) que sur des attributs liés à ces identifiants (le nom du vendeur ou du pays par exemple).

Lancez le script 009 - Full Analysis Queries Benchmarks.sql pour vérifier le comportement de la ré-écriture sur des requêtes utilisant les axes d'analyse.


IV. A venir :



               Version hors-ligne (Miroir)

Valid XHTML 1.1!Valid CSS!

Copyright © 2009 Nicolas Stefaniuk. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Contacter le responsable de la rubrique Oracle