devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Oracle中的游标_oracle 游标

作者：从前慢现在也慢 | 2024-04-26 04:04:11

赞

踩

oracle 游标

目录

一、游标定义

二、游标分类

2.1静态游标

2.1.1. 隐式游标：

2.1.2. 显式游标：

2.1.3. 游标变量：

2.1.4. 游标参数：

2.2动态游标

2.2.1强类型游标

2.2.2弱类型游标

2.2.3普通动态游标

三、游标的优缺点

优点：

缺点：

四、游标使用注意事项

五、游标的作用

一、游标定义

游标即cursor，是一种用于遍历结果集的数据类型。它是一个指向结果集的指针，可以用于遍历结果集中的每一行数据，但是一次只能指向一行。游标通常用于存储过程和函数中，以便在处理结果集时能够逐行处理数据。

游标提供了在逐行的基础上操作表中数据的方法，游标的结果集是由select语句产生的。
拿个表来打比方，游标打开时会在第一行数据的上面每fetch一次，下去一行。

二、游标分类

游标有两种类型：静态游标和动态游标。接下来分别描述各个类型的游标：

2.1静态游标

静态游标是一种在编译时就确定结果集的游标，其结果集不会随着时间或用户的不同而发生变化。在Oracle中，静态游标包括以下几种类型：

2.1.1. 隐式游标：

由SELECT语句自动创建的游标，其结果集在编译时就已经确定，不会随时间或用户的不同而发生变化。而且隐式游标是Oracle数据库默认使用的游标类型。它是一种只能在SQL语句中使用的游标，不能在PL/SQL代码中使用。隐式游标会在执行一条SELECT语句时自动创建，并且只能返回一行数据。例如：

  1. SELECT column1, column2
  2. FROM table1
  3. WHERE column3 = 'value';
  4.  
  5. SELECT * 
  6. FROM employees 
  7. WHERE department_id = 10;
  8.

 上面的SELECT语句会自动创建一个隐式游标，其结果集是所有部门ID为10的员工。由于结果集在编译时就已经确定，因此这是一种静态游标。

总结：

隐式游标不用声明，不用打开，不用赋值，不用关闭，这些都是oracle自动完成的。
常见的方式有 delete 、update、 insert select into 单行赋值（主要用来统计dml操作了多少行）格式：

INSERT UPDATE DELETE SELECT..int

隐式游标的四个属性

  • sql%isopen   判断游标是否打开 ，永远返回假
  • sql%found    判断指针里面是否有值 ，如果指针里曾经有值 ，返回的是真
  • sql%notfound 和found相反
  • sql%rowcount 返回指针指过的行数

举例说明：

要求给emp1表的10部门员工工资增加500，并打印有多少人增加了 工资：

  1. begin
  2.   update emp1 set sal=sal+500 where deptno=10;
  3.   dbms_output.put_line(sql%rowcount);
  4.   if sql%found then dbms_output.put_line('有人涨工资了');
  5.   end if;
  6. end;

2.1.2. 显式游标：

由DECLARE、OPEN、FETCH和CLOSE等语句手动创建的游标，其结果集在定义游标时就已经确定，不会随时间或用户的不同而发生变化。并且显式游标是由程序员在PL/SQL代码中显式声明和使用的游标类型。它可以在程序中读取和处理多行数据。例如：

  1. DECLARE
  2.   cursor_name CURSOR FOR
  3.     SELECT column1, column2
  4.     FROM table1
  5.     WHERE column3 = 'value';
  6.     
  7.   var1 table1.column1%TYPE;
  8.   var2 table1.column2%TYPE;
  9. BEGIN
  10.   OPEN cursor_name;
  11.   
  12.   LOOP
  13.     FETCH cursor_name INTO var1, var2;
  14.     EXIT WHEN cursor_name%NOTFOUND;
  15.     
  16.     -- 处理数据
  17.   END LOOP;
  18.   
  19.   CLOSE cursor_name;
  20. END;
  21. -------------------------------------------------------------------------------
  22. DECLARE
  23.   CURSOR c_emp IS SELECT * FROM employees WHERE department_id = 10;
  24.   v_emp employees%ROWTYPE;
  25. BEGIN
  26.   OPEN c_emp;
  27.   LOOP
  28.     FETCH c_emp INTO v_emp;
  29.     EXIT WHEN c_emp%NOTFOUND;
  30.     -- 对结果集进行处理
  31.   END LOOP;
  32.   CLOSE c_emp;
  33. END;
  34.

上面的代码定义了一个名为c_emp的显式游标，其结果集是所有部门ID为10的员工。由于结果集在定义游标时就已经确定，因此这是一种静态游标。

其实显示游标又分为带参数的显示游标和不带参数的显示游标。

Ⅰ、不带参数的显式游标 
声明方法：

cursor 游标名 is select 语句

例如：

打印部门dept表中的所有部门名称（dept表一共有4个部门）：

  1. declare
  2. cursor c1 is select dname from dept;
  3. v_name varchar2(20);
  4. begin
  5.   open c1;
  6.   fetch c1 into v_name;
  7.   dbms_output.put_line(v_name);
  8.   fetch c1 into v_name;
  9.   dbms_output.put_line(v_name);
  10.   fetch c1 into v_name;
  11.   dbms_output.put_line(v_name);
  12.   fetch c1 into v_name;
  13.   dbms_output.put_line(v_name);  
  14.   close c1;
  15. end;

 循环打印dept表中的所有部门名称：

  1. declare
  2. cursor c1 is select dname from dept;
  3. v_name varchar2(20);
  4. begin
  5.   open c1;
  6.  for i in 1..4 loop
  7.    fetch c1 into v_name;
  8.   dbms_output.put_line(v_name);
  9.   end loop;
  10.   close c1;
  11. end;

打印员工emp表所有的员工编号 （表内一共有14个员工信息）：

  1. declare
  2. cursor c1 is select empno from emp;
  3. v_name varchar2(20);
  4. begin
  5.   open c1;
  6.  for i in 1..14 loop
  7.    fetch c1 into v_name;
  8.   dbms_output.put_line(v_name);
  9.   end loop;
  10.   close c1;
  11. end;

但是如果我们不知道一张表内某个列中值有多少行时，就得用到游标的四个属性 ：

  • 游标名%isopen     判断游标是否打开，是的话返回真 ，否则返回假
  • 游标名%found       判断游标的指针里是否有值，有值返回真 ，没值返回假
  • 游标名%notfound  判断游标的指针里是否没值，没值返回真 ，有值返回假
  • 游标名%rowcount 游标的指针指了多少行，返回的是行数

普通循环搭配不带参数的显式游标的步骤顺序如下：

  • 1.打开游标
  • 2.loop
  • 3.fetch
  • 4.exit when
  • 5.打印
  • 6.end loop
  • 7.关闭游标

比如：

打印员工emp表中的所有员工编号 ：

  1. declare 
  2. cursor c1 is select empno from emp;
  3. v_empno number;
  4. begin
  5.   open c1;
  6.   loop
  7.     fetch c1 into v_empno;
  8.     exit when c1%notfound;
  9.     dbms_output.put_line(v_empno);
  10.   end loop;
  11.    close c1;
  12. end;

打印emp表经理是KING的员工姓名:

  1. declare 
  2. cursor c1 is select ename 
  3.              from emp 
  4.              where mgr=(select empno 
  5.                         from emp 
  6.                         where ename='KING');
  7. v_name varchar2(20);
  8. begin
  9.   open c1;
  10.   loop
  11.     fetch c1 into v_name;
  12.     exit when c1%notfound;
  13.     dbms_output.put_line(v_name);
  14.   end loop;
  15.    close c1;
  16. end;

 打印 emp表经理是KING的姓名以及人数:

  1. declare 
  2. cursor c1 is select ename 
  3.              from emp 
  4.              where mgr=(select empno 
  5.                         from emp 
  6.                         where ename='KING');
  7. v_name varchar2(20);
  8. begin
  9.   open c1;
  10.   loop
  11.     fetch c1 into v_name;
  12.     exit when c1%notfound;
  13.     dbms_output.put_line(v_name);   
  14.   end loop; 
  15.    dbms_output.put_line('有'||c1%rowcount||'人');
  16.    close c1;
  17. end;

while 循环和游标 -WHILE循环+%found的步骤 ：

  • 1.open       打开游标
  • 2.fetch      先提取一次 以便进入循环
  • 3.while      
  • 4.打印       进入循环先打印一次 避免漏掉第一条数据
  • 5.fetch
  • 6.end loop
  • 7.close

为什么这里要多打印一次呢，因为在open后fetch前，我们的游标%found是为假的，所以就无法进入while循环,必须先fetch一遍！！！

举例说明：

打印dept表中的所有部门名称：

  1. declare
  2. cursor c1 is select dname from dept;
  3. v_name varchar2(20);
  4. begin
  5.   open c1;
  6.   fetch c1 into v_name;      --先提取一次
  7.   while c1%found loop
  8.     dbms_output.put_line(v_name);
  9.     fetch c1 into v_name;
  10.   end loop;
  11.   close c1;
  12. end;

要求 打印emp表职位是销售的员工信息，使用while循环和游标方法，则语句如下：

  1. declare
  2. cursor c is select *
  3.             from emp 
  4.             where job='SALESMAN';
  5. v emp%rowtype;
  6. begin
  7.   open c;
  8.   fetch c into v;
  9.   while c%found loop
  10.     dbms_output.put_line(lpad(v.empno,9,' ')||''||
  11. lpad(v.ename,9,' ')||''||
  12. lpad(v.job,9,' ')||''||
  13. lpad(v.mgr,9,' ')||''||
  14. lpad(v.hiredate,9,' ')||''||
  15. lpad(v.sal,9,' ')||''||
  16. lpad(v.comm,9,' ')||''||
  17. lpad(v.deptno,9,' ')
  18. );
  19.     fetch c into v;
  20.   end loop;
  21.   close c;
  22. end;

Ⅱ、带参数的显式游标
声明参数时，只用写类型，不用写长度，参数可以在where条件后调用。使用时需要在open游标后加括号里面填上参数（多个参数用逗号隔开）。格式为：

CURSOR cur_name(参 类型,..) IS SELECT 语句(包含参);

比如：

要求打印emp表中部门编号是10的员工姓名，然后再打印emp表中部门编号是20的员工编号：

  1. declare
  2. cursor c1(v number) is 
  3.           select ename,empno from emp where deptno=v;
  4. vname varchar2(20);
  5. vempno number;
  6. begin
  7.   open c1(10);
  8.   loop
  9.     fetch c1 into vname,vempno;
  10.     exit when c1%notfound;
  11.     dbms_output.put_line(vname);
  12.   end loop;
  13.   close c1;
  14.   open c1(20);
  15.     loop
  16.     fetch c1 into vname,vempno;
  17.     exit when c1%notfound;
  18.     dbms_output.put_line(vempno);
  19.   end loop;
  20.   close c1;
  21. end;

请打印emp表中职位是CLERK的姓名，职位是MANAGER的工资 ：

  1. declare
  2. cursor c1 (v varchar2) is 
  3.        select ename,sal from emp where job=v;
  4. v_name varchar2(20);
  5. v_sal number;
  6. begin
  7.   open c1('CLERK'); 
  8.   loop
  9.   fetch c1 into v_name,v_sal;
  10.   exit when c1%notfound;
  11.   dbms_output.put_line(v_name);
  12.   end loop;
  13.   close c1;
  14.   open c1('MANAGER');
  15.   LOOP
  16.   fetch c1 into v_name,v_sal;
  17.   exit when c1%notfound;
  18.   dbms_output.put_line(v_sal);
  19.   end loop;
  20.   close c1;
  21.  end;

2.1.3. 游标变量：

可以将查询结果集存储在游标变量中，以便在后续的处理中使用。游标变量在定义时需要指定结果集，其结果集也是在编译时就已经确定的。游标变量是一种PL/SQL变量，它可以存储一个游标对象。游标变量可以在程序中传递和重复使用，可以在不同的程序块中声明和使用。例如：

  1. DECLARE
  2.   cursor_name SYS_REFCURSOR;
  3.   var1 table1.column1%TYPE;
  4.   var2 table1.column2%TYPE;
  5. BEGIN
  6.   OPEN cursor_name FOR
  7.     SELECT column1, column2
  8.     FROM table1
  9.     WHERE column3 = 'value';
  10.     
  11.   LOOP
  12.     FETCH cursor_name INTO var1, var2;
  13.     EXIT WHEN cursor_name%NOTFOUND;
  14.     
  15.     -- 处理数据
  16.   END LOOP;
  17.   
  18.   CLOSE cursor;
  19. ------------------------------------------------------------
  20. DECLARE
  21.   TYPE t_emp IS RECORD (
  22.     employee_id    employees.employee_id%TYPE,
  23.     first_name     employees.first_name%TYPE,
  24.     last_name      employees.last_name%TYPE,
  25.     email          employees.email%TYPE,
  26.     phone_number   employees.phone_number%TYPE
  27.   );
  28.   TYPE t_emp_list IS TABLE OF t_emp;
  29.   v_emp_list t_emp_list;
  30. BEGIN
  31.   SELECT employee_id, first_name, last_name, email, phone_number
  32.   BULK COLLECT INTO v_emp_list
  33.   FROM employees
  34.   WHERE department_id = 10;
  35.   -- 对结果集进行处理
  36. END;
  37.

上面的代码将所有部门ID为10的员工存储在名为v_emp_list的游标变量中。由于结果集在定义游标变量时就已经确定，因此这是一种静态游标。 

2.1.4. 游标参数：

可以将查询结果集作为参数传递给存储过程或函数，以便在后续的处理中使用。游标参数在定义时需要指定结果集，其结果集也是在编译时就已经确定的。例如：

  1. CREATE OR REPLACE PROCEDURE p_emp_list (p_dept_id IN NUMBER, 
  2.                                         p_emp_list OUT SYS_REFCURSOR)
  3. IS
  4. BEGIN
  5.   OPEN p_emp_list FOR
  6.     SELECT * FROM employees WHERE department_id = p_dept_id;
  7. END;

上面的代码定义了一个名为p_emp_list的存储过程，其参数p_dept_id是部门ID，p_emp_list是查询结果集。当调用p_emp_list存储过程时，会根据传入的部门ID返回相应的员工列表。该存储过程可以被其他程序调用，并将查询结果作为输出参数返回。

总结：

静态游标是一种在编译时就确定结果集的游标，其结果集不会随着时间或用户的不同而发生变化。在实际应用中，可以根据需要选择不同类型的静态游标来处理数据。

2.2动态游标

动态游标是一种在 PL/SQL 中使用游标的方式，它允许在运行时动态地构建 SQL 查询语句，以便适应不同的查询需求。相比于静态游标，动态游标更加灵活，可以根据不同的条件和参数生成不同的查询语句。

列举使用动态游标的示例：

  1. CREATE OR REPLACE PROCEDURE p_emp_list (p_dept_id IN NUMBER, 
  2.                                         p_emp_list OUT SYS_REFCURSOR)
  3. IS
  4.   v_query VARCHAR2(200);
  5. BEGIN
  6.   v_query := 'SELECT * FROM employees WHERE department_id = ' || p_dept_id;
  7.   OPEN p_emp_list FOR v_query;
  8. END;

在该存储过程中，使用一个 VARCHAR2 类型的变量 v_query 来构建动态查询语句。首先将一个固定的字符串 'SELECT * FROM employees WHERE department_id = ' 和输入参数 p_dept_id 拼接起来，生成一个完整的查询语句。然后使用 OPEN 语句打开游标 p_emp_list，并将动态查询语句作为参数传入。

通过使用动态游标，该存储过程可以根据不同的部门 ID 生成不同的查询语句，并返回不同的查询结果。这种灵活性使得动态游标在复杂的查询场景中非常有用。

但是动态游标也有强弱之分，下面分别描述：

2.2.1强类型游标

强游标（strong cursor）是指在游标打开时就将所有数据都读入到游标中，因此游标可以在任何时候访问数据，但是这种方式会占用大量的内存资源。而且强类型游标是可以更换结果集，但是不能换表结构。

比如：

要求打印emp表的10部门的员工姓名，并打印emp1职位是CLERK的员工编号，则语句如下：

  1. declare 
  2. type ty1 is ref cursor return emp%rowtype;
  3. c1 ty1;
  4. vemp emp%rowtype;
  5. begin
  6.   open c1 for select * from emp where deptno=10;
  7.   loop
  8.     fetch c1 into vemp;
  9.     exit when c1%notfound;
  10.     dbms_output.put_line(vemp.ename);
  11.   end loop;
  12.   close c1;
  13.   open c1 for select * from emp1 where job='CLERK';
  14.   loop
  15.    fetch c1 into vemp;
  16.     exit when c1%notfound;
  17.     dbms_output.put_line(vemp.empno);
  18.   end loop;
  19.   close c1;
  20. end;

创建三个表分别为 empa empb empc ，内容均和emp表一样，打印empa中10部门的员工姓名和部门编号，empb中工资大于2000的员工姓名和工资，empc中职位是CLERK的员工姓名和职位 ，则具体语句如下：

  1. create table empa as select * from emp;
  2. create table empb as select * from emp;
  3. create table empc as select * from emp;
  4.  
  5. declare
  6. type ty1 is ref cursor return emp%rowtype;
  7. c1 ty1;
  8. v_emp emp%rowtype;
  9. begin
  10.   open c1 for select * from empa where deptno=10;
  11.   loop
  12.     fetch c1 into  v_emp;
  13.     exit when c1%notfound;
  14.     dbms_output.put_line(v_emp.ename||' '||v_emp.deptno);
  15.   end loop;
  16.   close c1;
  17.   open c1 for select * from empb where sal>2000;
  18.   loop
  19.      fetch c1 into  v_emp;
  20.     exit when c1%notfound;
  21.     dbms_output.put_line(v_emp.ename||' '||v_emp.sal);
  22.   end loop;
  23.   close c1;
  24.   open c1 for select * from empc where job='CLERK';
  25.   loop
  26.     fetch c1 into v_emp;
  27.     exit when c1%notfound;
  28.     dbms_output.put_line(v_emp.ename||' '||v_emp.job);
  29.   end loop;
  30.   close c1;
  31. end;

2.2.2弱类型游标

弱游标（weak cursor）是指游标只在需要访问数据时才会读取数据，因此占用内存资源较少，但是需要在访问数据时进行频繁的I/O操作，因此效率较低。而且弱类型游标也可以更换结果集，而且可以换表结构。

比如：

要求打印emp表的员工姓名和dept表的部门所在地，并打印emp表每个部门的员工人数，则语句如下：

  1. declare
  2. type t1 is ref cursor;
  3. c1 t1;
  4. v1 varchar2(20);
  5. v2 number;
  6. begin
  7.   open c1  for select ename from emp;
  8.   loop
  9.     fetch c1 into v1;
  10.     exit when c1%notfound;
  11.     dbms_output.put_line(v1);
  12.   end loop;
  13.   close c1;
  14.  open c1 for select loc from dept;
  15.  loop
  16.    fetch c1 into v1;
  17.     exit when c1%notfound;
  18.     dbms_output.put_line(v1);
  19.   end loop;
  20.   close c1;
  21.  open c1 for select count(1) from emp group by deptno;
  22.  loop
  23.    fetch c1 into v2;
  24.    exit when c1%notfound;
  25.     dbms_output.put_line(v2);
  26.   end loop;
  27.   close c1;
  28. end;

总结：

在使用动态游标时，需要根据具体情况选择合适的游标类型，权衡内存资源和访问效率。

强类型游标和弱类型游标的区别：

  • 强类型有return open时for的结果集
  • 必须和return表结构一致
  • 弱类型没有return open时for的结果集比较自由

2.2.3普通动态游标

是最常用的动态游标，语句格式：

  1. declare
  2. c1 sys_refcursor; --声明一个动态游标

比如：

打印emp表的员工姓名和dept表的部门所在地，并打印emp表每个部门的员工人数，则语句如下：

  1. declare
  2. c1 sys_refcursor;
  3. v1 varchar2(20);
  4. v2 number;
  5. begin
  6.   open c1  for select ename from emp;
  7.   loop
  8.     fetch c1 into v1;
  9.     exit when c1%notfound;
  10.     dbms_output.put_line(v1);
  11.   end loop;
  12.   close c1;
  13.  open c1 for select loc from dept;
  14.  loop
  15.    fetch c1 into v1;
  16.     exit when c1%notfound;
  17.     dbms_output.put_line(v1);
  18.   end loop;
  19.   close c1;
  20.  open c1 for select count(1) from emp group by deptno;
  21.  loop
  22.    fetch c1 into v2;
  23.    exit when c1%notfound;
  24.     dbms_output.put_line(v2);
  25.   end loop;
  26.   close c1;
  27. end;

要求打印emp表名字包含A的员工姓名和人数，dept表包含A的部门名称和部门数，则语句如下：

  1. declare
  2. c1 sys_refcursor;
  3. vname varchar2(20);
  4. vcount number;
  5. begin
  6.   open c1 for select ename from emp where ename like'%A%';
  7.   loop
  8.     fetch c1 into vname;
  9.     exit when c1%notfound;
  10.     dbms_output.put_line(vname);
  11.     end loop;
  12.     close c1;
  13.   open c1 for  select count(1) from emp where ename like'%A%';
  14.     loop
  15.     fetch c1 into vcount;
  16.     exit when c1%notfound;
  17.     dbms_output.put_line(vcount);
  18.     end loop;
  19.     close c1;
  20.  open c1 for select dname from dept where dname like'%A%';
  21.   loop
  22.     fetch c1 into vname;
  23.     exit when c1%notfound;
  24.     dbms_output.put_line(vname);
  25.     end loop;
  26.     close c1;
  27.   open c1 for  select count(1) from dept where dname like'%A%';
  28.     loop
  29.     fetch c1 into vcount;
  30.     exit when c1%notfound;
  31.     dbms_output.put_line(vcount);
  32.     end loop;
  33.     close c1;
  34. end;

for循环+游标

Ⅰ、有游标名的
声明一个显式游标，不用打开 ，不用赋值 ，不用关闭，因为有游标名 所以可以用游标的属性；

比如：

打印dept表的所有信息：

  1. declare
  2. cursor c1 is select * from dept;
  3. begin
  4.   for i in c1 loop
  5.     dbms_output.put_line(i.deptno||' '||i.dname
  6.                         ||' '||i.loc);
  7.   end loop;
  8. end;

Ⅱ、没有游标名
不用声明 ，不用打开 ，不用赋值 ，不用关闭；不能和动态游标和带参数的显式游标一起使用 （直接for i in结果集） ；

比如：

打印dept表的所有信息：

  1. begin
  2.   for i in (select * from dept) loop
  3.     dbms_output.put_line(i.deptno||' '||i.dname||
  4.                          ' '||i.loc);
  5.   end loop;
  6. end;

三、游标的优缺点

优点：

  • 可以对大量数据进行有效的遍历和操作，尤其是在数据量较大时；
  • 可以根据需要随时调整游标位置，灵活性较高；
  • 可以在一些特定的场景下提高程序的效率；
  • 使用游标可以执行多个不相关的操作；
  • 使用游标可以提高脚本的可读性；
  • 使用游标可以建立命令字符串，可以传送表名，或者把变量传送到参数中，以便建立可以执行的命令字符串；
  • 提供基于游标位置而对表中数据进行删除或更新；

缺点：

  • 处理大数据量时可能会占用大量的系统资源，如内存和CPU，效率底下；
  • 可能会对数据库的性能产生一定的影响；
  • 可能会导致数据不一致的问题，如在游标遍历过程中修改了数据，但游标并不会立即反映出来；
  • 游标使用时会对行加锁，可能会影响其他业务的正常进行。

四、游标使用注意事项

在使用游标时，需要注意以下几点：

  • 1. 游标必须在使用前声明，并且声明时需要指定游标的类型和返回结果集的SELECT语句。
  • 2. 游标必须在使用前打开，并在使用完毕后关闭。
  • 3. 游标可以使用FETCH语句获取结果集中的每一行数据。
  • 4. 游标可以使用%ROWTYPE属性来定义一个与结果集结构相同的变量，以便在遍历结果集时方便地存储每一行数据。
  • 5. 游标可以使用FOR循环结构来遍历结果集，避免手动进行游标的打开、获取和关闭操作。

五、游标的作用

游标是一种数据库技术，通过游标可以在一个结果集中逐个地访问每一条记录，然后对记录进行操作。游标可以用于以下几个方面：

5.1. 遍历数据：

游标可以逐条地遍历查询结果集，对每一条数据进行处理，比如筛选、修改、删除等操作。

假设有一个包含学生姓名、年龄、成绩等信息的数据表，需要实现一个查询功能，查询所有成绩低于60分的学生姓名和年龄。通过游标可以实现：

  • 定义一个游标，用于查询数据表中的所有记录。

  • 使用FETCH语句逐条读取记录，然后对每条记录进行判断，如果成绩低于60分，则将学生姓名和年龄存储到一个临时表中。

  • 等待游标读取完毕后，从临时表中获取所有符合条件的学生姓名和年龄，然后返回给用户。

5.2. 分页查询：

通过游标可以实现分页查询，每次查询指定数量的记录，以便于提高查询效率和减少网络传输的数据量。

假设有一个包含1000条记录的数据表，需要实现一个每页显示10条记录的分页查询功能。通过游标可以实现以下步骤：

  • 1. 定义一个游标，用于查询数据表的所有记录。
  • 2. 使用FETCH语句逐条读取记录，然后将记录存储到一个缓存区中。
  • 3. 在缓存区中逐条读取记录，直到读取到10条记录，然后将这10条记录返回给用户。
  • 4. 等待用户请求下一页数据，然后再次从缓存区中读取下10条记录，直到所有记录都被读取完毕。

通过游标实现分页查询功能可以大大提高查询效率和减少网络传输的数据量。而且，由于游标可以灵活地控制查询进度，因此可以避免一些不必要的数据库操作，从而提高系统的性能和稳定性。

5.3. 数据库事务：

游标可以用于管理数据库事务，它可以让开发人员对每一条记录进行细粒度的控制，从而确保事务的安全性和一致性。

注意：

游标可以在事务中使用，但它并不是实现事务的关键。

5.4. 数据库备份和恢复：

游标可以用于数据库备份和恢复，通过游标可以逐条读取数据库中的数据，然后将数据写入备份文件中，或者将备份文件中的数据逐条恢复到数据库中。

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/488903
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号