list[index]

list[begin:end]

list[begin:end:step]

array_pop_back(list)

array_pop_front(list)

flatten(list_of_lists)

len(list)

list_aggregate(list, name)

list_any_value(list)

list_append(list, element)

list_concat(list1, ..., listn)

list_contains(list, element)

list_cosine_similarity(list1, list2)

list_cosine_distance(list1, list2)

list_distance(list1, list2)

list_distinct(list)

list_dot_product(list1, list2)

list_negative_dot_product(list1, list2)

list_extract(list, index)

list_filter(list, lambda)

list_grade_up(list)

list_has_all(list, sub-list)

list_has_any(list1, list2)

list_intersect(list1, list2)

list_position(list, element)

list_prepend(element, list)

list_reduce(list, lambda)

list_resize(list, size[, value])

list_reverse_sort(list)

list_reverse(list)

list_select(value_list, index_list)

list_slice(list, begin, end, step)

list_slice(list, begin, end)

list_sort(list)

list_transform(list, lambda)

list_unique(list)

list_value(any, ...)

list_where(value_list, mask_list)

list_zip(list1, list2, ...)

repeat(list, count)

unnest(list)

列表运算符

列表支持以下运算符

列表推导式

Python 风格的列表推导式可用于计算列表中元素的表达式。例如

SELECT [lower(x) FOR x IN strings] AS strings
FROM (VALUES (['Hello', '', 'World'])) t(strings);

SELECT [upper(x) FOR x IN strings IF len(x) > 0] AS strings
FROM (VALUES (['Hello', '', 'World'])) t(strings);

列表推导式还可以通过添加第二个变量来使用列表元素的位置。在以下示例中，我们使用 x, i，其中 x 是值，i 是位置

SELECT [4, 5, 6] AS l, [x FOR x, i IN l IF i != 2] AS filtered;

在底层，[f(x) FOR x IN y IF g(x)] 被转换为 list_transform(list_filter(y, x -> f(x)), x -> f(x))。

范围函数

DuckDB 提供了两个范围函数，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;

日期范围

TIMESTAMP 和 TIMESTAMP WITH TIME ZONE 值也支持日期范围。请注意，对于这些类型，stop 和 step 参数必须明确指定（不提供默认值）。

日期范围的 range 函数

SELECT *
FROM range(DATE '1992-01-01', DATE '1992-03-01', INTERVAL '1' MONTH);

日期范围的 generate_series 函数

SELECT *
FROM generate_series(DATE '1992-01-01', DATE '1992-03-01', INTERVAL '1' MONTH);

切片

函数 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 (可选)
  • 切片中元素之间的步长
  • 当 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_aggregate 允许对列表元素执行任意现有聚合函数。它的第一个参数是列表（列），第二个参数是聚合函数名称，例如 min、histogram 或 sum。

list_aggregate 在聚合函数名称之后接受额外的参数。这些额外参数直接传递给聚合函数，聚合函数作为 list_aggregate 的第二个参数。

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_* 重写函数

以下是现有重写函数的列表。重写函数通过仅将列表（列）作为其参数来简化列表聚合函数的使用。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 和 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

使用可选的分隔符连接列表/数组元素。

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 值应移至列表开头还是末尾。它与 DuckDB 的 ORDER BY 子句具有相同的排序行为。因此，list_sort 中的（嵌套）值与 ORDER BY 中的比较结果相同。

默认情况下，如果没有提供修饰符，DuckDB 会按 ASC NULLS FIRST 排序。即，值按升序排序，并且 NULL 值排在前面。这与 SQLite 的默认排序顺序相同。默认排序顺序可以使用 PRAGMA 语句更改。

list_sort 允许用户选择使用默认排序顺序还是自定义顺序。list_sort 最多接受两个额外的可选参数。第二个参数提供排序顺序，可以是 ASC 或 DESC。第三个参数提供 NULL 顺序，可以是 NULLS FIRST 或 NULLS LAST。

此查询使用默认排序顺序和默认 NULL 顺序。

SELECT list_sort([1, 3, NULL, 5, NULL, -5]);

[NULL, NULL, -5, 1, 3, 5]

此查询提供排序顺序。NULL 顺序使用可配置的默认值。

SELECT list_sort([1, 3, NULL, 2], 'ASC');

[NULL, 1, 2, 3]

此查询同时提供排序顺序和 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]);

[NULL, NULL, -5, 1, 3, 5]

此查询提供 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 函数

DuckDB 支持 (parameter1, parameter2, ...) -> expression 形式的 lambda 函数。有关详细信息，请参见lambda 函数页面。

相关函数

• 聚合函数 list 和 histogram 产生列表和结构体列表。
• unnest 函数用于将列表解除嵌套一层。