Oracle-cursor läuft durch das Letzte Element zweimal

Ich habe eine ein-cursor-Schleife, die das Gebäude von einer Zeichenfolge durch Verkettung der Inhalt einer Tabelle zusammen, mit code, die entlang dieser Linien:

OPEN cur_t;
LOOP
    FETCH cur_t INTO v_texttoadd;

    v_string := v_string || v_texttoadd;
EXIT WHEN cur_t%notfound;
END LOOP;

Das problem ist natürlich, dass das Letzte Element, das Hinzugefügt wird, zweimal, weil das system läuft noch einmal durch bevor Sie feststellen, dass es nichts mehr zu finden.

Habe ich versucht, das Spiel mit so etwas wie 

OPEN cur_t;
WHILE cur_t%found;
LOOP
    FETCH cur_t INTO v_texttoadd;

    v_string := v_string || v_texttoadd;
END LOOP;

Aber das schien nicht zu etwas zurückkehren an alle.

Welche syntax muss ich verwenden, so dass jede Zeile nur angezeigt wird, in die resultierende Zeichenfolge einmal?

InformationsquelleAutor Margaret | 2009-05-22
  1. 24

    Können Sie versuchen, diese:

    OPEN cur_t;
LOOP
  FETCH cur_t INTO v_texttoadd;
  EXIT WHEN cur_t%notfound;
  v_string := v_string || v_texttoadd;
END LOOP;

    Dies funktioniert, da das %notfound ist gesetzt, wenn die FETCH ausgeführt wird, und es gibt keine weiteren Zeilen mehr zu Holen. In Ihrem Beispiel haben Sie überprüft, %notfound nach der Verkettung und als ein Ergebnis, Sie hatte das doppelte am Ende.

    • Funktionierte nicht für meine. Haben Sie einen Blick auf meine Antwort, wenn Sie sich interessieren.
    • Danke, Petros...
    • Schön. In meinem Fall, ist der cursor noch geöffnet war und es hielt Iteration über die letzten Artikel, nie endend.
    InformationsquelleAutor Petros
  2. 3

    Richtigen Antworten wurden bereits gegeben, aber gerade die Ausarbeitung ein bisschen.

    Simulation Ihrer aktuellen situation:

    SQL> declare
  2    cursor cur_t
  3    is
  4    select ename
  5      from emp
  6     where deptno = 10
  7    ;
  8    v_texttoadd emp.ename%type;
  9    v_string    varchar2(100);
 10  begin
 11    open cur_t;
 12    loop
 13      fetch cur_t into v_texttoadd;
 14      v_string := v_string || v_texttoadd;
 15      exit when cur_t%notfound;
 16    end loop
 17    ;
 18    dbms_output.put_line(v_string);
 19  end;
 20  /
CLARKKINGMILLERMILLER

PL/SQL-procedure is geslaagd.

    Hier MILLER ist zweimal gedruckt. Nur durch Umschalten der EXIT-Anweisung und die v_string Zuordnung, Sie erhalten das gewünschte Ergebnis:

    SQL> declare
  2    cursor cur_t
  3    is
  4    select ename
  5      from emp
  6     where deptno = 10
  7    ;
  8    v_texttoadd emp.ename%type;
  9    v_string    varchar2(100);
 10  begin
 11    open cur_t;
 12    loop
 13      fetch cur_t into v_texttoadd;
 14      exit when cur_t%notfound;
 15      v_string := v_string || v_texttoadd;
 16    end loop
 17    ;
 18    dbms_output.put_line(v_string);
 19  end;
 20  /
CLARKKINGMILLER

PL/SQL-procedure is geslaagd.

    Jedoch, Ihre PL/SQL-code wird leichter, wenn die Verwendung einer cursor-for-Schleife. Sie können dann überspringen Sie die v_texttoadd variable und die Anzahl der Zeilen in der loop lässt:

    SQL> declare
  2    cursor cur_t
  3    is
  4    select ename
  5      from emp
  6     where deptno = 10
  7    ;
  8    v_string    varchar2(100);
  9  begin
 10    for r in cur_t
 11    loop
 12      v_string := v_string || r.ename;
 13    end loop
 14    ;
 15    dbms_output.put_line(v_string);
 16  end;
 17  /
CLARKKINGMILLER

PL/SQL-procedure is geslaagd.

    Können Sie auch direkt SQL um den Auftrag zu erfüllen. Ein Beispiel mit der SQL model Klausel, wenn Sie auf version 10g oder höher:

    SQL> select string
  2    from ( select string
  3                , rn
  4             from emp
  5            where deptno = 10
  6            model
  7                  dimension by (rownum rn)
  8                  measures (ename, cast(null as varchar2(100)) string)
  9                  ( string[any] order by rn desc = ename[cv()] || string[cv()+1]
 10                  )
 11         )
 12   where rn = 1
 13  /

STRING
-----------------------------------------------------------------------------------
CLARKKINGMILLER

1 rij is geselecteerd.

    Grüße,
    Rob.

    • +1 für die FOR .. IN ... LOOP-Anregungen und Beispiele. Cursor-FOR-Schleifen sind deine Freunde 😉 zusätzlicher bonus: Sie können oft das einbetten der cursor select-Anweisung in der FOR-Schleife: FOR Rec IN (SELECT...) - SCHLEIFE
    InformationsquelleAutor Rob van Wijk
  3. 2

    %notfound ist gesetzt, wenn die fetch fehlschlägt zum abrufen einer neuen Zeile.

    weitere Möglichkeit (das vermeidet die "wenn"s und "exit wenn"s):

    OPEN cur_t;
FETCH cur_t INTO v_texttoadd;
WHILE cur_t%found LOOP
    v_string := v_string || v_texttoadd;
    FETCH cur_t INTO v_texttoadd;
END LOOP;
    • Ich fürchte, dies ist die nur richtige Antwort hier!
    InformationsquelleAutor Erich Kitzmueller
  4. 0

    Einfache Antwort, auch wenn Sie möglicherweise nicht die beste:

    OPEN cur_t;
LOOP
    FETCH cur_t INTO v_texttoadd;
    IF cur_t%found THEN
        v_string := v_string || v_texttoadd;
    END IF;
EXIT WHEN cur_t%notfound;
END LOOP;
    • Ich denke, basierend auf Ihrem Einrücken, Sie sind unter der Annahme, dass die EXIT-Anweisung ist Teil der LOOP-syntax und müssen am Ende der Schleife. Dies ist nicht true; EXIT ist nur eine Feststellung wie jede andere im Körper der Schleife. Dies ist der Grund, warum, wie andere gezeigt haben, können Sie es sofort nach dem HOLEN um Ihr Problem zu lösen.
    • Funktionierte nicht für meine. Haben Sie einen Blick auf meine Antwort, wenn Sie sich interessieren.
    InformationsquelleAutor Margaret
  5. 0

    Ich habe viele cursor-basierte Lösungen in Microsoft SQL, das immer perfekt funktioniert (die Guten alten Tage! Ich möchte meinen SQL Server wieder so viel!) aber alle Antworten auf diese Frage erwies sich als falsch für mich, die Letzte Zeile des Cursors wird IMMER zweimal ausgeführt, egal wie eng ich folgte die Methode, die von Ihnen vorgeschlagen.

    Vergessen Sie das nicht -, während loop und vergessen exit ist das, was Sie tun MÜSSEN, um zu vermeiden, doppelte Ausführung (ziemlich viel, was Sie tun, in T-SQL auch!).

      cursor c_mm is select a, b, c, d from mytable;

  begin
    open c_mm;
    fetch c_mm into a, b, c, d;
    while (not c_mm%notfound) loop 
        -- do what you have to do here

        fetch c_mm into a, b, c, d;
    end loop;
    close c_mm;
  end;

    Was ich wirklich nicht verstehe, ist, warum alle Oracle knowledge base-Artikel und Foren-Beiträge (und stackoverflow) fördert diese exit-in-a-loop-Lösung, die ist natürlich falsch!

    InformationsquelleAutor mshthn
Schreibe einen Kommentar