/* 对象类型属于用户自定义的一种复合类型，它封装了数据结构和拥有操作这些数据结构的函数。
对象类型；对象类型体和对象类型规范组成
对象类型属性不能使用以下类型定义。如；long,rowid,%type,%rowtype,ref cursor,record, pls_integer等
涉及到成员方法。构造方法，静态方法，map方法（将对象类型进行比较，因为对象不像标量那样可以直接排序），最大只能定义一个map 方法
map方法可以对个对象进行排序，而order方法只能对两个对象实例比较大小 ,map和order不能同时定义。
《1》对象表
对象表是包含对象类型列的表，而普通表其列全部使用标量数据类型。分为行对象表和列对象表
1.行对象表，
eg; create table obj_emp of emp_type;
2.列对象（包含多个列）
eg; create table obj_emp(
dno number,dname varchar2(10),
emp emp_type
);
《2》对象类型继承
《3》引用对象类型 ref（指向对象的逻辑指针，是oracle的一种内置数据类型）(通过引用可以使不同表共享相同对象，从而降低内存占用）
如 create table obj_emp2 (
dno number,
emp ref obj_emp --引用上面的行对象
);
《4》建立对象类型
1.建立无方法的对象类型
create or replace type emp_type as object (
name varchar2(8),
birthdate date
);
--建立行对象表
create table emp_tab of emp_type ;
--插入数据
insert into emp_tab values('tom',to_date('1980-1-25','yyyy-mm-dd'));--普通插入
insert into emp_tab values(emp_type('sam',to_date('1983-1-25','yyyy-mm-dd'))); --采用对象类型构造方法插入
-- 在pl/sql块中，如果要将对象数据检索到对象变量中，则必须用value方法
declare
emp emp_type;
begin
select value(p) into emp from emp_tab p where p.name = '&name';
dbms_output.put_line(emp.birthdate);
end;
-- 更新行对象数据，如果根据对象属性更新数据时必须定义对象别名
eg; update emp_tab p set p.birthdate=to_date('2000-1-23',yyyy-mm-dd) where p.name=&name;
-- 删除行对象类型数据是如果根据对象属性删除数据 ，则删除时必须定义别名
begin
delete from emp_tab p where p.name=&name;
end;
/
==============================================================================================
-- 创建列对象表
create or replace type emp_l_tab as object (
dname varchar2(),emp emp_type
);
-- insert (用对象类型的构造方法插入数据)
insert into emp_l_tab values('db' emp_type('tom',to_date('2011-06-14',sysdate)));
-- 检索列对象
检索行对象类型数据到类型变量时必须用value方法，但检索列对象时可以直接检索到类型变量
declare
v_emp_l emp_type ;
v_dname varchar2(20) ;
select dname,emp into v_dname,emp from emp_l_tab b where b.dname=&dname;
--更新列对象时，必须为列对象定义别名(列对象别名.对象类型列名.对象属性名)
update emp_l_tab b set b.emp.birthdate = to_date('2011-06-14','yyyy-mm-dd') where b.dname=&dame;
--删除类同更新数据
2.建立有方法的对象类型
1》 建立和使用member（成员）方法的对象类型（建立对象类型规范）
eg;
create or replace type emp_m_type as object(
dname varchar2(20), ddate date,addr varchar2(100),
member procdure proc_change_addr(newaddr dname),
member function func_get_dname return varchar2
);
/
2》建立对象类型体
create or replace type body emp_m_type is
member procdure proc_change_addr(newaddr varchar2)
is
begin
addr ;= newaddr;
end;
member function func_get_dname return varchar2
is
v_dname varchar2(20);
begin
v_danme := '部门：'||dname ||'--'|| birthdate ;
return v_danme;
end;
end;
/
-- 插入数据类同上面
-- 提前数据
declare
v_emp emp_m_type;
begin
v_emp ;= emp.get_dname('上海徐汇');
......................
end;
/
--3 建立和使用static 方法
static 方法用于访问对象类型，如果需要在对象类型上执行全局操作，则应该定义static
方法。只能有对象类型访问static
create or replace type emp_type3 as object(
name varchar2(10),gender varchar2(2),
static function getname return varchar2,
member function get_gender return varchar2
);
--建立对象类型体
create or replace type body emp_type3 is
static function getname return varchar2 is
begin
return 'jecker';
end;
member function get_gender return varchar2
is
begin
return 'xingbie='||gender;
end;
end;
;
-- 基于对象类型emp_type3 建立 emp_tab3
create table emp_tab3(
eno number(6),emp emp_type3,
sal number(6,2),job varchar2(10)
);
-- 向表emp_tab3插入数据
begin
insert into emp_tab3(eno,sal,job,emp)
values(100001,9999,'CTO/CIO',emp_type3(
'jeckery',emp_type3.getname()
));
end;
-- 访问 静态static函数和成员方法（member）
declare
e emp_type3;
begin
select t.emp into e from emp_tab3 t where rownum=1;
raise_application_error(-20201,emp_type3.getname()||'-----'||e.get_gender());
end;
-- 4.建立和使用 map 方法
map方法用于将对象实例映射成标量值。
-- 建立对象类型emp_type4
create or replace type emp_type4 as object(
name varchar2(10),
birthdate date,
map member function get_birdate return varchar2
);
-- 为emp_type4 对象类型实现方法体
create or replace type body emp_type4 is
map member function get_birdate return varchar2 is
begin
return trunc((sysdate-birthdate)/365);
end;
end;
-- 根据对象类型empa_type4 创建表emp_tab4
create table emp_tab4 (
eno number(6),sal number(6,2),
job varchar2(20),emp4 emp_type4
);
-- 插入数据到emp_tab4
begin
insert into emp_tab4(eno,sal,job,emp4)
values(0011,9000,'dba',emp_type4('jacker',to_date('1990-12-19','yyyy-mm-dd')));
insert into emp_tab4(eno,sal,job,emp4)
values(0022,9900,'dba',emp_type4('jacker',to_date('1970-12-2','yyyy-mm-dd')));
end;
--比较数据
declare
type emp4_tab is table of emp_type4;
v_emp4_tab emp4_tab;
v_result varchar2(100);
begin
select emp4 bulk collect into v_emp4_tab from emp_tab4 ;
if v_emp4_tab(1).get_birdate()>v_emp4_tab(2).get_birdate() then
v_result := v_emp4_tab(1).name ||' 比 '||v_emp4_tab(2).name ||'大';
else
v_result := v_emp4_tab(1).name ||' 比 '||v_emp4_tab(2).name ||'小';
end if;
raise_application_error(-20201,v_result);
end;
-- 5 建立order 方法
1.order 与 map 在一个对象类型中不能同时存在
2.order 用于比较对象的2个实例大小
-- 建立对象类型emp_type4
create or replace type emp_type5 as object(
name varchar2(10),
birthdate date,
order member function compare(emp5 emp_type5) return int
);
-- 为emp_type4 对象类型实现方法体
create or replace type body emp_type5 is
order member function compare(emp5 emp_type5) return int is
begin
case
when birthdate>emp5.birthdate then return 1;
when birthdate=emp5.birthdate then return 0;
when birthdate<emp5.birthdate then return -1;
end case;
end;
end;
-- 根据对象类型empa_type4 创建表emp_tab4
create table emp_tab5 (
eno number(6),sal number(6,2),
job varchar2(20),emp5 emp_type5
);
-- 插入数据到emp_tab4
begin
insert into emp_tab5(eno,sal,job,emp5)
values(0011,9000,'dba',emp_type5('jacker',to_date('1990-12-19','yyyy-mm-dd')));
insert into emp_tab5(eno,sal,job,emp5)
values(0022,9900,'dba',emp_type5('tom',to_date('1970-12-2','yyyy-mm-dd')));
end;
--比较数据
declare
type emp5_tab is table of emp_type5;
v_emp5_tab emp5_tab;
v_result varchar2(100);
begin
select emp5 bulk collect into v_emp5_tab from emp_tab5 ;
if v_emp5_tab(1).compare(v_emp5_tab(2))=1 then
v_result := v_emp5_tab(1).name ||' 比 '||v_emp5_tab(2).name ||'大';
else
v_result := v_emp5_tab(1).name ||' 比 '||v_emp5_tab(2).name ||'小';
end if;
raise_application_error(-20201,v_result);
end;
-- 6. 建立包含自定义对象类型的构造方法
oracle 9i 开始可以自定义构造函数
create or replace type emp_type6 as object(
name varchar2(10),birthdate date,
constructor function emp_type6(name,varchar2) return self as result;
);
方法体的实现类同5
==========================================================================================
《2》复杂对象类型
1.嵌套对象类型：一个对象类型中嵌套另一个对象类型
create or replace typed emp_addr_type7 as object(
addr varchar2(100)
);
eg;
create or replace typed emp_type7 as object(
name varchar2(10), emp_addr emp_addr_type7
);
2.参照对象类型:建立对象表时 使用ref 定义表列，ref实际是指向对象数据的逻辑指针。
........
《3》查看对象类型
1.查看对象类型
select type_name ,final from user_types;
2.修改对象类型
alter type emp_type7 add atrribute addr varchar2(10) cascade;
...
https://blog.csdn.net/oypj2010/article/details/6541972
Oracle type object 对象类型 继承，参考官方文档：
oracle create type object inherit
2.3.5.2 Creating a Subtype Object
A subtype inherits the attributes and methods of the supertype.
These are inherited:
-
All the attributes declared in or inherited by the supertype.
-
Any methods declared in or inherited by supertype.
Example 2-15 defines the student_typ object as a subtype of person_typ, which inherits all the attributes declared in or inherited by person_typ and any methods inherited by or declared in person_typ.
Example 2-15 Creating a student_typ Subtype Using the UNDER Clause
-
-- requires Ex. 2-14
-
CREATE TYPE student_typ UNDER person_typ (
-
dept_id NUMBER,
-
major VARCHAR2(30),
-
OVERRIDING MEMBER FUNCTION show RETURN VARCHAR2)
-
NOT FINAL;
-
/
-
-
CREATE TYPE BODY student_typ AS
-
OVERRIDING MEMBER FUNCTION show RETURN VARCHAR2 IS
-
BEGIN
-
RETURN (self AS person_typ).show || ' -- Major: ' || major ;
-
END;
-
-
END;
-
/
The statement that defines student_typ specializes person_typ by adding two new attributes, dept_id and major and overrides the show method. New attributes declared in a subtype must have names that are different from the names of any attributes or methods declared in any of its supertypes, higher up in its type hierarchy.
原
Oracle Object type 对象类型
2013年08月05日 12:17:11 维C番薯片 阅读数：8292
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/bbliutao/article/details/9765469
Oracle Object type 对象类型
一、概述
Oracle对象类型是Oracle面向对象程序设计的体现，它封装了数据结构和用于操纵这些数据结构的过程和函数。
1、对象类型的组成
对象类型由两部分组成——对象类型头和对象类型体。
对象类型头用于定义对象的公用属性和方法；对象类型体用于实现对象类型头所定义的公用方法。
2、对象类型属性
定义对象类型最少要包含一个属性，最多包含1000个属性。定义时必须提供属性名和数据类型，但不能指定默认值和not null。
数据类型不能包括long、long raw、rowid、urowid和PL/SQL特有类型(boolean\%type\%rowtype
ef curdor等)
3、对象类型的方法
定义对象类型可以包含也可以不包含方法，可以定义构造方法、member方法、static方法、map方法和order方法。
1）、构造方法
用于初始化对象并返回对象实例。构造方法是与对象类型同名的函数，默认的构造方法参数是对象类型的所有属性。
9i前只能使用系统默认的构造方法、9i后可自定义构造函数，自定义必须使用constructor function关键字
2）、member方法
用于访问对象实例的数据。当使用member方法时，可以使用内置参数self访问当前对象实例。
当定义member方法时，无论是否定义self参数，它都会被作为第一个参数传递给member方法。
但如果要定义参数self，那么其类型必须要使用当前对象类型。member方法只能由对象实例调用，而不能由对象类型调用。
3）、static方法
用于访问对象类型，可以在对象类型上执行全局操作，而不需要访问特定对象实例的数据，因此static方法引用self参数。
static方法只能由对象类型调用，不能由对象实例调用(和member相反)。
4）、map方法
对象类型不同于标量类型可以直接比较，为了按照特定规则排序对象实例的数据，可以定义map方法，但只能有一个，与order互斥。
map方法将对象实例映射成标量数值来比较。
5）、order方法
map可以在对多个对象实例之间排序，而order只能比较2个实例的大小。定义对象类型时最多只能定义一个order方法，
而且map和order方法不能同时定义。使用原则是可不用则均不用，比较2个对象则用order，对个对象则用map。
4、对象表
对象表是指至少包含一个对象类型列的表。分为行对象表和列对象表。
行对象表是指直接基于对象类型所建立的表；列对象表则是只包含一个或多个列的对象表。
5、REF数据类型
ref是指向行对象的逻辑指针，是Oracle的一种内置数据类型。建表时通过使用REF引用行对象，可以使不同表共享相同对象。
例如：create table department(dno number(2),dname varchar2(10),emp ref employee_type)
二、对象类型的基本应用
1、概述
基本应用也属于最常规、最简单的应用，讲述如何建立和使用独立的并且与其他对象类型无关的对象类型。
包括语法、建立带方法和不带方法的对象类型。
2、语法
create or replace type type_name as object (
v_name1 datatype[,v_name2 datatype,...],
[member|static method1 spec,member|static method2 spec,...]);
create or replace type body type_name as
member|static method1 body;
member|static method1 body;...
其中，type_name是对象类型的名称，v_name是属性名称，datatype是属性数据类型，method是方法的名称，body是PL/SQL的方法实现代码。
如果定义对象类型头时没有定义方法，则不需要建立对象类型体。
3、建立和使用不包含任何方法的对象类型
--建立对象类型
create or replace type person_typ1 as object(name varchar2(10),gender varchar2(2),birthdate date);
1）、对于行对象表
--建立行对象表
create table persong_tab1 of person_typ1;
--插入
begin
insert into person_tab1 values('马丽','女','11-1月-76');--不用构造方法
insert into person_tab1 values(person_typ1('王鸣','男','12-2月-76'));--用构造方法
end;
--查询，必须使用value函数取得行数据
declare
person person_typ1;
begin
select value(p) into person from person_tab1 p where p.name='&name';
dbms_output.put_line(person.gender||','||person.birthdate);
end;
--更新
begin
update person_tab1 p set b.birthdate='11-2月-76' where p.name='马丽';
end;
--删除
begin
delete from person_tab1 p where p.name='马丽';
end;
2）、对于列对象表
--建立列对象表
create table employee_tab1(eno number(6),person person_typ1,sal number(6.2),job varchar2(10));
--插入，必须使用构造方法(默认构造方法)
begin
insert into employee_tab1(eno,sal,job,person) values(1,2000,'高级电工',person_typ1('王鸣','男'.'01-8月-76'));
end;
--查询
declare
employee person_typ1;
salary number(6,2);
begin
select person,sal into employee,salary from employee_tab1 where eno=&no;
dbms_output.put_line(employee.name||','||salary);
end;
--更新
begin
update employee_tab1 p set p.person.birthdate='&newdate' where p.person.name='&name';
end;
--删除
begin
delete from employee_tab1 p where p.person.name='王鸣';
end;
4、建立和使用包含方法的对象类型
--建立对象类型头
create or replace type person_typ2 as object
(
name varchar2(10),
gender varchar2(2),
birthdate date,
address varchar2(100),
regdate date,
member procedure change_address(new_addr varchar2),--member方法
member function get_info return varchar2,--member方法
static function getdate return date,--static方法
map member function getage return varchar2,--map方法
order member function compare(p person_typ2) return int,--order方法
constructor person typ2(name varchar2) return self as result,
constructor person typ2(name varchar2,gender varchar2) return self as result
);
--建立对象类型体
create or replace type body person_typ2 is
member procedure change_address(new_addr varchar2) is
begin
address := new_addr; --member方法体现之处，直接访问修改对象实例的数据address
end;
member function get_info return varchar2 is
v_info varchar2(100);
begin
v_info := name || ',' || birthdate || ',' || regdate;
return v_info;
end;
static function gerdate return date is
begin
return sysdate;
end;
map member function getage return varchar2 is
begin
return trunc((sysdate-birthdate)/365);--比较的依据是按照时间
end;
order member function compare(p person_typ2) return int is
begin
case
when birthdate>p.birthdate then return 1;
when birthdate=p.birthdate then return 0;
when birthdate>p.birthdate then return -1;
end case;
end;
constructor function person_typ2(name varchar2) return self as result is
begin
self.name:=name;
self.gender:='女';
self.birthdate:=sysdate;
return;
end;
constructor function person_typ2(name varchar2,gender varchar2) return self as result is
begin
self.name:=name;
self.gender:=gender;
self.birthdate:=sysdate;
return;
end;
end;
--建立列对象表
create table employee_tab2(eno number(6),person person_typ2,sal number(6,2),job varchar2(10));
--插入
insert into employee_tab2(eno,sal,job,person) values(1,1500,'图书管理员',
person_typ2('马丽','女','11-1月-75','呼和浩特11号',person_typ2.getdate()));--由对象类型调用的全局方法getdate(static方法)
insert into employee_tab2(eno,sal,job,person) values(2,2000,'高级焊工',
person_typ2('王鸣','男','11-5月-75','呼和浩特21号',person_typ2.getdate()));
insert into employee_tab2(eno,sal,job,person) values(3,3000,'高级工程师',
person_typ2('李奇','男','11-5月-70','呼和浩特31号',person_typ2.getdate()));
insert into employee_tab2(eno,sal,job,person) values(3,3000,'高级工程师',person_typ2('怪兽');--自定义构造方法
insert into employee_tab2(eno,sal,job,person) values(3,3000,'高级工程师',person_typ2('怪兽','男');
--调用
declare
v_person person_typ2;
type person_table_type is table of person_typ2;
person_table person_table_type;
begin
select person into v_person from employee_tab2 where eno = &&no;
v_person.change_address('呼和浩特12号');
update employee_tab2 set person = v_person where eno = &no;
dbms_output.put_line(v_person.get_info);
--map,取表中前2条数据来对比
select person bulk collect into person_table from employee_tab2;
if person_table(1).getage()>person_table(2).getage() then
dbms_output.put_line(person_table(1).name||'比'||person_table(2).name||'大');
else
dbms_output.put_line(person_table(2).name||'不比'||person_table(1).name||'大');
end if;
--compare
if person_table(1).compare(person_table(2))=1 then
dbms_output.put_line(person_table(1).name||'比'||person_table(2).name||'大');
else
dbms_output.put_line(person_table(2).name||'不比'||person_table(1).name||'大');
end if;
end;
三、对象类型的高级应用
1、概述
高级应用简述与其他对象类型具有关联关系的对象类型。包括对象类型的嵌套、参照对象类型、对象类型的继承。
2、对象类型的嵌套
1）、建立对象类型addr_typ7
create or replace type addr_typ7 as object(
state varchar2(20),city varchar2(20),street varchar2(50),zipcode(6),
member function get_addr return varchar2);
create or replace type body addr_typ7 as
member function get_addr return varchar2 is
begin
return state||city||street;
end;
end;
2）、建立对象类型person_typ7,嵌套addr_typ7对象类型
create or replace type person_typ7 as object(
name varchar2(10),gender varchar2(2),birthdate date,
address addr_typ7,member function get_info return varchar2);
create or replace type body person_typ7 as
member function get_info return varchar2 is
begin
return '姓名:'||name||',家庭住址'||address.get_addr();
end;
end;
3）、建立列对象表employee_tab7
create table employee_tab7(eno number(6),person person_typ7,sal number(6,2),job varchar2(10));
4）、插入
insert into employee_tab7(eno,sal,job,person) values
(1,1500,'图书管理员',person_typ7('马丽','女','01-11月-76',addr_typ7('内蒙古自治区','呼和浩特市','呼伦北路22号','010010')));
insert into employee_tab7(eno,sal,job,person) values
(2,2000,'高级钳工',person_typ7('王鸣','男','11-12月-75',addr_typ7('内蒙古自治区','呼和浩特市','呼伦北路50号','010010')));
5）、更新
declare
v_person person_typ7;
begin
select person into v_person from employee_tab7 where eno=1;
v_person.address.street:='北恒东街11号';
update employee_tab7 set person=v_person where eno=1;
end;
6）、查询
declare
v_person_typ7;
begin
select person into v_person from employee_tab7 where eno=1;
dbms_output.put_line(v_person.get_info);
end;
6）、删除
begin
delete from employ33_tab7 where eno=1;
end;
3、参照对象类型
1）、概述
参照对象类型是指在建立对象表时使用REF定义表列，REF实际是指向行对象表数据的指针。
通过使用REF定义表列，可以使得一个对象表引用另一个对象表（行对象表）的数据。
2）、建立对象类型person_typ8
create or replace type person_typ8 as object(
name varchar2(10),gender varchar2(2),birthdate date,address varchar2(100),
member function get_info return varchar2
);
create or replace type body person_typ8 as
member function get_info return varchar2 is
begin
return name||',0'||address;
end;
end;
3）、建立行对象表person_tab8
create table person_tab8 of person_typ8;
insert into person_tab8 values('马丽','女','11-1月-75','呼和浩特11号');
insert into person_tab8 values('王鸣','男','11-5月-75','呼和浩特21号');
4）、建立列对象表employee_tab8
说明：employee_tab8表直接引用person_tab8表的数据。
create table employee_tab8(
eno number(6),person ref person_typ8,sal number(6,2),job varchar2(10));
5）、插入
说明：因为employee_tab8的定义使用ref引用了person_tab8，所以插入需要引用该表数据。，使用函数REF
begin
insert into employee_tab8 select 1,ref(a),2000,'图书管理员' from person_tab8 a where a.name='马丽';
insert into employee_tab8 select 2,ref(a),2000,'高级钳工' from person_tab8 a where a.name='王鸣';
end;
6）、查询
说明：取ref对象列数据，必须使用deref。
declare
v_person person_typ8;
begin
select deref(person) into v_person from employee_tab8 where eno=1;
dbms_output.put_line(v_person.get_into);
end;
7）、更新
declare
v_person person_typ8;
begin
select deref(perosn) into v_person from employee_tab8 where eno=1;
v_person.address:='呼和浩特市神马路';
update person_tab8 set address=v_person.address where name=v_person.name;
end;
8）、删除
begin
delete from employee_tab8 where eno=1;
end;
4、对象类型的继承
1）、概述
9i新增，一个对象类型继承另一个对象类型。定义需要被继承的父类时需要指定not final，否则默认final，表示对象类型不能被继承。
2）、建立对象类型person_typ9
create or replace type person_typ9 as object(
name varchar2(10),gender varchar2(2),birthdate date,address varchar2(100),
member function get_info return varchar2
) not final;
create or replace type body person_typ8 as
member function get_info return varchar2 is
begin
return name||',0'||address;
end;
end;
3）、建立子对象类型
create or replace type employee_typ9 under person_typ9(
eno number(6),sal number(6,2),job varchar2(10),
member function get_other return varchar2);
create or replace type body employee_typ9 as
member function get_other return varchar2 is
begin
return name||','||sal;
end;
end;
4）、建立行对象表
create table employee_tab9 of employee_typ9;
insert into person_tab8 values('马丽','女','11-1月-75','呼和浩特11号',1,1500,'图书管理员');
insert into person_tab8 values('王鸣','男','11-5月-75','呼和浩特21号',2,2000,'高级钳工');
5）、查询
declare
v_employee employee_typ9;
begin
select value(a) into v_employee from employee_tab9 a where a.eno=1;
dbms_output.put_line(v_employee.get_info||','||v_employee.get_other);
end;
四、维护对象类型
1、显示对象类型信息
select type_name,attributes,final from user_types;
2、增删对象类型的属性
alter type person_typ1 add attribute address varchar2(50) cascade;
alter type person_typ1 drop attribute birthdate cascade;
--cascade级联更新依赖对象类型的对象类型和对象表。
3、增删对象类型的方法
alter type person_typ1 add member function get info return varchar2 cascade;
create or replace type body person_typ1 as
member function get_info return varchar2 is
begin
return name||','||address;
end;
end;
原文：https://blog.csdn.net/bbliutao/article/details/9765469
https://blog.csdn.net/shcqupc/article/details/50684477
转
Oracle TYPE OBJECT详解
2014年06月13日 13:24:58 zml19910422 阅读数：532
转自：http://blog.csdn.net/indexman/article/details/8435426
以下同：
https://www.2cto.com/database/201212/179282.html
Oracle TYPE OBJECT详解
2012-12-26 11:43:33
收藏 我要投稿
Oracle TYPE OBJECT详解
======================================================
最近在自学PL/SQL高级编程，了解到对象类型（OBJECT TYPE）。
www.2cto.com
特意搜索了一下10G官方文档，下面不才基于此进行拓展：
=======================================================
1. 介绍
Object-oriented programming is especially suited for building reusable components and complex
applications.
尤其适合于构建可重用的部件和复杂的应用程序的面向对象的编程。
www.2cto.com
In PL/SQL, object-oriented programming is based on object types.
在PL / SQL，面向对象的程序设计是基于对象类型。
They let you model real-world objects, separate interfaces and implementation details, and store
object-oriented data persistently in the database.
他们坚持让你模拟现实世界的对象，单独的接口和实现细节，面向对象的数据和存储在数据库中。
2. PL / SQL的声明和初始化对象
对象的类型可以代表任何真实世界的实体。例如，一个对象的类型可以代表一个学生，银行帐户，电脑屏幕上
，合理数量，或数据结构，如队列，堆栈，或列表。
[sql]
CREATE OR REPLACE TYPE address_typ AS OBJECT (
street VARCHAR2(30),
city VARCHAR2(20),
state CHAR(2),
postal_code VARCHAR2(6)
);
[sql]
CREATE OR REPLACE TYPE employee_typ AS OBJECT(
employee_id NUMBER(6),
first_name VARCHAR2(20),
last_name VARCHAR2(25),
email VARCHAR2(25),
phone_number VARCHAR2(25),
hire_date DATE,
job_id VARCHAR2(25),
salary NUMBER(8,2),
commission_pct NUMBER(2,2),
manager_id NUMBER(6),
department_id NUMBER(4),
address address_typ
MAP MEMBER FUNCTION get_idno RETURN NUMBER,
MEMBER PROCEDURE display_address(SELF IN OUT NOCOPY employee_typ)
);
--创建对象体
[sql]
CREATE TYPE BODY employee_typ AS
MAP MEMBER FUNCTION get_idno RETURN NUMBER IS
BEGIN
RETURN employee_id;
END;
MEMBER PROCEDURE display_address ( SELF IN OUT NOCOPY employee_typ ) IS
BEGIN
DBMS_OUTPUT.PUT_LINE(first_name || ' ' || last_name);
DBMS_OUTPUT.PUT_LINE(address.street);
DBMS_OUTPUT.PUT_LINE(address.city || ', ' || address.state || ' ' ||
address.postal_code);
END;
END;
--持久化对象
[sql]
CREATE TABLE employee_tab OF employee_typ;
CREATE TYPE emp_typ as table of employee_typ;
3. 在PL/SQL块中声明对象：
[sql]
DECLARE
emp employee_typ; -- emp is atomically null
BEGIN
-- call the constructor for employee_typ
emp := employee_typ(315, 'Francis', 'Logan', 'FLOGAN',
'555.777.2222', to_date('2012-12-24', 'yyyy-mm-dd'), 'SA_MAN', 11000, .15, 101, 110,
address_typ('376 Mission', 'San Francisco', 'CA', '94222'));
DBMS_OUTPUT.PUT_LINE(emp.first_name || ' ' || emp.last_name); -- display details
emp.display_address(); -- call object method to display details
END;
4. PL/SQL如何处理未初始化的对象：
[sql]
DECLARE
emp employee_typ; -- emp is atomically null
BEGIN
IF emp IS NULL THEN DBMS_OUTPUT.PUT_LINE('emp is NULL #1'); END IF;
IF emp.employee_id IS NULL THEN
DBMS_OUTPUT.PUT_LINE('emp.employee_id is NULL #1');
END IF;
emp.employee_id := 330;
IF emp IS NULL THEN DBMS_OUTPUT.PUT_LINE('emp is NULL #2'); END IF;
IF emp.employee_id IS NULL THEN
DBMS_OUTPUT.PUT_LINE('emp.employee_id is NULL #2');
END IF;
emp := employee_typ(NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL,
address_typ(NULL, NULL, NULL, NULL));
-- emp := NULL; -- this would have made the following IF statement TRUE
IF emp IS NULL THEN DBMS_OUTPUT.PUT_LINE('emp is NULL #3'); END IF;
IF emp.employee_id IS NULL THEN
DBMS_OUTPUT.PUT_LINE('emp.employee_id is NULL #3');
END IF;
EXCEPTION
WHEN ACCESS_INTO_NULL THEN
DBMS_OUTPUT.PUT_LINE('Cannot assign value to NULL object');
END;
5. 在PL/SQL中操纵对象：
5.1.调用对象构造器和方法（Calling Object Constructors and Methods）
[sql]
DECLARE
emp employee_typ;
BEGIN
INSERT INTO employee_tab VALUES (employee_typ(310, 'Evers', 'Boston', 'EBOSTON',
'555.111.2222', to_date('2012-12-24', 'yyyy-mm-dd'), 'SA_REP', 9000, .15, 101, 110,
address_typ('123 Main', 'San Francisco', 'CA', '94111')) );
INSERT INTO employee_tab VALUES (employee_typ(320, 'Martha', 'Dunn', 'MDUNN',
'555.111.3333', to_date('2012-11-5', 'yyyy-mm-dd'), 'AC_MGR', 12500, 0, 101, 110,
address_typ('123 Broadway', 'Redwood City', 'CA', '94065')) );
END;
5.2 更新和删除对象：
[sql]
DECLARE
emp employee_typ;
BEGIN
INSERT INTO employee_tab VALUES (employee_typ(370, 'Robert', 'Myers', 'RMYERS',
'555.111.2277', to_date('2012-3-7', 'yyyy-mm-dd'), 'SA_REP', 8800, .12, 101, 110,
address_typ('540 Fillmore', 'San Francisco', 'CA', '94011')) );
UPDATE employee_tab e SET e.address.street = '1040 California'
WHERE e.employee_id = 370;
DELETE FROM employee_tab e WHERE e.employee_id = 310;
END;
6. 通过REF修饰符操纵对象：
[sql]
DECLARE
emp employee_typ;
emp_ref REF employee_typ;
emp_name VARCHAR2(50);
BEGIN
SELECT REF(e) INTO emp_ref FROM employee_tab e WHERE e.employee_id = 370;
-- the following assignment raises an error, not allowed in PL/SQL
-- emp_name := emp_ref.first_name || ' ' || emp_ref.last_name;
-- emp := DEREF(emp_ref); not allowed, cannot use DEREF in procedural statements
SELECT DEREF(emp_ref) INTO emp FROM DUAL; -- use dummy table DUAL
emp_name := emp.first_name || ' ' || emp.last_name;
DBMS_OUTPUT.PUT_LINE(emp_name);
END;
7. 定义相当于PL/SQL集合类型的SQL类型（Defining SQL Types Equivalent to PL/SQL Collection Types）
7.1 定义嵌套表：
--建嵌套表类型
CREATE TYPE CourseList AS TABLE OF VARCHAR2(10) -- define type
--建对象类型
CREATE TYPE student AS OBJECT ( -- create object
id_num INTEGER(4),
name VARCHAR2(25),
address VARCHAR2(35),
status CHAR(2),
courses CourseList); -- declare nested table as attribute
--建立嵌套表类型表
CREATE TABLE sophomores of student
NESTED TABLE courses STORE AS courses_nt;
--插入数据
insert into sophomores
values(1,'dylan','CARL STREET','ACTIVE',
CourseList('MATH1020')
);
--查询
SELECT a.*, b.*
from sophomores a, TABLE(a.courses) b;
select /*+ nested_table_get_refs */ *
from courses_nt t;
7.2 定义数组：
-- 声明数组类型（Each project has a 16-character code name）
-- We will store up to 50 projects at a time in a database column.
CREATE TYPE ProjectList AS VARRAY(50) OF VARCHAR2(16);
--创建表
CREATE TABLE dept_projects ( -- create database table
dept_id NUMBER(2),
name VARCHAR2(15),
budget NUMBER(11,2),
-- Each department can have up to 50 projects.
projects ProjectList);
--插入数据：
INSERT INTO dept_projects
VALUES(60, 'Security', 750400,
ProjectList('New Badges', 'Track Computers', 'Check Exits'));
8. 在动态SQL中使用对象：
8.1 定义对象类型person_typ和数组类型hobbies_var,并创建报TEAMS:
[sql]
CREATE TYPE person_typ AS OBJECT (name VARCHAR2(25), age NUMBER);
CREATE TYPE hobbies_var AS VARRAY(10) OF VARCHAR2(25);
CREATE OR REPLACE PACKAGE teams
AUTHID CURRENT_USER AS
PROCEDURE create_table (tab_name VARCHAR2);
PROCEDURE insert_row (tab_name VARCHAR2, p person_typ, h hobbies_var);
PROCEDURE print_table (tab_name VARCHAR2);
END;
CREATE OR REPLACE PACKAGE BODY teams AS
PROCEDURE create_table (tab_name VARCHAR2) IS
BEGIN
EXECUTE IMMEDIATE 'CREATE TABLE ' || tab_name ||
' (pers person_typ, hobbs hobbies_var)';
END;
PROCEDURE insert_row (
tab_name VARCHAR2,
p person_typ,
h hobbies_var) IS
BEGIN
EXECUTE IMMEDIATE 'INSERT INTO ' || tab_name ||
' VALUES (:1, :2)' USING p, h;
END;
PROCEDURE print_table (tab_name VARCHAR2) IS
TYPE refcurtyp IS REF CURSOR;
v_cur refcurtyp;
p person_typ;
h hobbies_var;
BEGIN
OPEN v_cur FOR 'SELECT pers, hobbs FROM ' || tab_name;
LOOP
FETCH v_cur INTO p, h;
EXIT WHEN v_cur%NOTFOUND;
-- print attributes of 'p' and elements of 'h'
DBMS_OUTPUT.PUT_LINE('Name: ' || p.name || ' - Age: ' || p.age);
FOR i IN h.FIRST..h.LAST
LOOP
DBMS_OUTPUT.PUT_LINE('Hobby(' || i || '): ' || h(i));
END LOOP;
END LOOP;
CLOSE v_cur;
END;
END;
8.2 调用TEAMS包中的存储过程：
[sql]
DECLARE
team_name VARCHAR2(15);
BEGIN
team_name := 'Notables';
TEAMS.create_table(team_name);
TEAMS.insert_row(team_name, person_typ('John', 31),
hobbies_var('skiing', 'coin collecting', 'tennis'));
TEAMS.insert_row(team_name, person_typ('Mary', 28),
hobbies_var('golf', 'quilting', 'rock climbing', 'fencing'));
TEAMS.print_table(team_name);
END;
=================================================
output:
Name: John - Age: 31
Hobby(1): skiing
Hobby(2): coin collecting
Hobby(3): tennis
Name: Mary - Age: 28
Hobby(1): golf
Hobby(2): quilting
Hobby(3): rock climbing
Hobby(4): fencing
PL/SQL 过程已成功完成。