Oracle复合类型 ORACLE 集合变长数组(可变数组 varray) 关联数组联合数组（索引表）嵌套表记录类型的嵌套表

青旅半醒 2022-04-03 06:44 251阅读 0赞

# ORACLE 集合（关联数组，嵌套表，VARRAY） #

2014年10月25日 19:27:22 [vampireslove][] 阅读数：835 标签： [plsql][] 更多

个人分类： [ORACLE][]

<table style="width:556px;"> 三种集合比较 
 <tbody> 
 <tr> 
 <td>&nbsp;</td> 
 <td>元素下标</td> 
 <td>个数限制</td> 
 <td>初始化</td> 
 <td>表数据列</td> 
 </tr> 
 <tr> 
 <td>索引表</td> 
 <td>(binary_integer、pls_integer、varchar2)</td> 
 <td>无限制</td> 
 <td>不需要</td> 
 <td>不可以</td> 
 </tr> 
 <tr> 
 <td>嵌套表</td> 
 <td>从1开始</td> 
 <td>无限制</td> 
 <td>需要</td> 
 <td>可以</td> 
 </tr> 
 <tr> 
 <td>数组</td> 
 <td>从1开始</td> 
 <td>有最大个数</td> 
 <td>需要</td> 
 <td>可以</td> 
 </tr> 
 </tbody> 
</table>

1.索引表

type type\_name is table of element\_type\[not null\] index by key\_type;

type\_name 自定义数据类型的名称

is table .. index  表示索引表

element\_type 索引表元素的数据类型

not null 表示不请允许引用null元素

key\_type(binary\_integer、pls\_integer、varchar2) 索引表元素下标的数据类型,注意9i前只能用binary\_integer、pls\_integer

元素下标可以负值，元素大小个数没有限制

1.  set serveroutput on;  
2.  declare  
3.    type ename\_table\_type is table of emp.ename%type index by binary\_integer;  
4.    ename\_table ename\_table\_type;  
5.  begin  
6.    select ename into ename\_table(-1) from emp where empno = 7788;  
7.    dbms\_output.put\_line('雇员名:' || ename\_table(-1));  
8.  end;  
9.  /

1.  雇员名:SCOTT  
2.     
3.  PL/SQL procedure successfully completed

2.嵌套表

type type\_name is table of element\_type;

元素下标从1开始，元素个数没有限制，数组元素值可以稀疏

使用嵌套表元素时，必须首先使用其构造方法初始化嵌套表

1.  set serveroutput on;  
2.  declare  
3.    type ename\_table\_type is table of emp.ename%type;  
4.    ename\_table ename\_table\_type;  
5.  begin  
6.    ename\_table:=ename\_table\_type('A','A');  
7.    select ename into ename\_table(2) from emp where empno = 7788;  
8.    dbms\_output.put\_line('雇员名:' || ename\_table(2));  
9.  end;  
10. /  
11. 雇员名:SCOTT  
12.    
13. PL/SQL procedure successfully completed

嵌套表还可以作为表列的数据类型使用

1.  create type phone\_type is table of varchar2(20);  
2.  /  
3.  create table employee(  
4.  id number(4),name varchar2(10),sal number(6,2) ,phone phone\_type  
5.  )nested table phone store as phone\_table;  
6.  /  
7.  \--insert  
8.  insert into employee  
9.  values  
10.   (1, 'scott', 800, phone\_type('123456', '789012'));  
11. commit;  
12. \--select  
13. declare  
14.   phone\_table phone\_type;  
15. begin  
16.   select phone into phone\_table from employee where id=1;  
17.   for i in 1..phone\_table.count loop  
18.     dbms\_output.put\_line('电话号码:'||phone\_table(i));  
19.   end loop;  
20. end;  
21. /  
22. 电话号码:123456  
23. 电话号码:789012  
24.    
25. PL/SQL procedure successfully completed  
26. \--update  
27. declare  
28.   phone\_table phone\_type:=phone\_type('11','22','33');  
29. begin  
30.   update employee set phone=phone\_table where id=1;  
31.   commit;  
32. end;  
33. /

3.变长数组varray

type type\_name is varray(size\_limit) of element\_type\[not null\];

size\_limit 指定varray元素的最大个数

元素下标从1开始，最大元素有限制，可以当作表数据列

使用前，必须要使用构造方法初始化varray元素

1.  declare  
2.    type ename\_table\_type is varray(10) of emp.ename%type;--元素最大个数定义后不可改变  
3.    ename\_table ename\_table\_type := ename\_table\_type('A','B');--初始化两个元素，可以通过ename\_table.extend方法添加元素，默认为null，不能超过最大个数  
4.  begin  
5.    select ename into ename\_table(1) from emp where empno=7788; --下标从1开始，没有初始的不能直接使用，如ename\_table(3)错  
6.    dbms\_output.put\_line(ename\_table(1));  
7.  end;  
8.  /  
9.  SCOTT  
10. PL/SQL procedure successfully completed

在表列中使用varray

1.  create type phone\_type is varray(10) of varchar2(20);  
2.  /  
3.  create table employee(  
4.  id number(4),name varchar2(10),sal number(6,2),phone phone\_type  
5.  );  
6.  /  
7.  \--操作跟嵌套表列一样，元素个数有限制  
8.

[https://blog.csdn.net/VampiresLove/article/details/40455505][https_blog.csdn.net_VampiresLove_article_details_40455505]

#    Oracle复合类型：嵌套表、可变数组与索引表 #

2017年02月24日 11:04:13 [花公子丶][Link 1] 阅读数：567

# **一、 在pl/sql中使用嵌套表和可变数组** #

## **1、在pl/sql中使用嵌套表** ##

在PL/SQL中使用嵌套表，此时嵌套表就相当于其他语言中的数组。

### **①、示例：** ###

<code>set SERVEROUTPUT ON
 DECLARE
 --下面这句是嵌套表声明的
 TYPE ename_array_type is table of emp.ename%TYPE ;
 --定义一个游标
 CURSOR ename_cursor is select ename from emp where job='CLERK';
 --初始化嵌套表，此时嵌套表为空
 ename_arrayename_array_type:=ename_array_type();
 i number:=0;
 BEGIN
 forename in ename_cursor
 loop
 i:=i+1;
 --执行extend函数，为数组增加一个null元素
 ename_array.EXTEND;
 ename_array(i):=ename.ename;
 DBMS_OUTPUT.PUT_LINE(ename.ename); 
 end loop;
 --嵌套表下标是从1开始的，而不是0
 DBMS_OUTPUT.PUT_LINE('嵌套表：'||ename_array(1)||' '|| ename_array(2));
 END;
 /</code>

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22

### **②、嵌套表声明：** ###

TYPE type\_name is table of 表元素类型。例如：

<code>TYPE ename_array_type is table of emp.ename%TYPE ;</code>

*  1

### **③、嵌套表初始化：** ###

嵌套表必须初始化后才能使用，初始化方式有两种，   
一种是初始化为空，例如上面例子中

<code>ename_arrayename_array_type:=ename_array_type();</code>

*  1

由于ename\_array被初始化为空，所以如果需要往里面放数据，就   
需要为其增加一个元素，否则将会报错。EXTEND就是用来为数组增加元素的，例如上面例子中：   
ename\_array.EXTEND;

另一种是初始化时直接为数组分配元素，   
如：ename\_array:=ename\_array\_type(‘草泥马’,’草泥马’);   
此时ename\_array(1)和ename\_array(2)的值为草泥马。这时候也可以直接为ename\_array(1)和ename\_array(2)赋值，如

<code>ename_array(1):='羊驼';
 ename_array(2):='红色羊驼';</code>

*  1
 *  2

但是如果想为第三个元素赋值，需要先执行：ename\_array.EXTEND。   
因为在初始化的时候，只为数组分配了两个元素，所以想给第三   
个元素赋值就必须先为数组分配一个元素。

## **2、在pl/sql中使用可变数组** ##

### **①、示例：** ###

<code>set SERVEROUTPUT ON
 DECLARE
 --这个例子跟上面基本一样，只是下面这句原本is table变成is varray(5)
 TYPE ename_array_type is VARRAY(4) of emp.ename%TYPE ;
 CURSOR ename_cursor is select ename from emp where job='CLERK';
 ename_arrayename_array_type:=ename_array_type();
 i number:=0;
 BEGIN
 forename in ename_cursor
 loop
 i:=i+1;
 ename_array.EXTEND;
 ename_array(i):=ename.ename;
 DBMS_OUTPUT.PUT_LINE(ename.ename); 
 end loop;
 --下标也是从1开始的，而不是0
 DBMS_OUTPUT.PUT_LINE('嵌套表：'||ename_array(1)||' '|| ename_array(2));
 END;
 /</code>

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19

### **②、可变数组声明** ###

TYPE type\_name is varray(数组元素个数) of 表元素类型。例如：

<code>TYPE ename_array_type is VARRAY(4) of emp.ename%TYPE ;</code>

*  1

由于ename\_array\_type被声明为VARRAY(4)，这说明ename\_array\_type类   
型的数组，最多只能放4个元素。如果想为第5个元素赋值，将会报错，即   
ename\_array(5):=’hello’，此时将会报错，即使在赋值前调用EXTEND：   
ename\_array.EXTEND也依然会报错。

## **3、在pl/sql中使用嵌套表和可用数组的区别** ##

在PL/SQL中使用嵌套表和可变数组，基本是一样的，唯一的不同是，可变数   
组的元素个数是有限制的，而嵌套表没有元素个数的限制

# **二、 在表列中使用嵌套表和可变数组（面向对象的SQL）** #

## **1、在表列中使用嵌套表** ##

示例：

### **①、创建对象** ###

<code>create or replace TYPE comm_info AS OBJECT ( /*此类型为通讯方式的集合*/
 no number(3), /*通讯类型号*/
 comm_type varchar2(20), /*通讯类型*/
 comm_no varchar2(30)/*号码*/
 );</code>

*  1
 *  2
 *  3
 *  4
 *  5

### **②、创建嵌套表** ###

*  1

### **③、创建表** ###

<code>create table user_info(
 user_id number(6), /*用户ID号*/
 user_name varchar2(20), /*用户名称*/
 user_comm comm_info_list /*与用户联系的通讯方式*/
 )--下面这句的意思是把user_comm的数据放到user_comm_table表中存储
 nested table user_comm store as user_comm_table;</code>

*  1
 *  2
 *  3
 *  4
 *  5
 *  6

执行命令后，你会发现你创建了两张表，一张是user\_info，一张是嵌套表   
user\_comm\_table

### **④、插入数据** ###

<code>insert into user_info
 values(1,'mary',comm_info_list(
 comm_info(1,'手机','13651401919'),
 comm_info(2,'呼机','1281234567')
 )
 );
 
 insert into user_info
 values(2,'carl',comm_info_list(
 comm_info(1,'手机','13901018888'),
 comm_info(2,'呼机','1281234567')
 )
 );</code>

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13

### **⑤、查询嵌套表** ###

通过user\_info查询其嵌套表信息，此时注意括号内的查询，只能查询一列，即可以select user\_comm而不能select user\_comm,user\_name，并且只能返回一条记录，否则会报错

<code>selectcomm_type,comm_nofrom table(
 select user_comm from user_info where user_id=1
 );
 执行结果如下：
 COMM_TYPE COMM_NO 
 -------------------- ------------------------------
 手机 13651401919 
 呼机 1281234567 </code>

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8

如果不查询具体的嵌套表信息，则没有只能查询一列并且只能返回一条记录的限制，但是好像获取的信息不那么有用：

<code>select user_comm from user_info;
 执行如下：
 
 -------------------------------------------------------------------------------------------------------
 SCOTT.COMM_INFO_LIST(
 SCOTT.COMM_INFO(1,'手机','13651401919'),
 SCOTT.COMM_INFO(2,'呼机','1281234567')
 ) 
 SCOTT.COMM_INFO_LIST(
 SCOTT.COMM_INFO(1,'手机','13901018888'),
 SCOTT.COMM_INFO(2,'呼机','1281234567')
 ) </code>

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12

## **2、在表列中使用可变数组** ##

示例：

### **①、创建对象** ###

<code>create or replace TYPE comm_info AS OBJECT ( /*此类型为通讯方式的集合*/
 no number(3), /*通讯类型号*/
 comm_type varchar2(20), /*通讯类型*/
 comm_no varchar2(30)/*号码*/
 );</code>

*  1
 *  2
 *  3
 *  4
 *  5

### **②、创建可变数组** ###

*  1

### **③、创建表** ###

<code>create table user_info(
 user_id number(6), /*用户ID号*/
 user_name varchar2(20), /*用户名称*/
 user_comm comm_info_list /*与用户联系的通讯方式*/
 )</code>

*  1
 *  2
 *  3
 *  4
 *  5

至于数据插入，和查询，就跟嵌套表的是一模一样。

## **3、在表列中使用嵌套表和可变数组的区别** ##

第一个区别是：创建表的时候不一样，嵌套表创建时需要加这句   
nested table user\_comm store as user\_comm\_table，并且执行创建表语句后，   
会产生两张表，其中一张是嵌套表，嵌套表类型的信息就放在嵌套表里。而   
可变数组不需要加这句话，所以创建表的语句显得比较简单，而且执行创建   
后，只会创建一张表。

第二个区别：   
可变数组是有元素个数的限制的，比如   
create or replace TYPE comm\_info\_list AS varray(50) OF comm\_info;   
则comm\_info\_list类型的数组最多只能放50个元素，即插入的时候，

*  1
 *  2
 *  3
 *  4
 *  5
 *  6

括号内的comm\_info最多只能放50个，上面放了两个，分别是   
comm\_info(1,’手机’,’13651401919’)和 comm\_info(2,’呼机’,’1281234567’)   
而嵌套表没有这个限制。

# **三、 索引表（index by）** #

索引表只能用于PL/SQL中。在前面PL/SQL中使用嵌套表，其声明是：   
TYPE ename\_array\_type is table of emp.ename%TYPE ;   
而把这个声明改为index by就成了索引表，即：   
TYPE ename\_array\_type is table of emp.ename%TYPE index by binary\_integer ;   
binary\_integer后面也可以跟其他PL/SQL支持的类型，比如index by varchar2   
虽然索引表跟嵌套表很像，但是嵌套表像数组，而索引表更像key-value映射的map   
而index by后面的就是key的数据类型。

## **1、索引表使用示例：** ##

<code>set SERVEROUTPUT ON
 DECLARE
 TYPE ename_array_type is table of emp.ename%TYPE index by BINARY_INTEGER;
 CURSOR ename_cursor is select ename from emp where job='CLERK';
 ename_array ename_array_type;--这里直接定义就行，初始化都不用了
 i BINARY_INTEGER:=0;
 BEGIN
 for ename in ename_cursor
 loop
 -- ename_array.EXTEND;这句被注释起来了
 ename_array(i):=ename.ename;
 DBMS_OUTPUT.PUT_LINE(ename.ename); 
 i:=i+1;
 end loop;
 --下标从0开始
 DBMS_OUTPUT.PUT_LINE('嵌套表：'||ename_array(0)||' '|| ename_array(1));
 end;
 /</code>

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18

可以看到使用在PL/SQL中使用索引表会比使用嵌套表和可变数组简单很多。

## **2、索引表作为map的使用示例** ##

前面说索引表更像是map，为什么这么说，可以看下面的例子：

<code>set SERVEROUTPUT ON
 declare
 type map_type is table of number(3) index by varchar2(3);
 map_ map_type; 
 map_key varchar2(3);
 begin
 map_ ('a') := 10;
 map_ ('b') := 20; 
 map_key :=map_ .first;
 while(map_key is not null) loop
 dbms_output.put_line(map_ (map_key));
 map_key:=map_ .next(map_key);
 end loop;
 end;
 /</code>

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15

# **四、 嵌套表，可变数组与索引表的区别** #

嵌套表与可变数组的区别是，嵌套表没有元素个数的限制，而可变数组有元素个数的限制。嵌套表和可变数组与索引表的区别是，嵌套表和可变数组可以用于非PL/SQL环境，而索引表只能用于PL/SQL中。

# **五、 相关函数** #

1、COUNT 返回集合中元素的个数

2、删除集合元素DELETE，DELETE(x)，DELETE(x,y)，TRIM，TRIM(x)   
DELETE删除集合中所有元素   
DELETE(x) 删除元素下标为x的元素，如果x为null,则集合保持不变 对VARRAY   
非法   
DELETE(x,y) 删除元素下标从X到Y的元素，如果X>Y集合保持不变 对VARRAY   
非法   
TRIM 从集合末端开始删除一个元素 对index\_by不合法   
TRIM(x) 从集合末端开始删除x个元素 对index\_by不合法

3、判断元素是否存在EXIST(x)   
如果集合元素x已经初始化，则返回TRUE, 否则返回FALSE

4、为集合添加元素EXTEND，EXTEND(x)，EXTEND(x,n)   
EXTEND 在集合末尾添加一个元素 对Index\_by非法   
EXTEND(x) 在集合末尾添加x个元素 对Index\_by非法   
EXTEND(x,n) 在集合末尾添加元素n的x个副本 对Index\_by非法

5、返回集合元素下标FIRST、LAST、NEXT(x)，PRIOR(x)   
FIRST 返回集合中的第一个元素的下标号，对于VARRAY集合始终返回1。   
LAST 返回集合中最后一个元素的下标号, 对于VARRAY返回值始终等于COUNT。   
NEXT(x) 返回在元素x之后及紧挨着它的元素的下标值，如果该元素是最后一   
个元素，则返回null。   
PRIOR(x) 返回集合中在元素x之前紧挨着它的元素的下标值，如果该元素是第   
一个元素，则返回null。

6、LIMIT 返回VARRY集合的最大的元素个数，对于嵌套表和Index\_by集合无用。

[https://blog.csdn.net/yu766588220/article/details/56834930][https_blog.csdn.net_yu766588220_article_details_56834930]

# Oracle集合（联合数组（索引表），嵌套表，变长数组，记录类型的嵌套表）的初始化与赋值，以及它们的区别 #

2017年11月30日 22:17:01 [eussi][] 阅读数：444 标签： [oracle][][集合][Link 2] 更多

个人分类： [◆◇乀 ≡ oracle related][_ oracle related]

> 来源：[https://www.2cto.com/database/201301/184529.html][https_www.2cto.com_database_201301_184529.html]

Oracle集合（联合数组（索引表），嵌套表，变长数组，记录类型的嵌套表）的初始化与赋值，以及它们的区别
 
 
 
 --其中嵌套表与变长数组在赋值之前必须初始化，可以使用与集合类型同名的函数来进行初始化，
 联合数组无需初始化 www.2cto.com 
 
 
 
 --1.联合数组：
 
 DECLARE 
 
 TYPE ind_tab_type IS TABLE OF VARCHAR2(2000) 
 
 INDEX BY BINARY_INTEGER; 
 
 ind_tab ind_tab_type; 
 
 BEGIN 
 
 ind_tab(1) := 'lubinsu';--这里的下标可以随意指定，可以通过循环来获取 
 
 ind_tab(2) := 'luzhou'; 
 
 --dbms_output.put_line(ind_tab(0)); 
 
 --dbms_output.put_line(ind_tab(1)); 
 
 FOR i IN ind_tab.first..ind_tab.last LOOP 
 
 dbms_output.put_line('ind_tab(' || i || '):' || ind_tab(i)); 
 
 END LOOP; 
 
 END; 
 
 / 
 
 
 
 --2.嵌套表的初始化1
 
 --嵌套表的下标默认为1开始，也可以自己指定任意值 www.2cto.com 
 
 DECLARE 
 
 TYPE nest_tab_type IS TABLE OF VARCHAR2(2000) NOT NULL; --如果设置not null条件那么在初始化的时候不可以设置null 
 
 nest_tab nest_tab_type := nest_tab_type('lubinsu', 'luzhou'); --初始化的时候只要在集合变量之后使用空的构造函数或者直接赋值即可 
 
 BEGIN 
 
 FOR i IN nest_tab.first .. nest_tab.last LOOP 
 
 dbms_output.put_line('nest_tab(' || i || ') value is ' || nest_tab(i)); 
 
 END LOOP; 
 
 END; 
 
 / 
 
 
 
 --3.嵌套表和的初始化2
 
 DECLARE 
 
 TYPE nest_tab_type IS TABLE OF VARCHAR2(2000) NOT NULL; --如果设置not null条件那么在初始化的时候不可以设置null 
 
 nest_tab nest_tab_type := nest_tab_type(); --初始化的时候只要在集合变量之后使用空的构造函数或者直接赋值即可 
 
 BEGIN 
 
 nest_tab.extend; 
 
 nest_tab(1) := 'lubinsu'; 
 
 nest_tab.extend; 
 
 nest_tab(2) := 'luzhou'; 
 
 FOR i IN nest_tab.first .. nest_tab.last LOOP 
 
 dbms_output.put_line('nest_tab(' || i || '):' || nest_tab(i)); 
 
 END LOOP; 
 
 END; 
 
 / 
 
 --如果设置not null条件那么在初始化的时候不可以设置null,如：nest_tab(1) := null;否则出错提示； 
 
 ORA-06550: line 7, column 18: 
 
 PLS-00382: expression is of wrong type 
 
 ORA-06550: line 7, column 3: 
 
 PL/SQL: Statement ignored 
 
 --赋值的时候必须使用extend来扩展集合的容量否则会如下错误 
 
 ERROR at line 1: 
 
 ora-06533: subscript beyond count 
 
 ora-06512: at line 6 
 
 / 
 
 
 
 --4.变长数组类似于PL/SQL表，每个元素都被分配了一个连续的下标，从1开始
 
 --4.变长数组的初始化(与嵌套表的初始化方式一样)
 
 DECLARE 
 
 TYPE varray_tab_type IS VARRAY(10) OF VARCHAR2(2000); 
 
 varray_tab varray_tab_type := varray_tab_type('lubinsu', 'luzhou'); --初始化的时候只要在集合变量之后使用空的构造函数或者直接赋值即可 
 
 BEGIN 
 
 varray_tab.extend; 
 
 varray_tab(3) := 'zengq'; 
 
 varray_tab.extend; 
 
 varray_tab(4) := 'buwei'; 
 
 FOR i IN varray_tab.first .. varray_tab.last LOOP 
 
 dbms_output.put_line('varray_tab(' || i || '):' || varray_tab(i)); 
 
 END LOOP; 
 
 END; 
 
 / 
 
 
 
 --5.集合与集合之间的赋值必须是相同的TYPE
 
 DECLARE 
 
 TYPE type1 IS TABLE OF NUMBER(2); 
 
 TYPE type2 IS TABLE OF NUMBER(2); 
 
 type1_tab type1 := type1(1, 2, 3); 
 
 type1_tab2 type1 := type1(4, 5, 6); 
 
 type2_tab type2 := type2(3, 2, 1); 
 
 BEGIN 
 
 type1_tab2 := type1_tab; 
 
 --type1_tab2 := type2_tab; 不可用 
 
 FOR i IN type1_tab2.first .. type1_tab2.last LOOP 
 
 dbms_output.put_line('type1_tab2(' || i || '):' || type1_tab2(i)); 
 
 END LOOP; 
 
 END; 
 
 / 
 
 --type1_tab2 := type2_tab;报错 
 
 ORA-06550: line 10, column 17: 
 
 PLS-00382: expression is of wrong type 
 
 ORA-06550: line 10, column 3: 
 
 PL/SQL: Statement ignored 
 
 
 
 RESULT: 
 
 type1_tab2(1):1 
 
 type1_tab2(2):2 
 
 type1_tab2(3):3 
 
 / 
 
 
 
 --6.使用null值为集合赋值
 
 DECLARE 
 
 TYPE type1 IS TABLE OF NUMBER(2); 
 
 type1_tab type1 := type1();--已经初始化，不为空，虽然没有赋值 
 
 type1_tab2 type1;--未初始化，为空 
 
 BEGIN 
 
 IF type1_tab IS NOT NULL THEN 
 
 dbms_output.put_line('type1_tab is not null'); 
 
 END IF; 
 
 
 
 --type1_tab := NULL; 
 
 --或者 
 
 type1_tab := type1_tab2; 
 
 
 
 IF type1_tab IS NULL THEN 
 
 dbms_output.put_line('type1_tab is null'); 
 
 END IF; 
 
 END; 
 
 / 
 
 
 
 --7.超出变长数组长度的值将会被丢弃 www.2cto.com 
 
 --8.记录类型的嵌套表的初始化，赋值以及元素的引用
 
 DECLARE 
 
 TYPE object_rec IS RECORD( 
 
 object_id all_objects_loc.object_id%TYPE, 
 
 object_name all_objects_loc.object_name%TYPE, 
 
 object_type all_objects_loc.object_type%TYPE); 
 
 
 
 TYPE object_tab_type IS TABLE OF object_rec; 
 
 
 
 object_tab object_tab_type; 
 
 
 
 TYPE obj_cur_type IS REF CURSOR; --声明游标变量类型 
 
 obj_cur obj_cur_type; 
 
 BEGIN 
 
 OPEN obj_cur FOR 
 
 SELECT a.object_id, a.object_name, a.object_type 
 
 FROM all_objects_loc a 
 
 WHERE rownum <= 10; 
 
 
 
 FETCH obj_cur BULK COLLECT 
 
 INTO object_tab; 
 
 CLOSE obj_cur; 
 
 FOR i IN 1 .. object_tab.count LOOP 
 
 dbms_output.put_line('object_tab(' || i || '):' || object_tab(i) 
 
 .object_id || ',' || object_tab(i).object_name || ',' || object_tab(i) 
 
 .object_type); 
 
 END LOOP; 
 
 END; 
 
 /

[https://blog.csdn.net/eussi/article/details/78681710][https_blog.csdn.net_eussi_article_details_78681710]

[vampireslove]: https://me.csdn.net/VampiresLove
[plsql]: http://so.csdn.net/so/search/s.do?q=plsql&t=blog
[ORACLE]: https://blog.csdn.net/VampiresLove/article/category/2660287
[https_blog.csdn.net_VampiresLove_article_details_40455505]: https://blog.csdn.net/VampiresLove/article/details/40455505
[Link 1]: https://me.csdn.net/yu766588220
[https_blog.csdn.net_yu766588220_article_details_56834930]: https://blog.csdn.net/yu766588220/article/details/56834930
[eussi]: https://me.csdn.net/eussi
[oracle]: http://so.csdn.net/so/search/s.do?q=oracle&t=blog
[Link 2]: http://so.csdn.net/so/search/s.do?q=%E9%9B%86%E5%90%88&t=blog
[_ oracle related]: https://blog.csdn.net/eussi/article/category/7319926
[https_www.2cto.com_database_201301_184529.html]: https://www.2cto.com/database/201301/184529.html
[https_blog.csdn.net_eussi_article_details_78681710]: https://blog.csdn.net/eussi/article/details/78681710