list[index]

list[begin[:end][:step]]

arg1 || arg2

array_extract(list, index)

array_pop_back(list)

array_pop_front(list)

array_push_front(list, element)

array_to_string(list, delimiter)

array_to_string_comma_default(array)

concat(value, ...)

contains(list, element)

flatten(nested_list)

generate_series(start[, stop][, step])

length(list)

list_aggregate(list, function_name, ...)

list_any_value(list)

list_append(list, element)

list_approx_count_distinct(list)

list_avg(list)

list_bit_and(list)

list_bit_or(list)

list_bit_xor(list)

list_bool_and(list)

list_bool_or(list)

list_concat(list_1, ..., list_n)

list_contains(list, element)

list_cosine_distance(list1, list2)

list_cosine_similarity(list1, list2)

list_count(list)

list_distance(list1, list2)

list_distinct(list)

list_entropy(list)

list_extract(list, index)

list_filter(list, lambda(x))

list_first(list)

list_grade_up(list[, col1][, col2])

list_has_all(list1, list2)

list_has_any(list1, list2)

list_histogram(list)

list_inner_product(list1, list2)

list_intersect(list1, list2)

list_kurtosis(list)

list_kurtosis_pop(list)

list_last(list)

list_mad(list)

list_max(list)

list_median(list)

list_min(list)

list_mode(list)

list_negative_inner_product(list1, list2)

list_position(list, element)

list_prepend(element, list)

list_product(list)

list_reduce(list, lambda(x,y)[, initial_value])

list_resize(list, size[[, value]])

list_reverse(list)

list_reverse_sort(list[, col1])

list_select(value_list, index_list)

list_sem(list)

list_skewness(list)

list_slice(list, begin, end)

list_slice(list, begin, end, step)

list_sort(list[, col1][, col2])

list_stddev_pop(list)

list_stddev_samp(list)

list_string_agg(list)

list_sum(list)

list_transform(list, lambda(x))

list_unique(list)

list_value(arg, ...)

list_var_pop(list)

list_var_samp(list)

list_where(value_list, mask_list)

list_zip(list_1, ..., list_n[, truncate])

range(start[, stop][, step])

repeat(list, count)

unnest(list)

unpivot_list(arg, ...)

列表运算符

列表支持以下运算符

列表推导式

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 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)

范围函数

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 第二个参数的聚合函数。

顺序敏感的聚合函数按列表顺序应用。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_* 重写函数

以下是现有重写列表。重写通过仅将列表（列）作为参数来简化列表聚合函数的使用。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 支持 lambda parameter1, parameter2, ...: expression 形式的 lambda 函数。有关详细信息，请参阅 lambda 函数页面。

相关函数

• 聚合函数 list 和 histogram 生成列表和结构体列表。
• unnest 函数用于将列表取消嵌套一级。