# 集合支持的函数
#### 集合操作符
- = 参数：nesttable类型。
  返回值：TRUE或FALSE，BOOLEAN类型。
  功能描述：判断两个集合是否相等。
  示例：
  ```
  gaussdb=# DECLARE
   TYPE nest IS TABLE OF INT
   a nest := nest(1,2);
   b nest := nest(1,2);
   flag BOOL;
   BEGIN
      flag := a = b;
      RAISE INFO '%', flag;
  END;
   /
  INFO:  t
  ANONYMOUS BLOCK EXECUTE
  ```
  
- \<\> 参数：nesttable类型。
  返回值：TRUE或FALSE，BOOLEAN类型。
  功能描述：判断两个集合是否不相等。
  示例：
  ```
  gaussdb=# DECLARE
    TYPE nest IS TABLE OF INT;
    a nest := nest(1,2);
    b nest := nest(1,2);
    flag BOOL; 
   BEGIN
     flag := a <> b;
     RAISE INFO '%', flag;
  END;
  /
  INFO:  f
  ANONYMOUS BLOCK EXECUTE
  ```
  
 
- IS \[NOT\] NULL 参数：nesttable类型。
  返回值：TRUE或FALSE，BOOLEAN类型。
  功能描述：IS NULL判断一个集合是否为NULL，IS NOT NULL判断一个集合是否为非NULL。
  示例：
  ```
  gaussdb=# DECLARE
     TYPE nest IS TABLE OF INT;
     a nest;
     b nest := NULL;
     c nest := nest(1,2);
     flag BOOL; 
  BEGIN
      flag := a IS NULL;
      RAISE INFO '%', flag;
      flag := b IS NULL;
      RAISE INFO '%', flag;
      flag := c IS NULL;
      RAISE INFO '%', flag;
   END;
   /
  INFO:  t
  INFO:  t
  INFO:  f
  ANONYMOUS BLOCK EXECUTE
  gaussdb=# DECLARE
     TYPE nest IS TABLE OF INT;
     a nest;
     b nest := NULL;
     c nest := nest(1,2);
     flag BOOL; 
  BEGIN
      flag := a IS NOT NULL;
      RAISE INFO '%', flag;
      flag := b IS NOT NULL;
      RAISE INFO '%', flag;
      flag := c IS NOT NULL;
      RAISE INFO '%', flag;
   END;
   /
  INFO:  f
  INFO:  f
  INFO:  t
  ANONYMOUS BLOCK EXECUTE
  ```
  
- \^= 参数：nesttable类型。
  返回值：TRUE或FALSE，BOOLEAN类型。
  功能描述：判断两个集合是否不相等。
  示例：
  ```
  gaussdb=# DECLARE
     TYPE nest IS TABLE OF INT;
     a nest := nest(1,2);
     b nest := nest(1,2);
     flag BOOL; 
   BEGIN
     flag := a ^= b;
     RAISE INFO '%', flag;
   END;
   /
  INFO:  f
  ANONYMOUS BLOCK EXECUTE
  ```
  
- \[NOT\] IN 参数：nesttable类型。
  返回值：TRUE或FALSE，BOOLEAN类型。
  功能描述：判断一个集合是否在集合列表中。
  示例：
  ```
  gaussdb=# DECLARE
     TYPE tab IS TABLE OF VARCHAR(10);
     tmp1 tab := tab('a', 'b');
     tmp2 tab := tab('a', 'b');
     flag BOOL; 
   BEGIN
     flag := tmp2 in (tmp1);
     RAISE INFO '%', flag;
   END;
   /
  INFO:  t
  ANONYMOUS BLOCK EXECUTE
  ```
  
#### 集合MULTISET函数
- MULTISET UNION \[ALL \| DISTINCT\] 参数：nesttable类型。
  返回值：nesttable类型。
  功能描述：两个集合变量的并集，ALL表示不去除重复元素，DISTINCT表示去除重复元素，ALL为默认值。
  示例1，求两个集合变量的并集，且不去除重复元素，即MULTISET UNION ALL：
  ```
  gaussdb=# DECLARE
     TYPE nest IS TABLE OF INT;
     a nest := nest(1,2);
     b nest := nest(2,3);
   BEGIN
     a := a MULTISET UNION ALL b;
     RAISE INFO '%', a;
   end;
   /
  INFO:  {1,2,2,3}
  ANONYMOUS BLOCK EXECUTE
  ```
  示例2，求两个集合变量的并集，且去除重复元素，即MULTISET UNION DISTINCT：
  ```
  gaussdb=# DECLARE
      TYPE nest IS TABLE OF INT;
      a nest := nest(1,2);
      b nest := nest(2,3);
   BEGIN
      a := a MULTISET UNION DISTINCT b;
      RAISE INFO '%', a;
   END;
   /
  INFO:  {1,2,3}
  ANONYMOUS BLOCK EXECUTE
  ```
  
- MULTISET EXCEPT \[ALL \| DISTINCT\] 参数：nesttable类型。
  返回值：nesttable类型。
  功能描述：两个集合变量的差集。如A MULTISET EXCEPT B：ALL表示去除A中A具有的元素且B也具有的元素并返回，其中去除动作计算元素个数。例如，对于特定元素，如果A中出现了m次，B中出现了n次，当 m \> n时，则去除A中m - n个该元素，当m \<= n时，则去除A中m个该元素；DISTINCT表示去除A中A具有的元素且B也具有的元素并返回，其中去除动作不计算元素个数。对于特定元素，如果在A中出现且又在B中出现了，则去除A中所有该元素。ALL为默认值。
  示例1，求两个集合变量的差集，去除A中A具有的元素且B也具有的元素并返回，其中去除动作计算元素个数。即MULTISET EXCEPT ALL：
  ```
  gaussdb=# DECLARE
     TYPE nest IS TABLE OF INT;
     a nest := nest(1,2,2);
     b nest := nest(2,3);
   BEGIN
     a := a MULTISET EXCEPT ALL b;
     RAISE INFO '%', a;
   END;
   /
  INFO:  {1,2}
  ANONYMOUS BLOCK EXECUTE
  ```
  示例2，求两个集合变量的差集，去除A中A具有的元素且B也具有的元素并返回，其中去除动作不计算元素个数。即MULTISET EXCEPT DISTINCT：
  ```
  gaussdb=# DECLARE
     TYPE nest IS TABLE OF INT;
     a nest := nest(1,2,2);
     b nest := nest(2,3);
   BEGIN
     a := a MULTISET EXCEPT DISTINCT b;
     RAISE INFO '%', a;
   END;
   /
  INFO:  {1}
  ANONYMOUS BLOCK EXECUTE
  ```
  
- MULTISET INTERSECT \[ALL \| DISTINCT\] 参数：nesttable类型。
  返回值：nesttable类型。
  功能描述：两个集合变量的交集。如 A MULTISET INTERSECT B：ALL表示保留所有重复元素（包括多次重复的元素）；DISTINCT表示返回唯一值交集，去除重复元素。ALL为默认值。
  示例1，求两个集合变量的交集，不去除重复元素，即MULTISET INTERSECT ALL：
  ```
  gaussdb=# DECLARE
     TYPE nest IS TABLE OF INT;
     a nest := nest(1,2,2);
     b nest := nest(2,2,3);
   BEGIN
     a := a MULTISET INTERSECT ALL b;
     RAISE INFO '%', a;
   END;
   /
  INFO:  {2,2}
  ANONYMOUS BLOCK EXECUTE
  ```
  示例2，求两个集合变量的交集，去除重复元素，即MULTISET INTERSECT DISTINCT：
  ```
  gaussdb=# DECLARE
     TYPE nest IS TABLE OF INT;
     a nest := nest(1,2,2);
     b nest := nest(2,2,3);
   BEGIN
     a := a MULTISET INTERSECT DISTINCT b;
     RAISE INFO '%', a;
   END;
   /
  INFO:  {2}
  ANONYMOUS BLOCK EXECUTE
  ```
  
 
#### 集合类型函数
![](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 以下函数定义说明里\[\]中的内容代表可选项，如count\[()\]表示可以写成count或count()。
- 在内层表达式中，不支持通过嵌套的方式调用集合类型函数。
- 当类型嵌套且集合类型作为内部类型时，无参的extend、delete、trim函数只支持extend、delete、trim形式调用，不支持extend()、delete()、trim()形式调用。
 
- exists(idx) 参数：idx为INT4类型或VARCHAR类型。
  返回值：TRUE或FALSE，BOOLEAN类型。
  功能描述：查找指定位置是否存在有效元素。
  示例：
  ```
  gaussdb=# DECLARE
     TYPE nest IS TABLE OF VARCHAR2;
     a nest := nest('happy','?');
     flag BOOL;
   BEGIN
     flag := a.EXISTS(1);
     RAISE INFO '%', flag;
     flag := a.EXISTS(10);
     RAISE INFO '%', flag;
   END;
   /
  INFO:  t
  INFO:  f
  ANONYMOUS BLOCK EXECUTE
  gaussdb=# DECLARE
     TYPE nest IS TABLE OF VARCHAR2 INDEX BY VARCHAR2;
     a nest;
     flag BOOL;
   BEGIN
     a('1') := 'Be';
     a('2') := 'happy';
     a('3') := '.';
     flag := a.EXISTS('1');
     RAISE INFO '%', flag;
     flag := a.EXISTS('ddd');
     RAISE INFO '%', flag;
   END;
   /
  INFO:  t
  INFO:  f
  ANONYMOUS BLOCK EXECUTE
  ```
  
- extend\[(count\[, idx\])\] 参数：idx和count为INT4类型，没有参数传入时扩展1个元素值为NULL。
  返回值：无返回值。
  功能描述：extend函数仅支持nesttable类型变量使用。在nesttable变量末尾拓展1个或count个元素。存在idx下标元素时，复制count个idx下标元素到变量末尾。
  示例1，nesttable类型变量扩展1个元素且所扩展的元素值为NULL：
  ```
  gaussdb=# DECLARE
     TYPE nest IS TABLE OF INT;
     a nest := nest(1);
   BEGIN
     RAISE INFO '%', a;
     a.EXTEND;
     RAISE INFO '%', a;
     a.EXTEND;
     RAISE INFO '%', a;
   END;
   /
  INFO:  {1}
  INFO:  {1,NULL}
  INFO:  {1,NULL,NULL}
  ANONYMOUS BLOCK EXECUTE
  ```
  示例2，nesttable类型变量扩展n个元素且所扩展的元素值为NULL：
  ```
  gaussdb=# DECLARE
     TYPE nest IS TABLE OF INT;
     a nest := nest(1);
   BEGIN
     RAISE INFO '%', a;
     a.EXTEND(2);
     RAISE INFO '%', a;
   END;
   /
  INFO:  {1}
  INFO:  {1,NULL,NULL}
  ANONYMOUS BLOCK EXECUTE
  ```
  示例3，nesttable类型变量扩展n个元素且所扩展的元素值为指定下标元素的值：
  ```
  gaussdb=# DECLARE
     TYPE nest IS TABLE OF INT;
     a nest := nest(9);
   BEGIN
     RAISE INFO '%', a;
     a.EXTEND(2,1);
     RAISE INFO '%', a;
   END;
   /
  INFO:  {9}
  INFO:  {9,9,9}
  ANONYMOUS BLOCK EXECUTE
  ```
  
- delete\[(idx1\[, idx2\])\] 参数：idx1和idx2为INT4类型或VARCHAR2类型。
  返回值：无返回值。
  功能描述：无参数时，无索引集合nesttable类型变量删除集合类型的所有元素和空间，后续使用需要重新扩展空间，带索引集合indexbytable类型变量删除所有元素内容；一个参数删除指定位置元素（不删除空间）；两个参数则删除下标区间内的所有元素（不删除空间）。
  约束：对于无索引集合nesttable类型来说，删除元素而没删除空间，会使该空间处于无效状态，可继续赋值。作为函数返回值或自治事务入参时，会删除无效成员的存储空间，所有成员的下标会相应发生改变。
  示例1，无索引集合nesttable类型变量删除集合类型的所有元素和空间：
  ```
  gaussdb=# DECLARE
     TYPE nest IS TABLE OF INT;
     a nest := nest(1,2,3,4,5);
   BEGIN
     RAISE INFO '%', a;
     a.DELETE();
     RAISE INFO '%', a;
   END;
   /
  INFO:  {1,2,3,4,5}
  INFO:  {}
  ANONYMOUS BLOCK EXECUTE
  ```
  示例2，无索引集合nesttable类型变量删除指定位置元素：
  ```
  gaussdb=# DECLARE
     TYPE nest IS TABLE OF INT;
     a nest := nest(1,2,3,4,5);
   BEGIN
     RAISE INFO '%', a;
     a.DELETE(3);
     RAISE INFO '%', a;
     a(3) := 3;
     RAISE INFO '%', a;
   END;
   /
  INFO:  {1,2,3,4,5}
  INFO:  {1,2,4,5}
  INFO:  {1,2,3,4,5}
  ANONYMOUS BLOCK EXECUTE
  ```
  示例3，无索引集合nesttable类型变量删除指定区间元素：
  ```
  gaussdb=# DECLARE
     TYPE nest IS TABLE OF INT;
     a nest := nest(1,2,3,4,5);
   BEGIN
     RAISE INFO '%', a;
     a.DELETE(2,4);
     RAISE INFO '%', a(1);
     RAISE INFO '%', a(5);
     RAISE INFO '%', a;
   END;
   /
  INFO:  {1,2,3,4,5}
  INFO:  1
  INFO:  5
  INFO:  {1,5}
  ANONYMOUS BLOCK EXECUTE
  ```
  示例4，带索引集合indexbytable类型变量删除集合类型的所有元素和空间：
  ```
  gaussdb=# DECLARE
     TYPE t1 IS TABLE OF INT INDEX BY VARCHAR;
     v t1 := t1('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4);
   BEGIN
     v.DELETE();
     RAISE INFO '%', v.COUNT();
   END;
   /
  INFO:  0
  ANONYMOUS BLOCK EXECUTE
  ```
  示例5，带索引集合indexbytable类型变量删除指定位置元素：
  ```
  gaussdb=# declare
     type t1 is table of int index by varchar;
     v t1 := t1('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4);
   begin
     raise info '%', v('a');
     v.delete('a');
     raise info '%', v('a');
   end;
   /
  INFO:  1
  ERROR:  no data found
  CONTEXT:  PL/pgSQL function inline_code_block line 6 at RAISE
  ```
  示例6，带索引集合indexbytable类型变量删除指定区间元素：
  ```
  gaussdb=# declare
     type t1 is table of int index by varchar;
     v t1 := t1('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4);
   begin
     raise info '%', v('b');
     v.delete('a', 'c');
     raise info '%', v('b');
   end;
   /
  INFO:  2
  ERROR:  no data found
  CONTEXT:  PL/pgSQL function inline_code_block line 6 at RAISE
  ```
  
- trim\[(n)\] 参数：n为INT4类型。
  返回值：无返回值。
  功能描述：trim函数仅支持nesttable类型变量使用。无参数时，删除末尾一个元素空间，输入参数合法时，删除末尾指定数量元素空间。
  示例：
  ```
  gaussdb=# DECLARE
     TYPE nest IS TABLE OF INT;
     aa nest := nest(11,22,33,44,55);
   BEGIN
     RAISE INFO 'aa:%' ,aa;
     aa.TRIM;  -- 无参数
     RAISE INFO 'aa:%' ,aa;
     aa.TRIM();  -- 无参数
     RAISE INFO 'aa:%' ,aa;
     aa.TRIM(2);  -- 参数合法
     RAISE INFO 'aa:%' ,aa;
     aa.TRIM(2);  -- 集合元素空间不足2, 参数不合法报错
   END;
   /
  INFO:  aa:{11,22,33,44,55}
  INFO:  aa:{11,22,33,44}
  INFO:  aa:{11,22,33}
  INFO:  aa:{11}
  ERROR:  Subscript beyond count
  CONTEXT:  PL/pgSQL function inline_code_block line 11 at assignment
  ```
  
- count\[()\] 参数：无。
  返回值：INT类型。
  功能描述：返回集合中存在有效元素的个数。
  示例1，无索引集合类型变量使用count函数：
  ```
  gaussdb=# DECLARE
   TYPE nest IS TABLE OF INT;
   aa nest:=nest(11,22,33,44,55);
   BEGIN
   RAISE INFO 'count:%' ,aa.COUNT;
   aa.DELETE(3);  -- 删除一个元素，下标为3的元素无效
   RAISE INFO 'count:%' ,aa.COUNT();
   END;
   /
  INFO:  count:5
  INFO:  count:4
  ANONYMOUS BLOCK EXECUTE
  ```
  示例2，带索引集合类型变量使用count函数：
  ```
  gaussdb=# DECLARE
   TYPE t1 IS TABLE OF INT INDEX BY INT;
   aa t1;
   BEGIN
   aa(1) := 111;
   aa(2) := 222;
   aa(3) := 333;
   RAISE INFO 'count:%' ,aa.COUNT();
   END;
   /
  INFO:  count:3
  ANONYMOUS BLOCK EXECUTE
  gaussdb=# DECLARE
   TYPE t1 IS TABLE OF INT INDEX BY INT;
   aa t1;
   BEGIN
   aa(1) := 111;
   aa(2) := 222;
   aa(3) := 333;
   RAISE INFO 'count:%' ,aa.COUNT();
   END;
   /
  INFO:  count:3
  ANONYMOUS BLOCK EXECUTE
  ```
  
- first\[()\] 参数：无。
  返回值：INT类型或VARCHAR类型。
  功能描述：返回集合中第一个有效元素的下标。
  示例1，无索引集合类型变量使用first函数：
  ```
  gaussdb=# DECLARE
   TYPE nest IS TABLE OF INT;
   aa nest:=nest(11,22,33,44,55);
   BEGIN
   RAISE INFO 'first:%' ,aa.FIRST();
   aa.DELETE(1);
   RAISE INFO 'first:%' ,aa.FIRST;  -- 下标1的元素无效，第一个有效元素下标为2
   END;
   /
  INFO:  first:1
  INFO:  first:2
  ANONYMOUS BLOCK EXECUTE
  ```
  示例2，带索引集合类型变量使用first函数：
  ```
  gaussdb=# DECLARE
   TYPE t1 IS TABLE OF INT INDEX BY INT;
   aa t1;
   BEGIN
   aa(3) := 111;
   aa(2) := 222;
   aa(1) := 333;
   RAISE INFO 'first:%' ,aa.FIRST;
   END;
   /
  INFO:  first:1
  ANONYMOUS BLOCK EXECUTE
  gaussdb=# DECLARE
   TYPE t1 IS TABLE OF INT INDEX BY VARCHAR;
   aa t1;
   BEGIN
   aa('aaa') := 111;
   aa('bbb') := 222;
   aa('ccc') := 333;
   RAISE INFO 'first:%' ,aa.FIRST;
   END;
   /
  INFO:  first:aaa
  ANONYMOUS BLOCK EXECUTE
  ```
  
- last\[()\] 参数：无。
  返回值：INT类型或VARCHAR类型。
  功能描述：返回集合中最后一个有效元素的下标。
  示例1，无索引集合类型变量使用last函数：
  ```
  gaussdb=# DECLARE
   TYPE nest IS TABLE OF INT;
   aa nest:=nest(11,22,33,44,55);
   BEGIN
   RAISE INFO 'last:%' ,aa.LAST;
   aa.DELETE(5);
   RAISE INFO 'last:%' ,aa.LAST();  -- 下标5的元素无效，最后一个有效元素下标为4
   END;
   /
  INFO:  last:5
  INFO:  last:4
  ANONYMOUS BLOCK EXECUTE
  ```
  示例2，带索引集合类型变量使用last函数：
  ```
  gaussdb=# DECLARE
   TYPE t1 IS TABLE OF INT INDEX BY VARCHAR;
   aa t1;
   BEGIN
   aa(3) := 111;
   aa(2) := 222;
   aa(1) := 333;
   RAISE INFO 'last:%' ,aa.LAST();
   END;
   /
  INFO:  last:3
  ANONYMOUS BLOCK EXECUTE
  gaussdb=# DECLARE
   TYPE t1 IS TABLE OF INT INDEX BY VARCHAR;
   aa t1;
   BEGIN
   aa(3) := 111;
   aa(2) := 222;
   aa(1) := 333;
   RAISE INFO 'last:%' ,aa.LAST();
   END;
   /
  INFO:  last:ccc
  ANONYMOUS BLOCK EXECUTE
  ```
  
- prior(idx) 参数：idx为int类型或varchar类型。
  返回值：int类型或varchar类型。
  功能描述：返回集合中给定下标的前一个有效元素下标，下标不存在返回集合中最后一个元素。
  示例1，无索引集合类型变量使用prior函数：
  ```
  gaussdb=# DECLARE
   TYPE nest IS TABLE OF INT;
   aa nest:=nest(11,22,33,44,55);
   BEGIN
   RAISE INFO 'prior:%' ,aa.PRIOR(3);
   END;
   /
  INFO:  prior:2
  ANONYMOUS BLOCK EXECUTE
  ```
  示例2，带索引集合类型变量使用prior函数：
  ```
  gaussdb=# DECLARE
   TYPE t1 IS TABLE OF INT INDEX BY VARCHAR;
   aa t1;
   BEGIN
   aa('ccc') := 111;
   aa('bbb') := 222;
   aa('aaa') := 333;
   RAISE INFO 'prior:%' ,aa.PRIOR('bbb');
   RAISE INFO 'prior:%' ,aa.PRIOR('ddd');
   END;
   /
  INFO:  prior:aaa
  INFO:  prior:ccc
  ANONYMOUS BLOCK EXECUTE
  ```
  
- next(idx) 参数：idx为INT类型或VARCHAR类型，下标不存在返回集合中第一个元素。
  返回值：INT类型或VARCHAR类型。
  功能描述：返回集合中给定下标的后一个有效元素下标。
  示例1，无索引集合类型变量使用next函数：
  ```
  gaussdb=# DECLARE
   TYPE nest IS TABLE OF INT;
   aa nest:=nest(11,22,33,44,55);
   BEGIN
   RAISE INFO 'next:%' ,aa.NEXT(3);
   END;
   /
  INFO:  next:4
  ANONYMOUS BLOCK EXECUTE
  ```
  示例2，带索引集合类型变量使用next函数：
  ```
  gaussdb=# DECLARE
   TYPE t1 IS TABLE OF INT INDEX BY INT;
   aa t1;
  BEGIN
   aa(3) := 111;
   aa(2) := 222;
   aa(1) := 333;
   RAISE INFO 'next:%' ,aa.NEXT(2);
   RAISE INFO 'next:%' ,aa.NEXT(-999);
   END;
   /
  INFO:  next:3
  INFO:  next:1
  ANONYMOUS BLOCK EXECUTE
  ```
  
- limit 参数：无。
  返回值：NULL。
  功能描述：仅用于nesttable类型变量，且返回NULL值。
  示例：
  ```
  gaussdb=# DECLARE
   TYPE nest IS TABLE OF INT;
   aa nest:=nest(11,22,33,44,55);
   BEGIN
   RAISE INFO 'limit:%' ,aa.LIMIT;
   END;
   /
  INFO:  limit:<NULL>
  ANONYMOUS BLOCK EXECUTE
  ```
  
 
#### 集合相关函数
- unnest_table(anynesttable)或unnest(anynesttable) 参数：任意无索引集合类型。
  描述：返回给定nesttable中所有有效元素的结果集，会返回多行数据。
  返回类型：setof anyelement。
  示例：
  ```
  -- 当集合的元素类型为record类型且有元素为NULL时，该元素不会被返回，而是会返回一个非NULL的record值，该record的所有列为NULL。
  gaussdb=# CREATE OR REPLACE p1()
  gaussdb-# AS
  gaussdb$#     TYPE t1 IS TABLE OF INT;
  gaussdb$#     v2 t1 := t1(NULL, 2, 3, 4, NULL);
  gaussdb$#     tmp INT;
  gaussdb$#     CURSOR c1 IS SELECT * FROM UNNEST_TABLE(v2);
  gaussdb$# BEGIN
  gaussdb$# OPEN c1;
  gaussdb$# FOR i IN 1 .. v2.COUNT LOOP
  gaussdb$#     FETCH c1 INTO tmp;
  gaussdb$#     IF tmp IS NULL THEN
  gaussdb$#         DBE_OUTPUT.PRINT_LINE(i || ': is null');
  gaussdb$#     ELSE
  gaussdb$#         DBE_OUTPUT.PRINT_LINE(i || ': ' || tmp);
  gaussdb$#     END IF;
  gaussdb$# END LOOP;
  gaussdb$# CLOSE c1;
  gaussdb$# END;
  gaussdb$# /
  CREATE PROCEDURE
  gaussdb=# CALL p1();
  1: is null
  2: 2
  3: 3
  4: 4
  5: is null
   p1 
  ----
  (1 row)
  gaussdb=# DROP PROCEDURE IS EXISTS p1();
  DROP PROCEDURE
  -- nesttable嵌套record类型示例
  gaussdb=# CREATE OR REPLACE PROCEDURE p1() IS
  gaussdb$#   TYPE rec IS RECORD(c1 INT, c2 INT);
  gaussdb$#   TYPE t1 IS TABLE OF rec;
  gaussdb$#   v t1 := t1(rec(1, 1), rec(2, NULL), rec(NULL, NULL), NULL);
  gaussdb$#   v2 t1 := t1();
  gaussdb$#   CURSOR cur IS SELECT * FROM UNNEST(v);
  gaussdb$# BEGIN
  gaussdb$#   v2.EXTEND(v.COUNT);
  gaussdb$#   OPEN cur;
  gaussdb$#   FOR i IN 1 .. v.COUNT LOOP
  gaussdb$#     FETCH cur INTO v2(i);
  gaussdb$#     RAISE INFO '%', v2(i);
  gaussdb$#   END LOOP;
  gaussdb$#   CLOSE cur;
  gaussdb$# END
  gaussdb$# /
  CREATE PROCEDURE
  gaussdb=# CALL p1();
  INFO:  (1,1)
  INFO:  (2,)
  INFO:  (,)
  INFO:  (,)
   p1 
  ----
  (1 row)
  gaussdb=# DROP PROCEDURE IF EXISTS p1();
  DROP PROCEDURE
  ```
  

- unnest_table(anyindexbytable)或unnest(anyindexbytable) 参数：任意带索引集合类型。
  描述：返回给定indexbytable中所有元素根据索引排序后的结果集，会返回多行数据。
  返回类型：setof anyelement
  约束：只支持INDEX BY INT类型。
  示例：
  ```
  -- 当集合的元素类型为record类型且有元素为NULL时，该元素不会被返回，而是会返回一个非NULL的record值，该record的所有列为NULL。
  gaussdb=# CREATE OR REPLACE PROCEDURE p1()
  gaussdb-# AS
  gaussdb$#     TYPE t1 IS TABLE OF INT INDEX BY INT;
  gaussdb$#     v2 t1 := t1(1=>1, -10=>(-10), 6=>6, 4=>NULL);
  gaussdb$#     tmp INT;
  gaussdb$#     CURSOR c1 IS SELECT * FROM UNNEST_TABLE(v2);
  gaussdb$# BEGIN
  gaussdb$# OPEN c1;
  gaussdb$# FOR i IN 1 .. v2.COUNT LOOP
  gaussdb$#     FETCH c1 INTO tmp;
  gaussdb$#     IF tmp IS NULL THEN
  gaussdb$#         DBE_OUTPUT.PRINT_LINE(i || ': is null');
  gaussdb$#     ELSE
  gaussdb$#         DBE_OUTPUT.PRINT_LINE(i || ': ' || tmp);
  gaussdb$#     END IF;
  gaussdb$# END LOOP;
  gaussdb$# CLOSE c1;
  gaussdb$# END;
  gaussdb$# /
  CREATE PROCEDURE
  gaussdb=# CALL p1();
  1: -10
  2: 1
  3: is null
  4: 6
   p1 
  ----
  (1 row)
  gaussdb=# DROP PROCEDURE IF EXISTS p1();
  DROP PROCEDURE
  -- index by table嵌套record类型示例
  gaussdb=# CREATE OR REPLACE PROCEDURE p1() IS
  gaussdb$#   TYPE rec IS RECORD(c1 INT, c2 INT);
  gaussdb$#   TYPE t1 IS TABLE OF rec INDEX BY INT;
  gaussdb$#   v t1 := t1(1 => rec(1, 1), 2 => rec(2, NULL), 3 => rec(NULL, NULL), 4 => NULL);
  gaussdb$#   v2 t1 := t1();
  gaussdb$#   CURSOR cur IS SELECT * FROM UNNEST(v);
  gaussdb$# BEGIN
  gaussdb$#   OPEN cur;
  gaussdb$#   FOR i IN 1 .. v.COUNT LOOP
  gaussdb$#     FETCH cur INTO v2(i);
  gaussdb$#     RAISE INFO '%', v2(i);
  gaussdb$#   END LOOP;
  gaussdb$#   CLOSE cur;
  gaussdb$# END;
  gaussdb$# /
  CREATE PROCEDURE
  gaussdb=# CALL p1();
  INFO:  (1,1)
  INFO:  (2,)
  INFO:  (,)
  INFO:  (,)
   p1 
  ----
  (1 row)
  gaussdb=# drop procedure if exists p1();
  DROP PROCEDURE
  ```