quel sera le plus optimisé entre les deux manières d'exécuter ce query

Bonjour,
de manière mensuelle et au coup par coup si les règles sont modifiées en cours d'année j'ai une table de +/- 50millions de records a mettre a jour (l'update portant sur 10 millions de lignes).

l'update étant assez complexe j'ai tout regroupé dans une fonction.
A plusieurs endroits de cette fonction j'exécute le même query basique du style:

Code:

---

1 2 3

select champ1 into ma_var from ma_table where cle = parametre_in_de_ma_fonction

---

ce que je n'aime pas c'est que ce bout de code est répeté +/- 6 fois actuellement dans ma fonction et que cela risque d'augmenter et que c'est idiot.
Au niveau performance a ce que j'ai vu la compilation tranforme le query en sql dynamique car le select envoyé au moteur devient

Code:

---

1 2 3

select champ1 into ma_var from ma_table where cle = :1

---

et ca ca me plait déja bien.

par contre je me demandais si je risquais une perte de performance en le passant moi-même via un execute immediate, en réalité dans le cas présent ca ne va pas changer la face du monde, mais je commence a bien aimer comprendre les différences de ce genre de subtilité.

donc en gros y a t'il une différence entre faire ceci 6x

Code:

---

1 2 3

select champ1 into ma_var from ma_table where cle = parametre_in_de_ma_fonction

---

ou alors

Code:

---

1 2 3

qry:= 'select champ1 into ma_var from ma_table where cle = :1';

---

et faire 6 execute immediate?

(ca ressemble vraiment a une question d'enculeur de mouche mais je me suis réellement posé la question)

merci a vous

Si j'ai bien compris, la fonction te renvoie la valeur à mettre à jour.
Si tu fais un SELECT dans une fonction ce sera toujours plus rapide que si tu passe par de l'execute immediate qui fait un Hard Parse à chaque fois (pour vérifier que ta chaine de caractère est correcte).
Donc utilise le sql dynamique SEULEMENT pour du dynamique.

ok,
en fait j'avais l'idée (fausse) que avec la requete en string passée en execute immediate, elle était alors déja précompilée un peu comme dans un PreparedStatement java et que donc l'exécution globale étant plus rapide.
Comme quoi il faut parfois poser des bêtes questions :)

mais alors y a t'il un moyen de "factoriser" mes 6 requetes identiques, autrement que en recréant une sous-fonction?

merci encore

Pourquoi veux-tu les factoriser ?
Faire une sous fonction aura le même fonctionnement. La requete sera appellée 6 fois. Vu que tu as des paramètres, Oracle les BIND => la requete sera identique au niveau shared pool.

Donne le code de ta fonction, si tu veux on peut essayer de voir pour l'optimiser.

et bien en fait la raison c'est un peu comme ta citation: "More Code : More Bugs. Less Code : Less Bugs"

le code est assez basique pour cette partie, je dois tester sur un des parametres appelons le "code_prestation", et pour certains d'entre eux je dois aller rechercher le service associé "code_service" a un autre paramètre "centre_de_frais"

et donc ca ressemblerait a

Code:

---

1 2 3 4 5 6 7 8 9 10 11

case when code_prestation in (,,,,,,,,) then begin block1 end when code_prestation in (,,,,,,,,) then begin block2 end when code_prestation in (,,,,,,,,) then begin select code_service into variable_code_service from ma_table_de_centre_de_frais a where a.centre_de_frais = parametre_de_la_fonction_centre_de_frais; suite du traitement block3 end when code_prestation in (,,,,,,,,) then begin block4 end else null; end case

---

le code étant plus long que cela, donc niveau lisibilité j'y perd, et a la moindre modification je dois changer cela a différent endroit dans le programme.

merci

Si c'est juste au niveau lisibilité, tu fais une sous fonction.