Discussion :

[Zombiman]

BOnjour,

J'ai une requete sql qui ressemble à ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
select distinct(local.id_local) from local,parcelle,compte_proprietaire,compte,compte_parcelle,proprietaire 
where parcelle.id_parcelle=local.id_parcelle
and compte_proprietaire.id_compte= compte.id_compte
and compte_parcelle.id_compte= compte.id_compte
and compte_parcelle.id_parcelle= parcelle.id_parcelle
and proprietaire.id_proprietaire= compte_proprietaire.id_proprietaire
and local.co_nature_local like 'AP'
and local.co_nature_occupation like 'V'

J'aimerai l'optimiser, car si je me souviens bien en utilisant des JOIN on gagne en temps d’exécution, et se serait génial pour moi car j'ai plus de 7000 parcelles à traiter.

Cette requête n'est qu'une partie de tout mon traitement, mais il me suffi d'un seul modèle d'optimisation pour le reproduire sur tout mon traitement.

Je fait appel à la communauté car les clause JOIN ne sont pas ma tasse de thé, je sais comment les construire mais j'aimerai bien avoir quelques pistes, ou encore mieux des autres idées d'optimisation !!

J'ai recherché dans votre forum des cas utilisant des clauses JOIN mais je n'arrive pas à faire le rapprochement avec mon cas ! J'espère que je ne pollue pas le forum avec ma demande
J'espère aussi que mes explication sont claires, si ce n'est pas le cas, n'hésitez pas à me le faire remarquer !


Cordialement et en vous remerciant d'avance .

[Zombiman]

donc j'ai commencé

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
select distinct(local.id_local) from local
JOIN parcelle 
ON local.id_parcelle = parcelle.id_parcelle

mais le soucis c'est que pour le join suivant je fait appel a une nouvelle table "local
donc je ne peut pas faire ce genre de jointure

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
select distinct(local.id_local) from local
JOIN parcelle 
ON local.id_parcelle = parcelle.id_parcelle
JOIN compte_proprietaire
ON  compte.id_compte = compte_proprietaire.id_compte

Je ne reprend pas la table parcelle mais compte....

ALors ma nouvelle question est, est-il judicieux de faire plusieurs select ou alors je reste sur ma clause where avec des and ? je ne sais pas ce qui est le plus rapide en temps d’exécution

[lola06]

Je ne reprend pas la table parcelle mais compte....

Sans prendre en compte la partie optimisation de la requête, ta requête est faisable avec les JOIN, il suffit de mettre les tables dans la bonne logique.

Sinon pour l'optimisation, le fait d'utiliser LIKE à la place de = ne doit pas forcément être très bon.

Peux-tu nous mettre ton plan d'exécution ?

[Rei Ichido]

Est-il bien nécessaire de faire des jointures à tour de bras quand on veut seulement s'assurer de l'existence des jointures - vu qu'au final on ne prend qu'un id qui doit être la clé primaire, avec un DISTINCT ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
SELECT id_local 
 FROM LOCAL L
WHERE EXISTS ( SELECT 1
                FROM parcelle p
                  INNER JOIN compte_parcelle cpar 
                       ON cpar.id_parcelle= p.id_parcelle
                  INNER JOIN compte c
                       ON c.id_compte = cp.id_compte
                  INNER JOIN compte_proprietaire cpro
                       ON cpro.id_compte = c.id_compte
                  INNER JOIN proprietaire p
                       ON p.id_proprietaire = cpro.id_proprietaire
                 WHERE proprietaire parcelle.id_parcelle=L.id_parcelle
                )
AND L.co_nature_local LIKE 'AP'
AND L.co_nature_occupation LIKE 'V'

[Pomalaix]

...si je me souviens bien en utilisant des JOIN on gagne en temps d’exécution...

Ce n'est pas comme ça qu'il faut prendre le problème.
Mais :
- ma requête prend actuellement x secondes
- voici son plan d'exécution
- comment puis-je l'améliorer, j'aimerais descendre à y secondes

[Zombiman]

D'accord, je vais réflechir à tout ça !

[ojo77]

Ce n'est pas comme ça qu'il faut prendre le problème.

C'est surtout faux ... Lors de sa phase de réécriture, Oracle transforme les syntaxes de type JOIN en jointures "classiques".