本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 数组函数
本节介绍 AWS Clean Rooms中支持的 SQL 数组函数。
**Topics**
+ [数组函数](array.md)
+ [ARRAY\$1CONTAINS 函数](array_contains.md)
+ [数组\$1DISTINCT 函数](array_distinct.md)
+ [数组\$1EXCEPT 函数](array_except.md)
+ [ARRAY\$1INTERSECT 函数](array_intersect.md)
+ [ARRAY\$1JOIN 函数](array_join.md)
+ [ARRAY\$1REMOVE 函数](array_remove.md)
+ [ARRAY\$1UNION 函数](array_union.md)
+ [“爆炸” 功能](explode.md)
+ [Flatten 功能](flatten.md)
# 数组函数
使用给定元素创建一个数组。
## 语法
```
ARRAY( [ expr1 ] [ , expr2 [ , ... ] ] )
```
## 参数
*expr1、expr2*
除日期和时间类型之外的任何数据类型的表达式。参数不需要为相同的数据类型。
## 返回类型
数组函数返回一个包含表达式中元素的数组。
## 示例
以下示例显示了一个数值数组和一个不同数据类型的数组。
```
--an array of numeric values
select array(1,50,null,100);
array
------------------
[1,50,null,100]
(1 row)
--an array of different data types
select array(1,'abc',true,3.14);
array
-----------------------
[1,"abc",true,3.14]
(1 row)
```
# ARRAY\$1CONTAINS 函数
ARRAY\$1CONTAINS 函数可用于对数组数据结构执行基本的成员资格检查。当你需要检查数组中是否存在特定值时，ARRAY\$1CONTAINS 函数很有用。
## 语法
```
array_contains(array, value)
```
## Arguments
*array*
要搜索的数组。
*值*
一种表达式，其类型与数组元素共享最不常见的类型。
## 返回类型
ARRAY\$1CONTAINS 函数返回一个布尔值。
如果值为空，则结果为空。
如果数组中的任何元素为 NULL，则如果值与任何其他元素都不匹配，则结果为 NULL。
## 示例
以下示例检查数组是否`[1, 2, 3]`包含该值`4`。由于数组`[1, 2, 3`] 不包含该值`4`，因此 array\$1contains 函数返回。`false`
```
SELECT array_contains(array(1, 2, 3), 4)
false
```
以下示例检查数组是否`[1, 2, 3]`包含该值`2`。由于数组`[1, 2, 3]`确实包含该值`2`，因此 array\$1contains 函数返回。`true`
```
SELECT array_contains(array(1, 2, 3), 2);
true
```
# 数组\$1DISTINCT 函数
ARRAY\$1DISTINCT 函数可用于从数组中删除重复的值。当您需要从数组中删除重复项并仅处理唯一元素时，ARRAY\$1DISTINCT 函数非常有用。在您想要在不受到重复值干扰的情况下对数据集执行操作或分析的情况下，这会很有用。
## 语法
```
array_distinct(array)
```
## Arguments
*array*
一个数组表达式。
## 返回类型
ARRAY\$1DISTINCT 函数返回一个仅包含输入数组中唯一元素的数组。
## 示例
在此示例中，输入数组`[1, 2, 3, null, 3]`包含的重复值为`3`。该`array_distinct`函数删除此重复值，`3`并返回一个包含唯一元素的新数组:`[1, 2, 3, null]`.
```
SELECT array_distinct(array(1, 2, 3, null, 3));
[1,2,3,null]
```
在此示例中，输入数组`[1, 2, 2, 3, 3, 3]`包含`2`和的重复值`3`。该`array_distinct`函数删除这些重复项，并返回一个包含唯一元素的新数组:`[1, 2, 3]`.
```
SELECT array_distinct(array(1, 2, 2, 3, 3, 3))
[1,2,3]
```
# 数组\$1EXCEPT 函数
ARRAY\$1EXCEPT 函数将两个数组作为参数，并返回一个新数组，该数组仅包含第一个数组中存在的元素，而不包含第二个数组中存在的元素。
当您需要查找一个数组与另一个数组相比具有唯一性的元素时，ARRAY\$1EXCEPT 非常有用。在需要对数组执行类似集合的操作（例如找出两组数据之间的差异）的场景中，这可能很有用。
## 语法
```
array_except(array1, array2)
```
## Arguments
*数组 1*
具有可比元素的任何类型的数组。
*数组 2*
与 arr *ay1 的元素共享最不常见类型的元素数*组。
## 返回类型
ARRAY\$1EXCEPT 函数向 ar *ray* 1 返回一个类型匹配且没有重复项的数组。
## 示例
在此示例中，第一个数组`[1, 2, 3]`包含元素 1、2 和 3。第二个数组`[2, 3, 4]`包含元素 2、3 和 4。该`array_except`函数从第一个数组中删除元素 2 和 3，因为它们也存在于第二个数组中。生成的输出是数组`[1]`。
```
SELECT array_except(array(1, 2, 3), array(2, 3, 4))
[1]
```
在此示例中，第一个数组`[1, 2, 3]`包含元素 1、2 和 3。第二个数组`[1, 3, 5]`包含元素 1、3 和 5。该`array_except`函数从第一个数组中删除元素 1 和 3，因为它们也存在于第二个数组中。生成的输出是数组`[2]`。
```
SELECT array_except(array(1, 2, 3), array(1, 3, 5));
[2]
```
# ARRAY\$1INTERSECT 函数
ARRAY\$1INTERSECT 函数将两个数组作为参数，并返回一个包含两个输入数组中存在的元素的新数组。当您需要查找两个数组之间的公共元素时，此函数很有用。在需要对数组执行类似集合的操作（例如查找两组数据之间的交集）的场景中，这可能很有用。
## 语法
```
array_intersect(array1, array2)
```
## Arguments
*数组 1*
具有可比元素的任何类型的数组。
*数组 2*
与 array1 的元素共享最不常见类型的元素数组。
## 返回类型
ARRAY\$1INTERSECT 函数向 array1 返回一个类型相匹配的数组，其中没有重复项，数组 1 和 array2 中都包含元素。
## 示例
在此示例中，第一个数组`[1, 2, 3]`包含元素 1、2 和 3。第二个数组`[1, 3, 5]`包含元素 1、3 和 5。ARRAY\$1INTERSECT 函数标识两个数组之间的公共元素，即 1 和 3。生成的输出数组为`[1, 3]`。
```
SELECT array_intersect(array(1, 2, 3), array(1, 3, 5));
[1,3]
```
# ARRAY\$1JOIN 函数
ARRAY\$1JOIN 函数有两个参数：第一个参数是要连接的输入数组。第二个参数是用于连接数组元素的分隔符字符串。当您需要将字符串数组（或任何其他数据类型）转换为单个串联字符串时，此函数很有用。这在您想要将值数组呈现为单个格式化字符串的场景中很有用，例如用于显示目的或用于进一步处理。
## 语法
```
array_join(array, delimiter[, nullReplacement])
```
## Arguments
*array*
任何数组类型，但其元素都被解释为字符串。
*分隔符*
用于分隔连接的数组元素的 STRING。
*NULL替换*
用于在结果中表示空值的字符串。
## 返回类型
ARRAY\$1JOIN 函数返回一个字符串，其中数组的元素用分隔符分隔，并用空元素替换。`nullReplacement`如果省略，`nullReplacement`则`null`元素将被过滤掉。如果有任何参数`NULL`，则结果为`NULL`。
## 示例
在此示例中，ARRAY\$1JOIN 函数获取数组`['hello', 'world']`并使用分隔符`' '`（空格字符）连接元素。生成的输出是字符串`'hello world'`。
```
SELECT array_join(array('hello', 'world'), ' ');
hello world
```
在此示例中，ARRAY\$1JOIN 函数获取数组`['hello', null, 'world']`并使用分隔符`' '`（空格字符）连接元素。该`null`值将替换为提供的替换字符串`','`（逗号）。生成的输出是字符串`'hello , world'`。
```
SELECT array_join(array('hello', null ,'world'), ' ', ',');
hello , world
```
# ARRAY\$1REMOVE 函数
ARRAY\$1REMOVE 函数有两个参数：第一个参数是将从中删除元素的输入数组。第二个参数是将从数组中删除的值。当你需要从数组中删除特定元素时，这个函数很有用。在需要对值数组执行数据清理或预处理的情况下，这可能很有用。
## 语法
```
array_remove(array, element)
```
## Arguments
*array*
一个数组。
*元素*
一种与数组元素共享最不常见类型的表达式。
## 返回类型
ARRAY\$1REMOVE 函数返回与数组类型匹配的结果类型。如果要删除的元素是`NULL`，则结果为`NULL`。
## 示例
在此示例中，ARRAY\$1REMOVE 函数获取数组`[1, 2, 3, null, 3]`并删除所有出现的值 3。生成的输出是数组`[1, 2, null]`。
```
SELECT array_remove(array(1, 2, 3, null, 3), 3);
[1,2,null]
```
# ARRAY\$1UNION 函数
ARRAY\$1UNION 函数将两个数组作为参数，并返回一个包含两个输入数组中唯一元素的新数组。当你需要合并两个数组并消除任何重复的元素时，这个函数很有用。在需要对数组执行类似集合的操作（例如在两组数据之间找到并集）的场景中，这可能会很有用。
## 语法
```
array_union(array1, array2)
```
## Arguments
*数组 1*
一个数组。
*数组 2*
与 *array* 1 相同类型的数组。
## 返回类型
ARRAY\$1UNION 函数返回一个与数组类型相同的数组。
## 示例
在此示例中，第一个数组`[1, 2, 3]`包含元素 1、2 和 3。第二个数组`[1, 3, 5]`包含元素 1、3 和 5。ARRAY\$1UNION 函数将两个数组中的唯一元素组合在一起，生成输出数组。`[1, 2, 3, 5]`T
```
SELECT array_union(array(1, 2, 3), array(1, 3, 5));
[1,2,3,5]
```
# “爆炸” 功能
EXPLODE 函数用于将包含数组或映射列的单行转换为多行，其中每行对应于数组或映射中的单个元素。
## 语法
```
explode(expr)
```
## Arguments
*expr*
数组表达式或地图表达式。
## 返回类型
EXPLODE 函数返回一组行，其中每行代表输入数组或映射中的单个元素。
输出行的数据类型取决于输入数组或映射中元素的数据类型。
## 示例
以下示例采用单行数组 [10, 20] 并将其转换为两个单独的行，每行包含一个数组元素（10 和 20）。
```
SELECT explode(array(10, 20));
```
在第一个示例中，输入数组直接作为参数传递给`explode()`。在此示例中，使用`=>`语法指定输入数组，其中明确提供了列名 (`collection`)。
```
SELECT explode(array(10, 20));
```
这两种方法都是有效的，并且可以获得相同的结果，但是当你需要从更大的数据集中分解一列，而不仅仅是简单的数组文字时，第二种语法可能更有用。
# Flatten 功能
FLATTEN 函数用于将嵌套数组结构 “扁平” 为单个平面数组。
## 语法
```
flatten(arrayOfArrays)
```
## Arguments
*arrayOfArrays*
数组数组。
## 返回类型
FLATTEN 函数返回一个数组。
## 示例
在此示例中，输入是一个包含两个内部数组的嵌套数组，输出是一个包含内部数组所有元素的单个平面数组。FLATTEN 函数采用嵌套数组`[[1, 2], [3, 4]]`并将所有元素组合成一个数组`[1, 2, 3, 4]`。
```
SELECT flatten(array(array(1, 2), array(3, 4)));
[1,2,3,4]
```