PL/SQL编程急速上手

 1 --在列后添加约束
 2 create table table_name
 3 (
 4     col1 type constraint,
 5     ...
 6 )
 7 --单独添加约束
 8 create table table_name
 9 (
10     col1 type,
11     ....,
12     constration cons_name cons_type
13 )
14 --在Oracle中创建表和约束与标准SQL相同

 1 --创建索引（非唯一）
 2 --默认系统会在具有unique和primary key的列上创建唯一约束
 3 create index index_name on (col1...);
 4 --当提供多个列时，即创建复合索引
 5 --创建视图
 6 create or replace view view_name
 7 as
 8 select ...;
 9 --创建，如果已存在则修改视图
10 create view ...
11 as
12 ...
13 with read only;
14 --创建只读的视图（推荐）

1 --为表增加新的列
2 alter table table_name
3 add col_name type constration;
4 --移除表中已有的列
5 alter table table_name
6 drop column col_name;

1 --删除表
2 drop table table_name;
3 --删除视图
4 drop view view_name;
5 ...

1 --获取系统日期
2 select sysdate from dual;
3 --转换日期格式
4 select to_char(sysdate,'yyyy-mm-dd');
5 ...

1 --查询员工表中前10位员工相关信息
2 select rownum,ename,sal from emp
3 where rownum<=10;
4 -- 测试数据库 Oracle 11g 

1 select row_num,empno,ename,sal from (
2     select rownum as row_num,empno,ename,sal from emp
3 )a
4 where row_num >5 and row_num <=10;
5 -- 别名是为了防止服务器把外层的rownum再次当做伪列

1 --查看rowid
2 select rowidtochar(rowid) ename,sal from emp;
3 --基于rowid删除表中形同的记录
4 delete from emp
5 where rowid not in (
6     select min(rowid) from emp group by empno
7 );

 1 --方式一
 2 insert into table_name(column list)--如果不提供字段列表，下面的值列表需要提供每个字段的值，即使可以为空或有默认值
 3 values 
 4 (value list),
 5 (value list),
 6 ....
 7 --方式二
 8 insert into table_name
 9 select ...
10 --从其他查询获取数据，并插入表，数据必须符合表的约束

1 --方式一
2 update table_name
3 set col=newValue
4 where ...--如果不提供过滤条件，则更新表中所有的列
5 --方式二
6 update table_name
7 set (column list)=
8 (select ...)
9 --通过子查询更新表，如果只更新一列，则可以省略column list 的括号，需要注意子查询的字段顺序需要和更新的字段顺序一致

1 --方式一
2 delete from table_name
3 where ...--如果不提供过滤条件，则会删除所有记录

1 create sequence seq_name
2 increment by n --自增的步长，（省略该选项则）默认为1，负数表示递减
3 start with n --序列的初始值，默认为1
4 max value n | nomaxvalue --指定最大值或没有最大值(无限增长)
5 min value n  | nominvalue --指定最小值或没有最小值(无限减小)
6 cycle | nocycle --规定设置的序列到达最大或最小时是否从开头循环
7 cache n | nocache --规定是否在内存中缓存序列值，以改善性能

1 create sequence my_seq
2 start with 1
3 nomaxvalue
4 nocycle;

1 select my_seq.nextval from dual;--获取下一个序列值
2 select my_seq.currval from dual;--查看当前序列值
3 --在插入数据是使用序列
4 insert into table_name
5 values
6 (my_seq.nextval,...)
7 --使用循环批量插入时非常方便

1 alter sequence seq_name
2 ...
3 --为了保证主键的变化有相同的规律可循，一般不建议修改已创建的序列
4 drop sequence seq_name

 1 --把二进制转换成字符
 2 select CHR(0101) from dual;
 3 --连接字符串
 4 select concat(111,'aaa') from dual;
 5 select 111 || 'aaa' from dual;
 6 --首字母大写
 7 select INITCAP('char') from dual;
 8 --全大/小写转换
 9 select lower('ABC'),upper('abc') from dual;
10 --左/右填充
11 select lpad('aa',5,'*'),rpad('aa',5,'*') from dual;
12 --删除字符串左/右指定字符(第二个参数中包含的字符都会被删除)
13 select ltrim('aaa123aaa','1a'),rtrim('aa123aa','a') from dual;
14 --删除左右空格
15 select trim('  aaa  ') from dual;
16 --从左边开始删除指定字符（单个）,可选参数还包括：trailing（从右边开始）,both(两边一起)
17 select trim(leading 'a' from 'aa123aa') from dual;
18 --从指定位置开始截取指定长度的字符串
19 select substr('abcdefg',2,3) from dual;
20 --字符替换(第二个参数中包含的字符都会被替换)
21 select translate('11aa22aa11', 'a2', 'bb') from dual;
22 --替换 NULL 值
23 select nvl(NULL,'aha') from dual;

 1 --绝对值
 2 select abs(-123) from dual;
 3 --向上取整
 4 select ceil(1.2),ceil(-1.2) from dual;
 5 --向下取整
 6 select floor(1.8),floor(-1.8) from dual;
 7 --返回自然常数 e 的 n 次方
 8 select exp(5) from dual;
 9 --返回以第一个参数为底的第二个参数的对数
10 select log(3,10) from dual;
11 --求模,如果第二个参数为0，则返回第一个参数
12 select mod(10,3) from dual;
13 --返回第一个参数的第二个参数次方
14 select power(2，3) from dual;
15 --保留指定小数位，最后一位小数四舍五入得来
16 select round(1.2345,3) from dual;
17 --保留指定小数位，其余直接截断
18 select trunc(1.2345,3) from dual;
19 
20 --格式化数字(格式位数应该与数字位数相同)
21 
22 --用0格式化时，如果数字位数不够，结果会用0补齐位数
23 select to_char(123456789000,'000,000,000,000,000') from dual;
24 --用9格式化时，如果数字位数不够，结果会用空格补齐位数
25 select to_char(123456789000,'999,999,999,999,999') from dual;
26 --使用fm格式化小数
27 select to_char(123456.258,'fm999,999,999.99') from dual;
28 --使用 $（美元） 或 L（当地） 添加货币符号
29 select to_char(123.456,'L999.999') from dual;
30 /* 注意货币符号和小数不能一起使用 */

 1 --返回操作系统日期
 2 select sysdate from dual;
 3 --返回日期部分
 4 select current_date from dual;
 5 --返回日期+时间
 6 select current_timestamp from dual;
 7 --返回操作系统日期—+时间（包含时区信息）
 8 select systimestamp from dual;
 9 --按格式化日期为字符串
10 select to_char(sysdate,'YYYY-MM-DD HH:MM:SS') from dual;
11 --把字符串表示的日期转换成日期类型的值返回（前后格式需保持一致）
12 select to_date('2020-05-28 17:02:00','YYYY-MM-DD HH24:MI:SS') from dual;
13 --把字符串表示的日期转换成日期 + 时间类型的值返回（前后格式需保持一致）
14 select to_timestamp('2020-05-28 17:02:00','YYYY-MM-DD HH24:MI:SS') from dual;
15 --返回指定日期后几个月的日期
16 select add_months(sysdate,1) from dual;
17 --返回两个日期间间隔月数(注意正负)
18 select months_between(sysdate,to_date('2020-07-01','YYYY-MM-DD')) from dual;
19 --把日期按指定精度截断,可选参数有yyyy(精确到年，返回当年的第一天的日期),mm(精确到月，返回当月第一天的日期),rr(精确到日，返回当天的日期)
20 select trunc(sysdate,'mm') from dual;
21 
22 /* ----------------------日期可选格式--------------------- */
23 TO_CHAR(sysdate, 'DD-MON-YYYY HH24:MI:SS')
24 TO_CHAR(sysdate, 'DD-MON-YYYY HH12:MI:SS PM')
25 TO_CHAR(systimestamp, 'DD-MON-YYYY HH24:MI:SS.FF')
26 TO_CHAR(sysdate, 'DY, DD-MON-YYYY')
27 TO_CHAR(sysdate,'Month DDth, YYYY') 
28 TO_CHAR(systimestamp, 'DD-MON-YYYY HH24:MI:SS TZH:TZM')
29 TO_CHAR(sysdate, 'MM/DD/YYYY HH24:MI:SS')
30 TO_CHAR(sysdate, 'MM/DD/YY HH24:MI:SS')
31 TO_CHAR(sysdate, 'MM/DD/RRRR HH12:MI:SS PM')
32 TO_CHAR(sysdate, 'MM/DD/RR HH12:MI:SS PM')

 1 --计算行数（不计算空值）
 2 select count(*) from emp;--根据所有列计算
 3 select count(comm) from emp;--根据某一列计算（注意该列是否有空值）
 4 select count(distinct deptno) from emp;--计算deptno中不同值的个数
 5 --计算列的最大/小值
 6 select max(sal),min(sal) from emp;
 7 --返回中间值
 8 select median(sal) from emp;
 9 --返回标准差
10 select stddev(sal) from emp;
11 --求和
12 select sum(sal) from emp;
13 --计算方差
14 select variance(sal) from emp;
15 --伪列 rownum,每条数据的序号
16 select rownum,empno,ename,sal from emp;

1 set serveroutput on--可以不需要语句结束标记';',这是开发工具的命令
2 dbms_output.enable;--这是 Pl/SQL 提供的

1 declare
2 --... 包括变量、游标等
3 begin
4 --... 业务代码
5 exception
6 --... 异常处理
7 end;

1 --注意，PL/SQL业务代码必须运行在 begin...end 中
2 begin
3 dbms_output.put_line('hello world');
4 end;
5 --没有声明和异常部分

1 <<outer>>--oracle 11g 不允许给最外层块命名
2 begin
3 dbms_output.put_line('outer block');
4   <<inner>>
5   begin
6   dbms_output.put_line('inner block');
7   end;
8 end;

1 declare
2   v_name emp.ename%type;--通过动态获取表中列的数据类型，来确定变量的数据类型
3   v_job  varchar(50);--直接指定具体的数据类型
4 begin
5   v_name:='&name';--通过:=为变量赋值
6 end;

1 declare
2     v_job emp.job%type;
3 begin
4     select job into v_job from emp where ename=v_name;--通过select...into 为变量赋值
5     dbms_output.put_line(v_job);--输出变量值
6 end;

 1 declare
 2   type emp_record is record(--这里相当于定义了一种新的数据类型，类型名称是emp_record,和varcahr，int等类型一样
 3   v_name emp.ename%type,
 4   v_job emp.job%type,
 5   v_sal emp.sal%type
 6   );
 7   --记录类型类似其他编程语言中的类
 8   v_emp_record emp_record;--声明一个emp_record类型的变量，相当于创建一个类的实例
 9 begin
10   select ename,job,sal into v_emp_record from emp where ename='ALLEN';--注意查询的顺序必须和记录类型中定义的顺序一致
11   dbms_output.put_line(v_emp_record.v_name||' '||v_emp_record.v_job||' '||v_emp_record.v_sal);
12   --通过实例访问相关属性
13 end;

1 declare
2   v_emp_record emp%rowtype;--声明一个包含指定表中所有列的rowtype变量，使用上和记录类型完全一致，但它本质上并不是记录类型
3 begin
4   select * into v_emp_record from emp where ename='ALLEN';--把所有的列都查询出来赋值给该变量
5   dbms_output.put_line(v_emp_record.ename||' '||v_emp_record.sal);
6   --该变量中的属性和表的列名完全一致，可以根据需要，只使用部分数据
7 end;

1 declare
2   type idx_table is table of varchar(20) index by pls_integer;--创建索引表类型
3   -- index by 后可选的参数有pls_integer、binary_integer、varcahr(size)和使用%type 指定的varchar2类型
4   v_idx_table idx_table;--声明索引表类型的变量
5 begin
6   v_idx_table(1):='hello';--插入值
7   v_idx_table(2):='world';
8   dbms_output.put_line(v_idx_table(1)||' '||v_idx_table(2));
9 end;

 1 declare 
 2   type nest_table is table of varchar(20);--创建嵌套表类型
 3   v_nest_table nest_table:=nest_table('x');--声明嵌套表类型的变量并初始化
 4   --未初始化的嵌套表类型实际上是一个null，如果试图为其赋值会报错。初始化就是调用一个和创建的嵌套表类型同名的函数，
 5   --函数的参数值类型需要和嵌套表类型定义的存储值类型（of 后的类型）相同，并且参数的个数默认就是这个嵌套表类型变量的初始容量
 6 begin
 7   v_nest_table.extend(5);--扩充嵌套表类型变量的容量
 8   --如果要增加嵌套表的容量，需要调用extend方法（该方法将在稍后详细说明）
 9   v_nest_table(1):='hello';--插入值
10   v_nest_table(2):='world';
11   dbms_output.put_line(v_nest_table(1)||' '||v_nest_table(2));
12   dbms_output.put_line(nvl(v_nest_table(3),'it is null'));--没被使用的位置为null
13 end;

 1 declare
 2   type varr is varray(5) of int;--创建可变数组类型
 3   v_varr varr:=varr();--声明可变数组类型的变量并初始化
 4   --和嵌套表一样的原因，必须初始化
 5 begin
 6   for i in 1..5 loop--循环插入值
 7     v_varr.extend();
 8     v_varr(i):=i;
 9     end loop; dbms_output.put_line(v_varr(1)||','||v_varr(2)||','||v_varr(3)||','||v_varr(4)||','||v_varr(5));
10 end;

 1 --第一步，创建一个保存在数据库中的嵌套表类型
 2 create or replace type nest is table of varchar(20);
 3 --第二步，创建一个带有嵌套表类型列的数据表
 4 create table x(
 5   x_id int, 
 6   x_nest nest
 7 )nested table x_nest store as y;--使用nest table 指定这是一个包含嵌套表类型值的数据表，并通过 store as 创建一个关联表来专门存储嵌套表
 8 --插入一条数据（包含初始化的嵌套表类型值）
 9 insert into x values(1,nest('x','y','z'));
10 --第三步，在PL/SQL中读取嵌套表类型的值（多行操作使用游标）。数据表并没有直接存储嵌套表，所以不能直接使用select查询，而应该在PL/SQL程序块中查询
11 declare
12   v_nest nest;
13 begin
14   select x_nest into v_nest from x;
15   for i in 1..3 loop
16     dbms_output.put_line(v_nest(i));
17   end loop;
18 end;

1 集合.exists(n)--判断是否存在某个集合的值
2 集合.count--统计集合中值的个数
3 集合.limit--查询集合容量（长度）
4 集合.first/集合.last--集合中第一个/最后一个值的索引
5 集合.prior(n)/集合.nest(n)--指定索引位置前一个/下一个值的索引（一般用在索引表中，因为其下标可能不连续）
6 集合.extend/集合.extend(n)--为集合增加1个/n个容量（一般用在嵌套表和可变数组中）
7 集合.trim/集合.trim(n)--从集合末尾删除1个/n个元素（一般用在嵌套表和可变数组中）
8 集合.delete/集合.delete(n)--从集合中删除所有元素/第n个元素（一般用在索引表和嵌套表中）

 1 declare
 2  v1 int default 1;--外层块变量v1
 3 begin
 4  dbms_output.put_line(v1);
 5  --dbms_output.put_line(v2);error 必须声明v2
 6  declare
 7   v2 int default 2;---内层块变量
 8   v1 int default 3;
 9  begin
10   dbms_output.put_line(v1);--返回3
11  end;
12 end;

 1 declare
 2   v_sal int;
 3 begin
 4   select sal into v_sal from emp where empno=&empno;
 5   case v_sal
 6     when 800 then dbms_output.put_line('太少了吧');
 7     when 1600 then dbms_output.put_line('这还差不多');
 8     when 3000 then dbms_output.put_line('这样更好');
 9     when 5000 then dbms_output.put_line('这样最好');
10     else dbms_output.put_line('随缘吧');
11     end case;
12 end;

 1 begin
 2   select sal into v_sal from emp where empno=&empno;
 3   case 
 4     when v_sal<=1000 then dbms_output.put_line('太少了吧');
 5     when v_sal<=1600 then dbms_output.put_line('这还差不多');
 6     when v_sal<=3000 then dbms_output.put_line('这样更好');
 7     when v_sal<=5000 then dbms_output.put_line('这样最好');
 8     else dbms_output.put_line('随缘吧');
 9     end case;
10 end;

 1 declare
 2   v_sal int;
 3 begin
 4   select sal into v_sal from emp where empno=&empno;
 5   if v_sal>=5000
 6     then dbms_output.put_line('还有头发吗');
 7   elsif v_sal>=3000
 8     then dbms_output.put_line('还有一半吗');
 9   else
10     dbms_output.put_line('好好珍惜头发啊，少年');
11   end if;
12 end;

 1 declare
 2   i int default 1;--定义，初始化循环控制变量
 3 begin
 4   loop
 5     if i=5 then
 6       i:=i+1;
 7       continue;--当n等于5时，直接结束本次循环，不输出
 8     end if;
 9     dbms_output.put_line(i);
10     i:=i+1;--修改循环控制变量 
11     exit when i>10;--根据循环控制比变量，判断是否退出循环
12   end loop;--结束循环
13 end;

1 declare
2   i int default 1;--定义，初始化循环控制变量
3 begin
4   while i<=10 loop--根据循环控制变量，判断是否进入循环体
5     dbms_output.put_line(i);--循环体
6     i:=i+1;--修改循环控制变量
7   end loop;--结束循环
8 end;

1 begin
2   --在for循环中，初始化循环控制变量，只需指明变量名即可，类型系统默认为数字，min..max指明控制变量的变化范围，从min开始，到max结束
3   for i in reverse 1..10 loop--i可以被循环体引用，但不能被赋值
4   dbms_output.put_line(i);--循环体
5   --注意，因为初始化循环变量时已经指定了变化范围，这相当于限定了循环条件，当变量从min变化到max时将自动结束循环
6   end loop;  --结束循环
7   --最后说明，reverse是可选的参数，表示循环变量从max开始，到min结束
8 end;

1 begin
2   if ... then
3     ...
4   else
5     null;--什么也不做，但使整个语句块更丰满，可读性更高
6   end if;
7 end;

 1 declare
 2   i int:=0;
 3 begin
 4   <<outer>>--定义一个标签
 5   i:=i+1;
 6   dbms_output.put_line(i);
 7   if i<10 then
 8     goto outer;--通过goto实现类似循环的结构
 9   else
10     null;--通过使用null让语句块更易读
11   end if;
12 end;

 1 declare
 2     异常变量名 exception;
 3 begin
 4     ...
 5     raise 异常变量名;
 6     ...
 7     exception
 8       when 异常变量名
 9         then ...
10 end;

declare
    v_tmp varchar(10);
begin
    v_tmp:='超过10字节的长度了';
    exception
        when value_error
        then
            dbms_output.put_line('出现value_error错误！' || '错误编号：'|| sqlcode || '错误名称' || sqlerrm);
end;

 1 declare
 2   e_nocomm exception;--定义一个异常名称
 3   v_comm number(10,2);
 4 begin
 5   select comm into v_comm from emp where empno=&empno;
 6   if v_comm is null
 7     then raise e_nocomm;--触发自定义异常
 8   end if;
 9   exception
10     when e_nocomm--捕获自定义异常
11       then dbms_output.put_lne('该员工没有提成');
12     when others--捕获未定义的错误
13       then dbms_output.put_line('未知错误 !');
14 end;

 1 --在Oracle SQL Developer中
 2 begin
 3   insert into dept values(88,'开发部','cd');
 4   savepoint a;--设置保存点a
 5   insert into dept values(88,'设计部','cd');
 6   exception
 7     when dup_val_on_index then
 8     dbms_output.put_line('插入出错');
 9     rollback to a;--回滚到a
10 end;
11 --这里我们人为的制造了一个违反唯一约束的插入操作，在错误区捕获该错误，然后回滚到保存点a
12 select * from dept;--只能查询到开发部被插入

1 /* 在 SQL*Plus 中 */
2 SQL>select * from dept;
3 /* 连开发部都没有被插入 */　

1 -- 在 Oracle SQL Developer中
2 commit;
3 --现在插入已经被提交到数据库，在SQL*Plus 中也可以查询到了

1 begin
2   commit;
3   set transaction read only;--只读的事务
4   --settransaction read write;--可读写的事务
5   --set transaction isolation level [serializable | read commited];
6   --serializable：整个事务只能读到当前事务开始前就以提交的数据
7   --read commited：当前事务中的查询，只能读到该查询前以提交的数据（不是整个事务，而是该查询语句。这也是 Oracle 默认的隔离级别）
8 end;

1 --无参过程
2 create or replace procedure p2 as
3 begin
4   dbms_output.put_line('hello world');
5 end p2;
6 --or replace：如果存在则替换存储过程，建议使用
7 --p1：过程名
8 --as：不能省略，也可以用is代替
9 --end p2：创建完成时也要跟上过程名

 1 --带参数的过程
 2 create or replace procedure p2(p_deptno in int)--使用括号添加过程需要的形参
 3 as
 4   v_empcount number;--定义过程中需要使用的变量，只需指定数据类型，不能添加类型所占字节长度
 5 begin
 6   select count(ename) into v_empcount from emp where deptno=p_deptno;
 7   if v_empcount>0 then
 8     dbms_output.put_line('有人');
 9   else
10     dbms_output.put_line('没人');
11   end if;
12 end p2;--不要忘了过程名

1 --调用存储过程
2 begin
3   p2(20);--通过（）传递实参
4 end;
5 --call p2(20);

 1 --创建函数
 2 create or replace function f1
 3 return number--需要指定返回值类型，不需要长度
 4 as
 5 begin
 6   return 1;--需要使用return指定返回值
 7 end f1;
 8 --调用函数
 9 declare 
10   v_f1 number(10);
11 begin
12   v_f1:=f1();--调用函数，并把返回值赋值给变量
13   dbms_output.put_line(v_f1);
14 end;

1 create or replace trigger trigger_name--触发器名称
2 [before | after | instead of]--在事件之前还是之后执行触发器中的代码
3 trigger_event--触发事件
4 [referenceing_caluse]--通过新的名称引用当前正在更新的数据
5 [when trigger_condition]--指定触发条件
6 [for each row]--指定行级触发器（每一条记录都触发一次）
7 trigger_body--触发体（程序块）

 1 create test(--创建测试表
 2     id int primary key,
 3     name varchar(20)
 4 )
 5 create or replace trigger t_test--创建触发器
 6 after insert or update or delete--触发操作（也可以是其中一种）
 7 on test--在表test上
 8 for each row--行级触发器
 9 begin
10     if inserting then--在插入数据时
11         dbms_output.put_line('插入了数据，name：'||:new.name);
12     end if;
13     if updating then--在更新数据时
14         dbms_output.put_line('更新了数据，oldname：'||:old.name||',newname:'||:new.name);
15     end if;
16     if deleting then--在删除数据时
17         dbms_output.put_line('删除了数据，name：'||:old.name);
18     end if;
19 end;

1 ...
2 referencing old as test_old new as test_new
3 ...
4 --下面通过:test_old 引用修改前的数据，:test_new引用修改后的数据

1 insert into test values(1,'r');
2 update test set name='e' where id=1;
3 delete from test where id=1;
4 --注意观察输出结果

1 cursor cursor_name [形参]--形参可以用来在where子句中限定游标记录
2 [return type]--可选的指定游标返回的值类型
3 is query--通过is指定查询（在这里使用形参）
4 [for update[of column_list]]--允许在游标中修改表中的数据，并在游标打开期间锁定选中的记录

 1 declare
 2     deptrow dept%rowtype;--定义一个存储记录的变量
 3     cursor dept_cur is--通过cursor定义游标，is指定需要遍历的结果集（一个查询语句）
 4     select * from dept;
 5 begin
 6     open dept_cur;--打开游标
 7     loop--通过循环遍历游标中的记录
 8         fetch dept_cur into deptrow;--通过fetch提取游标中记录（每次一条）赋值给变量
 9         dbms_output.put_line(deptrow.deptno||':'||deptrow.dname);
10         exit when dept_cur%notfound;--通过%notfound判断游标中是否还有记录
11     end loop;
12     close dept_cur;--关闭游标
13 end;

1 cursor%isopen;--检测游标是否已打开，打开返回ture，否则返回false
2 cursor%found;--检测是否提取到值，提取到返回true，否者返回false
3 cursor%notfound;--与%found相反
4 cursor%rowcount;--统计到目前为止已提取的记录数

1 delcare
2     cursor dept_cur is
3     select * from dept;
4 begin
5     for dept_row in dept_cur loop
6         dbms_output.put_line(deptrow.deptno||':'||deptrow.dname);
7     end loop;
8 end;

 1 create or replace package pkg1--创建包规范
 2 as
 3   i int := 1;--标量变量
 4   dept_record dept%rowtype;--rowtype类型
 5   type dept_tab is table of varchar(20) index by pls_integer;--集合类型
 6 end pkg1;
 7 
 8 declare
 9   mydept pkg1.dept_tab;--创建一个包中集合类型的变量（通过"包.内容"的方式访问包中的内容）
10 begin
11   select * into pkg1.dept_record from dept where deptno=10;--给包中定义的rowtype类型变量赋值
12   dbms_output.put_line(pkg1.dept_record.dname);--访问包中的rowtype类型变量
13   dbms_output.put_line('-------------------------------------------');--分割线
14   for deptrow in (select * from dept) loop--使用游标给包中的集合赋值
15     mydept(pkg1.i) := deptrow.dname;
16     pkg1.i := pkg1.i+1;--修改包中的标量变量
17   end loop;
18   for j in 1..mydept.count loop--使用循环访问集合
19     dbms_output.put_line(mydept(j));
20   end loop;
21   pkg1.i := 1;--初始化包中的标量变量（防止下一次游标读取不到数据）
22 end;

 1 create or replace package pkg2--创建包规范
 2 as
 3   cursor dept_cur return dept%rowtype;--定义游标类型
 4   procedure dept_ins(p_deptno int,p_dname varchar);--定义存储过程
 5   function f2 return varchar;--定义函数
 6 end pkg2;
 7 
 8 create or replace package body pkg2--创建包体
 9 as
10   cursor dept_cur return dept%rowtype--创建游标
11   is
12     select * from dept;
13   procedure dept_ins(p_deptno in int,p_dname in varchar)--创建存储过程
14   as
15   begin
16     insert into dept(deptno,dname) values(p_deptno,p_dname);
17     dbms_output.put_line('新增了部门：'|| p_deptno||','||p_dname);
18   end dept_ins;
19   function f2 return varchar--创建函数
20   is
21   begin
22     return '这是个函数';
23   end f2;
24 end pkg2;
25 
26 
27 begin
28   for deptrow in pkg2.dept_cur loop--读取游标
29     dbms_output.put_line(deptrow.dname);
30   end loop;
31   pkg2.dept_ins(99,'TI');--执行存储过程
32   dbms_output.put_line(pkg2.f2());--执行函数
33 end;