pl/sql的介绍

为什么需要pl/sql编程？

因为使用纯的sql语句来操作数据库，有先天性的技术缺陷：

1、不能模块编程；

2、执行速度慢；

3、安全性有问题；

4、浪费带宽。

pl/sql是什么？

pl/sql(procedural language/sql)是oracle在标准的sql语言上的扩展。pl/sql不仅允许嵌入sql语言，还可以定义变量和常量，允许使用条件语句和循环语句，允许使用例外处理各种错误，这样使得它的功能变得更加强大。

学习必要性

1、提高应用程序的运行性能；

2、模块化的设计思想[分页的过程，订单的过程，转账的过程...]；

3、减少网络传输量；

4、提高安全性。

缺点:移植性不好。

sqlplus开发工具

sqlplus是oracle公司提供的一个工具。

举一个简单案例：

编写一个存储过程，该过程可以向某表中添加记录。

创建add_emp存储过程：

create procedure add_emp is

begin

insert into emp (empno,ename) values(4444,'4444');

end;

/

执行：

exec add_emp;

pl/sql developer开发工具

pl/sql developer是用于开发pl/sql块的集成开发环境(IDE)，他是一个独立的产品，而不是oracle的一个附带品。

举一个简单案例：

编写一个存储过程，该过程可以删除某表记录。

创建删除del_emp过程

create procedure del_emp(in_empno number) is

begin

delete from emp where empno=in_empno;

end;

/

执行过程：

exec del_emp(4444);

创建过程基本语法：

create procedure 过程名(参数1,...)

is

begin

执行语句;

end;

/

执行过程语法:

exec 过程名(传入参数,...)

pl/sql基础知识--介绍

开发人员使用pl/sql编写应用模块时，不仅需要掌握sql语句的编写方法，还要掌握pl/sql语句及语法规则。pl/sql编程可以使用变量和逻辑控制语句，从而可以编写非常有用的功能模块。

比如：分页存储过程模块、订单管理存储过程模块、转账存储过程模块。而且如果使用pl/sql编程，我们可以轻松的完成非常复杂的查询要求。

pl/sql简单分类

块(编程)包含：

过程(存储过程)、函数、触发器、包

pl/sql基础知识--编写规范

1、注释

单行注释：--

多行注释：/*...*/来划分

2、标识符号的命名规范

1)当定义变量时，建议用v_作为前缀；如：v_sal

2)当定义常量时，建议用c_作为前缀；如：c_rate

3)当定义游标时，建议用_cursor作为后缀；如：emp_cursor

4)当定义例外时，建议用e_作为前缀；如：e_error

pl/sql块介绍

块(block)是pl/sql的基本程序单元，编写pl/sql程序实际上就是编写pl/sql块。要完成相对简单的应用功能，可以只需要编写一个pl/sql块；但是如果要想实现复杂的功能，可能需要在一个pl/sql块中嵌套其它的pl/sql块。

块结构示意图：

pl/sql块由三个部分构成：定义部分、执行部分、例外处理部分。

如下所示：

declare

/*定义部分----定义常量、变量、游标、例外、复杂数据类型*/

begin

/*执行部分----要执行的pl/sql语句和sql语句*/

exception

/*例外处理部分----处理运行的各种错误*/

end;

重要说明：

1、定义部分是从declare开始的，该部分是可选的；

2、执行部分是从begin开始的，该部分是必需的；

3、例外处理部分是从exception开始的，该部分是可选的。

pl/sql实例：只包括执行部分的pl/sql块

案例：输出hello,world

相关说明：dbms_output是oracle所提供的包(类似java的开发包)，该包包含一些过程，put_line就是dbms_output的一个过程。

--开发一个只包括执行部分的block块

set serveroutput on;

begin

dbms_output.put_line('hello,world');

end;

/

特别说明：在默认情况下，dbms_output.put_line是不输出内容的，需要set serveroutput on;才可输出。

实例2：包含定义部分和执行部分的pl/sql块

案例：根据用户输入的雇员编号，显示该雇员的名字

相关说明：

&表示要接收从控制台输入的变量

||表示把两个串拼接起来

declare

--定义变量的格式：变量名称 变量类型

v_ename varchar2(64);

begin

select ename into v_ename from emp where empno=&empno;--把查询到的ename放到v_ename变量中

--输出v_ename

dbms_output.put_line('雇员名字：'||v_ename);

end;

/

将上面的块改为过程

create procedure pro3(in_empno number) is

v_ename varchar2(64);

begin

select ename into v_ename from emp where empno=in_empno;

dbms_output.put_line('雇员名字：'||v_ename);

end;

/

实例3--包含定义部分、执行部分和例外处理部分

为了避免pl/sql程序的运行错误，提高pl/sql的健壮性，应该对可能的错误进行处理，这个很有必要：

1、比如在实例2中，如果输入了不存在的雇员号，应当做例外处理；

2、有时出现异常，希望用另外的逻辑处理。比如，如果不存在就加入编号为1，名字为“马大哈”这么一个人。

我们看看如何完成1的要求：

相关说明：oracle事先预定义了一些例外，no_data_found就是找不到数据的例外。

可以查看pl/sql官方文档看看oracle提供了哪些例外。

declare

v_ename varchar2(64);

begin

select ename into v_ename from emp where empno=&empno;

dbms_output.put_line('雇员名字：'||v_ename);

exception

when no_data_found then

dbms_output.put_line('你查询的雇员信息不存在!');

end;

/

对该案例的细节说明：

这里我们涉及到异常处理，

异常的基本语法：

exception

when 异常的名称1 then

//对异常处理的代码

when 异常的名称2 then

//对异常处理的代码

end;

异常处理的作用：

1、可以捕获异常，可以给出明确提示；

2、有时可以利用异常来进行业务处理。

declare

v_ename varchar2(64);

begin

select ename into v_ename from emp where empno=&empno;

dbms_output.put_line('雇员名字：'||v_ename);

exception

when no_data_found then

dbms_output.put_line('你查询的雇员信息不存在!加入一条信息');

isnert into emp (empno,ename) values(1,'马大哈');

end;

/

java捕获异常

try{

//如果用户输入字串

int abc=Integer.parse(str);

}catch(Exception e){

//对不起你输入的字串不是一个数

}

pl/sql基础知识--过程快速入门

过程

过程用于执行特定的操作，当建立过程时，既可以指定输入参数(in)，也可以指定输出参数(out)。通过在过程中使用输入参数，可以将数据传递到执行部分；通过使用输出参数，可以将执行部分的数据传递到应用环境。在sqlplus中可以使用create procedure命令来建立过程。

实例如下：

1、请考虑编写一个过程，可以输入雇员名，新工资可修改雇员的工资

2、如何调用过程有两种方法：

exec 过程名(参数值,..)

call 过程名(参数值,..)

创建存储过程基本语法：

create or replace procedure 过程名(变量 in 变量类型,..,变量 out 变量类型) is

//定义变量

begin

//执行语句;

end;

/

特别说明：or replace在创建存储过程中可带也可不带。带or replace是指在存储过程名字相同时将其覆盖。不带则无法覆盖。在使用or replace时要小心，建议不使用or replace对原存储过程进行覆盖。

举例：请考虑编写一个过程，可以输入雇员名，新工资可修改雇员的工资

create procedure update_sal(in_name in varchar2,in_new_sal in number) is

begin

update emp set sal=in_new_sal where ename=in_name;

dbms_output.put_line('更新成功!');

end;

/

特别说明：当编写过程出现错误时，查看具体错误信息。输入show error;

java中调用过程

3、如何在java程序中调用一个存储过程？

动手体验：我们写一个java程序来调用前面的存储过程。

课堂小练习：编写一个过程，可以接受id和薪水，更新薪水，如果id不存在，需要在exception中捕获，并给出提示!

如何使用过程返回值？

特别说明：对于过程我们会在以后给大家详细具体的介绍，现在请大家先有一个概念。

Java代码:

package com.test;

import java.sql.CallableStatement;

import java.sql.Connection;

import java.sql.DriverManager;

public class TestProcedure {

//调用oracle中update_sal存储过程

public static void main(String[] args) {

Connection ct=null;

CallableStatement cs=null;

try {

//加载驱动

Class.forName("oracle.jdbc.driver.OracleDriver");

//得到连接

ct=DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:orcl","scott", "tiger");

//创建CallableStatement接口引用对象

cs=ct.prepareCall("{call update_sal(?,?)}");

//给？赋值

cs.setString(1, "BOSS");

cs.setFloat(2, 8888f);

//执行我们的语句

cs.execute();

//提交

ct.commit();

} catch (Exception e) {

e.printStackTrace();

}finally{

try {

if(cs!=null){

cs.close();

}

if(ct!=null){

ct.close();

}

} catch (Exception e2) {

e2.printStackTrace();

}

cs=null;

ct=null;

}

}

}

对前面的java程序的SQLHelper类进行升级，添加一个可以调用存储过程的方法

代码如下：

private static CallableStatement cs=null;

//调用存储过程的方法

public static void executeProcedure(String sql,String [] parameters){

try {

ct=DriverManager.getConnection(url,username,password);

cs=ct.prepareCall(sql);

if(parameters!=null){

for(int i=0;i<parameters.length;i++){

cs.setString(i+1, parameters[i]);

System.out.println(parameters[i]);

}

}

//执行

cs.execute();

} catch (Exception e) {

e.printStackTrace();

throw new RuntimeException(e.getMessage());

}finally{

close(rs, cs, ct);

}

}

调用方法：

//当我们需要去调用过程的时候传SQL语句

String sql="{call update_sal(?,?)}";

String paras[]={"BOSS","1520"};

SQLHelper.executeProcedure(sql, paras);

课堂小练习：编写一个过程，可以接受id和薪水，更新薪水，如果id不存在，需要在exception中捕获，并给出提示!需要在控制台和java程序中都调用。

oracle控制台

create procedure update_sal2(in_empno in number,in_new_sal in number) is

v_ename varchar2(32);

begin

select ename into v_ename from emp where empno=in_empno;

update emp set sal=in_new_sal where empno=in_empno;

dbms_output.put_line('更新成功!');

exception

when no_data_found then

dbms_output.put_line('输入的ID不存在!');

end;

/

pl/sql基本知识--函数快速入门

oracle函数

函数用于返回特定的数据，当建立函数时，在函数头部必须包含return子句，而在函数体内必须包含return语句返回的数据。我们可以使用create function来建立函数，实际案例：

建立函数的基本语法：

create function 函数名(参数1,...)

return 数据类型 is

    定义变量;

begin

    执行语句;

end;

/

函数调用的基本语法：

var 变量名 变量类型

call 函数名(参数值,...) into :变量名;

print 变量名

select 函数名(参数,...) from dual;

案例：请编写一个函数，可以接收用户名并返回该用户的年薪。

create function inName_outSal(v_in_name varchar2)

return number is

v_annual_sal number;

begin

select (sal+nvl(comm,0))*13 into v_annual_sal from emp where ename=v_in_name;

return v_annual_sal;

end;

/

函数和过程的区别：

1、函数必须有返回值，而过程可以没有；

2、函数和过程在java中调用的方式不一样；

java中调用oracle函数可以在select语句中直接调用，如：select 自定义的函数名(参数) from 表;

过程则是使用CallableStatement完成调用。

Java调用函数方式

package com.test;

import java.sql.ResultSet;

import java.sql.SQLException;

public class TestFunction {

//如何在java中调用自己编写的函数

public static void main(String[] args) {

String sql="select inName_outSal('KING') annual from dual";

ResultSet rs=SQLHelper.executeQuery(sql, null);

try {

if(rs.next()){

System.out.println(rs.getDouble("annual"));//此处可以用数字或别名接收返回值

}

} catch (SQLException e) {

e.printStackTrace();

}finally{

if(rs!=null){

try {

rs.close();

} catch (SQLException e) {

e.printStackTrace();

}

}

rs=null;

}

}

}

pl/sql基本知识--包

包用于在逻辑上组合过程和函数，它由包规范和包体两部分组成。

1、我们可以使用create package命令来创建包：

建包基本语法：

create [or replace] package 包名 is

    procedure 过程名(变量名 变量类型,...);

    function 函数名(变量名 变量类型,...) return 数据类型;

end;

/

包的规范只包含了过程和函数的说明，但是没有过程和函数的实现代码。包体用于实现包规范的过程和函数。

请编写一个包，该包有一个过程，该过程可以接收用户名和新的薪水。(将来用于通过用户去更新薪水)还有一个函数，该函数可以接收一个用户名(将来要实现得到该用户的年薪是多少)

create package emp_package is

procedure update_sal(v_in_ename varchar2,v_in_newsal number);

function inName_outSal(v_in_name varchar2) return number;

end;

2、建立包体可以使用create package body 命令

建立包体基本语法：

create or replace package body 包名 is

    procedure 过程名(变量名 变量类型,...) is

       --声明变量;

    begin

       --执行语句;

    exception

    when 异常名 then

       --异常处理;

    end;

    function 函数名(变量名 变量类型,...)

    return 数据类型 is

       --声明变量;

    begin

       --执行语句;

    end;

end;

/

案例：请实现前面定义的包中的过程和函数。

create or replace package body emp_package is

procedure update_sal(v_in_ename varchar2,v_in_newsal number) is

v_empno number;

begin

select empno into v_empno from emp where ename=v_in_ename;

update emp set sal=v_in_newsal where ename=v_in_ename;

dbms_output.put_line('员工号为：'||v_empno||'的薪水更新成功');

exception

when no_data_found then

dbms_output.put_line('您输入的人员信息不存在!');

end;

function inName_outSal(v_in_name varchar2)

return number is

v_annual_sal number;

begin

select (sal+nvl(comm,0))*13 into v_annual_sal from emp where

ename=v_in_name;

return v_annual_sal;

end;

end;

/

细节说明：

1、包体中要现实的函数或过程，应当在包规范中声明；

2、在调用包中的某个函数或过程的时候，需要使用对应的方法才可以调用。

3、如何调用包的过程或函数

当调用包的过程或是函数时，在过程和函数前需要带有包名，如果要访问其它方案的包，还需要在包名前加方案名。

调用基本方法：

exec 方案名.包名.过程名(参数,...);

call 方案名.包名.函数名(参数,...);

也可以直接用select 方案名.包名.函数名(参数,...) from dual;

在java中调用oracle包下的过程和函数与之前java调用的过程和函数是一致的，只是尽可能的将方案名.包名加上。

String sql="{call scott.emp_package.update_sal(?,?)}";//过程

String sql="select scott.emp_package.inName_outSal('KING') annual from dual";//函数

特别说明：包是pl/sql中非常重要的部分，在使用过程分页时，将会再次体验它的威力。

pl/sql基础知识--触发器

触发器简单介绍

触发器是指隐含的执行的存储过程。当定义触发器时，必须要指定触发的事件和触发的操作，常用的触发事件包括insert/update/delete语句，而触发操作实际就是一个pl/sql块。可以使用create trigger 来建立触发器。

特别说明：

我们会在后面详细为大家介绍触发器的使用，因为触发器是非常有用的，可维护数据库的案例和一致性。

pl/sql基础知识--定义并使用变量

介绍

在编写pl/sql程序时，可以定义变量和常量；在pl/sql程序中包括有：

1、标量类型(scalar)

2、复合类型(composite)

3、参照类型(reference)

4、lob(large object)

标量(scalar)--常用类型

在编写pl/sql块时，如果要使用变量，需在定义部分定义变量。

pl/sql中定义变量和常量的语法如下：

identifier [constant] datatype [not null] [:=|default expr]

名称 [指定常量] 数据类型 [不为null] [:=(赋初值) | default(默认值) expr(指定初始值)]

说明：

identifier:名称

constant:指定常量。需要指定它的初始值，且其值是不能改变的。

datatype:数据类型

not null:指定变量值不能为null

:=给变量或是常量指定初始值

default:用于指定初始值

expr:指定初始值的pl/sql表达式，可是文本值、其它变量、函数等。

标量定义的案例：

1、定义一个变长字符串

v_ename varchar2(10);

2、定义一个小数范围-9999.99～9999.99

v_sal number(6,2);

3、定义一个小数并给一个初始值为5.4 :=是pl/sql的赋值号

v_sal2 number(6,2):=5.4

4、定义一个日期类型的数据

v_hiredate date;

5、定义一个布尔变量，不能为空，初始值为false

v_valid boolean not null default false;

特别说明：pl/sql在定义一个变量的时候，如果要赋初值，则需要使用:=，如果只是=则是用于判断两个值是否相等。

标量(scalar)使用标量

在定义好变量后，就可以使用这些变量。这里需要说明的是pl/sql块为变量赋值不同于其它的编程语言，需要在等号前加冒号(:=)

案例：以输入员工号，显示雇员姓名、工资、个人所得税(税率为0.03)为例。说明变量的使用，看看如何编写？

create or replace procedure emp_info(in_empno number) is

v_ename varchar2(32);

v_sal number;

v_tax number;

c_tax_rate number(3,2):=0.03;

begin

select ename,sal,sal*c_tax_rate into v_ename,v_sal,v_tax from emp where empno=in_empno;

dbms_output.put_line('姓名：'||v_ename||'    工资：'||v_sal||'    个人所得税：'||v_tax);

exception

when no_data_found then

dbms_output.put_line('你的输入有误!');

end;

/

标量(scalar)--使用%type类型

对于上面的pl/sql块有一个问题：

就是如果员工的姓名超过了5字符的话，就会有错误，为了降低pl/sql程序的维护工作量，可以使用%type属性定义变量，这样它会按照数据库列来确定你定义的变量的类型和长度。

我们看看这个怎么使用：

%type类型使用的基本语法：

标识符名 表名.列名%type;

create or replace procedure emp_info(in_empno number) is

v_ename emp.ename%type;--为了让v_ename的类型更加灵活，我们使用%type，这样就会自适应

v_sal emp.sal%type;

v_tax number;

c_tax_rate number(3,2):=0.03;

begin

select ename,sal,sal*c_tax_rate into v_ename,v_sal,v_tax from emp where empno=in_empno;

dbms_output.put_line('姓名：'||v_ename||'    工资：'||v_sal||'    个人所得税：'||v_tax);

exception

when no_data_found then

dbms_output.put_line('你的输入有误!');

end;

/

复合变量(composite)--介绍

用于存放多个值的变量。常用的包括：1、pl/sql记录；2、pl/sql表

复合类型--pl/sql记录

类似与高级语言中的结构体，需要注意的是，当引用pl/sql记录成员时，必须要加记录变量作为前缀(记录变量.记录成员)如下：

复合变量定义基本语法：

type 自定义的pl/sql记录名 is record(

变量名 变量类型,

变量名 变量类型

);

//使用自定义的pl/sql记录

复合变量基本使用语法：

变量名 自定义的pl/sql记录名;

请编写一个过程，该过程可以接收一个用户编号，并显示该用户的名字，薪水，工作岗位(注意：要求用pl/sql记录实现)

create or replace procedure inEmpno(in_empno number) is

--定义一个记录数据类型

type my_emp_record is record(

v_ename emp.ename%type,

v_sal emp.sal%type,

v_job emp.job%type

);

--定义一个变量，该变量的类型是my_emp_record

v_emp_record my_emp_record;

begin

select ename,sal,job into v_emp_record from emp where empno=in_empno;

dbms_output.put_line('名字：'||v_emp_record.v_ename||'  工资：'||v_emp_record.v_sal||'  职位：'||v_emp_record.v_job);

exception

when no_data_found then

dbms_output.put_line('你的输入有误!');

end;

/

复合类型--pl/sql表(了解即可)

相当于高级语言中的数组，但是需要注意的是在高级语言中数组的下标不能为负数，而pl/sql是可以为负数的，并且表元素的下标没有限制。(可以理解为是oracle下的数组)实例如下:

复合类型pl/sql表的基本语法：

type 自定义的pl/sql表名 is table of 对应表.列名%type

index by binary_integer;

//使用自定义的pl/sql表

变量名 自定义的pl/sql表名;

declare

type sp_table_type is table of emp.ename%type

index by binary_integer;

sp_table sp_table_type;--定义一个变量：sp_table类型

begin

select ename into sp_table(-1) from emp where empno=7788;

dbms_output.put_line('员工名：'||sp_table(-1));

end;

说明：

sp_table_type 是pl/sql表类型

emp.ename%type 指定了表的元素的类型和长度

sp_table 为pl/sql表变量

sp_table(0) 则表示下标为0的元素

参照变量--介绍(重点，必须掌握)

参照变量是指用于存放数值指针的变量，通过使用参照变量，可以使得应用程序共享相同对象，从而降低占用的空间。在编写pl/sql程序时，可以使用游标变量(ref cursor)和对象类型变量(ref obj_type)两种参照变量类型。

游标变量

通过游标可以取得返回结果集(这个结果集，往往是select语句的结果)的任何一行数据，从而提供共享的效率。

参照变量--游标(ref cursor)使用

定义游标基本语法：

type 自定义游标名 is ref cursor;

变量名 自定义游标名;

打开游标基本语法：

open 游标变量 for select 语句;

取出当前游标指向的行基本语法：

fetch 游标变量 into 其它变量;

判断游标是否指向记录最后基本语法：

游标变量%notfound

参照变量--游标(ref cursor)变量

使用游标时，当定义游标时不需要指定相应的select语句，但是当使用游标时，(open时)需要指定select语句，这样一个游标就写一个select语句结合了。

实例如下：

1、请使用pl/sql编写一个过程，可以输入部门号，并显示该部门所有员工姓名和他的工资。

create or replace procedure test_cursor(in_deptno in number) is

--定义一个记录数据类型

type my_emp_record is record(v_ename emp.ename%type,v_sal emp.sal%type);

--定义一个变量，该变量的类型是my_emp_record

v_emp_record my_emp_record;

--先定义一个游标变量类型

type my_emp_cursor is ref cursor;

--定义一个游标变量

v_emp_cursor my_emp_cursor;

begin

--打开游标，执行语句

open v_emp_cursor for select ename,sal from emp where deptno=in_deptno;

--取出游标指向的每行数据，使用循环语句取出

loop

fetch v_emp_cursor into v_emp_record;--会引起游标向下走

--判断当前游标是否到达最后

exit when v_emp_cursor%notfound;--判断游标是否为空，为空时退出循环

dbms_output.put_line('姓名：'||v_emp_record.v_ename||'    工资：'||v_emp_record.v_sal);

end loop;

--关闭游标[游标使用完后，一定要关闭，避免资源浪费]

close v_emp_cursor;

end;

/

2、在1基础上，如果某个员工的工资低于200元，就增加100元。

create or replace procedure test_cursor(in_deptno in number) is

--创建一个记录数据类型

type my_emp_record is record(v_ename emp.ename%type,

v_sal emp.sal%type,

v_empno emp.empno%type

);

v_emp_record my_emp_record;

--创建游标

type my_emp_cursor is ref cursor;

v_emp_cursor my_emp_cursor;

begin

open v_emp_cursor for select ename,sal,empno from emp where deptno=in_deptno;

loop

fetch v_emp_cursor into v_emp_record;

exit when v_emp_cursor%notfound;

--判断工资低于200的人，加100块

if v_emp_record.v_sal<200 then

v_emp_record.v_sal:=v_emp_record.v_sal+100;

update emp set sal=v_emp_record.v_sal where empno=v_emp_record.v_empno;

end if;

dbms_output.put_line('姓名：'||v_emp_record.v_ename||'    工资：'||v_emp_record.v_sal);

end loop;

close v_emp_cursor;

end;

/

pl/sql练习题：

使用pl/sql块编程实现，注意必需的异常处理。

1、输入一个员工号，输出该员工的姓名、薪金和大概的服务年限(按年月日显示)

declare

v_ename emp.ename%type;

v_sal emp.sal%type;

v_year varchar2(20);

begin

select ename,sal,to_char(to_date('00010101','yyyymmdd')+(sysdate-hiredate)-366-31,'yy"年"mm"个月"dd"天"') into v_ename,v_sal,v_year from emp where empno=&empno;

dbms_output.put_line('姓名：'||v_ename||'  薪金：'||v_sal||'  服务年限：'||v_year);

exception

when no_data_found then

dbms_output.put_line('您输入的员工编号不存在!');

end;

/

2、接收一个员工号，输出该员工所在部门的名称

declare

v_ename emp.ename%type;

v_dname dept.dname%type;

begin

select e.ename,d.dname into v_ename,v_dname from emp e,dept d where e.deptno=d.deptno and empno=&empno;

dbms_output.put_line('姓名：'||v_ename||'  所在部门：'||v_dname);

exception

when no_data_found then

dbms_output.put_line('您输入的员工编号不存在!');

end;

/

3、接收一个部门号，如果该员工职位是MANAGER,并且在DALLAS工作那么就给他薪金加15%；如果该员工职位是CLERK,并且在NEW YORK工作，那么就给他薪金扣除5%,其他情况不作处理。

declare

v_deptno number;

v_deptno1 dept.deptno%type;

v_deptno2 dept.deptno%type;

begin

v_deptno:=&deptno;

select deptno into v_deptno1 from dept where loc='DALLAS';

select deptno into v_deptno2 from dept where loc='NEW YORK';

if v_deptno=v_deptno1 then

update emp set sal=sal*1.15 where job='MANAGER' and deptno=v_deptno1;

dbms_output.put_line('已将job为MANAGER且在DALLAS工作的员工薪资提高了15%');

elsif v_deptno=v_deptno2 then

update emp set sal=sal*0.95 where job='CLERK' and deptno=v_deptno2;

dbms_output.put_line('已将job为CLERK且在NEW YORK工作的员工薪资降低了5%');

else

dbms_output.put_line('数据未做修改或输入的部门号不存在!');

end if;

end;

/

4、接收一个员工号，输出这个员工所在部门的平均工资

declare

v_deptno emp.deptno%type;

v_avgsal number(7,2);

begin

select deptno into v_deptno from emp where empno=&empno;

select avg(sal+nvl(comm,0)) into v_avgsal from emp where deptno=v_deptno;

dbms_output.put_line(v_deptno||'部门的平均工资为：'||v_avgsal);

exception

when no_data_found then

dbms_output.put_line('您输入的员工编号不存在!');

end;

/

5、以交互的方式给部门插入一条记录，如果出现主键冲突的异常，请显示“部门号已被占用”的字样。

declare

v_deptno dept.deptno%type;

v_dname dept.dname%type;

v_loc dept.loc%type;

begin

v_deptno:=&deptno;

v_dname:=&dname;

v_loc:=&loc;

insert into dept (deptno,dname,loc) values(v_deptno,v_dname,v_loc);

dbms_output.put_line('部门编号：'||v_deptno||'部门名称：'||v_dname||'所在地：'||v_loc||'已成功添加!');

exception

when dup_val_on_index then

dbms_output.put_line('部门号已被占用!');

end;

/

过程函数练习题：

1、建立一个存储过程用来接收一个员工号，返回他的工资和他所在的部门的平均工资并作为传出参数传出。

create or replace procedure inempno_outsaldname(in_empno in number,out_sal out number,out_avgsal out number) is

v_deptno emp.deptno%type;

begin

select sal,deptno into out_sal,v_deptno from emp where empno=in_empno;

dbms_output.put_line('部门号：'||v_deptno);

select avg(sal) into out_avgsal from emp where deptno=v_deptno;

dbms_output.put_line('平均工资：'||out_avgsal);

end;

/

create or replace procedure in_out_emp(in_empno number) is

v_sal number;

v_avgsal number(7,2);

begin

inempno_outsaldname(in_empno,v_sal,v_avgsal);

dbms_output.put_line('员工号：'||in_empno||'工资为：'||v_sal||'平均工资为：'||v_avgsal);

exception

when no_data_found then

dbms_output.put_line('您输入的员工编号不存在!');

end;

/

2、建立一个存储过程用来接收一个部门号，找出其中的两位最老的员工的员工号，并打印。

create or replace procedure indeptno_outhiredate(in_deptno number) is

type my_emp_cursor is ref cursor;

v_emp_cursor my_emp_cursor;

v_i number;

type my_emp_record is record(v_empno emp.empno%type,v_ename emp.ename%type,v_hiredate emp.hiredate%type);

v_emp_record my_emp_record;

begin

v_i:=0;

open v_emp_cursor for select empno,ename,hiredate from emp where deptno=in_deptno order by hiredate;

loop

fetch v_emp_cursor into v_emp_record;

v_i:=v_i+1;

if(v_i=3)then

exit;

end if;

dbms_output.put_line('员工编号：'||v_emp_record.v_empno||'姓名：'||v_emp_record.v_ename||'入职日期：'||to_char(v_emp_record.v_hiredate,'yyyy-mm-dd'));

end loop;

close v_emp_cursor;

exception

when no_data_found then

dbms_output.put_line('您输入的部门编号不存在!');

end;

/

3、编写一个过程用来传入一个员工号，在emp表中删除一个员工，当该员工是该部门的最后一个员工时就在dept表中删除该员工所在的部门。

create or replace procedure inempno_deldept(in_empno number) is

v_count number;

v_empno emp.empno%type;

v_deptno emp.deptno%type;

begin

v_empno:=in_empno;

select deptno into v_deptno from emp where empno=v_empno;

delete from emp where empno=v_empno;

dbms_output.put_line('工号：'||v_empno||'成功删除!');

select count(*) into v_count from emp where deptno=v_deptno;

dbms_output.put_line(v_deptno||'部门还有'||v_count||'雇员!');

if v_count=0 then

delete from dept where deptno=v_deptno;

dbms_output.put_line(v_deptno||'删除部门成功!');

end if;

exception

when no_data_found then

dbms_output.put_line('您输入的员工编号不存在!');

end;

/

pl/sql的进阶

Procedural Language/SQL叫做过程化SQL编程语言，是oracle对SQL语句的扩展。在普通SQL语句的使用上增加了编程语言的特点，所以pl/sql就是把数据操作和查询语言组织在pl/sql代码的过程性单元中，通过逻辑判断，循环等操作实现复杂的功能或者计算的程序语言。

pl/sql进阶--控制结构

在任何计算机语言(c,java,c#,c++)都有各种控制语句(条件语句，循环语句，顺序控制结构..)在pl/sql中也存在这样的控制结构。

条件分支语句

pl/sql中提供了三种条件分支语句if--then,if--then--else,if--then--elsif--elsif--else这里我们可以和java语句进行一个比较。

简单的条件判断if--then

基本语法：

if 条件表达式 then

执行语句...;

end if;

编写一个过程，可以输入一个雇员名，如果该雇员的工资低于2000，就给该雇员工资增加10%。

create or replace procedure inempno_upsal(in_ename varchar2) is

v_sal emp.sal%type;

begin

select sal into v_sal from emp where ename=in_ename;

if v_sal<2000 then

update emp set sal=sal*1.1 where ename=in_ename;

end if;

exception

when no_data_found then

dbms_output.put_line('您输入的姓名不存在!');

end;

/

二重条件分支if--then--else

基本语法：

if 条件表达式 then

执行语句;

else

执行语句;

end if;

编写一个过程，可以输入一个雇员名，如果该雇员的补助不是0就在原来的基础上增加100；如果补助为0就把补助设为200；

create or replace procedure inname_upcomm(in_ename varchar2) is

v_comm emp.comm%type;

begin

select nvl(comm,0) into v_comm from emp where ename=in_ename;

if v_comm<>0 then

update emp set comm=comm+100 where ename=in_ename;

else

update emp set comm=comm+200 where ename=in_ename;

end if;

exception

when no_data_found then

dbms_output.put_line('您输入的姓名不存在!');

end;

/

多重条件分支if--then--elsif--else

基本语法：

if 条件表达式 then

执行语句;

elsif 条件表达式 then

执行语句;

else

执行语句;

end if;

编写一个过程，可以输入一个雇员编号，如果该雇员的职位是PRESIDENT就给他的工资增加1000，如果该雇员职位是MANAGER就给他的工资增加500，其它职位的雇员工资增加200。

create or replace procedure inempno_upsal(in_empno number) is

v_job emp.job%type;

begin

select job into v_job from emp where empno=in_empno;

if v_job='PRESIDENT' then

update emp set sal=sal+1000 where empno=in_empno;

elsif v_job='MANAGER' then

update emp set sal=sal+500 where empno=in_empno;

else

update emp set sal=sal+200 where empno=in_empno;

end if;

exception

when no_data_found then

dbms_output.put_line('您输入的编号有误!');

end;

/

循环结构--loop

是pl/sql中最简单的循环语句，这种循环语句以loop开头，以end loop结尾，这种循环至少会被执行一次。

基本语法：

loop

执行语句;

exit when 条件表达式;

end loop;

案例：现在有一张表users，表结构如下：

用户ID	用户名

请编写一个过程，可以输入用户名和添加用户的个数n;循环添加n个用户到users表中，用户编号从1开始增加，直到n

create table users(userId number primary key,userName varchar2(32));

create or replace procedure inname_adduser(in_username varchar2,in_n number) is

v_i number:=0;

begin

loop

exit when in_n<=0;

v_i:=v_i+1;

insert into users values(v_i,in_username);

exit when v_i=in_n;

end loop;

end;

/

循环语句--while循环

基本循环至少要执行循环体一次，而对于while循环来说，只有条件为true时，才会执行循环体语句，while循环以while..loop开始，以end loop结束。

基本语法：

while 条件表达式 loop

执行语句;

end loop;

案例：现在有一张表users，表结构如下：

用户ID	用户名

请编写一个过程，可输入用户名，并循环添加10个用户到users表中，用户编号从11开始增加。

create table users(userId number primary key,userName varchar2(32));

create or replace procedure inname_addusers(in_name varchar2) is

v_i number:=0;

v_j number:=10;

begin

while v_i<10 loop

v_j=v_j+1;

insert into users values(v_j,in_name);

end loop;

end;

/

看下面题判断是否正确

下面的过程是否正确，如果不正确，应该怎么改？

create or replace procedure sp_pro6(spName varchar2) is

v_test varchar2(40);

v_test:='aaa';--赋初值需在定义时就直接赋值，或在定义之后在begin中进行赋值。

begin

dbms_output.put_line(v_test);

end;

create or replace procedure sp_pro6(spName varchar2) is

v_test varchar2(40):='aaa';

begin

spName:='你好';--spName为传入变量，不能重复赋值。

dbms_output.put_line(v_test||spName);

end;

说明：

1、在is--begin之间只能定义变量类型同时初始化赋值，或定义变量类型后在begin内进行赋值，不能在定义变量类型之后再对变量赋值。

2、传入的参数变量不能在存储过程中再次赋值。

循环语句--for循环

基本for循环的基本结构如下：

begin

for i in reverse 1..10 loop

insert into users values(i,'顺平');

end loop;

end;

基本语法：

for 变量 in reverse 开始值..结束值 loop

执行语句;

end loop;

我们可以看到控制变量i,在隐含中就在不停的增加

注意：推荐使用loop循环结构，不推荐使用for循环。

顺序控制语句--goto,null

1、goto语句

goto语句用于跳转到特定标号去执行语句，注意由于使用goto语句会增加程序的复杂性，并使得应用程序可读性变差，所以在做一般应用开发时，建议大家不要使用goto语句。基本语法如下：goto lable，其中lable是已定义好的标号名。

基本语法：goto 标号;

标号定义：<<标号>>

例：

declare

i number:=1;

begin

<<start_loop>>

loop

dbms_output.put_line('输出i='||i);

if i=12 then

goto end_loop;

end if;

i:=i+1;

if i=10 then

goto start_loop;

end if;

end loop;

<<end_loop>>

dbms_output.put_line('循环结束');

end;

--输出1至12 循环结束。

2、null

null语句不会执行任何操作，并且会直接将控制传递到下一条语句。使用null语句的主要好处是可以提高pl/sql的可读性。

例：

declare

v_sal emp.sal%type;

v_ename emp.ename%type;

begin

select ename,sal into v_ename,v_sal from emp where empno=&no;

if v_sal<3000 then

update emp set comm=sal*0.1 where ename=v_ename;

else

null;

end if;

end;

pl/sql进阶--编写分页过程

介绍

分页是任何一个网站(bbs、网上商城、blog)都会使用到的技术，因此学习pl/sql编程开发一定要掌握该技术。

无返回值的存储过程

古人云：欲速则不达，为了让大家比较容易接受分页过程编写，还是从简单到复杂，循序渐进的给大家讲解。首先是掌握最简单的存储过程，无返回值的存储过程：

案例：现在有一张表book,表结构如下：

字段名      字段类型

id          number(5)

name        varchar2(100)

pubHouse    varchar2(100)

请编写一个过程，可以向book表添加书，要求通过java程序调用该过程。

提示查看jdk,看看CallableStatement是怎么调存储过程的!

建book表

create table book(id number(5) primary key,name varchar2(100) not null,pubHouse varchar2(100));

create or replace procedure inBook(in_id number,in_name varchar2,in_pubHouse varchar2)

begin

insert into book values(in_id,in_name,in_pubHouse);

exception

when dup_val_on_index then

dbms_output.put_line('错误：序号不能为空或不能重复!');

end;

java调用无返回值的存储过程代码:

//当我们需要去调用过程的时候传SQL语句

String sql="{call 存储过程名称(?,?)}";//调用格式{call 用户区.包名.过程名(参数?)}

String paras[]={"过程中的参数1","过程中的参数2"};

SQLHelper.executeProcedure(sql, paras);

 

public class SQLHelper {

//定义三个变量

private static Connection ct=null;

private static PreparedStatement ps=null;

private static ResultSet rs=null;

private static CallableStatement cs=null;

//连接数据库的用户名，密码，url，驱动

//说明：在实际开发中，我们往往把这些变量写到一个外部文件中

//当程序启动时，我们读入这些配置信息。java.util.Properites

private static String username;

private static String password;

private static String driver;

private static String url;

//使用静态块加载驱动(驱动只需要加载一次)

static{

//使用Properties类，来读取配置文件

Properties pp=new Properties();

FileInputStream fis=null;

try {

fis=new FileInputStream("dbinfo.properties");

//让pp与dbinfo.properties文件关联起来

pp.load(fis);

//获取dbinfo.properties文件内信息

username=pp.getProperty("username");

password=pp.getProperty("password");

driver=pp.getProperty("driver");

url=pp.getProperty("url");

//获得驱动

Class.forName(driver);

} catch (Exception e) {

e.printStackTrace();

}finally{

try {

if(fis!=null){

fis.close();

}

} catch (Exception e) {

e.printStackTrace();

}

fis=null;

}

}

//调用存储过程的方法

public static void executeProcedure(String sql,String [] parameters){

try {

ct=DriverManager.getConnection(url,username,password);

cs=ct.prepareCall(sql);

if(parameters!=null){

for(int i=0;i<parameters.length;i++){

cs.setString(i+1, parameters[i]);

System.out.println(parameters[i]);

}

}

//执行

cs.execute();

ct.commit();

} catch (Exception e) {

e.printStackTrace();

throw new RuntimeException(e.getMessage());

}finally{

close(rs, cs, ct);

}

}

//把关闭资源写成函数

public static void close(ResultSet rs,Statement ps,Connection ct){

//关闭资源

if(rs!=null){

try {

rs.close();

} catch (SQLException e) {

e.printStackTrace();

}

rs=null;

}

if(ps!=null){

try {

ps.close();

} catch (SQLException e) {

e.printStackTrace();

}

ps=null;

}

if(ct!=null){

try {

ct.close();

} catch (SQLException e) {

e.printStackTrace();

}

ct=null;

}

}

}

dbinfo.properties 连接Oracle数据库配置文件

username=scott

password=tiger

driver=oracle.jdbc.driver.OracleDriver

url=jdbc\:oracle\:thin\:@127.0.0.1\:1521\:orcl

有返回值的存储过程(非列表，只有一个返回值)

再看如何处理有返回值的存储过程：

建立有返回值的存储过程基本语法：

create or replace procedure 过程名(参数名 in 类型,..,参数名 out 类型,..) is

定义变量..;

begin

执行语句..;

exception

when 错误提示 then

处理或提示语句;

end;

案例：编写一个过程，可以输入雇员的编号，返回该雇员的姓名。

create or replace procedure inEmpno_outEname(in_v_empno in number,out_v_ename out varchar2) is

begin

select ename into out_v_ename from emp where empno=in_v_empno;

exception

when no_data_found then

dbms_output.put_line('您输入的雇员编号不存在!');

end;

在java中去调用该过程，并接受返回的用户名。

[TestProcedureOutValues.java]源码示例：

package com.test;

import java.sql.CallableStatement;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

public class TestProcedureOutValues {

//调用oracle存储过程并获得存储过程的返回值。

public static void main(String[] args) {

//定义需要的变量

Connection ct=null;

CallableStatement cs=null;

ResultSet rs=null;

try {

//加载驱动

Class.forName("oracle.jdbc.driver.OracleDriver");

//得到连接

ct=DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:orcl","scott","tiger");

//创建CallableStatement接口

cs=ct.prepareCall("{call inEmpno_outEname(?,?)}");//第一个?输入值，第二个?是获得值。

//给第一个?赋值

cs.setString(1, "7839");

//给第二个?注册(因为它是输出值)

cs.registerOutParameter(2, oracle.jdbc.OracleTypes.VARCHAR);

//执行

cs.execute();

//取出输出的值

String ename=cs.getString(2);

System.out.println("用户的名字是："+ename);

} catch (Exception e) {

e.printStackTrace();

}finally{

//关闭资源

try {

if(cs!=null){

cs.close();

}

if(rs!=null){

rs.close();

}

if(ct!=null){

ct.close();

}

} catch (Exception e) {

e.printStackTrace();

}

cs=null;

rs=null;

ct=null;

}

}

}

说明：

1、对于过程的输入值，使用set方法，对于输出值使用registerOutParameter来注册接收返回值。问号的顺序要对应，同时考虑类型。

2、取出过程返回值的方法是CallableStatement提供的get方法(输出参数的位置)；同时要考虑输出的参数类型。

java调用关键代码：

CallableStatement cs=null;

cs=ct.prepareCall("{call 过程名(?,?)}");

cs.registerOutParameter(输出参数的在第几个问号,oracle.jdbc.OracleTypes.类型);//Types.类型是输出参数的类型。

cs.get类型(输出参数在问号的位置);//不用的类型要用不同的get方法接收。

案例扩展：编写一个过程，可以输入雇员的编号，返回该雇员的姓名、工资和岗位。

create or replace procedure inEmpno_outAllinfo(in_v_empno in number,out_v_ename out varchar2,out_v_sal out number,out_v_job out varchar2) is

begin

select ename,sal,job into out_v_ename,out_v_sal,out_v_job from emp where empno=in_v_empno;

exception

when no_data_found then

dbms_output.put_line('您输入的雇员编号不存在!');

end;

在java中去调用该过程，并接受返回的用户名、工资、职位。

[TestProcedureOutValues.java]返回多个值的调用存储过程源代码。

package com.test;

import java.sql.CallableStatement;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

public class TestProcedureOutValues {

//调用oracle存储过程并获得存储过程的返回值。

public static void main(String[] args) {

//定义需要的变量

Connection ct=null;

CallableStatement cs=null;

ResultSet rs=null;

try {

//加载驱动

Class.forName("oracle.jdbc.driver.OracleDriver");

//得到连接

ct=DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:orcl","scott","tiger");

//创建CallableStatement接口

cs=ct.prepareCall("{call inEmpno_outAllinfo(?,?,?,?)}");//第一个?输入值，第二个?是获得值。

//给第一个?赋值

cs.setString(1, "7839");

//给第二-四个?注册(因为它是输出值)

cs.registerOutParameter(2, oracle.jdbc.OracleTypes.VARCHAR);

cs.registerOutParameter(3, oracle.jdbc.OracleTypes.NUMBER);

cs.registerOutParameter(4, oracle.jdbc.OracleTypes.VARCHAR);

//执行

cs.execute();

//取出输出的值

String ename=cs.getString(2);

Float sal=cs.getFloat(3);

String job=cs.getString(4);

System.out.println("姓名："+ename+"  工资："+sal+"  职位："+job);

} catch (Exception e) {

e.printStackTrace();

}finally{

//关闭资源

try {

if(cs!=null){

cs.close();

}

if(rs!=null){

rs.close();

}

if(ct!=null){

ct.close();

}

} catch (Exception e) {

e.printStackTrace();

}

cs=null;

rs=null;

ct=null;

}

}

}

有返回值的存储过程(列表[结果集])

案例：编写一个过程，输入部门号，返回该部门所有雇员信息。

对该题分析如下：

由于oracle存储过程没有返回值，它的所有返回值都是通过out参数来替代的，列表同样也不例外，但由于是集合，所以不能用一般的参数，必须要用package了，步骤如下：

1、建一个包。

2、建立存储过程。

3、下面如何在java程序中调用。

创建包同时定义一个游标类型

create or replace package empPackage is

--定义一个游标数据类型

type my_emp_cursor is ref cursor;

end;

创建存储过程

create or replace procedure indeptno_outAllInfo(v_in_deptno in number,v_out_result out empPackage.my_emp_cursor) is

begin

open v_out_result for select * from emp where deptno=v_in_deptno;

--close v_out_result;--此处不能关闭游标，需要在程序中关闭游标。

end;

编写java程序获得存储过程返回的结果集。

[TestProcedureOutAllValues.java]源代码

package com.test;

import java.sql.CallableStatement;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

public class TestProcedureOutAllValues {

//调用oracle存储过程并获得存储过程的返回结果集。

public static void main(String[] args) {

//定义需要的变量

Connection ct=null;

CallableStatement cs=null;

ResultSet rs=null;

try {

//加载驱动

Class.forName("oracle.jdbc.driver.OracleDriver");

//得到连接

ct=DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:orcl","scott","tiger");

//创建CallableStatement接口

cs=ct.prepareCall("{call indeptno_outAllInfo(?,?)}");

//给?赋值

cs.setInt(1, 20);

//给第二个?注册

cs.registerOutParameter(2, oracle.jdbc.OracleTypes.CURSOR);

//执行

cs.execute();

/*这里是关键所在，java没有接收结果集的get方法，所以只能用getObject来接收结果集，接收到后需要使用ResultSet强转才可以。*/

rs=(ResultSet)cs.getObject(2);

//循环取出

while(rs.next()){

System.out.println(rs.getString("ename")+" "+rs.getString("sal"));

}

} catch (Exception e) {

e.printStackTrace();

}finally{

//关闭资源

try {

if(cs!=null){

cs.close();

}

if(rs!=null){

rs.close();

}

if(ct!=null){

ct.close();

}

} catch (Exception e) {

e.printStackTrace();

}

cs=null;

rs=null;

ct=null;

}

}

}

编写分页过程

有了上面的基础，相信大家可以完成分页存储过程了。

要求：请大家编写一个存储过程，要求可以输入表名、每页显示记录数、当前页，排序字段(deptno降序)。返回总记录数，总页数和返回的结果集。

把一个字符串，当做sql语句执行，并把查询得到的结果赋给某个变量，语法如下：

execute immediate v_sql into myrows;

基本语法：

execute immediate 变量(sql拼接语句) into 输出变量名;

温馨提示：

如果大家忘了oracle中如何分页，请参考第三天的内容

提示：为了讲的清楚明白，这里使用循序渐进的方法，逐步增加传入的参数来讲解。

先简化再复杂

通过输入表名、每页显示记录数、当前页，返回结果集。

1、创建包同时创建游标

create or replace package pagingPackage is

type paging_cursor is ref cursor;

end;

2、创建分页存储过程

create or replace procedure paging_cursor(v_in_table in varchar2,v_in_pagesize in number,v_in_pagenow in number,v_out_result out pagingPackage.paging_cursor) is

--定义需要的变量

v_sql varchar2(4000);

v_start number;

v_end number;

begin

--执行代码

--计算v_start和v_end是多少

v_start:=v_in_pagesize*(v_in_pagenow-1)+1;

v_end:=v_in_pagesize*v_in_pagenow;

v_sql:='select t2.* from (select t1.*,rownum rn from (select * from '||v_in_table||') t1 where rownum<='||v_end||') t2 where rn>='||v_start;

--打开游标，让游标指向结果集

open v_out_result for v_sql;

end;

java调用分页存储过程

[TestProcedurePaging.java]源代码

package com.test;

import java.sql.CallableStatement;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

public class TestProcedurePaging {

//调用oracle分页存储过程并获得存储过程的返回结果集。

public static void main(String[] args) {

//定义需要的变量

Connection ct=null;

CallableStatement cs=null;

ResultSet rs=null;

try {

//加载驱动

Class.forName("oracle.jdbc.driver.OracleDriver");

//得到连接

ct=DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:orcl","scott","tiger");

//创建CallableStatement接口

cs=ct.prepareCall("{call paging_cursor(?,?,?,?)}");

//给in?赋值

cs.setString(1,"emp");//传表名

cs.setInt(2, 6);//传入pagesize，每页显示多少条记录

cs.setInt(3, 1);//传入pagenow，显示第几页。

//给out?注册

cs.registerOutParameter(4, oracle.jdbc.OracleTypes.CURSOR);

//执行

cs.execute();

/*这里是关键所在，java没有接收结果集的get方法，所以只能用getObject来接收结果集，接收到后需要使用ResultSet强转才可以。*/

rs=(ResultSet)cs.getObject(4);

//循环取出

while(rs.next()){

System.out.println(rs.getString("ename")+" "+rs.getString("sal"));

}

} catch (Exception e) {

e.printStackTrace();

}finally{

//关闭资源

try {

if(cs!=null){

cs.close();

}

if(rs!=null){

rs.close();

}

if(ct!=null){

ct.close();

}

} catch (Exception e) {

e.printStackTrace();

}

cs=null;

rs=null;

ct=null;

}

}

}

要求：请大家编写一个存储过程，要求可以输入表名、每页显示记录数、当前页，排序字段(deptno降序)。返回总记录数，总页数和返回的结果集。

1、创建包同时创建游标

create or replace package pagingPackage is

type paging_cursor is ref cursor;

end;

2、创建分页存储过程

create or replace procedure paging_cursor(v_in_table in varchar2,v_in_pagesize in number,v_in_pagenow in number,v_out_result out pagingPackage.paging_cursor,v_out_rows out number,v_out_pagecount out number) is

--定义需要的变量

v_sql varchar2(4000);

v_sql_select varchar2(4000);

v_start number;

v_end number;

begin

--执行代码

--计算v_start和v_end是多少

v_start:=v_in_pagesize*(v_in_pagenow-1)+1;

v_end:=v_in_pagesize*v_in_pagenow;

v_sql:='select t2.* from (select t1.*,rownum rn from (select * from '||v_in_table||') t1 where rownum<='||v_end||') t2 where rn>='||v_start;

--打开游标，让游标指向结果集

open v_out_result for v_sql;

--查询共有多少条记录

v_sql_select:='select count(*) from '||v_in_table;

execute immediate v_sql_select into v_out_rows;

--统计多少页记录

if mod(v_out_rows,v_in_pagesize)=0 then

v_out_pagecount:=v_out_rows/v_in_pagesize;

else

v_out_pagecount:=v_out_rows/v_in_pagesize+1;

end if;

end;

java调用分页存储过程(完整)源代码

[TestProcedurePaging.java]源代码

package com.test;

import java.sql.CallableStatement;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

public class TestProcedurePaging {

//调用oracle分页存储过程并获得存储过程的返回结果集。

public static void main(String[] args) {

//定义需要的变量

Connection ct=null;

CallableStatement cs=null;

ResultSet rs=null;

try {

//加载驱动

Class.forName("oracle.jdbc.driver.OracleDriver");

//得到连接

ct=DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:orcl","scott","tiger");

//创建CallableStatement接口

cs=ct.prepareCall("{call paging_cursor(?,?,?,?,?,?)}");

//给in?赋值

cs.setString(1,"emp");//传表名

cs.setInt(2, 6);//传入pagesize，每页显示多少条记录

cs.setInt(3, 1);//传入pagenow，显示第几页。

//给out?注册

cs.registerOutParameter(4, oracle.jdbc.OracleTypes.CURSOR);

cs.registerOutParameter(5, oracle.jdbc.OracleTypes.INTEGER);

cs.registerOutParameter(6, oracle.jdbc.OracleTypes.INTEGER);

//执行

cs.execute();

/*这里是关键所在，java没有接收结果集的get方法，所以只能用getObject来接收结果集，接收到后需要使用ResultSet强转才可以。*/

rs=(ResultSet)cs.getObject(4);

//循环取出

while(rs.next()){

System.out.println(rs.getString("ename")+" "+rs.getString("sal"));

}

//取出总记录数

int rowCount=cs.getInt(5);

//取出总页数

int pageCount=cs.getInt(6);

System.out.println("共有记录："+rowCount+"条!   "+"共有记录："+pageCount+"页!");

} catch (Exception e) {

e.printStackTrace();

}finally{

//关闭资源

try {

if(cs!=null){

cs.close();

}

if(rs!=null){

rs.close();

}

if(ct!=null){

ct.close();

}

} catch (Exception e) {

e.printStackTrace();

}

cs=null;

rs=null;

ct=null;

}

}

}