PLSQL_Les03--游标
PLSQL游标讲解
游标的概念为了处理SQL 语句，ORACLE 必须分配一片叫上下文( context area )的区域来处理所必需的信息，其中包括要处理的行的数目，一个指向语句被分析以后的表示形式的指针以及查询的活动集(active set)。
游标是一个指向上下文的句柄( handle)或指针。
通过游标，PL/SQL可以控制上下文区和处理语句时上下文区会发生些什么事情。
游标的概念对于不同的SQL语句，游标的使用情况不同：显式游标处理显式游标需要四个PL/SQL步骤定义游标：就是定义一个游标名，以及与其相对应的SELECT 语句，其一般形式为：CURSOR cursor_name IS select_statement;其中：游标声明部分是唯一可以出现在模块声明部分的步骤，其他三个步骤都在执行和异常处理部分中 游标名是表识符，所以也有作用域，并且必须在使用前进行说明任何SELECT语句都是合法的，但是SELECT …INTO语句是非法的在声明部分的末尾声明游标打开游标：就是执行游标所对应的SELECT 语句，将其查询结果放入工作区，并且指针指向工作区的首部，标识游标结果集合。
OPEN cursor_name其中：PL/SQL 程序不能用OPEN 语句重复打开一个游标提取游标：就是检索结果集合中的数据行，放入指定的输出变量中。
FETCH cursor_name INTO {variable_list | record_variable };关闭游标：当提取和处理完游标结果集合数据后，应及时关闭游标，以释放该游标所占用的系统资源，并使该游标的工作区变成无效，不能再使用FETCH 语句取其中数据。
关闭后的游标可以使用OPEN 语句重新打开。
CLOSE cursor_name;DECLAREv_ename emp.ename%TYPE;v_sal emp.sal%TYPE;CURSOR c_cursor IS SELECT ename, sal FROM emp WHERE rownum<11; BEGINOPEN c_cursor;FETCH c_cursor INTO v_ename, v_sal;WHILE c_cursor %FOUND LOOPDBMS_OUTPUT.PUT_LINE(v_ename||’---‘||to_char(v_sal) );FETCH c_cursor INTO v_ename, v_sal;END LOOP;CLOSE c_cursor;END;DECLAREv_ename emp.ename%TYPE;v_sal emp.sal%TYPE;CURSOR c_cursor(P_sal emp.sal%type)IS SELECT ename, sal FROM emp WHERE sal >= P_sal; BEGINOPEN c_cursor(1000);FETCH c_cursor INTO v_ename, v_sal;WHILE c_cursor %FOUND LOOPDBMS_OUTPUT.PUT_LINE(v_ename||’---‘||to_char(v_sal) );FETCH c_cursor INTO v_ename, v_sal;END LOOP;CLOSE c_cursor;END;游标属性处理隐式游标显式游标主要是用于对查询语句的处理，尤其是在查询结果为多条记录的情况下；而对于非查询语句，如修改、删除操作，则由ORACLE 系统自动地为这些操作设置游标并创建其工作区，这些由系统隐含创建的游标称为隐式游标，隐式游标的名字为SQL，这是由ORACLE 系统定义的。
Oracle_PL_SQL讲解2(游标)
employees; DBMS_OUTPUT.PUT_LINE(' Salary is : '
|| v_salary); END;
home back first prev next last 7
显式游标
• 通过显式游标, 你可从数据库获取多条记录, 得到一个可指向每行记录的指针, 逐行处理 每条记录.
employees WHERE department_id = 10; v_empno employees.employee_id%TYPE; v_lname st_name%TYPE;
BEGIN OPEN emp_cursor; LOOP FETCH emp_cursor INTO v_empno, v_lname; DBMS_OUTPUT.PUT_LINE(v_empno || ' ' ||
• 要返回多行记录, 需要使用显式游标.
home back first prev next last 4
游标和上下文区域
• Oracle 服务为SQL语句分配一块私有内存区域用 于保存相关数据 ，此内存区称为上下文区域 （ context area ）.
– 每个上下文区域(因而也就是每条 SQL 语句) 都有一个 关联的游标.
home back first prev next last 11
显式游标
home back first prev next last 12
显式游标
home back first prev next last 13
显式游标
• 游标的活动集由声明游标时给出的语句决定. • 语法:
『ORACLE』PLSQL动态游标的使用（11g）
『ORACLE』PLSQL动态游标的使⽤（11g）#静态游标指的是程序执⾏的时候不需要再去解析sql语⾔，对于sql语句的解析在编译的时候就可以完成的。
动态游标由于含有参数，对于sql语句的解析必须要等到参数确定的时候才能完成。
从这个⾓度来说，静态游标的效率也⽐动态游标更⾼⼀些。
#游标的相关概念： 定义： 游标它是⼀个服务器端的存储区，这个区域提供给⽤户使⽤，在这个区域⾥ 存储的是⽤户通过⼀个查询语句得到的结果集，⽤户通过控制这个游标区域当中 的指针来提取游标中的数据，然后来进⾏操作。
实质： 是⽤户在远程客户端上对服务器内存区域的操作，由数据库为⽤户提供这样的 ⼀个指针，使得⽤户能够去检索服务器内存区的数据。
#游标具有的属性：1、%ISOPEN（确定游标是否已经打开 true or false）2、%FOUND（返回是否从结果集提取到了数据 true or false）3、%NOTFOUND（返回是否从结果集没有提取到数据 true or false）4、%ROWCOUNT（返回到当前为⽌已经提取到的实际⾏数）#游标分类⼀、静态游标1、隐式游标：对于select..into...语句，⼀次只能从数据库中获取到⼀条数据，对于这种类型的DML SQL语句，就是隐式cursorselect update/insert/delete操作2、显⽰游标：由程序员定义和管理，对于从数据库中提取多⾏数据，就需要使⽤显式cursor1）定义游标---cursor [cursor name] is2）打开游标---open [cursor name]3）操作数据---fetch [cursor name]4）关闭游标---close [cursor name]⼆、REF游标1、REF 游标：动态关联结果集的临时对象。
即在运⾏的时候动态决定执⾏查询。
2、REF 游标作⽤：实现在程序间传递结果集的功能，利⽤REF CURSOR也可以实现BULK SQL，从⽽提⾼SQL性能。
Oracle数据库实验-PLSQL游标、过程、函数、包的使用
Oracle数据库实验-PLSQL游标、过程、函数、包的使用Oracle数据库基础实验5 PL/SQL游标、过程、函数、包的使用【实验学时】2学时【实验目的】1.了解PL/SQL语言中显式游标和隐式游标的概念和属性。
2.了解显式游标和隐式游标的差异。
3.掌握PL/SQL中cursor for循环的使用方法。
4.学会在PL/SQL程序中使用游标来解决实际问题。
5.学会在PL/SQL程序中进行异常处理的方法。
6.练习在PL/SQL中自定义异常。
7.理解过程和函数的作用。
8.学会编写过程、函数、包，并加以调用。
【实验内容】1.用显式游标编写程序，程序的功能是：计算每一个部门的平均工资。
注意异常的处理（例如，分母为0的异常）。
已写入文件afiedt.buf1 declare2 cursor c_dept is select * from dept order by deptno;3 cursor c_emp(p_dept emp.deptno%type)is selectename,sal from emp where deptno=p_dept4 order by ename;5 r_dept dept%rowtype;6 v_ename emp.ename%type;7 v_salary emp.sal%type;8 v_tot_salary emp.sal%type;9 begin10 open c_dept;11 loop12 fetch c_dept into r_dept;13 exit when c_dept%notfound;14dbms_output.put_line('department:'||r_dept.deptno||'-'||r_de pt.dname);15 v_tot_salary:=0;16 open c_emp(r_dept.deptno);17 loop18 fetch c_emp into v_ename,v_salary;19 exit when c_emp%notfound;20dbms_output.put_line('name:'||v_ename||'salary:'||v_salary);21 v_tot_salary:=v_tot_salary+v_salary;22 end loop;23 close c_emp;24 dbms_output.put_line('total salary fordept:'||v_tot_salary);25 end loop;26 close c_dept;27* end;SQL> /PL/SQL 过程已成功完成。
Oracle--plsql游标创建和使用
Oracle--plsql游标创建和使用为什么要游标：先看这个：DECLAREv_empnoemp.empno%type;v_enameemp.ename%type;BEGINSELECT empno,enameintov_ename,v_empnoFROM emp;dbms_output.put_line(v_empno||' '||v_ename);END;这个SELECT语句可能返回多条记录，所以这个赋值语句可能是错误的。
所以游标可以发挥作用了。
什么是游标？游标（cursor）是Oracle系统在内存中开辟的一个工作区，在其中存放SELECT语句返回的查询结果。
游标的分类：隐式游标：PL/SQL隐式建立并自动管理这一游标。
隐式游标也叫做SQL 游标。
对于SQL游标，不能对其显式地执行OPEN、CLOSE和FETCH 语句，但是可以使用游标属性从最近执行的SQL语句中获取信息。
显式游标:由程序员显式说明及控制，用于从表中取出多行数据，并将多行数据一行一行单独处理。
隐式游标：∙由Oracle在内部声明∙由Oracle自行管理游标∙可以使用游标属性从最近执行的SQL语句中获取信息∙用于处理DML语句以及返回单行的查询隐式游标属性：隐式游标举例：VARIABLE rows_deletedVARCHAR2(30)DECLAREv_deptno NUMBER := 20;BEGINDELETE FROM empWHERE deptno = v_deptno;:rows_deleted := (SQL%ROWCOUNT ||' rows deleted.');END;/返回所删除行的数量显式游标:由用户显式声明,查询返回多行记录∙使用游标时，select语句查询的结果可以是单条记录，多条记录，也可以是零条记录。
∙游标工作区中，存在着一个指针（POINTER）,在初始状态它指向查询结果的首记录。
plsql--游标用法
plsql--游标⽤法1.游标概念在 PL/SQL 块中执⾏ SELECT、INSERT、DELETE 和 UPDATE 语句时，ORACLE 会在内存中为其分配上下⽂区（Context Area），即缓冲区。
游标是指向该区的⼀个指针，或是命名⼀个⼯作区（Work Area），或是⼀种结构化数据类型。
它为应⽤等量齐观提供了⼀种对具有多⾏数据查询结果集中的每⼀⾏数据分别进⾏单独处理的⽅法，是设计嵌⼊式SQL 语句的应⽤程序的常⽤编程⽅式。
在每个⽤户会话中，可以同时打开多个游标，其数量由数据库初始化参数⽂件中的OPEN_CURSORS 参数定义。
对于不同的 SQL 语句，游标的使⽤情况不同：⾮查询语句--》隐式的结果是单⾏的查询语句 --》隐式的或显⽰的结果是多⾏的查询语句--》显⽰的2.处理显⽰游标2.1显⽰游标处理的4个步骤1.定义/ / 声明游标：就是定义⼀个游标名，以及与其相对应的 SELECT 语句。
格式：CURSOR cursor_name[(parameter[, parameter]…)][RETURN datatype]ISselect_statement;注意：1.游标参数只能为输⼊参数2.在指定数据类型时，不能使⽤长度约束3.[RETURN datatype]是可选的，表⽰游标返回数据的数据。
如果选择，则应该严格与 select_statement 中的选择列表在次序和数据类型上匹配。
⼀般是记录数据类型或带“%ROWTYPE”的数据。
2.打开游标就是执⾏游标所对应的 SELECT 语句，将其查询结果放⼊⼯作区，并且指针指向⼯作区的⾸部，标识游标结果集合。
如果游标查询语句中带有 FOR UPDATE 选项，OPEN 语句还将锁定数据库表中游标结果集合对应的数据⾏。
格式：OPEN cursor_name[([parameter =>] value[, [parameter =>] value]…)];3.提取游标就是检索结果集合中的数据⾏，放⼊指定的输出变量中。
03PLSQL中的游标(详解PLSQL游标)
FOR c1_rec IN c_cursor (30) LOOP
DBMS_OUTPUT.PUT_LINE(c1_rec.dname||’---‘||c1_rec.loc); END LOOP; DBMS_OUTPUT.PUT_LINE(CHR(10)||’使用默认的dept_no参数值10：’);
FOR c1_rec IN c_cursor LOOP
游标名是标识符，所以也有作用域，并且必须在使用前进行说明
任何SELECT语句都是合法的，但是SELECT …INTO语句是非法的 在声明部分的末尾声明游标*
1-4
显式游标
处理显式游标需要四个 PL/SQL步骤: 打开游标：就是执行游标所对应的SELECT 语句，将其查询结果放 入工作区，并且指针指向工作区的首部，标识游标结果集合。 OPEN cursor_name 其中： PL/SQL 程序不能用OPEN 语句重复打开一个游标(ORA-06511)
1-2
游标的概念
对于不同的SQL语句，游标的使用情况不同：
SQL语句 非查询语句 结果是单行的查示的
1-3
显式游标
处理显式游标需要四个 PL/SQL步骤: 定义游标：就是定义一个游标名，以及与其相对应的SELECT 语句 ， 其 一般形式为： CURSOR cursor_name IS select_statement; 其中： 游标声明部分是唯一可以出现在模块声明部分的步骤，其他三个 步骤都在执行和异常处理部分中
1-5
显式游标
处理显式游标需要四个 PL/SQL步骤:
提取游标：就是检索结果集合中的数据行，放入指定的输出变量中。
FETCH cursor_name INTO {variable_list | record_variable };
PLSQL的游标
1、游标游标是指向结果集的指针，它提供一种机制，可以对结果集进行逐行处理。
游标分为显式游标和隐式游标。
显式游标是Oracle提供的一种访问数据的方法，让用户创建和使用；隐式游标是在执行selec t…into、delete、update、insert等语句时，由Oracle自动创建的一个游标，隐式游标一次只能返回一行，不能对其进行操作，由系统自动处理。
2、显式游标的使用：(一般用来处理select语句返回的多行数据)(1)声明游标：cursor cursorName [(arg1 datatype[,arg2 datatyp e…])]isselect_statement;解释：cursorName是游标名，arg1为游标的参数；datatype为参数类型，不能指定长度，只能是输入类型；select_statement是指定游标的查询语句。
select_statment还可以加锁，如：cursor emp_cursor is select * from emp for update [of emp] [nowait];解释：多个表时of选项指定要加锁的表；nowait选项表示锁未添加成功时，则返回并由用户决定等待还是去执行其他语句。
(2)打开游标：打开游标时，Oracle会执行游标所对应的查询语句，并将查询的结果集暂存到结果集中，此时结果集是静态的，对其所作的操作不会对结果集有影响，直到关闭游标后，对其所作的操作才会在结果集中反映出来。
open cursor_name;--打开游标，cursor_name为游标名。
(3)提取游标指向的数据：提取一行数据的语法：fetch cursorName into var1,var2,…;解释：将cursorName指向的行的数据提取出来赋值给var1等，每执行一次fetch语句，游标就会指向下一行。
提取多行数据的语法：fetch cursorName bulk collect into collect1,collect2,…[limit rows];解释：将游标指向的单行中的各列数据分别赋给各个变量（这里的变量相当于数组(单列多行型)，保存多个值），然后取出下一行继续赋值，直到结束， limit指定取出的行数。
python的sqlite3游标知识总结
python的sqlite3游标知识总结SQLite3是Python中一种轻量级的数据库引擎，它允许我们在Python程序中使用SQL语言进行数据库操作。
游标（Cursor）是SQLite3模块中的一个重要概念，它用于执行SQL语句并处理查询结果。
以下是关于SQLite3游标的一些总结：1. 连接数据库：首先，我们需要使用`connect()`函数建立与数据库的连接。
连接成功后，我们可以通过调用`cursor()`方法创建一个游标对象。
2. 执行SQL语句：使用游标对象可以执行SQL语句。
可以使用`execute()`方法执行SQL查询语句，或者使用`executemany()`方法执行批量操作。
例如：```pythoncursor.execute("SELECT * FROM table_name")```3. 提交事务：当我们执行了对数据库有影响的操作（如插入、更新、删除等），需要调用`commit()`方法来提交事务，使得更改生效。
4. 获取查询结果：可以使用`fetchone()`方法获取查询结果的下一行数据，使用`fetchall()`方法获取所有的查询结果。
例如：```pythonrow = cursor.fetchone()rows = cursor.fetchall()```5. 关闭游标和数据库连接：在使用完游标后，应该调用`close()`方法关闭游标，以释放资源。
同时，也应该调用`close()`方法关闭数据库连接。
6. 异常处理：在使用游标进行数据库操作时，可能会出现异常情况。
我们可以使用`try-except`语句来捕获并处理这些异常。
总结起来，SQLite3游标是用于执行SQL语句和处理查询结果的重要工具。
通过连接数据库、执行SQL语句、提交事务、获取查询结果以及关闭游标和数据库连接，我们可以有效地操作SQLite3数据库。
PLSQL几种游标的用法
PLSQL⼏种游标的⽤法分类： Oracle1。
PL/SQL⾥的游标可以分为显式和隐式两种，⽽隐式有分为select into隐式游标和for .. in 隐式游标两种。
所以，我们可以认为，有3种游标⽤法： A. 显式游标普通显式游标代码:declarecursor c is select tname from tab ;l_tname varchar2(64);beginopen c ;loopfetch c into l_tname ;exit when c%notfound ;dbms_output.put_line(l_tname);end loop;close c;end;/....Bulk Collect的显式游标代码:declarecursor c is select tname from tab ;l_tname_array dbms_sql.varchar2_table;beginopen c ;fetch c bulk collect into l_tname_array ;for i in 1 .. l_tname_array.count loopdbms_output.put_line(l_tname_array(i) );end loop;close c;end;/....Bulk Collect的显式游标 + limit代码:declarecursor c is select tname from tab ;l_tname_array dbms_sql.varchar2_table;beginopen c ;loopfetch c bulk collect into l_tname_array limit 10 ;exit when c%notfound ;for i in 1 .. l_tname_array.count loopdbms_output.put_line(l_tname_array(i) );end loop;end loop;close c;end;/....B. select into隐式游标代码:declarel_tname varchar2(100);beginselect tname into l_tname from tab where rownum = 1 ;dbms_output.put_line(l_tname);end;/....动态SQL 的 select into隐式游标B代码:declarel_tname varchar2(100);l_table_name varchar2(100);l_sql varchar2(200);beginl_table_name := 'TAB' ;l_sql := 'select tname from '||l_table_name ||' where rownum = 1 ' ;execute immediate l_sql into l_tname;for i in 1 .. l_tname_array.count loopdbms_output.put_line(l_tname_array(i) );end loop;end;/....动态SQL 的 select into隐式游标 + Bulk Collect代码:declarel_tname_array dbms_sql.varchar2_table;l_table_name varchar2(100);l_sql varchar2(200);beginl_table_name := 'TAB' ;l_sql := 'select tname from '||l_table_name ;execute immediate l_sql bulk collect into l_tname_array;for i in 1 .. l_tname_array.count loopdbms_output.put_line(l_tname_array(i) );end loop;end;/....C. for .. in 隐式游标代码:beginfor c in (select tname from tab) loopdbms_output.put_line(c.tname);end loop;end;/....2.三种⽤法的优劣 A. 显式游标优点： ·可以⽤于Bulk Collect的批量处理句式以提⾼性能 ·可以⽤于动态SQL的游标处理缺点：⿇烦，需要定义，打开，Fetch,Close⼀堆代码，增加代码复杂度，从⽽增加出错的可能性B. select into隐式游标B 优点 ·代码量最少 ·可以⾃动Detect 返回数据超过⼀⾏或少于⼀⾏的错误 ·可以使⽤Bulk Collect 批量处理，但是⽆法使⽤Limit 关键字缺点 ·如果不使⽤Bulk Collect 批量处理，仅仅只能⽤于返回数据正好⼀⾏的情况，⽆法使⽤于返回数据超过⼀⾏或少于⼀⾏的环境 ·使⽤Bulk Collect 批量处理时，⽆法使⽤limit 关键字，⽆法处理返回⾏数太多的情况（不好处理，容易造成PGA过⼤）C. for .. in 隐式游标优点 ·代码量远少于显式游标 ·代码可读性优于显式游标 ·代码的出错可能性也⼩于显式游标缺点： ·⽆法⽤于动态SQL的游标处理 ·在返回⾏数超过10⾏的情况下，性能明显不如使⽤Bulk Collect的显式游标在性能对⽐⽅⾯，除⾮是使⽤了Bulk Collect,否则，三种⽅式没有明显性能差距。
plsql、游标、存储过程
plsql、游标、存储过程以下为个⼈学习笔记plsql语⾔不区分⼤⼩写。
1.程序结构：Plsql分为三个部分：声明部分、可执⾏部分、异常处理部分。
语法：declare--声明变量，游标i integer;begin--执⾏语句--异常处理end;⽰例：打印hello world（在测试窗⼝编写）begin-- 打印hello worldDBMS_OUTPUT.PUT_LINE('hello world');end;（在命令窗⼝编写）“set serveroutput on“开启输出命令Sqlplus中执⾏plsql程序需要在程序最后添加/，表⽰程序的结束。
SQL>set serveroutput onSQL>begin-- 打印hello worldDBMS_OUTPUT.PUT_LINE('hello world');end;/2.变量（1）普通数据类型（char,varchar2,date,number,boolean,long）（2）特殊变量类型（引⽤型变量、记录型变量）声明变量⽅式：变量名变量类型(变量长度) 例如：v_name varchar2(20);变量赋值：（1）直接赋值（变量 :=’值’）V_name :=’zhangsan’（2）语句赋值（select 值 into 变量）普通变量：--打印⼈员个⼈信息，包括：姓名、薪⽔、地址declare-- 姓名v_name varchar2(20) :='张三';--声明变量时直接赋值--薪⽔v_sal number;--地址v_addr varchar2(200);begin-- 在程序中直接赋值v_sal :=10000;-- 语句赋值select'北京'into v_addr from dual;-- 打印变量dbms_output.put_line('姓名'|| v_name ||'，薪⽔’ || v_sal || '，地址' || v_addr);end;引⽤型变量：变量的类型和长度取决于表中字段的类型和长度语法：变量名表名.列名%TYPE;--查询emp表中1089号员⼯个⼈信息，包括：姓名、薪⽔declare-- 姓名v_name emp.ename%TYPE;--薪⽔v_sal emp.sal%TYPE;begin-- 查询表中信息并赋值，保持字段顺序⼀致select ename,sal into v_name,v_sal from emp where id=1089;-- 打印变量dbms_output.put_line('姓名'|| v_name ||'，薪⽔’ || v_sal);end;记录型变量：接受表中的⼀整⾏记录，相当于java中的⼀个对象语法：变量名表名%ROWTYPE--查询emp表中1089号员⼯个⼈信息，包括：姓名、薪⽔declare-- 记录型变量v_emp emp%ROWTYPE;--薪⽔v_sal emp.sal%TYPE;begin-- 查询表中⼀⾏记录并赋值select*into v_mep from emp where id=1089;-- 打印变量dbms_output.put_line('姓名'|| v_emp.ename ||'，薪⽔’ || v_emp.sal); end;3.流程控制（1）条件分⽀语法：beginif条件1 then执⾏1-- 注意关键字elsifelsif 条件2 then执⾏2else执⾏3end if;end;⽰例：--判断emp表中记录数declare-- 记录型变量v_count number;beginselect count(1) into v_count from emp;if v_count >20thendbms_output.put_line('emp表中记录数⼤于20条，为：'|| v_count);elsif v_count >=10thendbms_output.put_line('emp表中记录数在10到20条之间，为：'|| v_count); elsedbms_output.put_line('emp表中记录数⼩于10条，为：'|| v_count);end if;end;（2）loop循环语法：beginloopexit when退出循环条件end loop;end;⽰例：--打印数字1-10declare-- 声明循环变量v_num number :=1;beginloopexit when v_num >10;dbms_output.put_line(v_num);-- 循环变量⾃增v_num := v_num +1;end loop;end;4.游标（1）概念：⽤于临时存储⼀个查询返回的多⾏数据（结果集，类似于Java的jdbc连接返回的ResultSet集合），通过遍历游标，可以逐⾏访问处理该结果集的数据。
PLSQL中CURSOR的用法
今天简单的总结一下PL/SQL中cursor(光标/游标)的用法.相信不少做开发或维护的DBA在找工作的时候，遇到过类似的面视问题：请简单的描述一下光标的类型，说一下普通光标和REF光标之间的区别，以及什么时候该正确应用哪一个?这个题目，我着实难住了不少人，其实他们在具体开发的时候，也还是比较能够把握正确的光标的使用的，但就是说不出来，当然了，这与大家自身的沟流交通能力是有关系的。
有的人不善于说，但做的却很好。
扯的扯就走远了，最后唠叨一下：做技术这条路，能干不能说，或者说会干不会包装，路是走不"远"的.显式cursor显式是相对与隐式cursor而言的，就是有一个明确的声明的cursor.显式游标的声明类似如下（详细的语法参加plsql ref doc ）cursor cursor_name (parameter list) is select ...游标从declare、open、fetch、close是一个完整的生命旅程。
当然了一个这样的游标是可以被多次open进行使用的，显式cursor是静态cursor，她的作用域是全局的，但也必须明白，静态cursor也只有pl/sql代码才可以使用她。
下面看一个简单的静态显式cursor的示例：declarecursor get_gsmno_cur (p_nettype in varchar2) is select gsmnofrom gsm_resourcewhere nettype=p_nettype and status='0'; v_gsmno gsm_resource.gsmno%type;beginopen get_gsmno_cur('139');loopfetch get_gsmno_cur into v_gsmno;exit when get_gsmno_cur%notfound; dbms_output.put_line(v_gsmno);end loop;close emp_cur;open get_gsmno_cur('138');loopfetch get_gsmno_cur into v_gsmno;exit when get_gsmno_cur%notfound; dbms_output.put_line(v_gsmno);end loop;close get_gsmno_cur;end;/上面这段匿名块用来实现选号的功能，我们显式的定义了一个get_gsmno_cur，然后根据不同的号段输出当前系统中该号短对应的可用手机号码。
plsql游标概念
plsql游标概念
PL/SQL游标（Cursor）是数据库编程中用于从数据库中检索数据的一种机制。
它允许程序逐行处理查询结果集，并对每一行执行特定的操作。
游标通常用于处理返回多行的查询，允许开发人员以编程方式访问和操作数据。
游标的工作原理是将从数据库中查询出来的数据以临时表的形式存放在内存中，然后通过指针或迭代器逐行访问这些数据。
在PL/SQL中，游标的使用通常涉及三个步骤：声明游标、打开游标、关闭游标。
声明游标：定义游标的名称、声明光标变量以及定义光标属性等。
打开游标：执行查询并将结果存储在游标变量中。
此时，游标处于打开状态，等待对结果集的检索操作。
关闭游标：完成对结果集的检索后，关闭游标以释放资源。
在PL/SQL中使用游标可以提供更灵活和强大的数据访问和处理能力，特别是在需要逐行处理大量数据的情况下。
然而，游标的使用也会增加程序的复杂性和资源消耗，因此在使用时应根据实际需求进行权衡和优化。
plsql基础（数据类型、定义变量）、游标、过程、函数、包、触发器（系统触发器）
【原创】oracle的学习六：pl/sql基础(数据类型、定义变量)、游标、过程、函数、包、触发器(系统触发器)2011-07-27 21:42:48| 分类：ORACLE | 标签：pl/sql基础数据类型定义变量游标、过程、函数包、触发器|字号大中小订阅1.PL/SQL的介绍∙pl/sql是什么pl/sql是oracle在标准sql语言上的扩展。
pl/sql不仅允许嵌入sql语言，还可以定义变量和常量，允许使用条件语句和循环语句，允许使用另外处理各种错误，功能强大。
∙为什么学pl/sql优点：1.提高应用程序的运行性能2.模块化得设计思想3.减少网络传输量4.提高数据库访问的安全性缺点：移植性不好∙开发工具：环境设置：∙页大小和行大小：set pagesize 50 linesize 120;∙更改日期格式：alter session setnls_date_format='YY-MM-DD HH24:MI:SS';∙为使用程序包DBMS_OUTPUT中的PUT_LINE过程输出: set serveroutput on;1.sqlplus---oracle公司提供的一个工具。
2.pl/sql developer 开发工具pl/sql developer 是用于开发pl/sql块的IDE，独立的产品。
举例：创建过程：create [or replace ] procedure 过程名is begin----执行过程end；/replace:表示如果存在过程名，就替换。
--：注释查看错误信息：show error调用过程：法一：exec 过程名(参数列)；法二：call 过程名(参数列)；∙块的类型所有的PL/Sql程序都是以块为基本单位。
块包含过程化语句和DML 语句。
块的分类：∙匿名块：出现在应用程序中的、没有名字、不存储在数据库中的块。
可以出现在SQL语句出现的地方。
可以调用其他程序，不能被调用。
【SQL】-基础知识梳理（六）-游标
【SQL】-基础知识梳理（六）-游标游标的概念结果集，结果集就是select查询之后返回的所有⾏数据的集合。
游标（Cursor）：是处理数据的⼀种⽅法。
它可以定位到结果集中的某⼀⾏，对数据进⾏读写。
也可以移动游标定位到你需要的⾏中进⾏数据操作。
是⾯向集合的数据库管理系统和⾯向⾏的程序设计之间的桥梁游标的分类SQL Server⽀持的API服务器游标分为4种：静态游标（ STATIC ）意味着，当游标被建⽴时，将会创建FOR后⾯的SELECT语句所包含数据集的副本存⼊tempdb数据库中，任何对于底层表内数据的更改不会影响到游标的内容。
动态游标（ DYNAMIC ）是和STATIC完全相反的选项,当底层数据库更改时，游标的内容也随之得到反映，在下⼀次fetch中，数据内容会随之改变。
键集驱动游标（ KEYSET ）可以理解为介于STATIC和DYNAMIC的折中⽅案。
将游标所在结果集的唯⼀能确定每⼀⾏的主键存⼊tempdb,当结果集中任何⾏改变或者删除时，@@FETCH_STATUS会为-2,KEYSET⽆法探测新加⼊的数据。
只进游标可以理解成不⽀持滚动，只⽀持从头到尾顺序提取数据，数据库执⾏增删改，在提取时是可见的，但由于该游标只能进不能向后滚动，所以在⾏提取后对⾏做增删改是不可见的。
（ FAST_FORWARD 可以理解为FORWARD_ONLY的优化版本.FORWARD_ONLY执⾏的是静态计划，⽽FAST_FORWARD是根据情况进⾏选择采⽤动态计划还是静态计划，⼤多数情况下FAST_FORWARD要⽐FORWARD_ONLY性能略好。
游标的语法DECLARE cursor_name CURSOR [ LOCAL |GLOBAL ][ FORWARD_ONLY | SCROLL ][ STATIC | KEYSET | DYNAMIC | FAST_FORWARD ][ READ_ONLY | SCROLL_LOCKS | OPTIMISTIC ][ TYPE_WARNING ]FOR select_statement[ FOR UPDATE [ OF column_name [ ,...n ] ] ]cursor_name：游标名称。
PLSQL编程变量控制语句游标
PLSQL编程变量控制语句游标PL/SQL编程概念1. PL/SQL是⼀种⾼级数据库程序设计语⾔，该语⾔专门⽤于在各种环境下对Oracle数据库进⾏访问。
有利于客户/服务器环境应⽤的运⾏过程化模块化运⾏错误的可处理性提供⼤量内置程序包2. 在PL/SQL中，只能使⽤SQL语句中的DML部分，不能使⽤DDL部分，如果要在PL/SQL中使⽤DDL（如 create table 等）的话，只能以动态的⽅式来使⽤。
3. PL/SQL程序由三个块组成，声明部分，执⾏部分，异常处理部分。
declare-- 声明部分：在此声明PL/SQL⽤到的变量，类型，及游标，以及局部存储过程的函数。
-- 标识符名不能超过30字符-- 第⼀个字符必须是字母-- 不分⼤⼩写-- 不能⽤-号开头-- 不能是sql保留字-- 不要把变量声明写成跟表中字段名⼀样begin-- 执⾏部分：过程及sql语句，即程序的主要部分。
exception-- 执⾏异常部分：错误处理end变量声明变量位于declare声明部分变量类型：类型⼦类说明char character和String定长字符串varchar2可变长字符串number Dec，Double，Integer,Int,Numeric,Real,Smalllong变长字符串Datebooleanrowid给变量赋值普通赋值语法：变量名变量类型 := 变量值；⽰例：i int := 10;数据库赋值（into）select语句赋值，每次select语句执⾏⼀次，就赋值⼀次declarename varchar2(20);beginselect ename into name from emp where empid = 10;dbms_output.put_line(name);endinsert,update,delete数据时⽤return赋值declareid rowid;name varchar2(20);begininsert into emp(eid,ename) values(123,'钟⽂涛') return eid,ename into id,name;dbms_output.put_line(id || '' || name);end复合数据类型记录类型把逻辑相关的，分离的，基本数据类型的变量组成⼀个整体储存起来。
PLSQL学习之——游标
PLSQL学习之——游标应⽤有个业务是跑⼀个全国的批量数据，但是存在执⾏时间过长的问题，因此考虑到分省执⾏的⽅法，即先将省号先存⼊游标⾥，然后省号通过变量的⽅式带⼊sql中where条件中执⾏。
在这个过程中也就⽤到了游标，作为⼀个dba，虽然没有必要根据业务写plsql，但是必须是要能看懂plsql的，以下为根据业务的语句，进⾏的模拟测试，需要注意的是plsql中的cursor和sql对应的cursor还是有区别的，具体区别会另写⽂章说明：*****************************创建cursor，并将cursor中的值进⾏打印，此⽅法在测试cursor中有⽆传⼊值时⾮常有⽤。
*****************************create table dayutest2(object_name varchar2(30),object_type varchar2(30),id number(30));insert into dayutest2 values('a','TABLE',1);insert into dayutest2 values('b','INDEX',1);set serveroutput ondeclarecursor v_product_cursor isselect object_type from dayutest2;beginfor v_object_type in v_product_cursor loopDBMS_OUTPUT.PUT_LINE('object_type = ' || v_object_type.object_type);end loop;end;/**************************以下为具体的⼀个测试案例**************************create table dayutest2(object_name varchar2(30),object_type varchar2(30),id number(30));insert into dayutest2 values('a','TABLE',1);insert into dayutest2 values('b','INDEX',1);drop table dayutes1;create table dayutest1 as select * from dba_objects where 1=2;create table test1 as select * from dba_objects;insert into test1 select * from test1;declarecursor v_product_cursor isselect object_type from dayutest2;BEGINFOR I IN v_product_cursor LOOPINSERT INTO dayutest1 d select /*+ parallel(t 4) */ * from test1 t where t.object_type=I.object_type; --这⾥需要特别注意⼀下COMMIT;END LOOP;end;/ --此过程创建的为块，并⾮为存储过程，运⾏直接会出结果。
Oracle PLSQL语言初级教程之游标(上)
文本Tag： PL/sql oracle
SQL是用于访问ORACLE数据库的语言，PL/SQL扩展和加强了SQL的功能，它同时引入ห้องสมุดไป่ตู้更强的程序逻辑。 PL/SQL支持DML命令和SQL的事务控制语句。DDL在PL/SQL中不被支持，这就意味作在PL/SQL程序块中不能创建表或其他任何对象。较好的PL/SQL程序设计是在PL/SQL块中使用象DBMS_SQL这样的内建包或执行EXECUTE IMMEDIATE命令建立动态SQL来执行DDL命令，PL/SQL编译器保证对象引用以及用户的权限。
%TYPE属性
在PL/SQL中可以将变量和常量声明为内建或用户定义的数据类型，以引用一个列名，同时继承他的数据类型和大小。这种动态赋值方法是非常有用的，比如变量引用的列的数据类型和大小改变了，如果使用了%TYPE,那么用户就不必修改代码，否则就必须修改代码。
例：
v_empno SCOTT.EMP.EMPNO%TYPE;
. TRUE :SELECT INTO至少返回一行
当SQL%FOUND为TRUE时,SQL%NOTFOUND为FALSE。
SQL%ROWCOUNT
在执行任何DML语句之前，SQL%ROWCOUNT的值都是NULL,对于SELECT INTO语句，如果执行成功，SQL%ROWCOUNT的值为1,如果没有成功，SQL%ROWCOUNT的值为0，同时产生一个异常NO_DATA_FOUND.
表1 隐式游标和显式游标
隐式游标 显式游标
PL/SQL维护，当执行查询时自动打开和关闭 在程序中显式定义、打开、关闭，游标有一个名字。
游标属性前缀是SQL 游标属性的前缀是游标名
实验3 PL_SQL的游标和异常
《数据库开发技术》课程之实验三PL/SQL的游标和异常处理DvhKpnQ199oJ7pMX709yvHax0_chdLJfS2eyiozCLm7DiBHBaRwAFWzWxERnmGJTeBGjPrwAU0iDLa一、实验目的1.掌握游标和参数化游标的使用方法。
2.掌握游标FOR循环、SELECT…FOR UPDATE游标和WHERE CURRENT OF子句的使用方法。
3.掌握正确使用异常处理的方法。
二、实验内容和要求1.编写匿名PL/SQL程序块，根据用户输入的部门编号实现在PL/SQL中逐行显示emp表中该部门员工的工资级别。
工资级别是：当工资为空时，为空，工资在1000元以下的为‘低’，在1000和3000之间的为‘中’，高于3000元的为‘高’。
要求使用参数化游标。
运行过程和效果如下：输入dept_id 的值: 10原值9: v_deptno:= &dept_id;新值9: v_deptno:= 10;7782,CLARK,2450,中7839,KING,5000,高7934,MILLER,1300,中PL/SQL 过程已成功完成。
代码：set serveroutput ondeclarev_empno emp.empno%type;v_ename emp.ename%type;v_sal emp.sal%type;v_deptno emp.deptno%type;sal_level varchar2(12);cursor c1 isselect empno,ename,sal from emp where deptno=&v_deptno;beginopen c1;loopfetch c1 into v_empno, v_ename,v_sal;exit when c1%notfound ;casewhen nvl(v_sal,0)=0 then sal_level:=' ';when v_sal<1000 then sal_level:='低';when v_sal>3000 then sal_level:='高';else sal_level:='中';end case;dbms_output.put_line(to_char(v_empno)||','||v_ename||','|| v_sal ||','|| to_char(sal_level));end loop;end;2.创建一个PL/SQL块，要求根据用户输入的员工编号（EMPNO），查询出EMP表中该编号员工所在的部门编号(deptno)及其直接管理者的姓名(ename)，要有异常处理(该员工编号不存在时或者该员工是总裁无直接主管时)。
postgreSQLPLSQL编程学习笔记（三）——游标（Cursors）
postgreSQLPLSQL编程学习笔记（三）——游标（Cursors）CursorsRather than executing a whole query at once, it is possible to set up a cursor that encapsulates the query, and then read the query result a few rows at a time. A more interesting usage is to return a reference to a cursor that a function has created, allowing the caller to read the rows.1. Declaring Cursor VariablesAll access to cursors in PL/pgSQL goes through cursor variables, which are always of the special data type refcursor. One way to create a cursor variable is just to declare it as a variable of type refcursor. Another way is to use the cursor declaration syntax, which in general is: name [ [ NO ] SCROLL ] CURSOR [ ( arguments ) ] FOR query;If SCROLL is specified, the cursor will be capable of scrolling backward;If NO SCROLL is specified, backward fetches will be rejected;If neither specification appears, it is query-dependent whether backward fetches will be allowed.Arguments, if specified, is a comma-separated list of pairs name datatype that define names to be replaced by parameter values in the given query.Some examples:DECLAREcurs1 refcursor;curs2 CURSOR FOR SELECT * FROM tenk1;curs3 CURSOR (key integer) FOR SELECT * FROM tenk1 WHERE unique1 = key;The variable curs1 is said to be unbound since it is not bound to any particular query. while the second has a fully specified query already bound to it, and the last has a parameterized query bound to it.2. Opening CursorsBefore a cursor can be used to retrieve rows, it must be opened. (equal to the SQL command DECLARE CURSOR.) PL/pgSQL has three forms of the OPEN statement, two of which use unbound cursor variables while the third uses a bound cursor variable.2.1. OPEN FOR queryOPEN unbound_cursorvar [ [ NO ] SCROLL ] FOR query;The cursor variable here should be a simple refcursor variable that has not been opened.The query must be a SELECT, or something else that returns rows (such as EXPLAIN). The query is treated in the same way as other SQL commands in PL/pgSQL: PL/pgSQL variable names are substituted, and the query plan is cached for possible reuse.When a PL/pgSQL variable is substituted into the cursor query, the value that is substituted is the one it has at the time of the OPEN; subsequent changes to the variable will not affect the cursor’s behavior.The SCROLL and NO SCROLL options have the same meanings as for a bound cursor.An example:OPEN curs1 FOR SELECT * FROM foo WHERE key = mykey;2.2. OPEN FOR EXECUTEOPEN unbound_cursorvar [ [ NO ] SCROLL ] FOR EXECUTE query_string[ USING expression [, ... ] ];The cursor variable is opened and given the specified query to execute. The cursor variable here should be a simple refcursor variable that has not been opened.The query is specified as a string expression, in the same way as in the EXECUTE command.As usual, this gives flexibility so the query plan can vary from one run to the next, and it also means that variable substitution is not done on the command string.As with EXECUTE, parameter values can be inserted into the dynamic command via format() and USING.The SCROLL and NO SCROLL options have the same meanings as for a bound cursor.An example:OPEN curs1 FOR EXECUTE format(’SELECT * FROM %I WHERE col1 = $1’,tabname) USING keyvalue;In this example, the table name is inserted into the query via format(). The comparison value for col1 is inserted via a USING parameter, so it needs no quoting.2.3. Opening a Bound CursorOPEN bound_cursorvar [ ( [ argument_name := ] argument_value [, ...] ) ];This form of OPEN is used to open a cursor variable whose query was bound to it when it was declared. The cursor cannot be open already. A list of actual argument value expressions must appear if and only if the cursor was declared to take arguments. These values will be substituted in the query.The query plan for a bound cursor is always considered cacheable; there is no equivalent of EXECUTE in this case.Notice that SCROLL and NO SCROLL cannot be specified in OPEN, as the cursor’s scrolling behavior was already determined. Argument values can be passed using either positional or named notation.In positional notation, all arguments are specified in order.In named notation, each argument’s name is specified using := to separate it from the argument expression.Similar to calling functions, it is also allowed to mix positional and named notation. Examples (these use the cursor declaration examples above):OPEN curs2;OPEN curs3(42);OPEN curs3(key := 42);Because variable substitution is done on a bound cursor’s query, there are really two ways to pass values into the cursor: either with an explicit argument to OPEN, or implicitly by referencing a PL/pgSQL variable in the query. For example, another way to get the same effect as the curs3 example above isDECLAREkey integer;curs4 CURSOR FOR SELECT * FROM tenk1 WHERE unique1 = key;BEGINkey := 42;OPEN curs4;3. Using CursorsOnce a cursor has been opened, it can be manipulated with the statements described here. These manipulations need not occur in the same function that opened the cursor to begin with. You can return a refcursor value out of a function and let the caller operate on the cursor.3.1. FETCHFETCH [ direction { FROM | IN } ] cursor INTO target;FETCH retrieves the next row from the cursor into a target, which might be a row variable, a record variable, or a comma-separated list of simple variables, just like SELECT INTO.If there is no next row, the target is set to NULL(s). As with SELECT INTO, the special variable FOUND can be checked to see whether a row was obtained or not.The direction clause can be any of the variants allowed in the SQL FETCH command except the ones that can fetch more than one row; namely, it can be NEXT, PRIOR, FIRST, LAST, ABSOLUTE count, RELATIVE count, FORWARD, or BACKWARD. Omitting direction is the same as specifying NEXT.direction values that require moving backward are likely to fail unless the cursor was declared or opened with the SCROLL option.cursor must be the name of a refcursor variable that references an open cursor portal.Examples:FETCH curs1 INTO rowvar;FETCH curs2 INTO foo, bar, baz;FETCH LAST FROM curs3 INTO x, y;FETCH RELATIVE -2 FROM curs4 INTO x;3.2. MOVEMOVE [ direction { FROM | IN } ] cursor;MOVE repositions a cursor without retrieving any data. MOVE works exactly like the FETCH command, except it only repositions the cursor and does not return the row moved to.As with SELECT INTO, the special variable FOUND can be checked to see whether there was a next row to move to.The direction clause can be any of the variants allowed in the SQL FETCH command. Omitting direction is the same as specifying NEXT. direction values that require moving backward are likely to fail unless the cursor was declared or opened with the SCROLL option. Examples:MOVE curs1;MOVE LAST FROM curs3;MOVE RELATIVE -2 FROM curs4;MOVE FORWARD 2 FROM curs4;3.3. UPDATE/DELETE WHERE CURRENT OFUPDATE table SET ... WHERE CURRENT OF cursor;DELETE FROM table WHERE CURRENT OF cursor;When a cursor is positioned on a table row, that row can be updated or deleted using the cursor to identify the row.There are restrictions on what the cursor’s query can be (in particular, no grouping) and it’s best to use FOR UPDATE in the cursor. For more information see the DECLARE reference page.An example:UPDATE foo SET dataval = myval WHERE CURRENT OF curs1;3.4. CLOSECLOSE cursor;CLOSE closes the portal underlying an open cursor. This can be used to release resources earlier than end of transaction, or to free up the cursor variable to be opened again.An example:CLOSE curs1;3.5. Returning CursorsPL/pgSQL functions can return cursors to the caller. This is useful to return multiple rows or columns, especially with very large result sets. To do this, the function opens the cursor and returns the cursor name to the caller (or simply opens the cursor using a portal name specified by or otherwise known to the caller).The caller can then fetch rows from the cursor. The cursor can be closed by the caller, or it will be closed automatically when the transaction closes.The portal name used for a cursor can be specified by the programmer or automatically generated. To specify a portal name, simply assign a string to the refcursor variable before opening it. The string value of the refcursor variable will be used by OPEN as the name of the underlying portal. However, if the refcursor variable is null, OPEN automatically generates a name that does not conflict with any existing portal, and assigns it to the refcursor variable.Note: A bound cursor variable is initialized to the string value representing its name, so that the portal name is the same as the cursor variable name, unless the programmer overrides it by assignment before opening the cursor. But an unbound cursor variable defaults to the null value initially, so it will receive an automatically-generated unique name, unless overridden.The following example shows one way a cursor name can be supplied by the caller:CREATE TABLE test (col text);INSERT INTO test VALUES (’123’);CREATE FUNCTION reffunc(refcursor) RETURNS refcursor AS ’BEGINOPEN $1 FOR SELECT col FROM test;RETURN $1;END;’ LANGUAGE plpgsql;BEGIN;SELECT reffunc(’funccursor’);FETCH ALL IN funccursor;COMMIT;The following example uses automatic cursor name generation:CREATE FUNCTION reffunc2() RETURNS refcursor AS ’DECLAREref refcursor;BEGINOPEN ref FOR SELECT col FROM test;RETURN ref;END;’ LANGUAGE plpgsql;-- need to be in a transaction to use cursors.BEGIN;SELECT reffunc2();reffunc2--------------------<unnamed cursor 1>(1 row)FETCH ALL IN "<unnamed cursor 1>";COMMIT;The following example shows one way to return multiple cursors from a single function:CREATE FUNCTION myfunc(refcursor, refcursor) RETURNS SETOF refcursor AS $$BEGINOPEN $1 FOR SELECT * FROM table_1;RETURN NEXT $1;OPEN $2 FOR SELECT * FROM table_2;RETURN NEXT $2;END;$$ LANGUAGE plpgsql;-- need to be in a transaction to use cursors.BEGIN;SELECT * FROM myfunc(’a’, ’b’);FETCH ALL FROM a;4. Looping Through a Cursor’s ResultThere is a variant of the FOR statement that allows iterating through the rows returned by a cursor.The syntax is:[ <<label>> ]FOR recordvar IN bound_cursorvar [ ( [ argument_name := ] argument_value [, ...] ) ] LOOPstatementsEND LOOP [ label ];The cursor variable must have been bound to some query when it was declared, and it cannot be open already. The FOR statement automatically opens the cursor, and it closes the cursor again when the loop exits.A list of actual argument value expressions must appear if and only if the cursor was declared to take arguments. These values will be substituted in the query, in just the same way as during an OPEN.The variable recordvar is automatically defined as type record and exists only inside the loop (any existing definition of the variable name is ignored within the loop). Each row returned by the cursor is successively assigned to this record variable and the loop body is executed.。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
DECLARE v_Major VARCHAR2(1000); v_PLSQLBlock VARCHAR2(1000); CURSOR c_EconMajor IS SELECT * FROM students WHERE major = v_Major ; -- 可以在定义游标的语句中使用前面已经定义的变量
游标提取循环
– 简单循环 – WHILE循环 – 游标式FOR循环
简单循环
使用简单循环LOOP…END LOOP;语法控制循环。
OPEN c_Cursor; LOOP FETCH c_Cursor INTO r_Cursor; EXIT WHEN c_Cursor%NOTFOUND; END LOOP;
参数化游标
CURSOR c_Class(p_Dep classes.department%TYPE, p_Course classes.course) IS SELECT * FROM classes WHERE department = p_Dep AND course = p_Course;
OPEN时将参数传递给游标
WHILE循环
使用 WHILE…LOOP语法构建提取循环。
OPEN c_HistoryStudents; FETCH c_HistoryStudents INTO v_StudentData; WHILE c_HistoryStudents%FOUND LOOP FETCH c_HistoryStudents INTO v_StudentData; END LOOP;
OPEN c_Class(‘HIS’,101);
隐式游标(SQL游标)
与显示游标不同的是，SQL游标不被程序打开和关闭，PL/SQL隐含 的打开SQL游标，处理其中的语句，然后关闭游标。 隐式游标用于处理INSERT, UPDATE, DELETE和单行的 SELECT…INTO语句。
具有以下属性 – SQL%NOTFOUND SQL%FOUND – SQL%ROWCOUNT – SELECT…INTO语句找不到任何行时，触 发 ORA-1403: no data found错误。
游标的属性
%FOUND %NOTFOUND %ISOPEN %ROWCOUNT
游标属性
%ISOPEN %FOUND %NOTFOUND
描述
BOOLEAN型，游标打开是返回TRUE。 BOOLEAN型,如果FETCH操作取得一行，返回 TURE。 BOOLEAN型, 与%FOUND相反。
%ROWCOUNT 数字型，返回到当前为止返回的纪录数。
– cursor_name是已经声明并打开的游标 – list_of_variable是已经被声明的变量的列表
– PL/SQL_record是已经被声明的PL/SQL记录。
– INTO子句中的变量类型必须与查询语句的选择列表的类型
兼容。
关闭游标
CLOSE cursor_name;
– cursor_name是原来已经打开的游标 – 一旦游标关闭就无法在提取数据
三.游标CURSOR
目标
完成本节课学习后，应当达到如下目标:
– 掌握处理游标所需的步骤。
– 通过游标的属性，对游标进行控制。 – 掌握不同种类的提取循环。
什么是游标
– 为了处理SQL语句，Oracle必须分配一片
内存区域，这就是context are。这个区域 包含了完成该语句的必需信息。 – 游标是指向context are的句柄或指针。通 过游标，PL/SQL程序可以控制context are 和在处理语句时context are发生些什么事 情。 – 游标可分为显示游标和隐式游标
– 讨论了不同的游标提取循环。
打开游标
OPEN cursor_name;
当游标打开时：
– 联编变量的取值被检查。 – 根据联编变量的取值，活动集被确定。 – 活动集的指针指向第一行。
从游标提取
FETCH cursor_name INTO list_of_variables; FETCH cursor_name INTO PL/SQL_record; 查询的INTO子句是FETCH语句的一部分。FETCH语句有以上两种形式。
游标式FOR循环
使用FOR循环，可以隐式地进行游标处理。
FOR v_StudentData IN c_HistoryStudents LOOP ….. END LOOP;
– FOR循环不需要OPEN, FETCH, CLOSE的语句。
– v_StudentData 变量不必要事先声明。
小结
– 讨论了处理游标所需的必要步骤。 – 讨论了游标的属性。
处理显示游标
显示游标的处理包括四个PL/SQL步骤:
– 声明游标(在声明部分) – 打开游标(在执行部分) – 将结果提取到PL/SQL变量中(在执行部分) – 关闭游标(在执行部分)
声明游标
CURSOR cursor-name IS SELECT-statement; 注：这里的SELECT-statement不包含 INTO 子句