Jaka jest różnica między kursorami jawnymi a domyślnymi w Oracle?

Jawny kursor jest zdefiniowany jako taki w bloku deklaracji:

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

Ukryty kursor jest wstawiany bezpośrednio do bloku kodu:

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

Jawny kursor to taki, który deklarujesz, jak:

CURSOR my_cursor IS
  SELECT table_name FROM USER_TABLES

Ukryty kursor to kursor stworzony do obsługi dowolnego pisanego w wierszu SQL (statycznego lub dynamicznego).

1.Kursor: gdy PLSQL wydaje polecenia sql, tworzy prywatny obszar roboczy aby przetworzyć i wykonać polecenie SQL nazywa się kursorem.

2.IMPLICIT: gdy dowolny blok PL / SQLexecutable wydaje polecenie sql. PL / SQL tworzy Ukryty kursor i zarządza automatycznie oznacza implcit open & close ma miejsce. Używany przy zwracaniu polecenia sql tylko jeden row.It posiada 4 atrybuty SQL%ROWCOUNT, znaleziono SQL%, SQL % NOTFOUND, SQL % ISOPEN.

3.EXPLICIT: jest tworzony i zarządzany przez programista. Potrzebuje każdego czas jawny otwórz, Pobierz i zamknij. Jest używany, gdy polecenie sql zwraca więcej niż jeden wiersz. Posiada również 4 atrybuty CUR_NAME % ROWCOUNT,CUR_NAME % FOUND,CUR_NAME % NOTFOUND, CUR_NAME % ISOPEN. Przetwarza kilka wierszy za pomocą pętli. Programista może również przekazać parametr do jawnego kursora.

• Przykład: Explicit Cursor

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;

Te dni Ukryte kursory są bardziej wydajne niż jawne Kursory.

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

W odpowiedzi na pierwsze pytanie. Prosto z wyroczni Dokumentacja

Kursor jest wskaźnikiem do prywatnego SQL obszar, który przechowuje informacje o przetwarzanie określonego SELECT lub DML oświadczenie.

Ukryte Kursory wymagają anonimowej pamięci bufora.

Jawne Kursory mogą być wykonywane wielokrotnie, używając ich nazwy.Są one przechowywane w przestrzeni pamięci zdefiniowanej przez użytkownika, a nie są przechowywane w anonimowej pamięci buforowej, a zatem mogą być łatwo dostępne później.

Z jawnymi kursorami masz pełną kontrolę nad dostępem do informacji w bazie danych. Ty decydujesz, kiedy otworzyć kursor, kiedy pobrać rekordy z kursora (a więc z tabeli lub tabel w instrukcji SELECT kursora), ile rekordów pobrać i kiedy zamknąć kursor. Informacje o aktualnym stanie kursora są dostępne poprzez sprawdzenie atrybutów kursora.

Zobacz http://www.unix.com.ua/orelly/oracle/prog2/ch06_03.htm Po szczegóły.

Google to twój przyjaciel: http://docstore.mik.ua/orelly/oracle/prog2/ch06_03.htm

PL / SQL wyświetla Ukryty kursor za każdym razem, gdy wykonujesz polecenie SQL bezpośrednio w Twoim kodzie, o ile to kod nie wykorzystuje jawnego kursor. Nazywa się to " implicit" kursor, bo ty, deweloper, robisz nie deklaruje jawnie kursora dla polecenie SQL.

Jawny kursor to SELECT oświadczenie, które jest wyraźnie zdefiniowane w sekcja deklaracji twojego kod i, w procesie, przypisany a nazwisko. Nie ma czegoś takiego jak jawny kursor do aktualizacji, usuwania, i wstawić Oświadczenia.

Kursor jest wybranym oknem w tabeli Oracle, oznacza to grupę rekordów obecnych w tabeli Oracle i spełniających określone warunki. Kursor może również zaznaczyć całą zawartość tabeli. Za pomocą kursora można manipulować kolumnami Oracle, aliasując je w wyniku. Przykład ukrytego kursora jest następujący:

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;
/

Z FOR ... Pętla... Pętla końcowa otwierasz i zamykasz kursor automatycznie, gdy wszystkie rekordy kursora zostały przeanalizowane.

An przykład jawnego kursora jest następujący:

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;
/

W jawnym kursorze otwierasz i zamykasz kursor w jawny sposób, sprawdzając obecność rekordów i określając warunek zakończenia.

Ukryty kursor zwraca tylko jeden rekord i jest wywoływany automatycznie. Jednak jawne kursory są wywoływane ręcznie i mogą zwracać więcej niż jeden rekord.

Wiem, że to stare pytanie, ale myślę, że dobrze byłoby dodać praktyczny przykład, aby pokazać różnicę między nimi z punktu widzenia wydajności.

Z punktu widzenia wydajności Ukryte kursory są szybsze.

Zobaczmy różnicę wydajności między tymi dwoma:

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.

Więc znacząca różnica jest wyraźnie widoczna.

Więcej przykładów tutaj .

Każde polecenie SQL wykonywane przez bazę danych Oracle ma powiązany z nim kursor, który jest prywatnym obszarem roboczym do przechowywania informacji przetwarzanych. Domyślne kursory są domyślnie tworzone przez serwer Oracle dla wszystkich instrukcji DML i SELECT.

Możesz zadeklarować i użyć jawnych kursorów, aby nazwać prywatny obszar roboczy i uzyskać dostęp do jego przechowywanych informacji w bloku programu.

Jak stwierdzono w innych odpowiedziach, Ukryte kursory są łatwiejsze w użyciu i mniej podatne na błędy.

I Kursory jawne w Oracle PL/SQL pokazują, że Kursory jawne są do dwóch razy szybsze od jawnych.

To dziwne, że nikt jeszcze nie wspomniał Implicit dla Loop Cursor :

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;

Kolejny przykład NA SO: PL / SQL dla loop IMPLICIT CURSOR .

To także zapewnia dobre obejście dla aktualizacji wielu tabel z CTE .

Explicit...

Kursor foo to select * from blah; begin otwórz fetch exit po zamknięciu kursora yada yada Yada

Nie używaj ich, użyj implicit

Kursor foo to select * from bla;

Dla n W pętli foo x = n. some_column end loop

Myślę, że możesz nawet to zrobić

For n in (select * from bla) loop...

Trzymać się dorozumianych, zamykają się, są bardziej czytelne, ułatwiają życie.