List 函数
list[index]
| 描述 | 使用（从 1 开始的）index 提取单个列表元素。 |
| 示例 | [4, 5, 6][3] |
| 结果 | 6 |
| 别名 | list_extract |
list[begin[:end][:step]]
| 描述 | 使用切片约定提取子列表。支持负值。 |
| 示例 | [4, 5, 6][3] |
| 结果 | 6 |
| 别名 | list_slice |
arg1 || arg2
| 描述 | 连接两个字符串、列表或 blob。任一输入为 NULL 时结果为 NULL。另见 concat(arg1, arg2, ...) 和 list_concat(list1, list2, ...)。 |
| 示例 1 | 'Duck' || 'DB' |
| 结果 | Goose |
| 示例 2 | [1, 2, 3] || [4, 5, 6] |
| 结果 | [1, 2, 3, 4, 5, 6] |
| 示例 3 | '\xAA'::BLOB || '\xBB'::BLOB |
| 结果 | \xAA\xBB |
array_extract(list, index)
| 描述 | 从 list 中提取第 index 个（从 1 开始）值。 |
| 示例 | array_extract([4, 5, 6], 3) |
| 结果 | 6 |
array_pop_back(list)
| 描述 | 返回去掉最后一个元素后的 list。 |
| 示例 | array_pop_back([4, 5, 6]) |
| 结果 | [4, 5] |
array_pop_front(list)
| 描述 | 返回去掉第一个元素后的 list。 |
| 示例 | array_pop_front([4, 5, 6]) |
| 结果 | [5, 6] |
array_push_front(list, element)
| 描述 | 将 element 前置到 list。 |
| 示例 | array_push_front([4, 5, 6], 3) |
| 结果 | [3, 4, 5, 6] |
array_to_string(list, delimiter)
| 描述 | 使用可选的 delimiter 连接 list/array 元素。 |
| 示例 1 | array_to_string([1, 2, 3], '-') |
| 结果 | 1-2-3 |
| 示例 2 | array_to_string(['aa', 'bb', 'cc'], '') |
| 结果 | aabbcc |
array_to_string_comma_default(array)
| 描述 | 使用逗号分隔符合并 list/array 元素。 |
| 示例 | array_to_string_comma_default(['Banana', 'Apple', 'Melon']) |
| 结果 | Banana,Apple,Melon |
concat(value, ...)
| 描述 | 连接多个字符串或列表。会跳过 NULL 输入。 另见运算符 ||。 |
| 示例 1 | concat('Hello', ' ', 'World') |
| 结果 | Hello World |
| 示例 2 | concat([1, 2, 3], NULL, [4, 5, 6]) |
| 结果 | [1, 2, 3, 4, 5, 6] |
contains(list, element)
| 描述 | 如果 list 包含 element，则返回 true。 |
| 示例 | contains([1, 2, NULL], 1) |
| 结果 | true |
flatten(nested_list)
| 描述 | Flattens a nested list by one level. |
| 示例 | flatten([[1, 2, 3], [4, 5]]) |
| 结果 | [1, 2, 3, 4, 5] |
generate_series(start[, stop][, step])
| 描述 | 创建 start 到 stop 之间的值列表，stop 参数为包含端。 |
| 示例 | generate_series(2, 5, 3) |
| 结果 | [2, 5] |
length(list)
| 描述 | 返回 list 的长度。 |
| 示例 | length([1,2,3]) |
| 结果 | 3 |
| 别名 | char_length, character_length, len |
list_aggregate(list, function_name, ...)
| 描述 | 在 list 的元素上执行聚合函数 function_name。更多信息请参见 List 聚合 一节。 |
| 示例 | list_aggregate([1, 2, NULL], 'min') |
| 结果 | 1 |
| 别名 | aggregate, array_aggr, array_aggregate, list_aggr |
list_any_value(list)
| 描述 | 将聚合函数 any_value 应用于 list。 |
| 示例 | list_any_value([3,3,9]) |
| 结果 | 3 |
list_append(list, element)
| 描述 | 将 element 追加到 list。 |
| 示例 | list_append([2, 3], 4) |
| 结果 | [2, 3, 4] |
| 别名 | array_append, array_push_back |
list_approx_count_distinct(list)
| 描述 | 将聚合函数 approx_count_distinct 应用于 list。 |
| 示例 | list_approx_count_distinct([3,3,9]) |
| 结果 | 2 |
list_avg(list)
| 描述 | 将聚合函数 avg 应用于 list。 |
| 示例 | list_avg([3,3,9]) |
| 结果 | 5.0 |
list_bit_and(list)
| 描述 | 将聚合函数 bit_and 应用于 list。 |
| 示例 | list_bit_and([3,3,9]) |
| 结果 | 1 |
list_bit_or(list)
| 描述 | 将聚合函数 bit_or 应用于 list。 |
| 示例 | list_bit_or([3,3,9]) |
| 结果 | 11 |
list_bit_xor(list)
| 描述 | 将聚合函数 bit_xor 应用于 list。 |
| 示例 | list_bit_xor([3,3,9]) |
| 结果 | 9 |
list_bool_and(list)
| 描述 | 将聚合函数 bool_and 应用于 list。 |
| 示例 | list_bool_and([true, false]) |
| 结果 | false |
list_bool_or(list)
| 描述 | 将聚合函数 bool_or 应用于 list。 |
| 示例 | list_bool_or([true, false]) |
| 结果 | true |
list_concat(list_1, ..., list_n)
| 描述 | 连接多个列表。会跳过 NULL 输入。 另见运算符 ||。 |
| 示例 | list_concat([2, 3], [4, 5, 6], [7]) |
| 结果 | [2, 3, 4, 5, 6, 7] |
| 别名 | list_cat, array_concat, array_cat |
list_contains(list, element)
| 描述 | 如果列表包含该元素，则返回 true。 |
| 示例 | list_contains([1, 2, NULL], 1) |
| 结果 | true |
| 别名 | array_contains, array_has, list_has |
list_cosine_distance(list1, list2)
| 描述 | 计算两个等长列表之间的余弦距离。 |
| 示例 | list_cosine_distance([1, 2, 3], [1, 2, 3]) |
| 结果 | 0.0 |
| 别名 | <=> |
list_cosine_similarity(list1, list2)
| 描述 | 计算两个等长列表之间的余弦相似度。 |
| 示例 | list_cosine_similarity([1, 2, 3], [1, 2, 3]) |
| 结果 | 1.0 |
list_count(list)
| 描述 | 将聚合函数 count 应用于 list。 |
| 示例 | list_count([3,3,9]) |
| 结果 | 3 |
list_distance(list1, list2)
| 描述 | 计算由两个等长输入列表给出的两点坐标之间的欧几里得距离。 |
| 示例 | list_distance([1, 2, 3], [1, 2, 5]) |
| 结果 | 2.0 |
| 别名 | <-> |
list_distinct(list)
| 描述 | 移除列表中的所有重复值和 NULL 值，不保留原始顺序。 |
| 示例 | list_distinct([1, 1, NULL, -3, 1, 5]) |
| 结果 | [5, -3, 1] |
| 别名 | array_distinct |
list_entropy(list)
| 描述 | 将聚合函数 entropy 应用于 list。 |
| 示例 | list_entropy([3,3,9]) |
| 结果 | 0.9182958340544893 |
list_extract(list, index)
| 描述 | 从列表中提取第 index 个（从 1 开始）值。 |
| 示例 | list_extract([4, 5, 6], 3) |
| 结果 | 6 |
| 别名 | list_element |
list_filter(list, lambda(x))
| 描述 | 从输入 list 中筛选出使 lambda 函数返回 true 的元素并构造新列表。 Goose 必须能够将 lambda 函数的返回类型转换为 BOOL。 list_filter 的返回类型与输入列表相同。 参见 list_filter 示例。 |
| 示例 | list_filter([3, 4, 5], lambda x : x > 4) |
| 结果 | [5] |
| 别名 | array_filter, filter |
list_first(list)
| 描述 | 将聚合函数 first 应用于 list。 |
| 示例 | list_first([3,3,9]) |
| 结果 | 3 |
list_grade_up(list[, col1][, col2])
| 描述 | 行为类似 list_sort，但返回的是对应原列表位置的索引而非实际值。 |
| 示例 | list_grade_up([3, 6, 1, 2]) |
| 结果 | [3, 4, 1, 2] |
| 别名 | array_grade_up, grade_up |
list_has_all(list1, list2)
| 描述 | 如果 list2 的所有元素都在 list1 中，则返回 true。忽略 NULL。 |
| 示例 | list_has_all([1, 2, 3], [2, 3]) |
| 结果 | true |
| 别名 | <@, @>, array_has_all |
list_has_any(list1, list2)
| 描述 | 如果两个列表有任意共同元素，则返回 true。忽略 NULL。 |
| 示例 | list_has_any([1, 2, 3], [2, 3, 4]) |
| 结果 | true |
| 别名 | &&, array_has_any |
list_histogram(list)
| 描述 | 将聚合函数 histogram 应用于 list。 |
| 示例 | list_histogram([3,3,9]) |
| 结果 | {3=2, 9=1} |
list_inner_product(list1, list2)
| 描述 | 计算两个等长列表之间的内积。 |
| 示例 | list_inner_product([1, 2, 3], [1, 2, 3]) |
| 结果 | 14.0 |
| 别名 | list_dot_product |
list_intersect(list1, list2)
| 描述 | 返回同时存在于 list1 和 list2 中的所有元素列表，不包含重复项。 |
| 示例 | list_intersect([1, 2, 3], [2, 3, 4]) |
| 结果 | [3, 2] |
| 别名 | array_intersect |
list_kurtosis(list)
| 描述 | 将聚合函数 kurtosis 应用于 list。 |
| 示例 | list_kurtosis([3,3,9]) |
| 结果 | NULL |
list_kurtosis_pop(list)
| 描述 | 将聚合函数 kurtosis_pop 应用于 list。 |
| 示例 | list_kurtosis_pop([3,3,9]) |
| 结果 | -1.4999999999999978 |
list_last(list)
| 描述 | 将聚合函数 last 应用于 list。 |
| 示例 | list_last([3,3,9]) |
| 结果 | 9 |
list_mad(list)
| 描述 | 将聚合函数 mad 应用于 list。 |
| 示例 | list_mad([3,3,9]) |
| 结果 | 0.0 |
list_max(list)
| 描述 | 将聚合函数 max 应用于 list。 |
| 示例 | list_max([3,3,9]) |
| 结果 | 9 |
list_median(list)
| 描述 | 将聚合函数 median 应用于 list。 |
| 示例 | list_median([3,3,9]) |
| 结果 | 3.0 |
list_min(list)
| 描述 | 将聚合函数 min 应用于 list。 |
| 示例 | list_min([3,3,9]) |
| 结果 | 3 |
list_mode(list)
| 描述 | 将聚合函数 mode 应用于 list。 |
| 示例 | list_mode([3,3,9]) |
| 结果 | 3 |
list_negative_inner_product(list1, list2)
| 描述 | 计算两个等长列表之间的负内积。 |
| 示例 | list_negative_inner_product([1, 2, 3], [1, 2, 3]) |
| 结果 | -14.0 |
| 别名 | list_negative_dot_product |
list_position(list, element)
| 描述 | 如果 list 包含 element，则返回其索引；若未找到，则返回 NULL。 |
| 示例 | list_position([1, 2, NULL], 2) |
| 结果 | 2 |
| 别名 | array_indexof, array_position, list_indexof |
list_prepend(element, list)
| 描述 | 将 element 前置到 list。 |
| 示例 | list_prepend(3, [4, 5, 6]) |
| 结果 | [3, 4, 5, 6] |
| 别名 | array_prepend |
list_product(list)
| 描述 | 将聚合函数 product 应用于 list。 |
| 示例 | list_product([3,3,9]) |
| 结果 | 81.0 |
list_reduce(list, lambda(x,y)[, initial_value])
| 描述 | 通过在累积结果与下一个列表元素上执行 lambda 函数，将输入 list 的全部元素归约为单个标量值。 lambda 函数有一个可选的 initial_value 参数。 参见 list_reduce 示例。 |
| 示例 | list_reduce([1, 2, 3], lambda x, y : x + y) |
| 结果 | 6 |
| 别名 | array_reduce, reduce |
list_resize(list, size[[, value]])
| 描述 | 将 list 调整为包含 size 个元素。新元素使用 value 初始化；若未设置 value 则为 NULL。 |
| 示例 | list_resize([1, 2, 3], 5, 0) |
| 结果 | [1, 2, 3, 0, 0] |
| 别名 | array_resize |
list_reverse(list)
| 描述 | 反转 list。 |
| 示例 | list_reverse([3, 6, 1, 2]) |
| 结果 | [2, 1, 6, 3] |
| 别名 | array_reverse |
list_reverse_sort(list[, col1])
| 描述 | 按逆序对列表元素排序。有关排序顺序和 NULL 值的更多信息，请参见列表排序。 |
| 示例 | list_reverse_sort([3, 6, 1, 2]) |
| 结果 | [6, 3, 2, 1] |
| 别名 | array_reverse_sort |
list_select(value_list, index_list)
| 描述 | 根据 index_list 选中的元素返回一个列表。 |
| 示例 | list_select([10, 20, 30, 40], [1, 4]) |
| 结果 | [10, 40] |
| 别名 | array_select |
list_sem(list)
| 描述 | 将聚合函数 sem 应用于 list。 |
| 示例 | list_sem([3,3,9]) |
| 结果 | 1.6329931618554523 |
list_skewness(list)
| 描述 | 将聚合函数 skewness 应用于 list。 |
| 示例 | list_skewness([3,3,9]) |
| 结果 | 1.7320508075688796 |
list_slice(list, begin, end)
| 描述 | 使用切片约定提取子列表或子字符串。支持负值。 |
| 示例 | list_slice([4, 5, 6], 2, 3) |
| 结果 | [5, 6] |
| 别名 | array_slice |
list_slice(list, begin, end, step)
| 描述 | 带步长参数的 list_slice。 |
| 示例 | list_slice([4, 5, 6], 1, 3, 2) |
| 结果 | [4, 6] |
| 别名 | array_slice |
list_sort(list[, col1][, col2])
| 描述 | 对列表元素进行排序。有关排序顺序和 NULL 值的更多信息，请参见列表排序。 |
| 示例 | list_sort([3, 6, 1, 2]) |
| 结果 | [1, 2, 3, 6] |
| 别名 | array_sort |
list_stddev_pop(list)
| 描述 | 将聚合函数 stddev_pop 应用于 list。 |
| 示例 | list_stddev_pop([3,3,9]) |
| 结果 | 2.8284271247461903 |
list_stddev_samp(list)
| 描述 | 将聚合函数 stddev_samp 应用于 list。 |
| 示例 | list_stddev_samp([3,3,9]) |
| 结果 | 3.4641016151377544 |
list_string_agg(list)
| 描述 | 将聚合函数 string_agg 应用于 list。 |
| 示例 | list_string_agg([3,3,9]) |
| 结果 | 3,3,9 |
list_sum(list)
| 描述 | 将聚合函数 sum 应用于 list。 |
| 示例 | list_sum([3,3,9]) |
| 结果 | 15 |
list_transform(list, lambda(x))
| 描述 | 返回对输入 list 的每个元素应用 lambda 函数后的结果列表。 返回类型由 lambda 函数的返回类型决定。 参见 list_transform 示例。 |
| 示例 | list_transform([1, 2, 3], lambda x : x + 1) |
| 结果 | [2, 3, 4] |
| 别名 | apply, array_apply, array_transform, list_apply |
list_unique(list)
| 描述 | 统计 list 中唯一元素的数量。 |
| 示例 | list_unique([1, 1, NULL, -3, 1, 5]) |
| 结果 | 3 |
| 别名 | array_unique |
list_value(arg, ...)
| 描述 | 创建包含参数值的 LIST。 |
| 示例 | list_value(4, 5, 6) |
| 结果 | [4, 5, 6] |
| 别名 | list_pack |
list_var_pop(list)
| 描述 | 将聚合函数 var_pop 应用于 list。 |
| 示例 | list_var_pop([3,3,9]) |
| 结果 | 8.0 |
list_var_samp(list)
| 描述 | 将聚合函数 var_samp 应用于 list。 |
| 示例 | list_var_samp([3,3,9]) |
| 结果 | 12.0 |
list_where(value_list, mask_list)
| 描述 | 将 mask_list 中的 BOOLEAN 作为掩码应用到 value_list，并返回结果列表。 |
| 示例 | list_where([10, 20, 30, 40], [true, false, false, true]) |
| 结果 | [10, 40] |
| 别名 | array_where |
list_zip(list_1, ..., list_n[, truncate])
| 描述 | 将 n 个 LIST 压缩为一个新的 LIST，其长度等于最长列表的长度。其元素是由各列表 list_1 … list_n 对应元素组成的结构体；缺失元素以 NULL 填充。若设置 truncate，则所有列表都会截断到最短长度。 |
| 示例 1 | list_zip([1, 2], [3, 4], [5, 6]) |
| 结果 | [(1, 3, 5), (2, 4, 6)] |
| 示例 2 | list_zip([1, 2], [3, 4], [5, 6, 7]) |
| 结果 | [(1, 3, 5), (2, 4, 6), (NULL, NULL, 7)] |
| 示例 3 | list_zip([1, 2], [3, 4], [5, 6, 7], true) |
| 结果 | [(1, 3, 5), (2, 4, 6)] |
| 别名 | array_zip |
range(start[, stop][, step])
| 描述 | 创建 start 到 stop 之间的值列表，stop 参数为不包含端。 |
| 示例 | range(2, 5, 3) |
| 结果 | [2] |
repeat(list, count)
| 描述 | 将 list 重复 count 次。 |
| 示例 | repeat([1, 2, 3], 5) |
| 结果 | [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3] |
unnest(list)
| 描述 | 将列表展开一层。注意这是一个会改变结果基数的特殊函数。详见 unnest 页面。 |
| 示例 | unnest([1, 2, 3]) |
| 结果 | Multiple rows: '1', '2', '3' |
unpivot_list(arg, ...)
| 描述 | 与 list_value 相同，但会作为 unpivot 的一部分生成，以提供更好的错误信息。 |
| 示例 | unpivot_list(4, 5, 6) |
| 结果 | [4, 5, 6] |
List 运算符
列表支持以下运算符：
| 运算符 | 描述 | 示例 | 结果 |
|---|---|---|---|
&& | Alias for list_has_any. | [1, 2, 3, 4, 5] && [2, 5, 5, 6] | true |
@> | Alias for list_has_all, where the list on the right of the operator is the sublist. | [1, 2, 3, 4] @> [3, 4, 3] | true |
<@ | Alias for list_has_all, where the list on the left of the operator is the sublist. | [1, 4] <@ [1, 2, 3, 4] | true |
| ` | ` | Similar to list_concat, except any NULL input results in NULL. | |
<=> | Alias for list_cosine_distance. | [1, 2, 3] <=> [1, 2, 5] | 0.007416606 |
<-> | Alias for list_distance. | [1, 2, 3] <-> [1, 2, 5] | 2.0 |
List 推导式
Python-style list comprehension can be used to compute expressions over elements in a list. 例如：
SELECT [lower(x) FOR x IN strings] AS strings
FROM (VALUES (['Hello', '', 'World'])) t(strings);
| strings |
|---|
| [hello, , world] |
SELECT [upper(x) FOR x IN strings IF len(x) > 0] AS strings
FROM (VALUES (['Hello', '', 'World'])) t(strings);
| strings |
|---|
| [HELLO, WORLD] |
列表推导式也可以通过添加第二个变量来使用元素位置。
在下面示例中，我们使用 x, i，其中 x 是值、i 是位置：
SELECT [4, 5, 6] AS l, [x FOR x, i IN l IF i != 2] AS filtered;
| l | filtered |
|---|---|
| [4, 5, 6] | [4, 6] |
底层上，[f(x) FOR x IN l IF g(x)] 会被转换为：
l.list_apply(lambda x, i: {'filter': g(x, i), 'result': f(x, i)})
.list_filter(lambda x: x.filter)
.list_apply(lambda x: x.result)
Range 函数
Goose 提供两个 range 函数，range(start, stop, step) 与 generate_series(start, stop, step)，以及它们在 stop 和 step 上使用默认参数的变体。这两个函数在 stop 参数上的行为不同，详见下文。
range
range 函数会创建 start 与 stop 之间范围内的值列表。
start 参数是包含端，stop 参数是不包含端。
start 的默认值是 0，step 的默认值是 1。
根据参数数量，range 有以下变体。
range(stop)
SELECT range(5);
[0, 1, 2, 3, 4]
range(start, stop)
SELECT range(2, 5);
[2, 3, 4]
range(start, stop, step)
SELECT range(2, 5, 3);
[2]
generate_series
generate_series 函数会创建 start 与 stop 之间范围内的值列表。
start 和 stop 参数均为包含端。
start 的默认值是 0，step 的默认值是 1。
根据参数数量，generate_series 有以下变体。
generate_series(stop)
SELECT generate_series(5);
[0, 1, 2, 3, 4, 5]
generate_series(start, stop)
SELECT generate_series(2, 5);
[2, 3, 4, 5]
generate_series(start, stop, step)
SELECT generate_series(2, 5, 3);
[2, 5]
generate_subscripts(arr, dim)
generate_subscripts(arr, dim) 函数会沿数组 arr 的第 dim 个维度生成索引。
SELECT generate_subscripts([4, 5, 6], 1) AS i;
| i |
|---|
| 1 |
| 2 |
| 3 |
日期范围
也支持 TIMESTAMP 和 TIMESTAMP WITH TIME ZONE 值的日期范围。
注意，对于这些类型，必须显式指定 stop 和 step 参数（不提供默认值）。
range for 日期范围
SELECT *
FROM range(DATE '1992-01-01', DATE '1992-03-01', INTERVAL '1' MONTH);
| range |
|---|
| 1992-01-01 00:00:00 |
| 1992-02-01 00:00:00 |
generate_series for 日期范围
SELECT *
FROM generate_series(DATE '1992-01-01', DATE '1992-03-01', INTERVAL '1' MONTH);
| generate_series |
|---|
| 1992-01-01 00:00:00 |
| 1992-02-01 00:00:00 |
| 1992-03-01 00:00:00 |
切片
函数 list_slice 可用于从列表中提取子列表。支持以下变体：
list_slice(list, begin, end)list_slice(list, begin, end, step)array_slice(list, begin, end)array_slice(list, begin, end, step)list[begin:end]list[begin:end:step]
参数说明如下：
list- 要进行切片的列表
begin- 切片中要包含的第一个元素索引
- 当
begin < 0时，索引从列表末尾开始计数 - 当
begin < 0且-begin > length时，begin会被钳制到列表开头 - 当
begin > length时，结果为空列表 - 方括号记法： 省略
begin时，默认从列表开头开始
end- 切片中要包含的最后一个元素索引
- 当
end < 0时，索引从列表末尾开始计数 - 当
end > length时，end会被钳制为length - 当
end < begin时，结果为空列表 - 方括号记法： 省略
end时，默认到列表末尾；若在省略end的同时提供了step，则必须用-替代end
step(optional)- 切片中元素之间的步长
- 当
step < 0时，切片反向，并交换begin与end - 必须为非零值
示例:
SELECT list_slice([1, 2, 3, 4, 5], 2, 4);
[2, 3, 4]
SELECT ([1, 2, 3, 4, 5])[2:4:2];
[2, 4]
SELECT([1, 2, 3, 4, 5])[4:2:-2];
[4, 2]
SELECT ([1, 2, 3, 4, 5])[:];
[1, 2, 3, 4, 5]
SELECT ([1, 2, 3, 4, 5])[:-:2];
[1, 3, 5]
SELECT ([1, 2, 3, 4, 5])[:-:-2];
[5, 3, 1]
List 聚合
函数 list_aggregate 允许在列表元素上执行任意现有聚合函数。其第一个参数是列表（列），第二个参数是聚合函数名，例如 min、histogram 或 sum。
list_aggregate 在聚合函数名之后还可接收额外参数。这些额外参数会直接传递给对应聚合函数。
对顺序敏感的聚合函数会按列表顺序执行。list_aggregate 不支持 ORDER BY、DISTINCT 和 FILTER 子句。
可通过 list_sort、list_grade_up、list_select、list_distinct 和 list_filter 进行等效模拟。
SELECT list_aggregate([1, 2, -4, NULL], 'min');
-4
SELECT list_aggregate([2, 4, 8, 42], 'sum');
56
SELECT list_aggregate([[1, 2], [NULL], [2, 10, 3]], 'last');
[2, 10, 3]
SELECT list_aggregate([2, 4, 8, 42], 'string_agg', '|');
2|4|8|42
list_* Rewrite Functions
以下是现有重写函数列表。重写函数只接收列表（列）作为参数，从而简化了 list 聚合函数的使用。 list_avg, list_var_samp, list_var_pop, list_stddev_pop, list_stddev_samp, list_sem, list_approx_count_distinct, list_bit_xor, list_bit_or, list_bit_and, list_bool_and, list_bool_or, list_count, list_entropy, list_last, list_first, list_kurtosis, list_kurtosis_pop, list_min, list_max, list_product, list_skewness, list_sum, list_string_agg, list_mode, list_median, list_mad and list_histogram.
SELECT list_min([1, 2, -4, NULL]);
-4
SELECT list_sum([2, 4, 8, 42]);
56
SELECT list_last([[1, 2], [NULL], [2, 10, 3]]);
[2, 10, 3]
array_to_string
使用可选分隔符连接 list/array 元素。
SELECT array_to_string([1, 2, 3], '-') AS str;
1-2-3
这等价于以下 SQL：
SELECT list_aggr([1, 2, 3], 'string_agg', '-') AS str;
1-2-3
列表排序
函数 list_sort 可按升序或降序对列表元素排序。
此外，还可以指定 NULL 值应放在列表开头还是结尾。
其排序行为与 Goose 的 ORDER BY 子句一致。
因此，（嵌套）值在 list_sort 与 ORDER BY 中的比较方式相同。
默认情况下，如果不提供修饰符，Goose 使用 ASC NULLS LAST 排序。
即值按升序排序，NULL 值放在最后。
默认排序顺序可通过 PRAGMA 语句修改。
list_sort 允许用户选择使用默认排序顺序或自定义顺序。
list_sort 最多接受两个额外可选参数。
第二个参数指定排序方向，可为 ASC 或 DESC。
第三个参数指定 NULL 顺序，可为 NULLS FIRST 或 NULLS LAST。
该查询使用默认排序顺序和默认 NULL 顺序。
SELECT list_sort([1, 3, NULL, 5, NULL, -5]);
[-5, 1, 3, 5, NULL, NULL]
该查询指定了排序顺序。
NULL 顺序使用可配置的默认值。
SELECT list_sort([1, 3, NULL, 2], 'ASC');
[1, 2, 3, NULL]
该查询同时指定排序顺序和 NULL 顺序。
SELECT list_sort([1, 3, NULL, 2], 'DESC', 'NULLS FIRST');
[NULL, 3, 2, 1]
list_reverse_sort 有一个可选的第二参数用于指定 NULL 排序顺序。
可选值为 NULLS FIRST 或 NULLS LAST。
该查询使用默认 NULL 排序顺序。
SELECT list_sort([1, 3, NULL, 5, NULL, -5]);
[-5, 1, 3, 5, NULL, NULL]
该查询指定了 NULL 排序顺序。
SELECT list_reverse_sort([1, 3, NULL, 2], 'NULLS LAST');
[3, 2, 1, NULL]
展平
flatten 是一个标量函数，可通过拼接各子列表将列表的列表转换为单个列表。
注意它一次只展平一层，而不是所有嵌套层级。
将列表的列表转换为单个列表：
SELECT
flatten([
[1, 2],
[3, 4]
]);
[1, 2, 3, 4]
如果列表存在多层嵌套，只会把第一层子列表拼接为单个列表：
SELECT
flatten([
[
[1, 2],
[3, 4],
],
[
[5, 6],
[7, 8],
]
]);
[[1, 2], [3, 4], [5, 6], [7, 8]]
通常，flatten 函数的输入应是列表的列表（而不是单层列表）。
不过，flatten 在处理空列表和 NULL 值时有特定行为。
如果输入列表为空，则返回空列表：
SELECT flatten([]);
[]
如果传给 flatten 的整体输入是 NULL，则返回 NULL：
SELECT flatten(NULL);
NULL
如果展平的列表唯一元素是 NULL，则返回空列表：
SELECT flatten([NULL]);
[]
如果列表的列表中的子列表仅包含 NULL，则不修改该子列表：
-- (Note the extra set of parentheses vs. the prior example)
SELECT flatten([[NULL]]);
[NULL]
即使每个子列表仅包含 NULL，也会将它们拼接在一起。注意展平过程中不会去重。去重请参见 list_distinct 函数：
SELECT flatten([[NULL], [NULL]]);
[NULL, NULL]
Lambda 函数
Goose 支持 lambda parameter1, parameter2, ...: expression 形式的 lambda 函数。
详情请参见 lambda 函数页面。
相关函数
- The aggregate functions
listandhistogramproduce lists and lists of structs. unnest函数用于将列表展开一层。