Optimiser le temps d'execution d'une requete avec plusieurs tables

Bonjour,

j'ai un soucis (qui est souvent récurrent à vrai dire), concernant l'optimisation du temps d'exécution des requêtes complexes car impliquant multi-jointures et tables.

J'ai une requête qui joint pas moins de 11 tables (et toutes sont nécessaires!)
Si je laisse tel que ma requête et mes jointures dans le code de ma procédure stockée, mon applicatif prend un certain temps à afficher les données.

1ère proposition : j'ai pensé alors mettre cette requête dans une vue et ainsi appeler la vue dans ma procédure stockée mais je ne sais pas si j'y gagnerai ou pas?

2ème proposition : mettre ma requête dans une vue, copier le contenu de la vue dans une table. Utiliser cette table dans ma procédure stockée. Et pour mettre a jour cette table, mettre en place une tache (si ça existe) qui copie le contenu de la vue dans la table (genre tous les jours ou 2X/jours). Et ainsi j'utilise cette table, au lieu de la requête, dans ma procédure stockée. Y gagnerai-je ou pas?

Y a t'il d'autres moyens plus efficace?

Merci de votre aide
:roll:

Votre seconde proposition existe "nativement" depuis SQL Server 2005 et s'appelle une vue indexée :
http://technet.microsoft.com/en-us/l.../cc917715.aspx

Tu devrais peut-être simplement étudier la possibilité de créer/changer certains index sur tes tables.

Sergejack, j'ai pensé effectivement à mettre certains index sur les tables, mais elles sont si volumineuses et nombreuses que je n'ai aucune idée sur l'efficacité que ça pourrait avoir.

Waldar, je ne connaissais pas cette possible! J'ai déjà créer des vues auparavant mais pas indexées. Comment "rajoute t'on" cette notion? Pour la création, je passe par l'IHM. Est ce possible par ce biais ou faut-il que j'intègre cette dimension à l'aide d'un script? Avez-vous un exemple?

Merci par avance ;)

Avant cela (création d'une vue indexée) commencez par poster intégralement :
1) la requête
2) la description sous forme DML de vos tables avec tous les index...

A +

Bonjour,
Concernant les indexes, je ne maitrise pas assez la chose pour en mettre en place, d'autant plus que je ne sais pas s'il en existe déjà...
C'est pour cela que la solution des vues indexes me parait "moins dangereuse" si ça peut répondre au problème de la même façon.

Je suis quasiment au bout mais je rencontre le soucis suivant :
Ma 1ère vue contient ces éléments suivants :

Code:

---

1 2 3 4 5 6 7

VIEW_EDITIONS ---------------- ID_EDITEURS ID_AUTEURS REFERENCES PUBLICATIONS

---

Ma 2ème vue contient :

Code:

---

1 2 3 4 5 6 7 8 9 10

VIEW_AUTEURS ---------------- ID_EDITEURS ID_AUTEURS EST_CLASSIQUE EST_HUMOURISTIQUE EST_POPULAIRE DETAILS DATE

---

Je souhaiterai faire une vue qui me permettrai de compléter la première avec 3 champs "flag":

Code:

---

1 2 3 4 5 6 7 8 9 10

VIEW_INTERMEDIAIRE --------------------- ID_EDITEURS ID_AUTEURS REFERENCES PUBLICATIONS EDITEUR_CLASSIQUE EDITEUR_HUMOURISTIQUE EDITEUR_POPULAIRE

---

Je pensais faire le traitement suivant mais je ne m'en sors pas!!
Dans la vue VIEW_AUTEURS on a effectivement les infos qui nous permettent de completer les 3 flag de VIEW_INTERMEDIAIRE, exemple :

Code:

---

1 2 3 4 5 6

ID_ED | ID_AUT | EST_CLASS |EST_HUM | EST_POP |DETAILS |DATE 1 1 1 0 0 xxxx 12/10/1980 1 2 0 1 0 xxxx 12/10/1990 1 3 1 0 0 xxxx 12/10/1995 1 3 1 1 0 xxxx 12/10/1995

---

On aurait donc dans la vue VIEW_INTERMEDIAIRE

Code:

---

1 2 3 4 5

ID_ED |ID_AUT|REF|EDITEUR_CLASS|EDITEUR_HUM|EDITEUR_POP 1 1 ## 1 0 0 1 2 ## 0 1 0 1 3 ## 1 1 0

---

Comment puis je faire?
j'ai essayé de passer par une fonction scalaire qui me remplirait donc mes flag du genre :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

ALTER FUNCTION [dbo].[FN_AUTEURS] (@ID_AUTEUR int) RETURNS int AS BEGIN DECLARE @ID_AUTEUR int SET @ID_AUTEUR = 0 Select @EDITEUR_CLASS = MAX(Case When (EST_CLASSIQUE = 0 or EST_CLASSIQUE = 'false' ) Then 0 Else 1 End) From VIEW_AUTEURS JOIN VIEW_EDITIONS ON VIEW_AUTEURS.ID_AUTEURS = VIEW_EDITIONS.ID_AUTEURS Where VIEW_AUTEURS.ID_AUTEURS =@ID_AUTEUR RETURN @EDITEUR_CLASS END

---

Mais bon ça ne fonctionne pas...:cry::cry::cry:
Je suis desèspérée...
HELPPPPPPPPPPPPPP!

Merci par avance!
++

Salut,

C'est quoi le "ID_EDITEURS" dans "VIEW_AUTEURS" ?

Pourquoi utiliser une fonction pour faire ça ?

Comment tu différencies les deux dernières lignes dans ton exemple de "VIEW_AUTEURS" ? (pour moi, la vue a décidément un sérieux problème de conception/cohérence)

Cette requête ne marche pas ?

Code:

---

1 2 3 4 5 6

select a.id_auteurs, max(e.editeur_classique) est_classique, max(e.editeur_humoriste) est_humoriste, max(e.editeur_populaire) est_populaire from view_auteurs a inner join view_editions e on e.id_auteurs = a.id_auteurs -- where a.id_auteur = @id_auteur group by a.id_auteur

---

=> Ensuite, tu peux rajouter une jointure sur VIEW_EDITIONS si t'as vraiment besoin de mélanger les informations, mais pour moi t'es en train de faire une belle potée auvergnate...


Sinon, ta fonction corrigée :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

ALTER FUNCTION [dbo].[FN_EST_CLASSIQUE] (@ID_AUTEUR int) RETURNS int AS BEGIN DECLARE @ID_AUTEUR_RES int SET @ID_AUTEUR_RES = 0 SELECT @ID_AUTEUR_RES = MAX(EDITEUR_CLASSIQUE) FROM VIEW_EDITIONS WHERE ID_AUTEURS =@ID_AUTEUR RETURN @ID_AUTEUR_RES END

---

Tout du moins, c'est ce que j'en comprends...

Plus simple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

ALTER FUNCTION [dbo].[FN_EST_CLASSIQUE] (@ID_AUTEUR int) RETURNS int AS BEGIN   RETURN COALESCE(SELECT MAX(EDITEUR_CLASSIQUE) FROM VIEW_EDITIONS WHERE ID_AUTEURS =@ID_AUTEUR), 0)   END

---

En définitive, et comme vous pouvez le constater il ne sert àrien de faire une telle fonction, car c'est juste un sous requête. Or en faisant une fonction vous vous interdisez l'utilisation des index, alors qu'avec une sous requête c'est possible !

A +

Moralité : vous pourriez créer une view.

Code:

---

1 2 3 4 5 6 7 8 9 10 11

CREATE VIEW dbo.vFN_EST_CLASSIQUE AS SELECT ISNULL(MAX(EDITEUR_CLASSIQUE) , 0) , VIEW_AUTEURS.ID_AUTEURS FROM VIEW_AUTEURS LEFT JOIN VIEW_EDITIONS ON ( VIEW_EDITIONS.ID_AUTEURS = VIEW_AUTEURS.ID_AUTEURS ) GROUP BY VIEW_AUTEURS.ID_AUTEURS

---

Bonsoir,

Merci pour vos réponses et votre précieuse aide. J'ai tout essayé :
- modification de la fonction d'après @StringBuilder et @SQLpro
- création de la vue à partir des éléments de @Sergejack

Malheureusement ça ne s'adapte pas à mon cas, étant donnée qu'il y a trop de tables, de jointures et de traitements-valeurs à remonter (les flags) qui sont très gourmandes en ressources :oops::oops:

De plus, je ne suis malheureusement pas assez calée en "indexation" pour les utiliser au mieux :oops: En revanche, si vous avez des liens, sites, docs d'info sur le sujet, je prends!

La solution que j'ai adopté et qui fonctionne à merveille est de passer par la création de 2 vues, de 2 tables et d'une procédure stockée, qui indexe les 2 tables à partir des 2 vues, que je lance de manière automatique par une tache planifiée. Mes temps de réponse sont très court, c'est hallucinant!

Merci infiniment pour vos réponses, j'ai pu expérimenter tout de même certaines choses que je ne connaissais pas jusqu'alors :ccool::ccool:

@bientôt 8-)

Le "Database Engine Tuning Advisor" est généralement de bon conseil pour les indexs lorsqu'il est employé en conjonction avec le "SQL Server Profiler" ;-)