Quelle est la différence entre les curseurs explicites et implicites dans Oracle?

Question

Quelle est la différence entre les curseurs explicites et implicites dans Oracle?

je suis un peu rouillé sur mon curseur lingo en PL/SQL. Quelqu'un sait ce?

25

oracle plsql

demandé sur Brian G 2008-09-16 20:06:52

15 réponses

score 37 · Answer 1

curseur implicite est créé automatiquement pour vous par Oracle lors de l'exécution d'une requête. Il est plus simple à coder, mais souffre de

inefficacité (la norme ANSI spécifie qu'il doit aller chercher deux fois pour vérifier s'il existe plus qu'un seul enregistrement)
vulnérabilité aux erreurs de données (si vous obtenez deux lignes, cela soulève une exception TOO_MANY_ROWS)

exemple

SELECT col INTO var FROM table WHERE something;

Un curseur explicite est celui que vous créez vous-même. Il faut plus de code, mais donne plus de contrôle - par exemple, vous pouvez simplement ouvrir-fetch-close si vous voulez seulement le premier enregistrement et ne vous souciez pas s'il y en a d'autres.

exemple

DECLARE   
  CURSOR cur IS SELECT col FROM table WHERE something; 
BEGIN
  OPEN cur;
  FETCH cur INTO var;
  CLOSE cur;
END;

score 16 · Answer 2

un curseur explicite est défini comme tel dans un bloc de déclaration:

DECLARE 
CURSOR cur IS 
  SELECT columns FROM table WHERE condition;
BEGIN
...

un curseur implicite est implanté directement dans un bloc de code:

...
BEGIN
   SELECT columns INTO variables FROM table where condition;
END;
...

score 4 · Answer 3

Un curseur explicite est celui que vous déclarez, comme:

CURSOR my_cursor IS
  SELECT table_name FROM USER_TABLES

un curseur implicite est un curseur créé pour supporter n'importe quel SQL en ligne que vous écrivez (statique ou dynamique).

score 4 · Answer 4

1.Curseur: lorsque PLSQL émet des énoncés sql, il crée une zone de travail privée pour analyser et exécuter la déclaration sql s'appelle curseur.

2.Implicite: Lorsqu'un bloc PL/SQLexecutable émet une déclaration sql. PL / SQL crée un curseur implicite et gère automatiquement les moyens implcit d'ouverture et de clôture. Il est utilisé lorsque l'instruction sql retourne une seule rangée.Il a 4 attributs SQL%ROWCOUNT, SQL % FOUND, SQL % NOTFOUND, SQL%ISOPEN.

3.Explicite: il est créé et géré par le programmeur. Il faut de tout temps explicite open,fetch et fermer. Il est utilisé lorsque la déclaration sql retourne plus d'une ligne. Il a également 4 attributs CUR_NAME%ROWCOUNT, CUR_NAME%FOUND, CUR_NAME%NOTFOUND, CUR_NAME%ISOPEN. Il traite plusieurs lignes en utilisant loop. Le programmeur peut passer le paramètre trop explicite curseur.

Exemple: Curseur Explicite

declare 
   cursor emp_cursor 
   is 
   select id,name,salary,dept_id 
   from employees; 
   v_id employees.id%type; 
   v_name employees.name%type; 
   v_salary employees.salary%type; 
   v_dept_id employees.dept_id%type; 
   begin 
   open emp_cursor; 
   loop 
   fetch emp_cursor into v_id,v_name,v_salary,v_dept_id; 
   exit when emp_cursor%notfound;
   dbms_output.put_line(v_id||', '||v_name||', '||v_salary||','||v_dept_id); 
   end loop;                    
   close emp_cursor; 
   end;

score 3 · Answer 5

de nos jours, les curseurs implicites sont plus efficaces que les curseurs explicites.

http://www.oracle.com/technology/oramag/oracle/04-sep/o54plsql.html

http://asktom.oracle.com/pls/asktom/f?p=100:11:0::::P11_QUESTION_ID:1205168148688

score 3 · Answer 6

En réponse à la première question. Directement de L'Oracle documentation

un curseur est un pointeur vers un SQL privé la zone qui stocke des informations sur traitement D'un SELECT ou D'un DML spécifique déclaration.

score 3 · Answer 7

Les curseurs implicites

nécessitent une mémoire tampon anonyme.

les curseurs explicites peuvent être exécutés encore et encore en utilisant leur nom.Ils sont stockés dans un espace mémoire défini par l'utilisateur plutôt que dans une mémoire tampon anonyme et sont donc facilement accessibles par la suite.

score 2 · Answer 8

avec des curseurs explicites, Vous avez le contrôle complet sur la façon d'accéder à l'information dans la base de données. Vous décidez quand ouvrir le curseur, quand récupérer les enregistrements à partir du curseur (et donc à partir de la table ou des tables dans la déclaration SELECT du curseur) combien d'enregistrements à récupérer, et quand fermer le curseur. Des informations sur l'état actuel de votre curseur sont disponibles en examinant les attributs du curseur.

voir http://www.unix.com.ua/orelly/oracle/prog2/ch06_03.htm pour plus de détails.

score 1 · Answer 9

Google est votre ami: http://docstore.mik.ua/orelly/oracle/prog2/ch06_03.htm

PL / SQL émet un curseur implicite chaque fois que vous exécutez une instruction SQL directement dans votre code, tant que la le code n'emploie pas de curseur. Il est appelé un "implicite" curseur parce que vous, le développeur, ne pas explicitement déclarer un curseur pour la déclaration SQL.

un curseur explicite est SÉLECTIONNEZ un énoncé explicitement défini dans la section déclaration de votre code, et, dans le processus, affectée d'un nom. Il n'y a pas une telle chose comme un curseur explicite pour mettre à jour, supprimer, et insérez les déclarations.

score 1 · Answer 10

un curseur est une fenêtre sélectionnée sur une table Oracle, ce qui signifie un groupe d'enregistrements présents dans une table Oracle, et satisfaisant à certaines conditions. Un curseur peut également sélectionner tout le contenu d'une table. Avec un curseur, vous pouvez manipuler les colonnes D'Oracle, en les alienant dans le résultat. Un exemple de curseur implicite est le suivant:

BEGIN
   DECLARE
      CURSOR C1
      IS
         SELECT DROPPED_CALLS FROM ALARM_UMTS;

      C1_REC   C1%ROWTYPE;
   BEGIN
      FOR C1_REC IN C1
      LOOP
         DBMS_OUTPUT.PUT_LINE ('DROPPED CALLS: ' || C1_REC.DROPPED_CALLS);
      END LOOP;
   END;
END;
/

With FOR ... BOUCLE... Boucle de fin vous ouvrez et fermez le curseur authomatically, quand les enregistrements du curseur ont été tous analysés.

un exemple de curseur explicite est le suivant:

BEGIN
   DECLARE
      CURSOR C1
      IS
         SELECT DROPPED_CALLS FROM ALARM_UMTS;

      C1_REC   C1%ROWTYPE;
   BEGIN
      OPEN c1;

      LOOP
         FETCH c1 INTO c1_rec;

         EXIT WHEN c1%NOTFOUND;

         DBMS_OUTPUT.PUT_LINE ('DROPPED CALLS: ' || C1_REC.DROPPED_CALLS);
      END LOOP;

      CLOSE c1;
   END;
END;
/

dans le curseur explicite, vous ouvrez et fermez le curseur de manière explicite, en vérifiant la présence des enregistrements et en indiquant une condition de sortie.

score 1 · Answer 11

le curseur implicite renvoie un seul enregistrement et est appelé automatiquement. Cependant, les curseurs explicites sont appelés manuellement et peuvent renvoyer plus d'un enregistrement.

score 1 · Answer 12

je sais que c'est une vieille question, mais je pense qu'il serait bon d'ajouter un exemple pratique pour montrer la différence entre les deux du point de vue de la performance.

du point de vue de la performance, les curseurs implicites sont plus rapides.

voyons la différence de performance entre les deux:

SQL> SET SERVEROUTPUT ON
SQL> DECLARE
  2    l_loops  NUMBER := 100000;
  3    l_dummy  dual.dummy%TYPE;
  4    l_start  NUMBER;
  5
  6    CURSOR c_dual IS
  7      SELECT dummy
  8      FROM   dual;
  9  BEGIN
 10    l_start := DBMS_UTILITY.get_time;
 11
 12    FOR i IN 1 .. l_loops LOOP
 13      OPEN  c_dual;
 14      FETCH c_dual
 15      INTO  l_dummy;
 16      CLOSE c_dual;
 17    END LOOP;
 18
 19    DBMS_OUTPUT.put_line('Explicit: ' ||
 20                         (DBMS_UTILITY.get_time - l_start) || ' hsecs');
 21
 22    l_start := DBMS_UTILITY.get_time;
 23
 24    FOR i IN 1 .. l_loops LOOP
 25      SELECT dummy
 26      INTO   l_dummy
 27      FROM   dual;
 28    END LOOP;
 29
 30    DBMS_OUTPUT.put_line('Implicit: ' ||
 31                         (DBMS_UTILITY.get_time - l_start) || ' hsecs');
 32  END;
 33  /
Explicit: 332 hsecs
Implicit: 176 hsecs

PL/SQL procedure successfully completed.

ainsi, une différence significative est clairement visible.

Plus d'exemples ici .

score 0 · Answer 13

chaque instruction SQL exécutée par la base de données Oracle a un curseur associé avec elle, qui est une zone de travail privée pour stocker des informations de traitement. Les curseurs implicites sont implicitement créés par le serveur Oracle pour toutes les instructions DML et SELECT.

vous pouvez déclarer et utiliser des curseurs explicites pour nommer la zone de travail privée, et accéder à ses informations stockées dans votre bloc de programme.

score 0 · Answer 14

comme il est indiqué dans d'autres réponses, les curseurs implicites sont plus faciles à utiliser et sont moins sujets aux erreurs.

et les curseurs implicites vs. explicites dans Oracle PL/SQL montrent que les curseurs implicites sont jusqu'à deux fois plus rapides que les curseurs explicites.

il est étrange que personne n'ait encore mentionné implicite pour curseur boucle :

begin
  for cur in (
    select t.id from parent_trx pt inner join trx t on pt.nested_id = t.id
    where t.started_at > sysdate - 31 and t.finished_at is null and t.extended_code is null
  )
  loop
    update trx set finished_at=sysdate, extended_code = -1 where id = cur.id;
    update parent_trx set result_code = -1 where nested_id = cur.id;
  end loop cur;
end;

un autre exemple sur SO: PL / SQL pour BOUCLE CURSEUR IMPLICITE .

c'est bien plus court que la forme explicite.

cela fournit également une bonne solution de contournement pour mise à jour de plusieurs tables de CTE .

score -2 · Answer 15

explicite...

curseur foo est select * from bla; commencer ouvrir la sortie fetch quand fermer le curseur yada yada yada

ne les utilisez pas, utilisez implicite

curseur foo est select * from bla;

pour n foo boucle x = n.some_column boucle d'extrémité

je pense que vous pouvez même le faire

pour n in (select * from bla) en boucle...

s'en tenir à implicites, ils se ferment, ils sont plus lisibles, ils rendent la vie facile.

Las etiquetas más populares

Quelle est la différence entre les curseurs explicites et implicites dans Oracle?

15 réponses