zoukankan html css js c++ java

plsql游标

本篇主要内容如下：

4.1 游标概念

4.1.1 处理显式游标

4.1.2 处理隐式游标

4.1.3 关于 NO_DATA_FOUND 和 %NOTFOUND的区别

4.1.4 使用游标更新和删除数据

4.2 游标变量

4.2.1 声明游标变量

4.2.2 游标变量操作

游标的使用

在 PL/SQL 程序中，对于处理多行记录的事务经常使用游标来实现。

4.1 游标概念

在PL/SQL块中执行SELECT、INSERT、DELETE和UPDATE语句时，ORACLE会在内存中为其分配上下文区（Context Area），即缓冲区。游标是指向该区的一个指针，或是命名一个工作区（Work Area），或是一种结构化数据类型。它为应用等量齐观提供了一种对具有多行数据查询结果集中的每一行数据分别进行单独处理的方法，是设计嵌入式SQL语句的应用程序的常用编程方式。

在每个用户会话中，可以同时打开多个游标，其数量由数据库初始化参数文件中的OPEN_CURSORS参数定义。

对于不同的SQL语句，游标的使用情况不同：

SQL语句	游标
非查询语句	隐式的
结果是单行的查询语句	隐式的或显示的
结果是多行的查询语句	显示的

4.1.1 处理显式游标

1. 显式游标处理

显式游标处理需四个 PL/SQL步骤:

l 定义/声明游标：就是定义一个游标名，以及与其相对应的SELECT 语句。

格式：

    CURSOR cursor_name[(parameter[, parameter]…)]
           [RETURN datatype]
    IS
        select_statement;

游标参数只能为输入参数，其格式为：

parameter_name [IN] datatype [{:= | DEFAULT} expression]

在指定数据类型时，不能使用长度约束。如NUMBER(4),CHAR(10) 等都是错误的。

[RETURN datatype]是可选的，表示游标返回数据的数据。如果选择，则应该严格与select_statement中的选择列表在次序和数据类型上匹配。一般是记录数据类型或带“%ROWTYPE”的数据。

l 打开游标：就是执行游标所对应的SELECT 语句，将其查询结果放入工作区，并且指针指向工作区的首部，标识游标结果集合。如果游标查询语句中带有FOR UPDATE选项，OPEN 语句还将锁定数据库表中游标结果集合对应的数据行。

格式：

OPEN cursor_name[([parameter =>] value[, [parameter =>] value]…)];

在向游标传递参数时，可以使用与函数参数相同的传值方法，即位置表示法和名称表示法。PL/SQL 程序不能用OPEN 语句重复打开一个游标。

l 提取游标数据：就是检索结果集合中的数据行，放入指定的输出变量中。

格式：

FETCH cursor_name INTO {variable_list | record_variable };

执行FETCH语句时，每次返回一个数据行，然后自动将游标移动指向下一个数据行。当检索到最后一行数据时，如果再次执行FETCH语句，将操作失败，并将游标属性%NOTFOUND置为TRUE。所以每次执行完FETCH语句后，检查游标属性%NOTFOUND就可以判断FETCH语句是否执行成功并返回一个数据行，以便确定是否给对应的变量赋了值。

l 对该记录进行处理；

l 继续处理，直到活动集合中没有记录；

l 关闭游标：当提取和处理完游标结果集合数据后，应及时关闭游标，以释放该游标所占用的系统资源，并使该游标的工作区变成无效，不能再使用FETCH 语句取其中数据。关闭后的游标可以使用OPEN 语句重新打开。

格式：

CLOSE cursor_name;

注：定义的游标不能有INTO 子句。

例1. 查询前10名员工的信息。

DECLARE
   CURSOR c_cursor
   IS SELECT first_name || last_name, Salary
   FROM EMPLOYEES
   WHERE rownum<11;
   v_ename  EMPLOYEES.first_name%TYPE;
   v_sal    EMPLOYEES.Salary%TYPE;
BEGIN
  OPEN c_cursor;
  FETCH c_cursor INTO v_ename, v_sal;
  WHILE c_cursor%FOUND LOOP
     DBMS_OUTPUT.PUT_LINE(v_ename||'---'||to_char(v_sal) );
     FETCH c_cursor INTO v_ename, v_sal;
  END LOOP;
  CLOSE c_cursor;
END;

例2. 游标参数的传递方法。

DECLARE

  DeptRec    DEPARTMENTS%ROWTYPE;
  Dept_name  DEPARTMENTS.DEPARTMENT_NAME%TYPE;
  Dept_loc   DEPARTMENTS.LOCATION_ID%TYPE;
  CURSOR c1 IS
  SELECT DEPARTMENT_NAME, LOCATION_ID FROM DEPARTMENTS
  WHERE DEPARTMENT_ID <= 30;

  CURSOR c2(dept_no NUMBER DEFAULT 10) IS
    SELECT DEPARTMENT_NAME, LOCATION_ID FROM DEPARTMENTS
    WHERE DEPARTMENT_ID <= dept_no;
  CURSOR c3(dept_no NUMBER DEFAULT 10) IS
    SELECT * FROM DEPARTMENTS
    WHERE DEPARTMENTS.DEPARTMENT_ID <=dept_no;
BEGIN
  OPEN c1;
  LOOP
    FETCH c1 INTO dept_name, dept_loc;
    EXIT WHEN c1%NOTFOUND;
        DBMS_OUTPUT.PUT_LINE(dept_name||'---'||dept_loc);
    END LOOP;
    CLOSE c1;

    OPEN c2;
    LOOP
        FETCH c2 INTO dept_name, dept_loc;
        EXIT WHEN c2%NOTFOUND;
        DBMS_OUTPUT.PUT_LINE(dept_name||'---'||dept_loc);
    END LOOP;
    CLOSE c2;

    OPEN c3(dept_no =>20);
    LOOP
        FETCH c3 INTO deptrec;
        EXIT WHEN c3%NOTFOUND;
        DBMS_OUTPUT.PUT_LINE(deptrec.DEPARTMENT_ID||'---'||deptrec.DEPARTMENT_NAME||'---'||deptrec.LOCATION_ID);
    END LOOP;
    CLOSE c3;
END;

2.游标属性

Cursor_name%FOUND 布尔型属性，当最近一次提取游标操作FETCH成功则为 TRUE,否则为FALSE；

Cursor_name%NOTFOUND 布尔型属性，与%FOUND相反；

Cursor_name%ISOPEN 布尔型属性，当游标已打开时返回 TRUE；

Cursor_name%ROWCOUNT 数字型属性，返回已从游标中读取的记录数。

例3：给工资低于1200 的员工增加工资50。

DECLARE

   v_empno  EMPLOYEES.EMPLOYEE_ID%TYPE;
   v_sal      EMPLOYEES.Salary%TYPE;
   CURSOR c_cursor IS SELECT EMPLOYEE_ID, Salary FROM EMPLOYEES;
BEGIN
   OPEN c_cursor;
   LOOP
      FETCH c_cursor INTO v_empno, v_sal;
      EXIT WHEN c_cursor%NOTFOUND;
      IF v_sal<=1200 THEN
            UPDATE EMPLOYEES SET Salary=Salary+50 WHERE EMPLOYEE_ID=v_empno;
            DBMS_OUTPUT.PUT_LINE('编码为'||v_empno||'工资已更新!');
      END IF;
   DBMS_OUTPUT.PUT_LINE('记录数:'|| c_cursor %ROWCOUNT);
   END LOOP;
   CLOSE c_cursor;
END;

例4：没有参数且没有返回值的游标。

DECLARE

   v_f_name employees.first_name%TYPE;
   v_j_id   employees.job_id%TYPE;
   CURSOR c1       --声明游标,没有参数没有返回值
   IS
      SELECT first_name, job_id FROM employees
      WHERE department_id = 20;
BEGIN
   OPEN c1;        --打开游标
   LOOP
      FETCH c1 INTO v_f_name, v_j_id;    --提取游标
      IF c1%FOUND THEN
         DBMS_OUTPUT.PUT_LINE(v_f_name||'的岗位是'||v_j_id);
      ELSE
         DBMS_OUTPUT.PUT_LINE('已经处理完结果集了');
         EXIT;
      END IF;
   END LOOP;
   CLOSE c1;   --关闭游标
END;

例5：有参数且没有返回值的游标。

DECLARE

   v_f_name employees.first_name%TYPE;
   v_h_date employees.hire_date%TYPE;
   CURSOR c2(dept_id NUMBER, j_id VARCHAR2) --声明游标,有参数没有返回值
   IS
      SELECT first_name, hire_date FROM employees
      WHERE department_id = dept_id AND job_id = j_id;
BEGIN
   OPEN c2(90, 'AD_VP');  --打开游标,传递参数值
   LOOP
      FETCH c2 INTO v_f_name, v_h_date;    --提取游标
      IF c2%FOUND THEN
         DBMS_OUTPUT.PUT_LINE(v_f_name||'的雇佣日期是'||v_h_date);
      ELSE
         DBMS_OUTPUT.PUT_LINE('已经处理完结果集了');
         EXIT;
      END IF;
   END LOOP;
   CLOSE c2;   --关闭游标
END;

例6：有参数且有返回值的游标。

DECLARE

   TYPE emp_record_type IS RECORD(
        f_name   employees.first_name%TYPE,
        h_date   employees.hire_date%TYPE);
   v_emp_record EMP_RECORD_TYPE;

   CURSOR c3(dept_id NUMBER, j_id VARCHAR2) --声明游标,有参数有返回值
          RETURN EMP_RECORD_TYPE
   IS
      SELECT first_name, hire_date FROM employees
      WHERE department_id = dept_id AND job_id = j_id;
BEGIN
   OPEN c3(j_id => 'AD_VP', dept_id => 90);  --打开游标,传递参数值
   LOOP
      FETCH c3 INTO v_emp_record;    --提取游标
      IF c3%FOUND THEN
         DBMS_OUTPUT.PUT_LINE(v_emp_record.f_name||'的雇佣日期是'
                            ||v_emp_record.h_date);
      ELSE
         DBMS_OUTPUT.PUT_LINE('已经处理完结果集了');
         EXIT;
      END IF;
   END LOOP;
   CLOSE c3;   --关闭游标
END;

例7：基于游标定义记录变量。

DECLARE

   CURSOR c4(dept_id NUMBER, j_id VARCHAR2) --声明游标,有参数没有返回值
   IS
      SELECT first_name f_name, hire_date FROM employees
      WHERE department_id = dept_id AND job_id = j_id;
    --基于游标定义记录变量，比声明记录类型变量要方便，不容易出错
    v_emp_record c4%ROWTYPE;
BEGIN
   OPEN c4(90, 'AD_VP');  --打开游标,传递参数值
   LOOP
      FETCH c4 INTO v_emp_record;    --提取游标
      IF c4%FOUND THEN
         DBMS_OUTPUT.PUT_LINE(v_emp_record.f_name||'的雇佣日期是'
                            ||v_emp_record.hire_date);
      ELSE
         DBMS_OUTPUT.PUT_LINE('已经处理完结果集了');
         EXIT;
      END IF;
   END LOOP;
   CLOSE c4;   --关闭游标
END;

3. 游标的FOR循环

PL/SQL语言提供了游标FOR循环语句，自动执行游标的OPEN、FETCH、CLOSE语句和循环语句的功能；当进入循环时，游标FOR循环语句自动打开游标，并提取第一行游标数据，当程序处理完当前所提取的数据而进入下一次循环时，游标FOR循环语句自动提取下一行数据供程序处理，当提取完结果集合中的所有数据行后结束循环，并自动关闭游标。

格式：

  FOR index_variable IN cursor_name[(value[, value]…)] LOOP
    -- 游标数据处理代码
  END LOOP;

其中：

index_variable为游标FOR 循环语句隐含声明的索引变量，该变量为记录变量，其结构与游标查询语句返回的结构集合的结构相同。在程序中可以通过引用该索引记录变量元素来读取所提取的游标数据，index_variable中各元素的名称与游标查询语句选择列表中所制定的列名相同。如果在游标查询语句的选择列表中存在计算列，则必须为这些计算列指定别名后才能通过游标FOR 循环语句中的索引变量来访问这些列数据。

注：不要在程序中对游标进行人工操作；不要在程序中定义用于控制FOR循环的记录。

例8：

DECLARE

   CURSOR c_sal IS SELECT employee_id, first_name || last_name ename, salary
   FROM employees ;
BEGIN
   --隐含打开游标
   FOR v_sal IN c_sal LOOP
   --隐含执行一个FETCH语句
      DBMS_OUTPUT.PUT_LINE(to_char(v_sal.employee_id)||'---'|| v_sal.ename||'---'||to_char(v_sal.salary)) ;
   --隐含监测c_sal%NOTFOUND
   END LOOP;
--隐含关闭游标
END;

例9：当所声明的游标带有参数时，通过游标FOR 循环语句为游标传递参数。

DECLARE
  CURSOR c_cursor(dept_no NUMBER DEFAULT 10)
  IS
    SELECT department_name, location_id FROM departments WHERE department_id <= dept_no;
BEGIN
    DBMS_OUTPUT.PUT_LINE('当dept_no参数值为30：');
    FOR c1_rec IN c_cursor(30) LOOP        DBMS_OUTPUT.PUT_LINE(c1_rec.department_name||'---'||c1_rec.location_id);
    END LOOP;
    DBMS_OUTPUT.PUT_LINE(CHR(10)||'使用默认的dept_no参数值10：');
    FOR c1_rec IN c_cursor LOOP        DBMS_OUTPUT.PUT_LINE(c1_rec.department_name||'---'||c1_rec.location_id);
    END LOOP;
END;

例10：PL/SQL还允许在游标FOR循环语句中使用子查询来实现游标的功能。

BEGIN
FOR c1_rec IN(SELECT department_name, location_id FROM departments) LOOP DBMS_OUTPUT.PUT_LINE(c1_rec.department_name||'---'||c1_rec.location_id);
END LOOP;
END;

4.1.2 处理隐式游标

显式游标主要是用于对查询语句的处理，尤其是在查询结果为多条记录的情况下；而对于非查询语句，如修改、删除操作，则由ORACLE 系统自动地为这些操作设置游标并创建其工作区，这些由系统隐含创建的游标称为隐式游标，隐式游标的名字为SQL，这是由ORACLE 系统定义的。对于隐式游标的操作，如定义、打开、取值及关闭操作，都由ORACLE 系统自动地完成，无需用户进行处理。用户只能通过隐式游标的相关属性，来完成相应的操作。在隐式游标的工作区中，所存放的数据是与用户自定义的显示游标无关的、最新处理的一条SQL 语句所包含的数据。

格式调用为： SQL%

注：INSERT, UPDATE, DELETE, SELECT 语句中不必明确定义游标。

隐式游标属性

属性	值	SELECT	INSERT	UPDATE	DELETE
SQL%ISOPEN		FALSE	FALSE	FALSE	FALSE
SQL%FOUND	TRUE	有结果		成功	成功
SQL%FOUND	FALSE	没结果		失败	失败
SQL%NOTFUOND	TRUE	没结果		失败	失败
SQL%NOTFOUND	FALSE	有结果		成功	失败
SQL%ROWCOUNT		返回行数，只为1	插入的行数	修改的行数	删除的行数

例11: 删除EMPLOYEES表中某部门的所有员工，如果该部门中已没有员工，则在DEPARTMENT表中删除该部门。

DECLARE
    V_deptno department_id%TYPE :=&p_deptno;
BEGIN
    DELETE FROM employees WHERE department_id=v_deptno;
    IF SQL%NOTFOUND THEN
        DELETE FROM departments WHERE department_id=v_deptno;
    END IF;
END;

例12: 通过隐式游标SQL的%ROWCOUNT属性来了解修改了多少行。

DECLARE
   v_rows NUMBER;
BEGIN
--更新数据
   UPDATE employees SET salary = 30000
   WHERE department_id = 90 AND job_id = 'AD_VP';
--获取默认游标的属性值
   v_rows := SQL%ROWCOUNT;
   DBMS_OUTPUT.PUT_LINE('更新了'||v_rows||'个雇员的工资');
--回退更新，以便使数据库的数据保持原样
   ROLLBACK;
END;

4.1.3 关于 NO_DATA_FOUND 和 %NOTFOUND的区别

SELECT … INTO 语句触发 NO_DATA_FOUND；

当一个显式游标的WHERE子句未找到时触发%NOTFOUND；

当UPDATE或DELETE 语句的WHERE 子句未找到时触发 SQL%NOTFOUND；在提取循环中要用 %NOTFOUND 或%FOUND 来确定循环的退出条件，不要用 NO_DATA_FOUND.4.1.4 使用游标更新和删除数据

游标修改和删除操作是指在游标定位下，修改或删除表中指定的数据行。这时，要求游标查询语句中必须使用FOR UPDATE选项，以便在打开游标时锁定游标结果集合在表中对应数据行的所有列和部分列。

为了对正在处理(查询)的行不被另外的用户改动，ORACLE 提供一个 FOR UPDATE 子句来对所选择的行进行锁住。该需求迫使ORACLE锁定游标结果集合的行，可以防止其他事务处理更新或删除相同的行，直到您的事务处理提交或回退为止。

语法：

SELECT column_list FROM table_list FOR UPDATE [OF column[, column]…] [NOWAIT]

如果另一个会话已对活动集中的行加了锁，那么SELECT FOR UPDATE操作一直等待到其它的会话释放这些锁后才继续自己的操作，对于这种情况，当加上NOWAIT子句时，如果这些行真的被另一个会话锁定，则OPEN立即返回并给出：

ORA-0054 ：resource busy and acquire with nowait specified.

如果使用 FOR UPDATE 声明游标，则可在DELETE和UPDATE 语句中使用

WHERE CURRENT OF cursor_name子句，修改或删除游标结果集合当前行对应的数据库表中的数据行。

例13：从EMPLOYEES表中查询某部门的员工情况，将其工资最低定为 1500；

DECLARE
    V_deptno employees.department_id%TYPE :=&p_deptno;
    CURSOR emp_cursor
  IS
  SELECT employees.employee_id, employees.salary
    FROM employees WHERE employees.department_id=v_deptno
  FOR UPDATE NOWAIT;
BEGIN
    FOR emp_record IN emp_cursor LOOP
    IF emp_record.salary < 1500 THEN
        UPDATE employees SET salary=1500
    WHERE CURRENT OF emp_cursor;
    END IF;
    END LOOP;
--    COMMIT;
END;

例14：将EMPLOYEES表中部门编码为90、岗位为AD_VP的雇员的工资都更新为2000元；

DECLARE
   v_emp_record employees%ROWTYPE;
   CURSOR c1
   IS
      SELECT * FROM employees FOR UPDATE;
BEGIN
   OPEN c1;
   LOOP
      FETCH c1 INTO v_emp_record;
      EXIT WHEN c1%NOTFOUND;
      IF v_emp_record.department_id = 90 AND
         v_emp_record.job_id = 'AD_VP'
      THEN
         UPDATE employees SET salary = 20000
         WHERE CURRENT OF c1;  --更新当前游标行对应的数据行
      END IF;
   END LOOP;
   COMMIT;   --提交已经修改的数据
   CLOSE c1;
END;

4.2 游标变量

与游标一样，游标变量也是一个指向多行查询结果集合中当前数据行的指针。但与游标不同的是，游标变量是动态的，而游标是静态的。游标只能与指定的查询相连，即固定指向一个查询的内存处理区域，而游标变量则可与不同的查询语句相连，它可以指向不同查询语句的内存处理区域（但不能同时指向多个内存处理区域，在某一时刻只能与一个查询语句相连），只要这些查询语句的返回类型兼容即可。

4.2.1 声明游标变量

游标变量为一个指针，它属于参照类型，所以在声明游标变量类型之前必须先定义游标变量类型。在PL/SQL中，可以在块、子程序和包的声明区域内定义游标变量类型。

语法格式为：

TYPE ref_type_name IS REF CURSOR
[ RETURN return_type];

其中：ref_type_name为新定义的游标变量类型名称；

return_type 为游标变量的返回值类型，它必须为记录变量。

在定义游标变量类型时，可以采用强类型定义和弱类型定义两种。强类型定义必须指定游标变量的返回值类型，而弱类型定义则不说明返回值类型。

声明一个游标变量的两个步骤：

步骤一：定义一个REF CURSOU数据类型，如：

TYPE ref_cursor_type IS REF CURSOR;

步骤二：声明一个该数据类型的游标变量，如：

cv_ref REF_CURSOR_TYPE;

例：创建两个强类型定义游标变量和一个弱类型游标变量：

DECLARE
    TYPE deptrecord IS RECORD(
        Deptno departments.department_id%TYPE,
        Dname departments.department_name%TYPE,
        Loc departments.location_id%TYPE
    );
    TYPE deptcurtype IS REF CURSOR RETURN departments%ROWTYPE;
    TYPE deptcurtyp1 IS REF CURSOR RETURN deptrecord;
    TYPE curtype IS REF CURSOR;
    Dept_c1 deptcurtype;
    Dept_c2 deptcurtyp1;
    Cv curtype;

4.2.2 游标变量操作

与游标一样，游标变量操作也包括打开、提取和关闭三个步骤。

1．打开游标变量

打开游标变量时使用的是OPEN…FOR 语句。格式为：

OPEN {cursor_variable_name | :host_cursor_variable_name}
FOR select_statement;

其中：cursor_variable_name为游标变量，host_cursor_variable_name为PL/SQL主机环境（如OCI: ORACLE Call Interface，Pro*c 程序等）中声明的游标变量。

OPEN…FOR 语句可以在关闭当前的游标变量之前重新打开游标变量，而不会导致CURSOR_ALREAD_OPEN异常错误。新打开游标变量时，前一个查询的内存处理区将被释放。

2．提取游标变量数据

使用FETCH语句提取游标变量结果集合中的数据。格式为：

FETCH {cursor_variable_name | :host_cursor_variable_name}
INTO {variable [, variable]…| record_variable};

其中：cursor_variable_name和host_cursor_variable_name分别为游标变量和宿主游标变量名称；variable和record_variable分别为普通变量和记录变量名称。

3．关闭游标变量

CLOSE语句关闭游标变量，格式为：

CLOSE {cursor_variable_name | :host_cursor_variable_name}

其中：cursor_variable_name和host_cursor_variable_name分别为游标变量和宿主游标变量名称，如果应用程序试图关闭一个未打开的游标变量，则将导致INVALID_CURSOR异常错误。

例15：强类型参照游标变量类型

DECLARE
    TYPE emp_job_rec IS RECORD(
        Employee_id employees.employee_id%TYPE,
        Employee_name employees.first_name%TYPE,
        Job_title employees.job_id%TYPE
    );
    TYPE emp_job_refcur_type IS REF CURSOR RETURN emp_job_rec;
    Emp_refcur emp_job_refcur_type ;
    Emp_job emp_job_rec;
BEGIN
    OPEN emp_refcur FOR
    SELECT employees.employee_id, employees.first_name||employees.last_name, employees.job_id
  FROM employees
  ORDER BY employees.department_id;

    FETCH emp_refcur INTO emp_job;
    WHILE emp_refcur%FOUND LOOP
       DBMS_OUTPUT.PUT_LINE(emp_job.employee_id||': '||emp_job.employee_name||' is a '||emp_job.job_title);
    FETCH emp_refcur INTO emp_job;
    END LOOP;
END;

例16：弱类型参照游标变量类型

PROMPT
PROMPT 'What table would you like to see?'
ACCEPT tab PROMPT '(D)epartment, or (E)mployees:'

DECLARE
    Type refcur_t IS REF CURSOR;
    Refcur refcur_t;
    TYPE sample_rec_type IS RECORD (
        Id number,
        Description VARCHAR2 (30)
    );
    sample sample_rec_type;
    selection varchar2(1) := UPPER (SUBSTR ('&tab', 1, 1));
BEGIN
    IF selection='D' THEN
        OPEN refcur FOR
    SELECT departments.department_id, departments.department_name FROM departments;
        DBMS_OUTPUT.PUT_LINE('Department data');
    ELSIF selection='E' THEN
        OPEN refcur FOR
    SELECT employees.employee_id, employees.first_name||' is a '||employees.job_id FROM employees;
        DBMS_OUTPUT.PUT_LINE('Employee data');
    ELSE
        DBMS_OUTPUT.PUT_LINE('Please enter ''D'' or ''E''');
        RETURN;
    END IF;
    DBMS_OUTPUT.PUT_LINE('----------------------');
    FETCH refcur INTO sample;
    WHILE refcur%FOUND LOOP
        DBMS_OUTPUT.PUT_LINE(sample.id||': '||sample.description);
        FETCH refcur INTO sample;
    END LOOP;
    CLOSE refcur;
END;

例17：使用游标变量（没有RETURN子句）

DECLARE
--定义一个游标数据类型
   TYPE emp_cursor_type IS REF CURSOR;
--声明一个游标变量
   c1 EMP_CURSOR_TYPE;
--声明两个记录变量
   v_emp_record employees%ROWTYPE;
   v_reg_record regions%ROWTYPE;

BEGIN
   OPEN c1 FOR SELECT * FROM employees WHERE department_id = 20;
   LOOP
      FETCH c1 INTO v_emp_record;
      EXIT WHEN c1%NOTFOUND;
      DBMS_OUTPUT.PUT_LINE(v_emp_record.first_name||'的雇佣日期是'
                            ||v_emp_record.hire_date);
   END LOOP;
--将同一个游标变量对应到另一个SELECT语句
   OPEN c1 FOR SELECT * FROM regions WHERE region_id IN（1，2）;
   LOOP
      FETCH c1 INTO v_reg_record;
      EXIT WHEN c1%NOTFOUND;
      DBMS_OUTPUT.PUT_LINE(v_reg_record.region_id||'表示'
                            ||v_reg_record.region_name);
   END LOOP;
   CLOSE c1;
END;

例18：使用游标变量（有RETURN子句）

DECLARE
--定义一个与employees表中的这几个列相同的记录数据类型
   TYPE emp_record_type IS RECORD(
        f_name   employees.first_name%TYPE,
        h_date   employees.hire_date%TYPE,
        j_id     employees.job_id%TYPE);
--声明一个该记录数据类型的记录变量
   v_emp_record EMP_RECORD_TYPE;
--定义一个游标数据类型
   TYPE emp_cursor_type IS REF CURSOR
        RETURN EMP_RECORD_TYPE;
--声明一个游标变量
   c1 EMP_CURSOR_TYPE;
BEGIN
   OPEN c1 FOR SELECT first_name, hire_date, job_id
               FROM employees WHERE department_id = 20;
   LOOP
      FETCH c1 INTO v_emp_record;
      EXIT WHEN c1%NOTFOUND;
      DBMS_OUTPUT.PUT_LINE('雇员名称：'||v_emp_record.f_name
                ||'  雇佣日期：'||v_emp_record.h_date
                ||'  岗位：'||v_emp_record.j_id);
   END LOOP;
   CLOSE c1;
END;

原创作品，转贴请注明作者和出处，留此信息。

cnBlobs:http://www.cnblogs.com/huyong/

CSDN：http://blog.csdn.net/chinahuyong

游标实例：

set serveroutput on;

create or replace PROCEDURE p_endTask(in_taskCode in t_taskuserrel.taskcode%type, in_directUser in t_taskuserrel.directUser%type)
as 
    v_clientUser t_taskuserrel.clientuser%type;
    v_taskCode t_usertask.taskCode%type;
    v_actCode t_usertask.taskCode%type;
    v_orgCode t_userorg.orgCode%type;
    v_count number;
    --create cursor
    cursor c_taskUserRel is select clientUser from t_taskuserrel where taskcode = in_taskCode and directUser = in_directUser;
    cursor c_userAct(in_userTask_taskCode in t_usertask.taskCode%type) is select actCode from t_userAct where taskCode = in_userTask_taskCode;
    cursor c_userOrg(in_userTask_taskCode in t_usertask.taskCode%type) is select orgCode from t_userOrg where taskCode = in_userTask_taskCode;    
begin 
    --open cursor 
    open c_taskUserRel;
    loop
        fetch c_taskUserRel into v_clientUser;
        exit when c_taskUserRel %notfound;
        dbms_output.put_line(v_clientUser);
        
        select count(*) into v_count from t_userTask where taskStatus = 9 and username = v_clientUser;
        if v_count > 0 then
            select taskCode into v_taskCode from t_userTask where taskStatus = 9 and username = v_clientUser;
            --update t_userTask
            update t_usertask set taskstatus = 0 where taskCode = v_taskCode;
            
            /* */
            --delete t_userActItem
            open c_userAct(v_taskCode);
            loop 
                fetch c_userAct into v_actCode;
                exit when c_userAct %notfound;
                delete from t_userActItem where actcode = v_actCode;
            end loop;
            close c_userAct;
            
            --delete t_userAct
            delete from t_userAct where taskcode = v_taskCode;
            
            --delete t_userOrgItem and t_userorgunit;
            open c_userOrg(v_taskCode);
            loop 
                fetch c_userOrg into v_orgCode;
                exit when c_userOrg %notfound;
                delete from t_userOrgItem where orgcode = v_orgCode;
                delete from t_userorgunit where orgcode = v_orgCode;
            end loop;
            close c_userOrg;
            
            --delete t_userOrg
            delete from t_userorg where taskcode = v_taskCode;
            
            --delete t_usernotes
            delete from t_usernotes where taskCode = v_taskCode;
        end if;    
    end loop;
    --close cursor
    close c_taskUserRel;
exception 
    when no_data_found then        
        dbms_output.put_line('没找到记录');
    when others then
        dbms_output.put_line('出错了');
end;
/

存储过程实例

create sequence s_error_id start with 1 increment by 1;
create table t_error (
    id int primary key,
    orgCode varchar2(30),
    itemCode varchar2(30),
    itemNum number,
    errInfo varchar2(1024),
    errDate date
);

--带返回值的用function, 不带返回值用procedure
create or replace PROCEDURE p_updateOrgItem(in_itemNum in t_userorgitem.itemNum%type, in_orgCode in t_userorgitem.orgCode%type, in_itemCode in t_userorgitem.itemCode%type, in_actCode in t_userAct.actCode%type)
as 
    v_itemNum t_userorgitem.itemNum%type;
    v_orgCode t_userorgitem.orgCode%type;
    v_itemCode t_userorgitem.itemNum%type;
    v_count number;
    v_errorInfo varchar2(2000);
begin 
    select count(*) into v_count from t_userorgitem where orgCode = in_orgCode and itemCode = in_itemCode;
    if v_count = 0 then
        if in_itemNum > 0 then
            insert into t_userorgitem values(in_orgCode, in_itemCode, in_itemNum, '');
        else
            v_errorInfo := '当前医疗机构没有此数据，并且数据小于0';
            insert into t_error values(s_error_id.nextval, in_orgCode, in_itemCode, in_itemNum, v_errorInfo, sysdate);
            update t_userAct set actMode = 9 where actCode = in_actCode;
        end if;
    else 
        select itemNum, orgCode, itemCode into v_itemNum, v_orgCode, v_itemCode from t_userorgitem where orgCode = in_orgCode and itemCode = in_itemCode;
        if v_itemNum >= in_itemNum then
            update t_userorgitem set itemNum = itemNum + in_itemNum;
        else
            v_errorInfo := '当前医疗机构没有这么多物资';
            insert into t_error values(s_error_id.nextval, in_orgCode, in_itemCode, in_itemNum, v_errorInfo, sysdate);
            update t_userAct set actMode = 8 where actCode = in_actCode;
        end if;
    end if;
        
end;
/

游标for循环

--带返回值的用function, 不带返回值用procedure
create or replace PROCEDURE p_timer
as 
    v_count number;
    v_itemNum t_userOrgItem.itemNum%type;
    v_errorInfo varchar2(2000);

    v_sysdate date := sysdate;
    
    --使用for循环的时候可以不申明
    --v_userTask t_userTask%rowtype;
    --v_userAct t_userAct%rowtype;
    --v_userActItem t_userActItem%rowtype;
    
    cursor c_userTask is select * from t_userTask where taskStatus != '0';
    cursor c_userAct(in_needStatus t_userAct.needStatus%type, in_taskCode t_userAct.taskCode%type) is select * from t_userAct where actMode = '0' AND EXECTIME <= v_sysdate AND taskCode = in_taskCode AND (needStatus is null or needStatus = in_needStatus) order by EXECTIME;
    cursor c_userActItem(in_actCode t_userActItem.actCode%type) is select * from t_userActItem where actCode = in_actCode;
begin
    dbms_output.put_line(to_char(v_sysdate, 'yyyy-mm-dd hh24:mi:ss'));
    for v_userTask in c_userTask loop
        dbms_output.put_line(v_userTask.taskCode);
        
        for v_userAct in c_userAct(v_userTask.taskStatus, v_userTask.taskCode) loop
            dbms_output.put_line(v_userAct.actCode);
            
            --只有任务进入战中之后，才去查找是否有子数据
            if v_userTask.taskStatus >= 5 then
                --任务下是否有子数据
                for v_userActItem in c_userActItem(v_userAct.actCode) loop
                    --修改医疗机构数据
                    select count(*) into v_count from t_userOrgItem where orgCode = v_userActItem.orgCode AND itemCode = v_userActItem.itemCode;
                    if v_count = 0 then
                        if v_userActItem.itemNum > 0 then
                            insert into t_userorgitem values(v_userActItem.orgCode, v_userActItem.itemCode, v_userActItem.itemNum, '');
                        else
                            v_errorInfo := '出现错误，原因是您要减少一个不存在的物资';
                            insert into t_error values(s_error_id.nextval, v_userActItem.orgCode, v_userActItem.itemCode, v_userActItem.itemNum, v_errorInfo, sysdate);
                            update t_userAct set actMode = '9' where actCode = v_userActItem.actCode;
                        end if;
                    else
                        select itemNum into v_itemNum from t_userOrgItem where orgCode = v_userActItem.orgCode AND itemCode = v_userActItem.itemCode;
                        if v_itemNum >= v_userActItem.itemNum then
                            update t_userorgitem set itemNum = itemNum + v_userActItem.itemNum where itemCode = v_userActItem.itemCode AND orgCode = v_userActItem.orgCode;
                        else
                            v_errorInfo := '出现错误，原因是当前医疗机构物资不足';
                            insert into t_error values(s_error_id.nextval, v_userActItem.orgCode, v_userActItem.itemCode, v_userActItem.itemNum, v_errorInfo, sysdate);
                            update t_userAct set actMode = '8' where actCode = v_userActItem.actCode;
                        end if;
                    end if;
                end loop;
            end if;
            
            --是否需要改变任务状态
            dbms_output.put_line(v_userAct.taskStatus || '_' || v_userAct.needStatus);
            if v_userAct.needStatus IS NULL OR v_userAct.taskStatus != v_userAct.needStatus then
                dbms_output.put_line('更新了');
                UPDATE t_userTask SET taskStatus = v_userAct.taskStatus WHERE taskCode = v_userTask.taskCode;
            end if;
            
            --将消息状态设为未读
            UPDATE t_userAct SET actMode = '1' WHERE actCode = v_userAct.actCode and actMode = '0';
    
        end loop;
    end loop;
    
    commit;
    
    exception
        when others then
        rollback;
        dbms_output.put_line('error');
        v_errorInfo := '存储过程异常';
        insert into t_error values(s_error_id.nextval, '0', '0', '0', v_errorInfo, sysdate);
end;
/

exec p_timer;

蚂蚁大战大象递归实例

create table article (
    id number primary key,
    pid number,
    content varchar2(4000),
    isleaf number(1),
    alevel number(2)
);

insert into article values (1, 0, '蚂蚁大战大象', 0, 0);
insert into article values (2, 1, '大象被打趴下了', 0, 1);
insert into article values (3, 2, '蚂蚁也不好过', 1, 2);
insert into article values (4, 2, '瞎说', 0, 2);
insert into article values (5, 4, '没有瞎说', 1, 3);
insert into article values (6, 1, '怎么可能', 0, 1);
insert into article values (7, 6, '怎么没有可能', 1, 2);
insert into article values (8, 6, '可能性是很大的', 1, 2);
insert into article values (9, 2, '大象进医院了', 0, 2);
insert into article values (10, 9, '护士是蚂蚁', 1, 3);

set serveroutput on;

create or replace procedure p(in_pid in article.id%type) 
as
    v_content article.content%type;
    v_id article.id%type;
    v_pid article.id%type;
    v_isleaf article.isleaf%type;
    v_alevel article.alevel%type;
    v_printStr varchar2(100) := '';
    cursor c is select id, content, isleaf, alevel content from article where pid = in_pid;
begin
    open c;
    loop
        fetch c into v_id, v_content, v_isleaf, v_alevel;
        exit when c %notfound;
        
        while v_alevel > 0 loop
            v_printStr := v_printStr || '--';
            v_alevel := v_alevel - 1;
        end loop;
        dbms_output.put_line(v_printStr || v_content);
        v_printStr := '';
        if v_isleaf = 0 then
            p(v_id);
        end if;
    end loop;
    close c;
end;
/

exec p(0);



/*
蚂蚁大战大象
--大象被打趴下了
----蚂蚁也不好过
----瞎说
------没有瞎说
----大象进医院了
------护士是蚂蚁
--怎么可能
----怎么没有可能
----可能性是很大的
*/

create or replace procedure p1(in_pid in article.id%type) 
as
    v_article article%rowtype;
    v_printStr varchar2(10) := '';
    cursor c is select * from article where pid = in_pid;
begin
    FOR v_article IN c LOOP
        for i in 1..v_article.alevel loop
            v_printStr := v_printStr || '--';
        end loop;
        dbms_output.put_line(v_printStr || v_article.content);
        v_printStr := '';
        if v_article.isleaf = 0 then
            p1(v_article.id);
        end if;
    END LOOP;
end;
/

exec p1(0);

查看全文

相关阅读:
权限和分组
 验证与授权
 CSRF、XSS、clickjacking、SQL 的攻击与防御
 上下文处理器及中间件
 类和实例
 偏函数
 生成器
 迭代复习
 函数调用复习
 复习条件判断,循环

原文地址：https://www.cnblogs.com/hzm112567/p/3079531.html