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

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

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] 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 Aggregates

函数 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([]);

[]

如果展平的整个输入是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 函数用于将列表展开一级。