数组、集合和record

数组

数组类型的使用

在使用数组之前，需要自定义一个数组类型。

在存储过程中紧跟AS关键字后面定义数组类型。定义方法如下。

TYPE array_type IS VARRAY(size) OF data_type;

其中:

array_type: 要定义的数组类型名。
VARRAY: 表示要定义的数组类型。
size: 取值为正整数，表示可以容纳的成员的最大数量。
data_type: 要创建的数组中成员的类型。

说明:

在MogDB中，数组会自动增长，访问越界会返回一个NULL，不会报错。

在存储过程中定义的数组类型，其作用域仅在该存储过程中。

建议选择上述定义方法的一种来自定义数组类型，当同时使用两种方法定义同名的数组类型时，MogDB会优先选择存储过程中定义的数组类型来声明数组变量。

data_type也可以为存储过程中定义的record类型（匿名块不支持），但不可以为存储过程中定义的数组或集合类型。

MogDB支持使用圆括号来访问数组元素，且还支持一些特有的函数，如extend、count、first、last、prior、exists、 trim、next、delete来访问数组的内容。

说明:

存储过程中如果有DML语句（SELECT、UPDATE、INSERT、DELETE），DML语句推荐使用中括号来访问数组元素，使用小括号默认识别为数组访问，若数组不存在，则识别为函数表达式。

存储过程中的table of类型、record类型、clob作为出入参、游标、raise info等对大于1GB的clob类型不支持。

集合

集合类型的使用

在使用集合之前，需要自定义一个集合类型。

在存储过程中紧跟AS关键字后面定义集合类型。定义方法如下。

其中：

table_type：要定义的集合类型名。
TABLE：表示要定义集合类型。
data_type：要创建的集合中成员的类型。
indexby_type：创建集合索引的类型。

无索引的集合类型

以变长数组的方式存储指定数据类型的成员，用户可以通过extend函数扩展存储空间，通过trim函数释放存储空间。存储空间为10，成员类型为int的集合变量x，存储方式如下图所示：

其中成员 x(2)，x(5)，x(8)三个成员是无效的，但是存储空间仍然保留，后续可以继续赋值，而不需要重新分配空间。

定义集合类型后，使用table_type作为类型名声明变量：

var_name table_type [:= table_type([v1[,...]])];

可在变量声明时或者声明后使用类型构造器对变量进行初始化。如未初始化，变量var_name的值为NULL。

变量声明和初始化后，可通过下标访问集合成员，或者对成员进行赋值。下标的范围为 [1, upper], upper 的值为当前空间的大小。如访问已被删除的成员，读取到的是已删除成员下一个索引位置的值。

说明：

非兼容A模式下（参数sql_compatibility值不为A），不支持创建集合类型。

在MogDB中，无索引的集合不会自动增长，访问下标越界时会报错。

支持在schema、匿名块、存储过程、自定义函数、package中定义的集合类型，其作用域各不相同。

NOT NULL只支持语法不支持功能。

char、vachar、numeric、float、number等元素类型的范围约束语法创建集合类型，例如：“create type t1 is table of numeric(5); ”只支持语法创建，不支持元素的范围约束功能，功能等同于“create type t1 is table of numeric;”。

data_type可以为基础数据类型、或存储过程内定义的record类型、集合类型、数组类型，不支持ref cursor类型。

不同的集合类型的变量不能相互赋值。即使成员类型相同，但集合类型名称不同，也是不同的集合类型。如TYPE t1 IS TABLE OF int;和TYPE t2 IS TABLE OF int;定义的两个集合类型，t1和t2是不同的集合类型，以其定义的变量不支持相互赋值。

不支持数组成员的类型为集合类型，包括间接嵌套的场景，如数组成员为record类型，record类型某个成员的类型为集合的场景。

只支持集合的等值(=)与非等值(<>或!=)比较，不支持其他关系运算和算数运算操作。

集合类型与NULL比较时，请使用 IS [ NOT ] NULL，使用 = 操作符与NULL比较的结果不准确。

支持集合类型变量作为函数的参数和返回值，此时要求参数或者返回值的类型是在schema或者package中定义的集合类型。

无索引的集合作为函数入参时，可以传入对应子元素类型相同的数组类型作为入参，不支持多维数组，且要求数组下标从1开始（过时的方法，不建议使用该功能。可执行“set behavior_compat_options = 'disable_rewrite_nesttable';”禁用）。

不支持对XML类型数据操作。

集合类型的构造器不支持浮点数以及表达式作为下标。

MogDB支持使用圆括号来访问集合元素，且还支持一些特有的函数，如extend，count，first，last, prior, next, delete来访问集合的内容。

集合函数支持multiset union/intersect/except all/distinct函数。

带索引的集合类型

该集合类型将下标和对应成员值以键值对的方式存储在HASH表中，对该类型变量的所有操作实际就是对HASH表的操作。用户无需自行扩展或释放存储空间，仅需通过赋值或delete方式进行存储和删除成员。集合相关操作、说明如下：

类型定义

索引集合类型定义需同时指定成员类型data_type和下标类型indexby_type，其中下标类型仅支持integer和varchar。
变量声明和初始化

索引集合类型声明后存在3种初始化场景：未初始化、初始化为空、初始化指定下标和成员值。其中未初始化和初始化为空场景对变量的效果一致。未初始化或初始化为空后变量不为NULL，后续都可以对变量直接进行赋值。初始化指定下标和成员值场景会将指定的下标和成员值以键值对的形式保存到变量中。
变量赋值

索引集合类型变量赋值分为两种：成员赋值和整体赋值。成员赋值可通过指定下标方式对某个成员赋值，若该成员不存在则直接赋值，若存在则刷新该成员值。整体赋值则会将被赋值变量中原有成员都清空后重新保存新的成员值。整体赋值场景不能给变量赋NULL值，否则报错。
变量取值

通过指定下标方式可获取变量中对应下标的成员值，若通过下标找不到该成员则会返回no data found的错误信息。

说明：

非兼容A模式下（参数sql_compatibility值不为A），不支持创建带索引集合类型。

支持在匿名块、存储过程、自定义函数、package中定义带索引集合类型，其作用域各不相同。不支持在schema中定义带索引集合类型。

NOT NULL只支持语法不支持功能。

char、vachar、numeric、float、number等元素类型的范围约束语法创建集合类型，例如：“type t1 is table of numeric(5) index by int; ”只支持语法创建，不支持元素的范围约束功能，功能等同于“create type t1 is table of numeric;”。

data_type可以为基础数据类型，或存储过程内定义的record类型，集合类型，数组类型，不支持ref cursor类型。

indexby_type仅支持integer和varchar，其中varchar的长度暂不约束。

未初始化的带索引集合类型变量非NULL。

带索引集合类型变量不能赋NULL值，否则报错。

带索引集合类型变量作为入参不能赋NULL值或''。

不同的带索引集合类型的变量不能相互赋值。即使成员类型和下标类型相同，但集合类型名称不同，也是不同的集合类型。如 TYPE t1 IS TABLE OF int index by int; 和 TYPE t2 IS TABLE OF int index by int; 定义的两个集合类型，t1和t2是不同的集合类型，以其定义的变量不支持相互赋值。

带索引集合类型不支持关系运算和算数运算操作。

select … bulk collect into 方式赋值带索引集合类型变量时，只支持下标为integer类型的集合类型，下标为varchar类型集合不支持。

支持带索引集合类型变量作为存储过程的参数，此时要求参数类型是在package中定义的集合类型。

带索引的集合作为函数入参时，可以传入对应子元素类型相同的数组类型作为入参，不支持多维数组，不支持索引类型为varcahr（过时的方法，不建议使用该功能。可执行“set behavior_compat_options = 'disable_rewrite_nesttable';”禁用）。

类型构造器目前仅支持集合类型，其参数个数的上限与用户自定义函数参数个数上限相同。对于带索引的集合类型，构造器在使用时索引的值仅支持为常量。

不支持对XML类型数据操作。

示例

示例1：无索引的集合类型。

--演示在存储过程中对集合进行操作。
MogDB=# CREATE OR REPLACE PROCEDURE table_proc AS
DECLARE
       TYPE TABLE_INTEGER IS TABLE OF INTEGER;--定义集合类型
       TABLEINT TABLE_INTEGER := TABLE_INTEGER();  --声明集合类型的变量 
BEGIN 
       TABLEINT.extend(10);  
       FOR I IN 1..10 LOOP  
           TABLEINT(I) := I; 
       END LOOP; 
       RAISE NOTICE '%', TABLEINT.COUNT;  
       RAISE NOTICE '%', TABLEINT(1);  
       RAISE NOTICE '%', TABLEINT(10); 
END;  
/

--调用该存储过程。
MogDB=# CALL table_proc();

--删除存储过程。
MogDB=# DROP PROCEDURE table_proc;

--演示在存储过程中对嵌套集合进行操作。
MogDB=# CREATE OR REPLACE PROCEDURE nest_table_proc AS
DECLARE
       TYPE TABLE_INTEGER IS TABLE OF INTEGER;--定义集合类型
       TYPE NEST_TABLE_INTEGER IS TABLE OF TABLE_INTEGER;--定义集合类型
       NEST_TABLE_VAR NEST_TABLE_INTEGER := NEST_TABLE_INTEGER(); --声明嵌套集合类型的变量
BEGIN 
       NEST_TABLE_VAR.extend(10);
       FOR I IN 1..10 LOOP  
           NEST_TABLE_VAR(I) := TABLE_INTEGER();
           NEST_TABLE_VAR(I)(I) := I; 
       END LOOP; 
       RAISE NOTICE '%', NEST_TABLE_VAR.COUNT;
       RAISE NOTICE '%', NEST_TABLE_VAR(1)(1);
       RAISE NOTICE '%', NEST_TABLE_VAR(10)(10);
END;  
/

--调用该存储过程。
MogDB=# CALL nest_table_proc();

--删除存储过程。
MogDB=# DROP PROCEDURE nest_table_proc;

示例2：带索引的集合类型。

--演示在存储过程中对带索引集合进行操作。
MogDB=# CREATE OR REPLACE PROCEDURE index_table_proc AS
DECLARE
       TYPE TABLE_INTEGER IS TABLE OF INTEGER INDEX BY INTEGER; --定义集合类型
       TYPE TABLE_VARCHAR IS TABLE OF INTEGER INDEX BY VARCHAR; --定义集合类型
       TABLEINT_01 TABLE_INTEGER;                               --声明集合类型变量,未初始化
       TABLEINT_02 TABLE_INTEGER := TABLE_INTEGER();            --声明集合类型变量,初始化为空 
       TABLEINT_03 TABLE_INTEGER := TABLE_INTEGER();   --声明集合类型变量,初始化为空
       RES INTEGER;
BEGIN     
       TABLEINT_03(2) := 3;         --初始化指定值
       TABLEINT_03(3) := 4;         --初始化指定值
       FOR I IN 1..10 LOOP  
           TABLEINT_01(I) := I;     --成员赋值
           TABLEINT_02(I) := I + 1; --成员赋值
       END LOOP; 
       TABLEINT_01 := TABLEINT_02;  --整体赋值
       RES := TABLEINT_03(2);       --取值 
       RAISE NOTICE '%', RES;
       RAISE NOTICE '%', TABLEINT_01(1);
       RAISE NOTICE '%', TABLEINT_01(10);
END;  
/

--调用该存储过程。
MogDB=# CALL index_table_proc();

--删除存储过程。
MogDB=# DROP PROCEDURE index_table_proc;

--演示在存储过程中对嵌套集合进行操作。
MogDB=# CREATE OR REPLACE PROCEDURE nest_table_proc AS
DECLARE
       TYPE TABLE_INTEGER IS TABLE OF INTEGER INDEX BY INTEGER;           --定义集合类型
       TYPE NEST_TABLE_INTEGER IS TABLE OF TABLE_INTEGER INDEX BY INTEGER;--定义集合类型
       NEST_TABLE_VAR NEST_TABLE_INTEGER;                                 --声明嵌套集合类型的变量
BEGIN 
       FOR I IN 1..10 LOOP  
               NEST_TABLE_VAR(I)(I) := I; 
       END LOOP; 
       RAISE NOTICE '%', NEST_TABLE_VAR.COUNT;
       RAISE NOTICE '%', NEST_TABLE_VAR(1)(1);
       RAISE NOTICE '%', NEST_TABLE_VAR(10)(10);
END;  
/

--调用该存储过程。
MogDB=# CALL nest_table_proc();

--删除存储过程。
MogDB=# DROP PROCEDURE nest_table_proc;

集合支持的函数

集合操作符

参数：nesttable类型

返回值：true or false，bool类型

功能描述：两个集合类型是否相等。

示例：

MogDB=# declare
MogDB-#     type nest is table of int;
MogDB-#     a nest := nest(1,2);
MogDB-#     b nest := nest(1,2);
MogDB-#     flag bool; 
MogDB-# begin
MogDB$#     flag := a = b;
MogDB$#     raise info '%', flag;
MogDB$# end;
MogDB$# /
INFO:  t
ANONYMOUS BLOCK EXECUTE

参数：nesttable类型

返回值：true or false，bool类型

功能描述：两个集合类型是否不相等。

示例：

MogDB=# declare
MogDB-#     type nest is table of int;
MogDB-#     a nest := nest(1,2);
MogDB-#     b nest := nest(1,2);
MogDB-#     flag bool; 
MogDB-# begin
MogDB$#     flag := a <> b;
MogDB$#     raise info '%', flag;
MogDB$# end;
MogDB$# /
INFO:  f
ANONYMOUS BLOCK EXECUTE

集合MULTISET函数

MULTISET UNION [ALL | DISTINCT]

参数：nesttable类型

返回值：nesttable类型

功能描述：两个集合变量的并集，ALL不去除重复元素，DISTINCT去除重复元素。

示例：

MogDB=# declare
MogDB-#     type nest is table of int;
MogDB-#     a nest := nest(1,2);
MogDB-#     b nest := nest(2,3);
MogDB-# begin
MogDB$#     a := a MULTISET UNION ALL b;
MogDB$#     raise info '%', a;
MogDB$# end;
MogDB$# /
INFO:  {1,2,2,3}
ANONYMOUS BLOCK EXECUTE

MogDB=# declare
MogDB-#     type nest is table of int;
MogDB-#     a nest := nest(1,2);
MogDB-#     b nest := nest(2,3);
MogDB-# begin
MogDB$#     a := a MULTISET UNION DISTINCT b;
MogDB$#     raise info '%', a;
MogDB$# end;
MogDB$# /
INFO:  {1,2,3}
ANONYMOUS BLOCK EXECUTE

MULTISET EXCEPT [ALL | DISTINCT]

参数：nesttable类型

返回值：nesttable类型

功能描述：两个集合变量的差集。如A MULTISET EXCEPT B：ALL表示去除A中与B重复的元素；DISTINCT表示先对A进行去重操作，然后去除与B中有重复的元素。

示例：

MogDB=# declare
MogDB-#     type nest is table of int;
MogDB-#     a nest := nest(1,2,2);
MogDB-#     b nest := nest(2,3);
MogDB-# begin
MogDB$#     a := a MULTISET EXCEPT ALL b;
MogDB$#     raise info '%', a;
MogDB$# end;
MogDB$# /
INFO:  {1,2}
ANONYMOUS BLOCK EXECUTE

MogDB=# declare
MogDB-#     type nest is table of int;
MogDB-#     a nest := nest(1,2,2);
MogDB-#     b nest := nest(2,3);
MogDB-# begin
MogDB$#     a := a MULTISET EXCEPT DISTINCT b;
MogDB$#     raise info '%', a;
MogDB$# end;
MogDB$# /
INFO:  {1}
ANONYMOUS BLOCK EXECUTE

MULTISET INTERSECT [ALL | DISTINCT]

参数：nesttable类型

返回值：nesttable类型

功能描述：两个集合变量的交集。如 A MULTISET INTERSECT B：ALL表是取A与B所有重复的元素；DISTINCT表示取A与B中重复元素，且去除重复元素。

示例：

MogDB=# declare
MogDB-#     type nest is table of int;
MogDB-#     a nest := nest(1,2,2);
MogDB-#     b nest := nest(2,2,3);
MogDB-# begin
MogDB$#     a := a MULTISET INTERSECT ALL b;
MogDB$#     raise info '%', a;
MogDB$# end;
MogDB$# /
INFO:  {2,2}
ANONYMOUS BLOCK EXECUTE

MogDB=# declare
MogDB-#     type nest is table of int;
MogDB-#     a nest := nest(1,2,2);
MogDB-#     b nest := nest(2,2,3);
MogDB-# begin
MogDB$#     a := a MULTISET INTERSECT DISTINCT b;
MogDB$#     raise info '%', a;
MogDB$# end;
MogDB$# /
INFO:  {2}
ANONYMOUS BLOCK EXECUTE

集合类型函数

exists(idx)

参数：idx为int4类型或varchar类型，

返回值：true or false，bool类型

功能描述：查找指定位置是否存在有效元素。

示例：

MogDB=# declare
MogDB-#     type nest is table of varchar2;
MogDB-#     a nest := nest('happy','?');
MogDB-#     flag bool;
MogDB-# begin
MogDB$#     flag := a.exists(1);
MogDB$#     raise info '%', flag;
MogDB$#     flag := a.exists(10);
MogDB$#     raise info '%', flag;
MogDB$# end;
MogDB$# /
INFO:  t
INFO:  f
ANONYMOUS BLOCK EXECUTE

MogDB=# declare
MogDB-#     type nest is table of varchar2 index by varchar2;
MogDB-#     a nest;
MogDB-#     flag bool;
MogDB-# begin
MogDB$#     a('1') := 'Be';
MogDB$#     a('2') := 'happy';
MogDB$#     a('3') := '.';
MogDB$#     flag := a.exists('1');
MogDB$#     raise info '%', flag;
MogDB$#     flag := a.exists('ddd');
MogDB$#     raise info '%', flag;
MogDB$# end;
MogDB$# /
INFO:  t
INFO:  f
ANONYMOUS BLOCK EXECUTE

extend[(e)]

参数：e为int4类型

返回值：无返回值

功能描述：仅支持nesttable类型。在nesttable变量末尾拓展1个元素。

约束：嵌套场景不支持extend()。

示例：

MogDB=# declare
MogDB-#     type nest is table of int;
MogDB-#     a nest := nest(1);
MogDB-# begin
MogDB$#     raise info '%', a;
MogDB$#     a.extend;
MogDB$#     raise info '%', a;
MogDB$# end;
MogDB$# /
INFO:  {1}
INFO:  {1,NULL}
ANONYMOUS BLOCK EXECUTE

MogDB=# declare
MogDB-#     type nest is table of int;
MogDB-#     a nest := nest(1);
MogDB-# begin
MogDB$#     raise info '%', a;
MogDB$#     a.extend(2);
MogDB$#     raise info '%', a;
MogDB$# end;
MogDB$# /
INFO:  {1}
INFO:  {1,NULL,NULL}
ANONYMOUS BLOCK EXECUTE

delete[(idx)]

参数：idx为int4类型或varchar2类型

返回值：无返回值

功能描述：无参数时，（nesttable）删除集合类型的所有元素和空间，后续使用需要重新extend，（indexbytable）删除所有元素内容，一个参数删除指定位置元素（不删除空间）。

约束：嵌套场景不支持delete()。

示例：

MogDB=# declare
MogDB-#     type nest is table of int;
MogDB-#     a nest := nest(1,2,3,4,5);
MogDB-# begin
MogDB$#     raise info '%', a;
MogDB$#     a.delete;
MogDB$#     raise info '%', a;
MogDB$# end;
MogDB$# /
INFO:  {1,2,3,4,5}
INFO:  {}
ANONYMOUS BLOCK EXECUTE

MogDB=# declare
MogDB-#     type nest is table of int;
MogDB-#     a nest := nest(1,2,3,4,5);
MogDB-# begin
MogDB$#     raise info '%', a;
MogDB$#     a.delete(3);
MogDB$#     raise info '%', a;
MogDB$# end;
MogDB$# /
INFO:  {1,2,3,4,5}
INFO:  {1,2,4,5}
ANONYMOUS BLOCK EXECUTE

trim[(n)]

参数：n为int4类型

返回值：无返回值

功能描述：仅支持nesttable类型，无参数时，删除末尾一个元素空间，输入参数合法时，删除末尾指定数量元素空间。

约束：嵌套场景不支持trim()。

示例：

MogDB=# declare
MogDB-# type nest is table of int;
MogDB-# aa nest:=nest(11,22,33,44,55);
MogDB-# begin
MogDB$# raise info 'aa:%' ,aa;
MogDB$# aa.trim;
MogDB$# raise info 'aa:%' ,aa;
MogDB$# aa.trim(2);
MogDB$# raise info 'aa:%' ,aa;
MogDB$# end;
MogDB$# /
INFO:  aa:{11,22,33,44,55}
INFO:  aa:{11,22,33,44}
INFO:  aa:{11,22}
ANONYMOUS BLOCK EXECUTE

count

参数：无

返回值：int类型

功能描述：返回集合中存在有效元素的个数。

示例：

MogDB=# declare
MogDB-# type nest is table of int;
MogDB-# aa nest:=nest(11,22,33,44,55);
MogDB-# begin
MogDB$# raise info 'count:%' ,aa.count;
MogDB$# end;
MogDB$# /
INFO:  count:5
ANONYMOUS BLOCK EXECUTE

MogDB=# declare
MogDB-# type nest is table of int index by varchar;
MogDB-# aa nest;
MogDB-# begin
MogDB$# aa('aaa') := 111;
MogDB$# aa('bbb') := 222;
MogDB$# aa('ccc') := 333;
MogDB$# raise info 'count:%' ,aa.count;
MogDB$# end;
MogDB$# /
INFO:  count:3
ANONYMOUS BLOCK EXECUTE

first

参数：无

返回值：int类型或varchar类型

功能描述：返回集合中第一个有效元素的下标。

示例：

MogDB=# declare
MogDB-# type nest is table of int;
MogDB-# aa nest:=nest(11,22,33,44,55);
MogDB-# begin
MogDB$# raise info 'first:%' ,aa.first;
MogDB$# end;
MogDB$# /
INFO:  first:1
ANONYMOUS BLOCK EXECUTE

MogDB=# declare
MogDB-# type nest is table of int index by varchar;
MogDB-# aa nest;
MogDB-# begin
MogDB$# aa('aaa') := 111;
MogDB$# aa('bbb') := 222;
MogDB$# aa('ccc') := 333;
MogDB$# raise info 'first:%' ,aa.first;
MogDB$# end;
MogDB$# /
INFO:  first:aaa
ANONYMOUS BLOCK EXECUTE

last

参数：无

返回值：int类型或varchar类型

功能描述：返回集合中最后一个有效元素的下标。

示例：

MogDB=# declare
MogDB-# type nest is table of int;
MogDB-# aa nest:=nest(11,22,33,44,55);
MogDB-# begin
MogDB$# raise info 'last:%' ,aa.last;
MogDB$# end;
MogDB$# /
INFO:  last:5
ANONYMOUS BLOCK EXECUTE

MogDB=# declare
MogDB-# type nest is table of int index by varchar;
MogDB-# aa nest;
MogDB-# begin
MogDB$# aa('aaa') := 111;
MogDB$# aa('bbb') := 222;
MogDB$# aa('ccc') := 333;
MogDB$# raise info 'last:%' ,aa.last;
MogDB$# end;
MogDB$# /
INFO:  last:ccc
ANONYMOUS BLOCK EXECUTE

prior(idx)

参数：idx为int类型或varchar类型

返回值：int类型或varchar类型

功能描述：返回集合中当前下标的前一个有效元素下标。

示例：

MogDB=# declare
MogDB-# type nest is table of int;
MogDB-# aa nest:=nest(11,22,33,44,55);
MogDB-# begin
MogDB$# raise info 'prior:%' ,aa.prior(3);
MogDB$# end;
MogDB$# /
INFO:  prior:2
ANONYMOUS BLOCK EXECUTE

MogDB=# declare
MogDB-# type nest is table of int index by varchar;
MogDB-# aa nest;
MogDB-# begin
MogDB$# aa('aaa') := 111;
MogDB$# aa('bbb') := 222;
MogDB$# aa('ccc') := 333;
MogDB$# raise info 'prior:%' ,aa.prior('bbb');
MogDB$# end;
MogDB$# /
INFO:  prior:aaa
ANONYMOUS BLOCK EXECUTE

next(idx)

参数：idx为int类型或varchar类型

返回值：int类型或varchar类型

功能描述：返回集合中当前下标的后一个有效元素下标。

示例：

MogDB=# declare
MogDB-# type nest is table of int;
MogDB-# aa nest:=nest(11,22,33,44,55);
MogDB-# begin
MogDB$# raise info 'next:%' ,aa.next(3);
MogDB$# end;
MogDB$# /
INFO:  next:4
ANONYMOUS BLOCK EXECUTE

MogDB=# declare
MogDB-# type nest is table of int index by varchar;
MogDB-# aa nest;
MogDB-# begin
MogDB$# aa('aaa') := 111;
MogDB$# aa('bbb') := 222;
MogDB$# aa('ccc') := 333;
MogDB$# raise info 'next:%' ,aa.next('bbb');
MogDB$# end;
MogDB$# /
INFO:  next:ccc
ANONYMOUS BLOCK EXECUTE

limit

参数：无

返回值：null

功能描述：用于nesttable类型，返回集合中最大可以储存的元素个数，只适用于array类型，nesttable返回空。

示例：

MogDB=# declare
MogDB-# type nest is table of int;
MogDB-# aa nest:=nest(11,22,33,44,55);
MogDB-# begin
MogDB$# raise info 'limit:%' ,aa.limit;
MogDB$# end;
MogDB$# /
INFO:  limit:<NULL>
ANONYMOUS BLOCK EXECUTE

record

record类型的变量

创建一个record变量的方式:

定义一个record类型，然后使用该类型来声明一个变量。

语法

record类型的语法参见图1。

图 1 record类型的语法

record类型的语法

对以上语法格式的解释如下:

record_type: 声明的类型名称。
field: record类型中的成员名称。
datatype: record类型中成员的类型。
expression: 设置默认值的表达式。

说明:

在MogDB中:

record类型变量的赋值支持：

在函数或存储过程的声明阶段，声明一个record类型，并且可以在该类型中定义成员变量。

一个record变量到另一个record变量的赋值。

SELECT INTO和FETCH向一个record类型的变量中赋值。

将一个NULL值赋值给一个record变量。

不支持INSERT和UPDATE语句使用record变量进行插入数据和更新数据。

如果成员有复合类型，在声明阶段不支持指定默认值，该行为同声明阶段的变量一样。

date_type也可以为存储过程中定义的record类型、数组类型和集合类型（匿名块不支持）。

示例

下面示例中用到的表定义如下:
MogDB=# \d emp_rec
                Table "public.emp_rec"
  Column  |              Type              | Modifiers
----------+--------------------------------+-----------
 empno    | numeric(4,0)                   | not null
 ename    | character varying(10)          |
 job      | character varying(9)           |
 mgr      | numeric(4,0)                   |
 hiredate | timestamp(0) without time zone |
 sal      | numeric(7,2)                   |
 comm     | numeric(7,2)                   |
 deptno   | numeric(2,0)                   |

--演示在函数中对数组进行操作。
MogDB=# CREATE OR REPLACE FUNCTION regress_record(p_w VARCHAR2)
RETURNS
VARCHAR2  AS $$
DECLARE

   --声明一个record类型.
   type rec_type is record (name  varchar2(100), epno int);
   employer rec_type;

   --使用%type声明record类型
   type rec_type1 is record (name  emp_rec.ename%type, epno int not null :=10);
   employer1 rec_type1;

   --声明带有默认值的record类型
   type rec_type2 is record (
         name varchar2 not null := 'SCOTT',
         epno int not null :=10);
    employer2 rec_type2;
    CURSOR C1 IS  select ename,empno from emp_rec order by 1 limit 1;

BEGIN
      --对一个record类型的变量的成员赋值。
     employer.name := 'WARD';
     employer.epno = 18;
     raise info 'employer name: % , epno:%', employer.name, employer.epno;

     --将一个record类型的变量赋值给另一个变量。
     employer1 := employer;
     raise info 'employer1 name: % , epno: %',employer1.name, employer1.epno;

      --将一个record类型变量赋值为NULL。
     employer1 := NULL;
     raise info 'employer1 name: % , epno: %',employer1.name, employer1.epno;

      --获取record变量的默认值。
     raise info 'employer2 name: % ,epno: %', employer2.name, employer2.epno;

      --在for循环中使用record变量
      for employer in select ename,empno from emp_rec order by 1  limit 1
          loop
               raise info 'employer name: % , epno: %', employer.name, employer.epno;
          end loop;

      --在select into 中使用record变量。
      select ename,empno  into employer2 from emp_rec order by 1 limit 1;
      raise info 'employer name: % , epno: %', employer2.name, employer2.epno;

      --在cursor中使用record变量。
      OPEN C1;
      FETCH C1 INTO employer2;
      raise info 'employer name: % , epno: %', employer2.name, employer2.epno;
      CLOSE C1;
      RETURN employer.name;
END;
$$
LANGUAGE plpgsql;

--调用该函数。
MogDB=# CALL regress_record('abc');

--删除函数。
MogDB=# DROP FUNCTION regress_record;