Différence entre FETCH / FOR pour boucler un CURSOR en PL / SQL

Je sais que l'extraction d'un curseur va me donner l'accès à des variables comme l' %ROWCOUNT, %ROWTYPE, %TROUVÉ, %NOTFOUND, %ISOPEN

...mais je me demandais si il y a d'autres raisons d'utiliser

Open - Fetch - Fermer les instructions de la boucle d'un curseur

plutôt que

Boucle le curseur avec un POUR le cycle... (À mon avis c'est mieux becase il est simple)

Qu'en pensez-vous?

source d'informationauteur Jimmy

27

À partir d'un point de vue des performances, la différence est beaucoup plus compliqué que le Tim Hall astuce que OMG Poneys lié à impliquerait. Je crois que cette astuce est une introduction à une section plus grande qui a été extrait pour le web-je attendre que Tim s'est rendu à rendre la plupart, si pas tous ces points dans le livre. En outre, toute la discussion dépend de l'Oracle de la version que vous utilisez. Je crois que c'est correct pour la version 10.2, 11.1 et 11.2, mais il y a certainement des différences si vous commencez à revenir à des versions plus anciennes.

L'exemple particulier de la pointe, tout d'abord, est plutôt irréaliste. Je n'ai jamais vu quelqu'un de code d'une seule ligne d'extraction à l'aide d'un curseur explicite plutôt qu'un SELECT INTO. Donc, le fait que SÉLECTIONNER DANS est plus efficace est d'une grande importance pratique. Si nous discutons de la boucle, la performance qui nous intéresse est la façon dont elle est chère pour récupérer le nombre de lignes. Et c'est là que la complexité commence à venir.

Oracle a introduit la possibilité de faire un VRAC de RECUEILLIR des données à partir d'un curseur en PL/SQL de la collection dans la version 10.1. C'est une façon beaucoup plus efficace pour obtenir des données à partir du moteur SQL PL/SQL de la collection, car il vous permet de minimiser le contexte de changements par l'extraction de plusieurs lignes à la fois. Et les opérations ultérieures de ces collections sont plus efficaces parce que votre code peut rester dans le PL/SQL du moteur.

Afin de profiter au maximum de la masse de RECUEILLIR la syntaxe, même si, en général, vous devez utiliser des curseurs parce que de cette façon, vous pouvez remplir un PL/SQL de la collection, puis par la suite utiliser le POURTOUT de la syntaxe pour écrire les données dans la base de données (sur l'hypothèse raisonnable que si vous êtes aller chercher un paquet de données dans un curseur, il y a une forte probabilité que vous faites une sorte de manipulation et de sauver les manipuler des données quelque part). Si vous utilisez un curseur implicite dans une boucle FOR, comme OMG Poneys à juste titre, Oracle va faire un bloc de RECUEILLIR les coulisses de faire de la récupération de données moins coûteux. Mais votre code sera fait plus lent, ligne par ligne les insertions et mises à jour, car les données ne sont pas dans une collection. Explicite les curseurs offre également la possibilité de définir la LIMITE explicitement ce qui peut améliorer les performances sur la valeur par défaut de 100 pour un curseur implicite dans une boucle FOR.

En général, en supposant que vous êtes sur 10.2 ou plus et que votre code est celui de l'extraction de données et de l'écrire à la base de données,

Plus rapide
1. Explicite les curseurs de faire un bloc de RECUEILLIR dans une collection locale (avec une LIMITE appropriée) et à l'aide de POURTOUT à écrire de nouveau à la base de données.
2. Implicite des curseurs de faire un bloc de COLLECTER pour vous les coulisses de long avec une ligne unique écrit sur le datbase.
3. Explicite les curseurs qui n'en font pas un bloc de RECUEILLIR et de ne pas profiter de PL/SQL collections.
Plus lent

Sur l'autre main, à l'aide de curseurs implicites vous obtient un peu de l'avantage de l'utilisation des opérations en bloc pour très peu de coût initial de refactoring de code ancien, de l'apprentissage ou de la nouvelle fonctionnalité. Si la plupart de vos PL/SQL développement est fait par les développeurs dont la langue maternelle est autre chose, ou qui n'ont pas nécessairement suivre les nouvelles fonctionnalités de la langue, POUR les boucles sont va être plus facile à comprendre et à maintenir qu'explicite curseur code qui utilise toutes les nouvelles en VRAC de RECUEILLIR des fonctionnalités. Et quand Oracle a introduit de nouvelles optimisations dans l'avenir, il est beaucoup plus probable que le curseur implicite code bénéficiez automatiquement alors que le code explicite peut nécessiter un traitement manuel pour la reprise du travail.

Bien sûr, par le temps que vous êtes de résolution des problèmes de performance au point où vous vous souciez vraiment de la façon dont beaucoup plus rapidement les différentes variantes de votre code de boucle peut-être, vous êtes au point où vous voulez à considérer le déplacement de plus logique en pur SQL et amerrissage forcé le code de boucle entièrement.
7

L'OUVERTURE /CHERCHER /de clôture est appelé explicite curseur de la syntaxe; le dernier est appelé curseur implicite de la syntaxe.

Une différence clé que vous avez déjà remarqué, c'est que vous ne pouvez pas utiliser %TROUVÉ/%NOTFOUND/etc implicite curseurs... une Autre chose à prendre en compte est qu'implicite curseurs sont plus rapides qu'explicite-ils de lecture à l'avance (~100 enregistrements?) en plus de ne pas soutenir de manière explicite de la logique.

Informations supplémentaires:
- Implicite vs Explicite Curseurs
3

Je ne sais pas à propos des différences cruciales dans ce deux réalisations d'ailleurs l'une: for ... loop implicitement ferme le curseur à la fin de la boucle est fini et si open ... fetch ... close syntaxe préfère fermer le curseur de vous-même (juste une bonne manière) - la pensée ce n'est pas une nécessité: Oracle va fermer le curseur automatiquement sortant de la visibilité de la portée. Aussi, vous ne pouvez pas utiliser %FOUND et %NOTFOUND dans for ... loop curseurs.

Comme pour moi, je trouve le for ... loop réalisation beaucoup plus facile à lire et de soutien.
3

Corrigez-moi si je me trompe, mais je pense que les deux ont une bonne fonction de ce que l'autre n'ont pas.

Avec la boucle for, vous pouvez faire comme ceci:
```
for i in (select * from dual)
  dbms_output.put_line('ffffuuu');
end loop;
```
Et à ouvrir ... fetch vous pouvez le faire comme ceci:
```
declare
  cur sys_refcursor;
  tmp dual.dummy%type;
begin
  open cur for 'select dummy from dual';
  loop
    fetch cur into tmp;
    exit when cur%notfound;
    dbms_output.put_line('ffffuuu');
  end loop;
  close cur;
end;
```
Donc, avec l'ouvrir récupérer, vous pouvez utiliser les curseurs dynamiques mais avec la boucle for, vous pouvez définir curseur normal sans déclaration.

Vous devez vous connecter pour publier un commentaire.