oracle proc learning strategies

限。或者EXCUTE ANY PROCEDURE 权限。
如果单独赋予权限，如下例所示：
grant execute on MY_PROCEDURE to Jelly
调用一个存储过程的例子：
execute MY_PROCEDURE( 'ONE PARAMETER');
存储过程(PROCEDURE)和函数(FUNCTION)的区别。
function 有返回值，并且可以直接在Query 中引用function 和或者使用function 的返回
值。
本质上没有区别,都是PL/SQL 程序,都可以有返回值。最根本的区别是： 存储过程是命
令, 而函数是表达式的一部分。比如：
select max(NAME) FROM
但是不能exec max(NAME) 如果此时max 是函数。
PACKAGE 是function，procedure，variables 和sql 语句的组合。package 允许多个
procedure 使用同一个变量和游标。
创建procedure的语法：
CREATE [ OR REPLACE ] PROCEDURE [ schema.]procedure
[(argument [IN | OUT | IN OUT ] [NO COPY] datatype
[, argument [IN | OUT | IN OUT ] [NO COPY] datatype]...
)]
[ authid { current_user | definer }]
{ is | as } { pl/sql_subprogram_body |
language { java name 'String' | c [ name, name] library lib_name
}]
Sql 代码：
CREATE PROCEDURE sam.credit (acc_no IN NUMBER, amount IN NUMBER) AS
BEGIN
UPDATE accounts
SET balance = balance + amount
WHERE account_id = acc_no;
END;
可以使用create or replace procedure 语句， 这个语句的用处在于，你之前赋予的
excute 权限都将被保留。
IN, OUT, IN OUT用来修饰参数。
IN 表示这个变量必须被调用者赋值然后传入到PROCEDURE 进行处理。
OUT 表示PRCEDURE 通过这个变量将值传回给调用者。
IN OUT 则是这两种的组合。
authid代表两种权限：
定义者权限（difiner right 默认），执行者权限（invoker right）。
定义者权限说明这个procedure 中涉及的表，视图等对象所需要的权限只要定义者拥有
权限的话就可以访问。
执行者权限则需要调用这个procedure 的用户拥有相关表和对象的权限。
Oracle存储过程的基本语法
1. 基本结构
CREATE OR REPLACE PROCEDURE 存储过程名字
(
参数1 IN NUMBER,
参数2 IN NUMBER
) AS
变量1 INTEGER :=0;
变量2 DATE;
BEGIN
END 存储过程名字
2. SELECT INTO STATEMENT
将select 查询的结果存入到变量中，可以同时将多个列存储多个变量中，必须有一条
记录，否则抛出异常(如果没有记录抛出NO_DATA_FOUND)
例子：
BEGIN
SELECT col1,col2 into 变量1,变量2 FROM typestruct where xxx;
EXCEPTION
WHEN NO_DATA_FOUND THEN
xxxx;
END;
...
3. IF 判断
IF V_TEST=1 THEN
BEGIN
do something
END;
END IF;
4. while 循环
WHILE V_TEST=1 LOOP
BEGIN
XXXX
END;
END LOOP;
5. 变量赋值
V_TEST := 123;
6. 用for in 使用cursor
...
IS
CURSOR cur IS SELECT * FROM xxx;
BEGIN
FOR cur_result in cur LOOP
BEGIN
V_SUM :=cur_result.列名1+cur_result.列名2
END;
END LOOP;
END;
7. 带参数的cursor
CURSOR C_USER(C_ID NUMBER) IS SELECT NAME FROM USER WHERE TYPEID=C_ID;
OPEN C_USER(变量值);
LOOP
FETCH C_USER INTO V_NAME;
EXIT FETCH C_USER%NOTFOUND;
do something
END LOOP;
CLOSE C_USER;
8. 用pl/sql developer debug
连接数据库后建立一个Test WINDOW
在窗口输入调用SP 的代码,F9 开始debug,CTRL+N 单步调试
9. Pl/Sql中执行存储过程
在sql*plus 中：
declare
--必要的变量声明，视你的过程而定
begin
execute yourprocudure(parameter1,parameter2,...);
end
/
在SQL/PLUS中调用存储过程，显示结果：
SQL>set serveoutput on --打开输出
SQL>var info1 number; --输出1
SQL>var info2 number; --输出2
SQL>declare
var1 varchar2(20); --输入1
var2 varchar2(20); --输入2
var3 varchar2(20); --输入2
BEGIN
pro(var1,var2,var3,:info1,:info2);
END;
/
SQL>print info1;
SQL>print info2;
注：在EXECUTE IMMEDIATE STR 语句是SQLPLUS 中动态执行语句，它在执行中会自动
提交，类似于DP 中FORMS_DDL 语句，在此语句中str 是不能换行的,只能通过连接字符"||"，
或着在在换行时加上"-"连接字符。
关于Oracle存储过程的若干问题备忘
1. 在Oracle中，数据表别名不能加as。
如：
select a.appname from appinfo a;-- 正确
select a.appname from appinfo as a;-- 错误
也许，是怕和Oracle 中的存储过程中的关键字as 冲突的问题吧
2. 在存储过程中，select某一字段时，后面必须紧跟into，
如果select整个记录，利用游标的话就另当别论了。
select af.keynode into kn
from APPFOUNDATION af
where af.appid=aid and af.foundationid=fid; -- 有into，正确编译
select af.keynode
from APPFOUNDATION af
where af.appid=aid and af.foundationid=fid;-- 没有into ， 编译报错， 提示：
Compilation Error: PLS-00428: an INTO clause is expected in this SELECT statement
3. 在利用select...into...语法时，必须先确保数据库中有该条
记录，否则会报出"no data found"异常。
可以在该语法之前，先利用select count(*) from 查看数据库中是否存在该记录，如果存
在，再利用select...into...
4. 在存储过程中，别名不能和字段名称相同，否则虽然编译
可以通过，但在运行阶段会报错
select keynode into kn from APPFOUNDATION where appid=aid and foundationid=fid;
-- 正确运行
select af.keynode into kn from APPFOUNDATION af where af.appid=appid and af.foundationid
=foundationid;
-- 运行阶段报错，提示：
ORA-01422:exact fetch returns more than requested number of rows
5. 在存储过程中，关于出现null的问题
假设有一个表A，定义如下：
create table A(
id varchar2(50) primary key not null,
vcount number(8) not null,
bid varchar2(50) not null -- 外键
);
如果在存储过程中，使用如下语句：
select sum(vcount) into fcount from A where bid='xxxxxx';
如果A 表中不存在bid="xxxxxx"的记录，则fcount=null(即使fcount 定义时设置了默认值，
如：fcount number(8):=0 依然无效，fcount 还是会变成null)，这样以后使用fcount 时就可能
有问题，所以在这里最好先判断一下：
if fcount is null then
fcount:=0;
end if;
这样就一切ok 了。
6. Hibernate调用Oracle存储过程
this.pnumberManager.getHibernateTemplate().execute(
new HibernateCallback() ...{
public Object doInHibernate(Session session)
throws HibernateException, SQLException ...{
CallableStatement cs = session
.connection()
.prepareCall("{call
modifyapppnumber_remain(?)}");
cs.setString(1, foundationid);
cs.execute();
return null;
}
});
用Java调用Oracle存储过程总结
一、无返回值的存储过程
测试表:
-- Create table
create table TESTTB
(
ID VARCHAR2(30),
NAME VARCHAR2(30)
)t
ablespace BOM
pctfree 10
initrans 1
maxtrans 255
storage
(
initial 64K
minextents 1
maxextents unlimited
);
例: 存储过程为(当然了，这就先要求要建张表TESTTB,里面两个字段（I_ID，I_NAME）。
)：
CREATE OR REPLACE PROCEDURE TESTA(PARA1 IN VARCHAR2, PARA2 IN VARCHAR2)
AS
BEGIN
INSERT INTO BOM.TESTTB(ID, NAME) VALUES (PARA1, PARA2);
END TESTA;
在Java 里调用时就用下面的代码：
package com.yiming.procedure.test;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class TestProcedureDemo1 {
public TestProcedureDemo1() {
}
public static void main(String[] args) {
String driver = "Oracle.jdbc.driver.OracleDriver";
String strUrl = "jdbc:Oracle:thin:@10.20.30.30:1521:vasms";
Statement stmt = null;
ResultSet rs = null;
Connection conn = null;
CallableStatement proc = null;
try {
Class.forName(driver);
conn = DriverManager.getConnection(strUrl, "bom", "bom");
proc = conn.prepareCall("{ call BOM.TESTA(?,?) }");
proc.setString(1, "100");
proc.setString(2, "TestOne");
proc.execute();
} catch (SQLException ex2) {
ex2.printStackTrace();
} catch (Exception ex2) {
ex2.printStackTrace();
} finally {
try {
if (rs != null) {
rs.close();
if (stmt != null) {
stmt.close();
}i
f (conn != null) {
conn.close();
}
}
} catch (SQLException ex1) {
}
}
}
}
二、有返回值的存储过程（非列表）
例：存储过程为：
CREATE OR REPLACE PROCEDURE TESTB(PARA1 IN VARCHAR2, PARA2 OUT VARCHAR2)
AS
BEGIN
SELECT NAME INTO PARA2 FROM TESTTB WHERE ID = PARA1;
END TESTB;
在Java 里调用时就用下面的代码：
package com.yiming.procedure.test;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
public class TestProcedureDemo2 {
public static void main(String[] args) {
String driver = "Oracle.jdbc.driver.OracleDriver";
String strUrl = "jdbc:Oracle:thin:@10.20.30.30:1521:vasms";
Statement stmt = null;
ResultSet rs = null;
Connection conn = null;
CallableStatement proc = null;
try {
Class.forName(driver);
conn = DriverManager.getConnection(strUrl, "bom", "bom");
proc = conn.prepareCall("{ call BOM.TESTB(?,?) }");
proc.setString(1, "100");
proc.registerOutParameter(2, Types.VARCHAR);
proc.execute();
String testPrint = proc.getString(2);
System.out.println("=testPrint=is=" + testPrint);
} catch (SQLException ex2) {
ex2.printStackTrace();
} catch (Exception ex2) {
ex2.printStackTrace();
} finally {
try {
if (rs != null) {
rs.close();
if (stmt != null) {
stmt.close();
}
if (conn != null) {
conn.close();
}
}
} catch (SQLException ex1) {
}
}
}
}
注意，这里的proc.getString(2)中的数值2 并非任意的，而是和存储过程中的out 列对应
的， 如果out 是在第一个位置， 那就是proc.getString(1) ， 如果是第三个位置， 就是
proc.getString(3)，当然也可以同时有多个返回值，那就是再多加几个out 参数了。
三、返回列表
由于Oracle存储过程没有返回值，它的所有返回值都是通过out参数来替代的，列表
同样也不例外，但由于是集合，所以不能用一般的参数，必须要用pagkage 了.所以要分两
部分，
1. 建一个程序包。如下：
CREATE OR REPLACE PACKAGE TESTPACKAGE AS
TYPE TEST_CURSOR IS REF CURSOR;
end TESTPACKAGE;
2. 建立存储过程，存储过程为：
CREATE OR REPLACE PROCEDURE TESTC(P_CURSOR out
TESTPACKAGE.TEST_CURSOR) IS
BEGIN
OPEN P_CURSOR FOR
SELECT * FROM BOM.TESTTB;
END TESTC;
可以看到，它是把游标（可以理解为一个指针），作为一个out 参数来返回值的。
在Java 里调用时就用下面的代码：
在这里要注意，在执行前一定要先把Oracle 的驱动包放到class 路径里，否则会报错的。
package com.yiming.procedure.test;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class TestProcedureDemo3 {
public static void main(String[] args) {
String driver = "Oracle.jdbc.driver.OracleDriver";
String strUrl = "jdbc:Oracle:thin:@10.20.30.30:1521:vasms";
Statement stmt = null;
ResultSet rs = null;
Connection conn = null;
CallableStatement proc = null;
try {
Class.forName(driver);
conn = DriverManager.getConnection(strUrl, "bom", "bom");
proc = conn.prepareCall("{ call bom.testc(?) }");
proc.registerOutParameter(1,
Oracle.jdbc.OracleTypes.CURSOR);
proc.execute();
rs = (ResultSet) proc.getObject(1);
while (rs.next()) {
System.out.println("<tr><td>" + rs.getString(1) +
"</td><td>"
+ rs.getString(2) + "</td></tr>");
}
} catch (SQLException ex2) {
ex2.printStackTrace();
} catch (Exception ex2) {
ex2.printStackTrace();
} finally {
try {
if (rs != null) {
rs.close();
if (stmt != null) {
stmt.close();
}i
f (conn != null) {
conn.close();
}
}
} catch (SQLException ex1) {
}
}
}
}
在存储过程中做简单动态查询
在存储过程中做简单动态查询代码,例如:
CREATE OR REPLACE procedure ZXM_SB_GZ_GET
(p_table in varchar2,
p_name in varchar2,
p_value in varchar2,
outpara out lntxdba.zxm_pag_cs_power.c_type
)
as
begin
declare
wherevalue varchar2(200);
begin
wherevalue:=select * from ||p_table|| where ||p_name||=||p_value;
open outpara for
wherevalue;
end;
end;
一般的PL/SQL 程序设计中，在DML 和事务控制的语句中可以直接使用SQL，但是DDL
语句及系统控制语句却不能在PL/SQL 中直接使用，要想实现在PL/SQL 中使用DDL 语句及系
统控制语句，可以通过使用动态SQL 来实现。
首先我们应该了解什么是动态SQL，在Oracle 数据库开发PL/SQL 块中我们使用的SQL
分为：静态SQL 语句和动态SQL 语句。所谓静态SQL 指在PL/SQL 块中使用的SQL 语句在编
译时是明确的，执行的是确定对象。而动态SQL 是指在PL/SQL 块编译时SQL 语句是不确定
的，如根据用户输入的参数的不同而执行不同的操作。编译程序对动态语句部分不进行处理，
只是在程序运行时动态地创建语句、对语句进行语法分析并执行该语句。
Oracle 中动态SQL 可以通过本地动态SQL 来执行，也可以通过DBMS_SQL 包来执行。下面就
这两种情况分别进行说明：
一、本地动态SQL
本地动态SQL 是使用EXECUTE IMMEDIATE 语句来实现的。
1、本地动态SQL 执行DDL 语句：
需求：根据用户输入的表名及字段名等参数动态建表。
create or replace procedure proc_test
(
table_name in varchar2, --表名
field1 in varchar2, --字段名
datatype1 in varchar2, --字段类型
field2 in varchar2, --字段名
datatype2 in varchar2 --字段类型
) as
str_sql varchar2(500);
begin
str_sql:=’create
table ’||table_name||’(’||field1||’ ’||datatype1||’,’||field2||’ ’||datatype2||’)’;
execute immediate str_sql; --动态执行DDL 语句
exception
when others then
null;
end ;
以上是编译通过的存储过程代码。下面执行存储过程动态建表。
SQL> execute proc_test(’dinya_test’,’id’,’number(8) not null’,’name’,’varchar2(100)’);
PL/SQL procedure successfully completed
SQL> desc dinya_test;
Name Type Nullable Default Comments
---- ------------- -------- ------- --------
ID NUMBER(8)
NAME VARCHAR2(100) Y
SQL>
到这里，就实现了我们的需求，使用本地动态SQL 根据用户输入的表名及字段名、字段
类型等参数来实现动态执行DDL 语句。
2、本地动态SQL 执行DML 语句。
需求：将用户输入的值插入到上例中建好的dinya_test 表中。
create or replace procedure proc_insert
(
id in number, --输入序号
name in varchar2 --输入姓名
) as
str_sql varchar2(500);
begin
str_sql:=’insert into dinya_test values(:1,:2)’;
execute immediate str_sql using id,name; --动态执行插入操作
exception
when others then
null;
end ;
执行存储过程，插入数据到测试表中。
SQL> execute proc_insert(1,’dinya’);
PL/SQL procedure successfully completed
SQL> select * from dinya_test;
ID NAME
1 dinya
在上例中，本地动态SQL 执行DML 语句时使用了using 子句，按顺序将输入的值绑定
到变量，如果需要输出参数，可以在执行动态SQL 的时候，使用RETURNING INTO 子句，如：
declare
p_id number:=1;
v_count number;
begin
v_string:=’select count(*) from table_name a where a.id=:id’;
execute immediate v_string into v_count using p_id;
end ;
二、使用DBMS_SQL包
使用DBMS_SQL 包实现动态SQL 的步骤如下：
A、先将要执行的SQL 语句或一个语句块放到一个字符串变量中。
B、使用DBMS_SQL 包的parse 过程来分析该字符串。
C、使用DBMS_SQL 包的bind_variable 过程来绑定变量。
D、使用DBMS_SQL 包的execute 函数来执行语句。
1、使用DBMS_SQL 包执行DDL 语句
需求：使用DBMS_SQL 包根据用户输入的表名、字段名及字段类型建表。
create or replace procedure proc_dbms_sql
(
table_name in varchar2, --表名
field_name1 in varchar2, --字段名
datatype1 in varchar2, --字段类型
field_name2 in varchar2, --字段名
datatype2 in varchar2 --字段类型
)as
v_cursor number; --定义光标
v_string varchar2(200); --定义字符串变量
v_row number; --行数
begin
v_cursor:=dbms_sql.open_cursor; --为处理打开光标
v_string:=’create
table ’||table_name||’(’||field_name1||’ ’||datatype1||’,’||field_name2||’ ’||datatype2||’)’;
dbms_sql.parse(v_cursor,v_string,dbms_sql.native); --分析语句
v_row:=dbms_sql.execute(v_cursor); --执行语句
dbms_sql.close_cursor(v_cursor); --关闭光标
exception
when others then
dbms_sql.close_cursor(v_cursor); --关闭光标
raise;
end;
以上过程编译通过后，执行过程创建表结构：
SQL> execute proc_dbms_sql(’dinya_test2’,’id’,’number(8) not null’,’name’,’varchar2(100)’);
PL/SQL procedure successfully completed
SQL> desc dinya_test2;
Name Type Nullable Default Comments
---- ------------- -------- ------- --------
ID NUMBER(8)
NAME VARCHAR2(100) Y
SQL>
2、使用DBMS_SQL 包执行DML 语句
需求：使用DBMS_SQL 包根据用户输入的值更新表中相对应的记录。
查看表中已有记录：
SQL> select * from dinya_test2;
ID NAME
1 Oracle
2 CSDN
3 ERP
SQL>
建存储过程，并编译通过：
create or replace procedure proc_dbms_sql_update
(
id number,
name varchar2
)as
v_cursor number; --定义光标
v_string varchar2(200); --字符串变量
v_row number; --行数
begin
v_cursor:=dbms_sql.open_cursor; --为处理打开光标
v_string:=’update dinya_test2 a set a.name=:p_name where a.id=:p_id’;
dbms_sql.parse(v_cursor,v_string,dbms_sql.native); --分析语句
dbms_sql.bind_variable(v_cursor,’:p_name’,name); --绑定变量
dbms_sql.bind_variable(v_cursor,’:p_id’,id); --绑定变量
v_row:=dbms_sql.execute(v_cursor); --执行动态ＳＱＬ
dbms_sql.close_cursor(v_cursor); --关闭光标
exception
when others then
dbms_sql.close_cursor(v_cursor); --关闭光标
raise;
end;
执行过程，根据用户输入的参数更新表中的数据：
SQL> execute proc_dbms_sql_update(2,’csdn_dinya’);
PL/SQL procedure successfully completed
SQL> select * from dinya_test2;
ID NAME
1 Oracle
2 csdn_dinya
3 ERP
SQL>
执行过程后将第二条的name 字段的数据更新为新值csdn_dinya。这样就完成了使用
dbms_sql 包来执行DML 语句的功能。
使用DBMS_SQL 中，如果要执行的动态语句不是查询语句，使用DBMS_SQL.Execute 或
DBMS_SQL.Variable_Value 来执行， 如果要执行动态语句是查询语句， 则要使用
DBMS_SQL.define_column 定义输出变量， 然后使用DBMS_SQL.Execute,
DBMS_SQL.Fetch_Rows, DBMS_SQL.Column_Value 及DBMS_SQL.Variable_Value 来执行查询并
得到结果。
总结说明：
在Oracle 开发过程中，我们可以使用动态SQL 来执行DDL 语句、DML 语句、事务控制
语句及系统控制语句。但是需要注意的是，PL/SQL 块中使用动态SQL 执行DDL 语句的时候
与别的不同，在DDL 中使用绑定变量是非法的（bind_variable(v_cursor,’:p_name’,name)），分
析后不需要执行DBMS_SQL.Bind_Variable，直接将输入的变量加到字符串中即可。另外，DDL
是在调用DBMS_SQL.PARSE 时执行的，所以DBMS_SQL.EXECUTE 也可以不用，即在上例中的
v_row:=dbms_sql.execute(v_cursor)部分可以不要。
Oracle存储过程调用Java方法
存储过程中调用Java程序段
软件环境：
1、操作系统：Windows 2000 Server
2、数据库：Oracle 8i R2 (8.1.7) for NT 企业版
3、安装路径：C:\ORACLE
实现方法：
1、创建一个文件为Test.java
public class Test {
public static void main(String args[]) {
System.out.println("HELLO THIS iS A Java PROCEDURE");
}
}
2、javac Test.java
3、java Test
4、SQL> conn system/manager
SQL> grant create any directory to scott;
SQL> conn scott/tiger
SQL> create or replace directory test_dir as 'd:\';
目录已创建。
SQL> create or replace java class using bfile(test_dir,'TEST.CLASS')
2 /
Java 已创建。
SQL> select object_name,object_type,STATUS from user_objects;
SQL> create or replace procedure test_java
as language java
name 'TEST.main(java.lang.String[])';
/
过程已创建。
SQL> set serveroutput on size 5000
SQL> call dbms_java.set_output(5000);
调用完成。
SQL> execute test_java;
HELLO THIS iS A Java PROCEDURE
PL/SQL 过程已成功完成。
SQL> call test_java();
HELLO THIS iS A Java PROCEDURE
调用完成。
Oracle 8I 9I 都测试通过。
Oracle高效分页存储过程实例
create or replace package p_page is
-- Author : PHARAOHS
-- Created : 2006-4-30 14:14:14
-- Purpose : 分页过程
TYPE type_cur IS REF CURSOR; --定义游标变量用于返回记录集
PROCEDURE Pagination(
Pindex in number, --分页索引
Psql in varchar2, --产生dataset 的sql 语句
Psize in number, --页面大小
Pcount out number, --返回分页总数
v_cur out type_cur --返回当前页数据记录
);
procedure PageRecordsCount(
Psqlcount in varchar2, --产生dataset 的sql 语句
Prcount out number --返回记录总数
);
end p_page;
/
create or replace package body p_page is
PROCEDURE Pagination(
Pindex in number,
Psql in varchar2,
Psize in number,
Pcount out number,
v_cur out type_cur
)
AS
v_sql VARCHAR2(1000);
v_count number;
v_Plow number;
v_Phei number;
Begin
------------------------------------------------------------取分页总数
v_sql := 'select count(*) from (' || Psql || ')';
execute immediate v_sql into v_count;
Pcount := ceil(v_count/Psize);
------------------------------------------------------------显示任意页内容
v_Phei := Pindex * Psize + Psize;
v_Plow := v_Phei - Psize + 1;
--Psql := 'select rownum rn,t.* from zzda t' ; --要求必须包含rownum 字段
v_sql := 'select * from (' || Psql || ') where rn between ' || v_Plow || ' and ' || v_Phei ;
open v_cur for v_sql;
End Pagination;
--*****************************************************************************
*********
procedure PageRecordsCount(
Psqlcount in varchar2,
Prcount out number
)
as
v_sql varchar2(1000);
v_prcount number;
begin
v_sql := 'select count(*) from (' || Psqlcount || ')';
execute immediate v_sql into v_prcount;
Prcount := v_prcount; --返回记录总数
end PageRecordsCount;
--*****************************************************************************
*********
end p_page;
/