anyarray @> anyarray → boolean

第一个数组是否包含第二个数组，即第二个数组中出现的每个元素是否都等于第一个数组的某个元素？（重复项没有特殊处理，因此 ARRAY[1] 和 ARRAY[1,1] 每个都被认为包含另一个。）

ARRAY[1,4,3] @> ARRAY[3,1,3] → t

anyarray <@ anyarray → boolean

第一个数组是否包含在第二个数组中？

ARRAY[2,2,7] <@ ARRAY[1,7,4,2,6] → t

anyarray && anyarray → boolean

数组是否有重叠，即是否有任何元素相同？

ARRAY[1,4,3] && ARRAY[2,1] → t

anycompatiblearray || anycompatiblearray → anycompatiblearray

连接两个数组。连接 null 或空数组是无操作；否则数组必须具有相同数量的维度（如第一个示例所示）或维度数量相差 1（如第二个示例所示）。如果数组的元素类型不同，则会强制转换为公共类型（请参阅第 10.5 节）。

ARRAY[1,2,3] || ARRAY[4,5,6,7] → {1,2,3,4,5,6,7}

ARRAY[1,2,3] || ARRAY[[4,5,6],[7,8,9.9]] → {{1,2,3},{4,5,6},{7,8,9.9}}

anycompatible || anycompatiblearray → anycompatiblearray

将元素连接到数组的开头（数组必须为空或一维）。

3 || ARRAY[4,5,6] → {3,4,5,6}

anycompatiblearray || anycompatible → anycompatiblearray

将元素连接到数组的末尾（数组必须为空或一维）。

ARRAY[4,5,6] || 7 → {4,5,6,7}

array_append ( anycompatiblearray, anycompatible ) → anycompatiblearray

将元素附加到数组末尾（与 anycompatiblearray || anycompatible 运算符相同）。

array_append(ARRAY[1,2], 3) → {1,2,3}

array_cat ( anycompatiblearray, anycompatiblearray ) → anycompatiblearray

连接两个数组（与 anycompatiblearray || anycompatiblearray 运算符相同）。

array_cat(ARRAY[1,2,3], ARRAY[4,5]) → {1,2,3,4,5}

array_dims ( anyarray ) → text

返回数组维度文本表示形式。

array_dims(ARRAY[[1,2,3], [4,5,6]]) → [1:2][1:3]

array_fill ( anyelement, integer[] [, integer[] ] ) → anyarray

返回填充了给定值副本的数组，它的维度是由第二个参数指定的长度。可选的第三个参数为每个维度提供了下限值（默认为所有 1）。

array_fill(11, ARRAY[2,3]) → {{11,11,11},{11,11,11}}

array_fill(7, ARRAY[3], ARRAY[2]) → [2:4]={7,7,7}

array_length ( anyarray, integer ) → integer

返回所请求数组维度的长度。（对于维度为空或缺失的数组，会生成 NULL 而不是 0。）

array_length(array[1,2,3], 1) → 3

array_length(array[]::int[], 1) → NULL

array_length(array['text'], 2) → NULL

array_lower ( anyarray, integer ) → integer

返回所请求的数组维度的下限。

array_lower('[0:2]={1,2,3}'::integer[], 1) → 0

array_ndims ( anyarray ) → integer

返回数组的维度数量。

array_ndims(ARRAY[[1,2,3], [4,5,6]]) → 2

array_position ( anycompatiblearray, anycompatible [, integer ] ) → integer

返回数组中第二个参数的第一个出现的下标，如果不存在，则返回 NULL。如果给定第三个参数，则搜索从该下标开始。数组必须是一维的。比较是使用 IS NOT DISTINCT FROM 语义进行的，因此可以搜索 NULL。

array_position(ARRAY['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'], 'mon') → 2

array_positions ( anycompatiblearray, anycompatible ) → integer[]

返回数组中第一个参数所给出的数组中第二个参数的所有出现次数的下标数组。数组必须是一维的。比较是使用 IS NOT DISTINCT FROM 语义进行的，因此可以搜索 NULL。仅当数组为 NULL 时才返回 NULL；如果数组中没有找到该值，则返回一个空数组。

array_positions(ARRAY['A','A','B','A'], 'A') → {1,2,4}

array_prepend ( 任意兼容, 任意兼容数组 ) → 任意兼容数组

把元素前置到数组的开头（和 anycompatible || anycompatiblearray 运算符相同）。

array_prepend(1, ARRAY[2,3]) → {1,2,3}

array_remove ( 任意兼容数组, 任意兼容 ) → 任意兼容数组

从数组中删除所有等于给定值的元素。数组必须是一维的。比较使用 IS NOT DISTINCT FROM 语义完成，因此可以删除 NULL。

array_remove(ARRAY[1,2,3,2], 2) → {1,3}

array_replace ( 任意兼容数组, 任意兼容, 任意兼容 ) → 任意兼容数组

用第三个参数替换数组中等于第二个参数的每个数组元素。

array_replace(ARRAY[1,2,5,4], 5, 3) → {1,2,3,4}

array_sample ( array 任意数组, n 整数 ) → 任意数组

从 array 中随机选择 n 个项目并返回一个数组。 n 不能超过 array 的第一个维度的长度。如果 array 是多维的，那么 “项目”则是一个包含给定第一个下标的切片。

array_sample(ARRAY[1,2,3,4,5,6], 3) → {2,6,1}

array_sample(ARRAY[[1,2],[3,4],[5,6]], 2) → {{5,6},{1,2}}

array_shuffle ( 任意数组 ) → 任意数组

随机打乱数组的第一个维度。

array_shuffle(ARRAY[[1,2],[3,4],[5,6]]) → {{5,6},{1,2},{3,4}}

array_to_string ( array anyarray, delimiter text [, null_string text ] ) → text

将每个数组元素转换为其文本表示形式，并使用 delimiter 字符串将其连接起来。如果给定了 null_string，并且不为 NULL，则 NULL 数组项将使用该字符串表示；否则，输出时将其省略。另请参阅 string_to_array。

array_to_string(ARRAY[1, 2, 3, NULL, 5], ',', '*') → 1,2,3,*,5

array_upper ( anyarray, integer ) → integer

返回所需数组维度的上限。

array_upper(ARRAY[1,8,3,7], 1) → 4

cardinality ( anyarray ) → integer

返回数组中的元素总数，如果数组为空，则返回 0。

cardinality(ARRAY[[1,2],[3,4]]) → 4

trim_array ( array anyarray, n integer ) → anyarray

通过移除最后的 n 个元素对数组进行修剪。如果数组是多维的，则仅修剪第一维。

trim_array(ARRAY[1,2,3,4,5,6], 2) → {1,2,3,4}

unnest ( anyarray ) → setof anyelement

将数组展开为一组行。按存储顺序读出数组元素。

unnest(ARRAY[1,2]) →

 1
 2

unnest(ARRAY[['foo','bar'],['baz','quux']]) →

 foo
 bar
 baz
 quux

unnest ( anyarray, anyarray [, ... ] ) → setof anyelement, anyelement [, ... ]

将多个数组（可能是不同的数据类型）展开为一组行。如果数组长度不相同，则用 NULL 填充较短的数组。此形式仅允许在查询的 FROM 子句中使用；请参见 第 7.2.1.4 节。

select * from unnest(ARRAY[1,2], ARRAY['foo','bar','baz']) as x(a,b) →

 a |  b
---+-----
 1 | foo
 2 | bar
   | baz