Explicit Cursor

An explicit cursor is used to process query statements, particularly when query results are multiple records.

Procedure

An explicit cursor performs the following six PL/SQL steps to process query statements:

Define a static cursor: Define a cursor name and its corresponding SELECT statement.
Figure 1 shows the syntax diagram for defining a static cursor.

Figure 1 static_cursor_define::=

or

Figure 2 static_cursor_define::=

Parameter description:
- cursor_name: defines a cursor name.
- parameter: cursor parameter, which can only be an input parameter. The default value can be defined by :=, =, or default. For details about the format, see Figure 3.
  Figure 3 Reference diagram for using the parameter format
- select_statement: specifies a query statement.
- The system automatically determines whether the cursor can be used for backward fetching based on the execution plan.
- In syntax, parameter can be an output parameter, but its behavior is the same as that of an input parameter.
Define a dynamic cursor: Define a ref cursor, which means that the cursor can be opened dynamically by a set of static SQL statements. Define the type of the ref cursor first, and then the cursor variable of this cursor type. Dynamically bind a SELECT statement through OPEN FOR when the cursor is opened.

Figure 4 and Figure 5 show the syntax diagrams for defining a dynamic cursor.

Figure 4 cursor_typename::=

GaussDB supports the dynamic cursor type sys_refcursor. A function or stored procedure can use the sys_refcursor parameter to pass on or pass out the cursor result set. A function can return sys_refcursor to return the cursor result set.

Figure 5 dynamic_cursor_define::=
Open the static cursor: Execute the SELECT statement corresponding to the cursor. The query result is placed in the workspace and the pointer directs to the head of the workspace to identify the cursor result set. If the cursor query statement carries the FOR UPDATE option, the OPEN statement locks the data rows corresponding to the cursor result set in the database table.
Figure 6 shows the syntax diagram for opening a static cursor.

Figure 6 open_static_cursor::=

Open the dynamic cursor: Use the OPEN FOR statement to open the dynamic cursor and the SQL statement is dynamically bound.

Figure 7 shows the syntax diagram for opening a dynamic cursor.

Figure 7 open_dynamic_cursor::=

A PL/SQL program cannot use the OPEN statement to repeatedly open a cursor.
Fetch cursor data: Retrieve data rows in the result set and place them in specified output variables.
Figure 8 shows the syntax diagram for fetching cursor data.

Figure 8 fetch_cursor::=
Process the record.
Continue to process until the active set has no record.
Close the cursor: After you fetch and process the data in the cursor result set, close the cursor in time to release system resources used by the cursor and invalidate the workspace of the cursor so that the FETCH statement cannot be used to fetch data anymore. A closed cursor can be reopened by an OPEN statement.
Figure 9 shows the syntax diagram for closing a cursor.

Figure 9 close_cursor::=

Attributes

Cursor attributes are used to control program procedures or learn about program status. When a DML statement is executed, the PL/SQL opens a built-in cursor and processes its result. A cursor is a memory segment for maintaining query results. It is opened when a DML statement is executed and closed when the execution is finished. An explicit cursor has the following attributes:

%FOUND: Boolean attribute, which returns TRUE if the last fetch returns a row.
%NOTFOUND: Boolean attribute, which returns TRUE if the last fetch fails to return a row.
%ISOPEN: Boolean attribute, which returns TRUE if the cursor has been opened.
%ROWCOUNT: numeric attribute, which returns the number of records fetched from the cursor.

Examples

DDL and DML statements are prepared. Subsequent examples in this section depend on this case.

gaussdb=# drop schema if exists hr cascade;
gaussdb=# create schema hr;
gaussdb=# set current_schema = hr;
gaussdb=# drop table if exists sections;
gaussdb=# drop table if exists staffs;
gaussdb=# drop table if exists department;
-- Create a department table.
gaussdb=# create table sections(
    section_name varchar(100),
    place_id     int,
    section_id   int
);
gaussdb=# insert into sections values ('hr',1,1);

-- Create an employee table.
gaussdb=# create table staffs(
    staff_id number(6),
    salary number(8,2),
    section_id int,
    first_name varchar(20)
);
gaussdb=# insert into staffs values (1,100,1,'Tom');

-- Create a department table.
gaussdb=# create table department(
    section_id int
);

    
     
       
       
         -- Specify the method for passing cursor parameters.
gaussdb=# CREATE OR REPLACE PROCEDURE cursor_proc1()
AS 
DECLARE
    DEPT_NAME VARCHAR(100);
    DEPT_LOC NUMBER(4);
    -- Define a cursor.
    CURSOR C1 IS 
        SELECT section_name, place_id FROM hr.sections WHERE section_id <= 50;
    CURSOR C2(sect_id INTEGER) IS
        SELECT section_name, place_id FROM hr.sections WHERE section_id <= sect_id;
    TYPE CURSOR_TYPE IS REF CURSOR;
    C3 CURSOR_TYPE;
    SQL_STR VARCHAR(100);
BEGIN
    OPEN C1;-- Open the cursor.
    LOOP
        -- Fetch data from the cursor.
        FETCH C1 INTO DEPT_NAME, DEPT_LOC;
        EXIT WHEN C1%NOTFOUND;
        DBE_OUTPUT.PRINT_LINE(DEPT_NAME||'---'||DEPT_LOC);
    END LOOP;
    CLOSE C1;-- Close the cursor.

    OPEN C2(10);
    LOOP
        FETCH C2 INTO DEPT_NAME, DEPT_LOC;
        EXIT WHEN C2%NOTFOUND;
        DBE_OUTPUT.PRINT_LINE(DEPT_NAME||'---'||DEPT_LOC);
    END LOOP;
    CLOSE C2;
    
    SQL_STR := 'SELECT section_name, place_id FROM hr.sections WHERE section_id <= :DEPT_NO;';
    OPEN C3 FOR SQL_STR USING 50;
    LOOP
        FETCH C3 INTO DEPT_NAME, DEPT_LOC;
        EXIT WHEN C3%NOTFOUND;
        DBE_OUTPUT.PRINT_LINE(DEPT_NAME||'---'||DEPT_LOC);
    END LOOP;
    CLOSE C3;
END;
/
gaussdb=# CALL cursor_proc1();

hr---1
hr---1
hr---1
 cursor_proc1 
--------------

(1 row)


gaussdb=# DROP PROCEDURE cursor_proc1;

        

      

    
   

    
     
       
       
         -- Give a salary raise to employees whose salary is lower than 3000 by adding 500.
gaussdb=# CREATE TABLE hr.staffs_t1 AS TABLE hr.staffs;

gaussdb=# CREATE OR REPLACE PROCEDURE cursor_proc2()
AS 
DECLARE
   V_EMPNO  NUMBER(6);
   V_SAL    NUMBER(8,2);
   CURSOR C IS SELECT staff_id, salary FROM hr.staffs_t1; 
BEGIN
   OPEN C;
   LOOP
      FETCH C INTO V_EMPNO, V_SAL;
      EXIT WHEN C%NOTFOUND; 
      IF V_SAL<=3000 THEN
            UPDATE hr.staffs_t1 SET salary =salary + 500 WHERE staff_id = V_EMPNO;
      END IF;
   END LOOP;
   CLOSE C;
END; 
/

gaussdb=# CALL cursor_proc2();
 cursor_proc2 
--------------

(1 row)

-- Delete the stored procedure.
gaussdb=# DROP PROCEDURE cursor_proc2;
gaussdb=# DROP TABLE hr.staffs_t1;

        

      

    
   

    
     
       
       
         -- Use function parameters of the SYS_REFCURSOR type.
gaussdb=# CREATE OR REPLACE PROCEDURE proc_sys_ref(O OUT SYS_REFCURSOR)
IS 
C1 SYS_REFCURSOR; 
BEGIN 
OPEN C1 FOR SELECT section_id FROM HR.sections ORDER BY section_id; 
O := C1; 
END; 
/

gaussdb=# DECLARE 
C1 SYS_REFCURSOR; 
TEMP NUMBER(4); 
BEGIN 
proc_sys_ref(C1); 
LOOP 
  FETCH C1 INTO TEMP; 
  DBE_OUTPUT.PRINT_LINE(C1%ROWCOUNT);
  EXIT WHEN C1%NOTFOUND; 
END LOOP;  
END; 
/
1
1
ANONYMOUS BLOCK EXECUTE
-- Delete the stored procedure.
gaussdb=# DROP PROCEDURE proc_sys_ref;

        

      

    
   