【PostgreSQL】从零开始:（三十）数据类型-Arrays数组类型

数组

数组是一种数据结构，可以容纳多个相同类型的元素。数组可以存储基本数据类型（如整数、浮点数等）或者对象类型（如字符串、自定义对象等）。在大多数编程语言中，数组有固定的大小，一旦声明后，大小不可改变。数组的元素可以通过索引访问，索引通常从0开始。数组可以用于存储和操作大量数据，提供了快速访问和修改元素的能力。有些编程语言还提供了一些方便的方法和函数来处理数组，如排序、查找、插入和删除元素等。

数组类型

PostgreSQL支持数组类型，允许在单个列中存储多个值。数组类型可以包含各种数据类型的元素，如整数、文本、日期等。数组类型在存储和检索多个相关值时非常有用。

在创建表时，可以使用数组类型定义列。以下是使用数组类型定义列的示例：

CREATE TABLE sal_emp (
    name            text,
    pay_by_quarter  integer[],
    schedule        text[][]
);

如上所示，数组数据类型是通过在数组元素的数据类型名称后附加方括号[]来命名的。上面的命令将创建一个表，sal_emp表具有 text 类型的列name、integer 类型的一维数组pay_by_quarter（表示员工按季度的工资）和 text 的二维数组schedule（表示员工的每周日程安排）。

CREATE TABLE的语法允许指定数组的确切大小，例如：

CREATE TABLE tictactoe (
    squares   integer[3][3]
);

但是，当前实现忽略了任何提供的数组大小限制，即行为与未指定长度的数组相同。

当前实现也不强制执行声明的维度数。特定元素类型的数组都被视为同一类型，无论大小或维度数如何。因此，CREATE TABLE声明数组大小或维度数只是文档;它不会影响运行时行为。

另一种语法ARRAY，通过使用关键字符合 SQL 标准，可用于一维数组pay_by_quarter。 可以定义为：

 pay_by_quarter  integer ARRAY[4],

或者，如果未指定数组大小：

  pay_by_quarter  integer ARRAY,

值的输入

若要将数组值写入文本常量，请将元素值括在大括号内，并用逗号分隔它们。（如果您了解 C，这与初始化结构的 C 语法没有什么不同。您可以在任何元素值两边加上双引号，如果它包含逗号或大括号，则必须这样做。（更多细节见下文。因此，数组常量的一般格式如下：

'{ val1 delim val2 delim ... }'

其中 delim 是类型的分隔符，如pg_type其条目中记录的那样。在 PostgreSQL 发行版中提供的标准数据类型中，除了使用分号 （;） 的box类型外，所有数据类型都使用逗号 （,）。每个 val 要么是数组元素类型的常量，要么是子数组。数组常量的一个示例是：

'{{1,2,3},{4,5,6},{7,8,9}}'

该常量是一个二维 3×3 数组，由三个整数子数组组成。

若要将数组常量的元素设置为 NULL，请写入元素值NULL。NULL（任何大写或小写变体都可以。如果需要实际的字符串值“NULL”，则必须在它周围加上双引号。

现在我们可以显示一些语句：INSERT

INSERT INTO sal_emp
    VALUES ('Bill',
    '{10000, 10000, 10000, 10000}',
    '{{"meeting", "lunch"}, {"training", "presentation"}}');

INSERT INTO sal_emp
    VALUES ('Carol',
    '{20000, 25000, 25000, 25000}',
    '{{"breakfast", "consulting"}, {"meeting", "lunch"}}');

前两次插入的结果如下所示：

SELECT * FROM sal_emp;
 name  |      pay_by_quarter       |                 schedule
-------+---------------------------+-------------------------------------------
 Bill  | {10000,10000,10000,10000} | {{meeting,lunch},{training,presentation}}
 Carol | {20000,25000,25000,25000} | {{breakfast,consulting},{meeting,lunch}}
(2 rows)

多维数组必须具有每个维度的匹配范围。不匹配会导致错误，例如：

INSERT INTO sal_emp
    VALUES ('Bill',
    '{10000, 10000, 10000, 10000}',
    '{{"meeting", "lunch"}, {"meeting"}}');
ERROR:  multidimensional arrays must have array expressions with matching dimensions

还可以使用ARRAY构造函数语法：

    VALUES ('Bill',
    ARRAY[10000, 10000, 10000, 10000],
    ARRAY[['meeting', 'lunch'], ['training', 'presentation']]);

INSERT INTO sal_emp
    VALUES ('Carol',
    ARRAY[20000, 25000, 25000, 25000],
    ARRAY[['breakfast', 'consulting'], ['meeting', 'lunch']]);

请注意，数组元素是普通的 SQL 常量或表达式;例如ARRAY，字符串文字是单引号，而不是像数组文字那样用双引号。

数组的查询

现在，我们可以在表上运行一些查询。首先，我们展示如何访问数组的单个元素。此查询检索其工资在第二季度发生变化的员工的姓名：

SELECT name FROM sal_emp WHERE pay_by_quarter[1] <> pay_by_quarter[2];

 name
-------
 Carol
(1 row)

数组下标数字写在方括号内。默认情况下，PostgreSQL 对数组使用从 1 开始的编号约定array[1]，即 n 个元素的数组以 开头并以 array[n]结尾。
此查询检索所有员工的第三季度工资：

SELECT pay_by_quarter[3] FROM sal_emp;

 pay_by_quarter
----------------
          10000
          25000
(2 rows)

我们还可以访问数组或子数组的任意矩形切片。数组切片通过写入一个或多个数组维度来表示。例如lower-bound:upper-bound，此查询检索一周前两天 Bill 计划中的第一项：

SELECT schedule[1:2][1:1] FROM sal_emp WHERE name = 'Bill';

        schedule
------------------------
 {{meeting},{training}}
(1 row)

如果任何维度被写成切片，即包含冒号，则所有维度都被视为切片。任何只有一个数字（没有冒号）的维度都被视为从 1 到指定的数字。例如[2][1:2]，被视为 ，如下例所示：

SELECT schedule[1:2][2] FROM sal_emp WHERE name = 'Bill';

                 schedule
-------------------------------------------
 {{meeting,lunch},{training,presentation}}
(1 row)

为避免与非切片情况混淆，最好对所有维度使用切片语法，例如[1:2]，[1:1]，而不是[2][1:1]。

可以省略切片说明符的下界和/或上限;缺失的边界将替换为数组下标的下限或上限。例如：

SELECT schedule[:2][2:] FROM sal_emp WHERE name = 'Bill';

        schedule
------------------------
 {{lunch},{presentation}}
(1 row)

SELECT schedule[:][1:1] FROM sal_emp WHERE name = 'Bill';

        schedule
------------------------
 {{meeting},{training}}
(1 row)

如果数组本身或任何下标表达式为 null，则数组下标表达式将返回 null。此外，如果下标超出数组边界，则返回 null（这种情况不会引发错误）。例如schedule[1:3][1:2]，如果当前具有维度，则引用将生成 NULL。同样，schedule[3][3]具有错误数量的下标的数组引用会产生 null 而不是错误。

如果数组本身或任何下标表达式为 null，则数组切片表达式同样会生成 null。但是，在其他情况下，例如选择完全超出当前数组边界的数组切片，切片表达式将生成一个空（零维）数组，而不是 null。（这与非切片行为不匹配，并且是出于历史原因。如果请求的切片部分与数组边界重叠，则会以静默方式将其简化为仅重叠区域，而不是返回 null。

可以使用以下函数检索任何数组值的当前维度：array_dims

SELECT array_dims(schedule) FROM sal_emp WHERE name = 'Carol';

 array_dims
------------
 [1:2][1:2]
(1 row)

array_dims产生一个text结果，它便于人们阅读，但对程序来说可能不方便。也可以使用array_upper和 array_lower检索维度，它们分别返回指定数组维度的上限和下限：

SELECT array_upper(schedule, 1) FROM sal_emp WHERE name = 'Carol';

 array_upper
-------------
           2
(1 row)

array_length将返回指定数组维度的长度：

SELECT array_length(schedule, 1) FROM sal_emp WHERE name = 'Carol';

 array_length
--------------
            2
(1 row)

cardinality返回数组中所有维度的元素总数。它实际上是调用将产生的行数：

SELECT cardinality(schedule) FROM sal_emp WHERE name = 'Carol';

 cardinality
-------------
           4
(1 row)

修改数组

数组值可以完全替换：

UPDATE sal_emp SET pay_by_quarter = '{25000,25000,27000,27000}'
    WHERE name = 'Carol';

或使用表达式语法：ARRAY

UPDATE sal_emp SET pay_by_quarter = ARRAY[25000,25000,27000,27000]
    WHERE name = 'Carol';

数组也可以在单个元素处更新：

UPDATE sal_emp SET pay_by_quarter[4] = 15000
    WHERE name = 'Bill';

或在切片中更新：

UPDATE sal_emp SET pay_by_quarter[1:2] = '{27000,27000}'
    WHERE name = 'Carol';

省略下限和/或上限的切片语法也可以使用，但只有在更新非 NULL 或零维的数组值时才能使用（否则，没有现有的下标限制可以替换）。

存储的数组值可以通过分配给不存在的元素来放大。以前存在的元素和新分配的元素之间的任何位置都将用空值填充。例如myarray，如果数组当前有 4 个元素，则在分配给 myarray[6]; 将包含 null。目前，只允许对一维数组进行这种方式的放大，而不允许对多维数组进行放大。

下标赋值允许创建不使用从 1 开始的下标的数组。例如myarray[-2:7]，可以赋值为 to 以创建一个下标值从 -2 到 7 的数组。

也可以使用串联运算符||构造新的数组值：

SELECT ARRAY[1,2] || ARRAY[3,4];
 ?column?
-----------
 {1,2,3,4}
(1 row)

SELECT ARRAY[5,6] || ARRAY[[1,2],[3,4]];
      ?column?
---------------------
 {{5,6},{1,2},{3,4}}
(1 row)

串联运算符允许将单个元素推送到一维数组的开头或结尾。它还接受两个 N 维数组，或一个 N 维数组和一个 N+1 维数组。

当单个元素被推送到一维数组的开头或结尾时，结果是一个与数组操作数具有相同下限的数组。例如：

SELECT array_dims(1 || '[0:1]={2,3}'::int[]);
 array_dims
------------
 [0:2]
(1 row)

SELECT array_dims(ARRAY[1,2] || 3);
 array_dims
------------
 [1:3]
(1 row)

当两个维数相等的数组连接在一起时，结果将保留左侧操作数外部维度的下限下标。结果是一个数组，由左手操作数的每个元素组成，后跟右手操作数的每个元素。例如：

SELECT array_dims(ARRAY[1,2] || ARRAY[3,4,5]);
 array_dims
------------
 [1:5]
(1 row)

SELECT array_dims(ARRAY[[1,2],[3,4]] || ARRAY[[5,6],[7,8],[9,0]]);
 array_dims
------------
 [1:5][1:2]
(1 row)

当 N 维数组被推送到 N+1 维数组的开头或结尾时，结果类似于上面的元素数组情况。每个 N 维子数组本质上都是 N+1 维数组外维的一个元素。例如：

SELECT array_dims(ARRAY[1,2] || ARRAY[[3,4],[5,6]]);
 array_dims
------------
 [1:3][1:2]
(1 row)

也可以使用函数array_prepend 、 array_append或array_cat 来构造数组。前两个仅支持一维数组，但：array_cat支持多维数组。

SELECT array_prepend(1, ARRAY[2,3]);
 array_prepend
---------------
 {1,2,3}
(1 row)

SELECT array_append(ARRAY[1,2], 3);
 array_append
--------------
 {1,2,3}
(1 row)

SELECT array_cat(ARRAY[1,2], ARRAY[3,4]);
 array_cat
-----------
 {1,2,3,4}
(1 row)

SELECT array_cat(ARRAY[[1,2],[3,4]], ARRAY[5,6]);
      array_cat
---------------------
 {{1,2},{3,4},{5,6}}
(1 row)

SELECT array_cat(ARRAY[5,6], ARRAY[[1,2],[3,4]]);
      array_cat
---------------------
 {{5,6},{1,2},{3,4}}

在简单情况下，上面讨论的串联运算符比直接使用这些函数更可取。但是，由于串联运算符过载以处理所有三种情况，因此在某些情况下，使用其中一个函数有助于避免歧义。例如，请考虑：

SELECT ARRAY[1, 2] || '{3, 4}';  -- the untyped literal is taken as an array
 ?column?
-----------
 {1,2,3,4}

SELECT ARRAY[1, 2] || '7';                 -- so is this one
ERROR:  malformed array literal: "7"

SELECT ARRAY[1, 2] || NULL;                -- so is an undecorated NULL
 ?column?
----------
 {1,2}
(1 row)

SELECT array_append(ARRAY[1, 2], NULL);    -- this might have been meant
 array_append
--------------
 {1,2,NULL}

在上面的示例中，解析器在串联运算符的一侧看到一个整数数组，在另一侧看到一个类型不确定的常量。它用于解析常量类型的启发式方法是假设它与运算符的其他输入（在本例中为整数数组）的类型相同。因此，假定串联运算符表示array_cat ，而不是array_append 。当这是一个错误的选择时，可以通过将常量转换为数组的元素类型来修复它;但显式使用array_append 可能是一个更可取的解决方案。

在数组中搜索

若要在数组中搜索值，必须检查每个值。如果您知道数组的大小，则可以手动完成此操作。例如：

SELECT * FROM sal_emp WHERE pay_by_quarter[1] = 10000 OR
                            pay_by_quarter[2] = 10000 OR
                            pay_by_quarter[3] = 10000 OR
                            pay_by_quarter[4] = 10000;

但是，对于大型数组来说，这很快就会变得乏味，如果数组的大小未知，则无济于事。第 9.24 节中描述了另一种方法。上面的查询可以替换为：

SELECT * FROM sal_emp WHERE 10000 = ANY (pay_by_quarter);

此外，您还可以找到数组的所有值都等于 10000 的行：

SELECT * FROM sal_emp WHERE 10000 = ALL (pay_by_quarter);

或者，可以使用该函数。例如：generate_subscripts

SELECT * FROM
   (SELECT pay_by_quarter,
           generate_subscripts(pay_by_quarter, 1) AS s
      FROM sal_emp) AS foo
 WHERE pay_by_quarter[s] = 10000;

您还可以使用运算符搜索数组，该运算符检查左操作数是否与右操作数重叠。例如：&&

SELECT * FROM sal_emp WHERE pay_by_quarter && ARRAY[10000];

第 9.19 节中进一步描述了此运算符和其他数组运算符。它可以通过适当的索引来加速，如第 11.2 节所述。

您还可以使用 和 函数搜索数组中的特定值。前者返回数组中值第一次出现的下标;后者返回一个数组，其中包含数组中所有出现的值的下标。例如：array_positionarray_positions

SELECT array_position(ARRAY['sun','mon','tue','wed','thu','fri','sat'], 'mon');
 array_position
----------------
              2
(1 row)

SELECT array_positions(ARRAY[1, 4, 3, 1, 3, 4, 2, 1], 1);
 array_positions
-----------------
 {1,4,8}
(1 row)

数组值的外部文本表示形式由根据数组元素类型的 I/O 转换规则解释的项以及指示数组结构的修饰组成。修饰由数组值周围的大括号 {} （typ和 delim） 以及相邻项之间的分隔符组成。分隔符通常是逗号 （box），但也可以是其他字符：它由数组元素类型的设置决定。在 PostgreSQL 发行版中提供的标准数据类型中，所有数据类型都使用逗号，但 type 除外，它使用分号 （;）。在多维数组中，每个维度（行、平面、立方体等）都有自己的大括号级别，并且必须在同一级别的相邻大括号实体之间写入分隔符。

如果元素值为空字符串、包含大括号、分隔符、双引号、反斜杠或空格，或者与单词 匹配，则数组输出例程将在元素值周围加上双引号。嵌入在元素值中的双引号和反斜杠将被反斜杠转义。对于数值数据类型，可以安全地假设双引号永远不会出现NULL，但对于文本数据类型，应该准备好应对引号的存在与否。

默认情况下，数组维度的下限索引值设置为 1。若要表示具有其他下限的数组，可以在写入数组内容之前显式指定数组下标范围。此修饰由方括号 （[） 组成，方括号 （]） 将每个数组维度的下限和上限括起来，中间有一个冒号 （:） 分隔符。数组维度修饰后跟一个等号 （=）。例如：

SELECT f1[1][-2][3] AS e1, f1[1][-1][5] AS e2
 FROM (SELECT '[1:1][-2:-1][3:5]={{{1,2,3},{4,5,6}}}'::int[] AS f1) AS ss;

 e1 | e2
----+----
  1 |  6
(1 row)

仅当存在一个或多个下限不同时，数组输出例程才会在其结果中包含显式维度。

如果为元素写入的值为 （在任何情况下为 variant），则该元素被视为 NULL。如果存在任何引号或反斜杠，则禁用此功能，并允许输入文本字符串值“NULL”。此外，NULL为了向后兼容 PostgreSQL 8.2 之前的版本，可以打开 array_nulls 配置参数off以禁止识别为 NULL。

如前所述，在编写数组值时，可以在任何单个数组元素周围使用双引号。如果元素值会混淆数组值解析器，则必须这样做。例如NULL，包含大括号、逗号（或数据类型的分隔符）、双引号、反斜杠或前导或尾随空格的元素必须用双引号引起来。空字符串和与单词匹配的字符串也必须用引号括起来。若要在带引号的数组元素值中放置双引号或反斜杠，请在其前面加上反斜杠。或者，您可以避免使用引号并使用反斜杠转义来保护所有数据字符，否则这些字符将被视为数组语法。

您可以在左大括号之前或右大括号之后添加空格。您还可以在任何单个项目字符串之前或之后添加空格。在所有这些情况下，空格都将被忽略。但是，双引号元素中的空格或元素的两侧被非空格字符包围的空格不会被忽略。