Oracle PL/SQL基础知识

过程(存储过程)

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

调用过程有两种方法：

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

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

创建存储过程基本语法：

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

//定义变量

begin

//执行语句;

end;

/

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

过程创建举例：

--输入员工编号，新工资，修改员工的工资
create or replace procedure p4(v_in_emp in number,v_in_new_sal in number) is
v_ename varchar2(30);
begin
  select ename into v_ename from emp2 where empno = v_in_emp;
  update emp2 set sal = v_in_new_sal where empno = v_in_emp;
exception
  when no_data_found then
       dbms_output.put_line('员工编号不存在');
end;
/

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

Java调用过程
/**
 * 调用过程
 */
package com.oracle.db;
import java.sql.*;
public class db4 {
	// 调用p4过程
	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:Switch", "scott",
					"123456");
			// 创建CallableStatement
			cs = ct.prepareCall("{call p4(?,?)}");
			// 给?赋值
			cs.setInt(1, 7369);
			cs.setFloat(2, 1000.5f);
			// 执行
			cs.execute();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				// 关闭资源
				if (cs != null) {
					cs.close();
				}
				if (ct != null) {
					ct.close();
				}
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
	}
}

扩展SQLHelper类，使之实现无返回参数的存储过程的方法

package com.oracle.db;
import java.io.FileInputStream;
import java.sql.*;
import java.util.Properties;

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 = (String) pp.getProperty("username");
			password = (String) pp.getProperty("password");
			driver = (String) pp.getProperty("driver");
			url = (String) 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 && !"".equals(parameters)) {
				for(int i = 0; i < parameters.length; i++){
					cs.setString(i + 1, parameters[i]);
				}
			}
			//执行
			cs.execute();
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e.getMessage());
		} finally {
			close(rs, cs, ct);
		}
	}

	// 统一的cud操作
	public static void executeUpdate(String sql, String[] parameters) {
		try {
			ct = DriverManager.getConnection(url, username, password);
			ps = ct.prepareStatement(sql);
			if (parameters != null) {
				for (int i = 0; i < parameters.length; i++) {
					ps.setString(i + 1, parameters[i]);
				}
			}		
			// 执行
			ps.executeUpdate();

		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e.getMessage());
		} finally {
			close(rs, ps, ct);
		}
	}

	// 写一个方法，完成查询任务
	// sql表示要执行的sql语句
	// sql select * from emp where ename=?
	public static ResultSet executeQuery(String sql, String[] parameters) {
		try {
			// 根据实际情况我们对sql语句?赋值
			// 得到连接
			ct = DriverManager.getConnection(url, username, password);
			// 创建ps对象，得到sql语句对象
			ps = ct.prepareStatement(sql);
			// 如果parameters不为null，才赋值
			if (parameters != null) {
				for (int i = 0; i < parameters.length; i++) {
					ps.setString(i + 1, parameters[i]);
				}
			}
			rs = ps.executeQuery();
		} catch (SQLException e) {
			e.printStackTrace();
			// 抛出运行异常
			throw new RuntimeException(e.getMessage());
		} finally {
			// close(rs,ps,ct);
		}
		return rs;
	}

	// 把关闭资源写成函数
	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;
		}
	}

	public static Connection getCt() {
		return ct;
	}

	public static PreparedStatement getPs() {
		return ps;
	}
}

dbinfo.propeties中的属性

driver = oracle.jdbc.driver.OracleDriver

url = jdbc:oracle:thin:@127.0.0.1:1521:Switch

username = scott

password =123456

dbinfo.propeties中的属性
driver = oracle.jdbc.driver.OracleDriver
url = jdbc:oracle:thin:@127.0.0.1:1521:Switch
username = scott
password =123456

函数

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

建立函数的基本语法：

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

return 数据类型 is

定义变量;

begin

执行语句;

end;

/

函数调用的基本语法：

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

实例：

--用函数接收用户名，返回用户年薪
create or replace function f1(v_in_ename varchar2)
return number is
v_annual_sal number;
begin
  select (sal+nvl(comm,0))*13 into v_annual_sal from emp2 where ename  = v_in_ename;
  return v_annual_sal;
end;
/

函数和过程的区别：

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

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

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

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

/**
 * 使用SQLHelper调用函数
 */
package com.oracle.db;
import java.sql.*;
public class db6 {
	public static void main(String[] args) {
		String sql = "select f1('SMITH') from dual";
		ResultSet rs = SQLHelper.executeQuery(sql, null);
		try {
			if(rs.next()){
				System.out.println(rs.getDouble(1));
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
}

包

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

1、使用create package命令来创建包：

建包基本语法：

create [or replace] package 包名 is

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

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

end;

/

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

实例：

--声明一个包
create or replace package pack1 is
--声明一个过程用于输入员工姓名，新工资，修改员工的工资
       procedure p1(v_in_ename in varchar2,v_in_newsal number);
--声明一个函数用于接收用户名，返回用户年薪
       function f1(v_in_ename in 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 pack1 is
--实现一个过程用于输入员工姓名，新工资，修改员工的工资
       procedure p1(v_in_ename in varchar2,v_in_newsal number) is
       begin
         update emp2 set sal = v_in_newsal where ename = v_in_ename;
       end;
--实现一个函数用于接收用户名，返回用户年薪
       function f1(v_in_ename in varchar2) return number is
       v_annual_sal number;
       begin
         select (sal+nvl(comm,0))*13 into v_annual_sal from emp2 where ename = v_in_ename;
       return v_annual_sal;
       end;
end;
/

细节说明：

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

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

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

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

调用基本方法：

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

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

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

/**
 * 使用SQLHelper调用包中函数
 */
package com.oracle.db;
import java.sql.*;
public class db7 {
	public static void main(String[] args) {
		String sql = "select scott.pack1.f1('SMITH') from dual";
		ResultSet rs = SQLHelper.executeQuery(sql, null);
		try {
			if(rs.next()){
				System.out.println(rs.getDouble(1));
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
}

触发器

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

PS：触发器也是用来维护表的完整性的，触发器将在之后单独写成一篇博客。

定义并使用变量

在编写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]

说明：

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在定义一个变量的时候，如果要赋初值，则需要使用:=，如果只是=则是用于判断两个值是否相等。

实例：

--编写过程，以输入的员工号，显示员工的姓名、工资、个人所得税(税率为0.03)
create or replace procedure p5(v_in_empno in number) is
v_ename varchar2(30);
v_sal number;
v_tax_rate number(3,2) := 0.03;
v_tax number;
begin
  select ename,sal into v_ename,v_sal from emp2 where empno = v_in_empno;
  v_tax := v_sal * v_tax_rate;
  dbms_output.put_line('员工的姓名为：' || v_ename || ' 员工的工资为：' || v_sal || ' 员工的个人所得税为： ' || v_tax);
end;
/

%type类型

为了降低pl/sql程序的维护工作量，可以使用%type属性定义变量，这样它会按照数据库列来确定你定义的变量的类型和长度。

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

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

--优化
create or replace procedure p6(v_in_empno in number) is
v_ename emp2.ename%type;    --使用emp2中ename的类型定义
v_sal emp2.sal%type;        --使用emp2中sal的类型定义
v_tax_rate emp2.sal%type := 0.03;   --使用emp2中sal的类型定义
v_tax emp2.sal%type;        --使用emp2中sal的类型定义
begin
  select ename,sal into v_ename,v_sal from emp2 where empno = v_in_empno;
  v_tax := v_sal * v_tax_rate;
  dbms_output.put_line('员工的姓名为：' || v_ename || ' 员工的工资为：' || v_sal || ' 员工的个人所得税为： ' || v_tax);
end;
/

复合变量(composite)

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

复合类型–pl/sql记录

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

复合变量定义基本语法：

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

变量名 变量类型,

变量名 变量类型

);

复合变量基本使用语法：

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

--复合类型
--编写过程，接收员工编号，显示该员工的名字、薪水、工作岗位(用pl/sql记录实现)
create or replace procedure p7(v_in_empno in emp2.ename%type) is
--定义记录类型
type emps_record is record
(
     v_ename emp2.ename%type,
     v_sal emp2.sal%type,
     v_job emp2.job%type
);
--定义emps_record记录类型的变量
emps emps_record;
begin
  select ename,sal,job into emps.v_ename,emps.v_sal,emps.v_job from emp2 where empno = v_in_empno;
  dbms_output.put_line('员工的姓名为：' || emps.v_ename || ' 员工的工资为：' || emps.v_sal || ' 员工的工作为： ' || emps.v_job);
end;
/

复合类型–pl/sql表

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

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

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

index by binary_integer;

declare
type table_type is table of emp2.ename%type
index by binary_integer;
stable table_type;--定义一个变量
begin
select ename into stable(-1) from emp where empno=7788;
dbms_output.put_line('员工名：'||stable(-1));
end;

说明：

table_type 是pl/sql表类型

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

stable 为pl/sql表变量

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

参照变量

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

游标变量

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

游标(ref cursor)使用

定义游标基本语法：

type 自定义游标名 is ref cursor;

变量名 自定义游标名;

打开游标基本语法：

open 游标变量 for select 语句;

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

fetch 游标变量 into 其它变量;

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

游标变量%notfound

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

--参照变量
--编写过程，输入部门号，显示该部门所有员工的姓名和工资
create or replace procedure p8(v_in_deptno in dept2.deptno%type) is
--定义游标变量类型
type emp_cursor is ref cursor;
--定义游标变量
v_emp_cursor emp_cursor;
v_ename emp2.ename%type;
v_sal emp2.sal%type;
begin
  --打开游标
  open v_emp_cursor for select ename,sal from emp2 where deptno = v_in_deptno;
  --用循环语句取出游标中指向的每行数据
  loop
    --取出每行数据
    fetch v_emp_cursor into v_ename,v_sal;
    --判断游标退出
    exit when v_emp_cursor%notfound;
    --输出每行数据
    dbms_output.put_line('员工的姓名为：' || v_ename || ' 员工的工资为：' || v_sal);
  end loop;
  --关闭游标
  close v_emp_cursor;
end;
/

--参照变量
--编写过程，输入部门号，显示该部门所有员工的姓名和工资并且如果某个员工的工资低于2000则增加100
create or replace procedure p9(v_in_deptno in dept2.deptno%type) is
--定义游标变量类型
type emp_cursor is ref cursor;
--定义游标变量
v_emp_cursor emp_cursor;
v_ename emp2.ename%type;
v_sal emp2.sal%type;
v_empno emp2.empno%type;
begin
  --打开游标
  open v_emp_cursor for select ename,sal,empno from emp2 where deptno = v_in_deptno;
  --用循环语句取出游标中指向的每行数据
  loop
    --取出每行数据
    fetch v_emp_cursor into v_ename,v_sal,v_empno;
    --判断游标退出
    exit when v_emp_cursor%notfound;
    --如果某个员工的工资低于2000则增加100
    if(v_sal < 2000) then
             update emp2 set sal = sal + 100 where empno = v_empno;
    end if;
    --输出每行数据
    dbms_output.put_line('员工的姓名为：' || v_ename || ' 员工的工资为：' || v_sal);
  end loop;
  --关闭游标
  close v_emp_cursor;
end;
/

———-参考《韩顺平玩转Oracle》