Spec-Zone.ru › DuckDB

Функции списков

Имя Описание
list[index] Нотация в квадратных скобках используется как псевдоним для list_extract.
list[begin:end] Нотация в квадратных скобках с двоеточием — это псевдоним для list_slice.
list[begin:end:step] list_slice в нотации квадратных скобок с добавлением функции step.
array_pop_back(list) Возвращает список без последнего элемента.
array_pop_front(list) Возвращает список без первого элемента.
flatten(list_of_lists) Объединяет список списков в один список. Это уплощает только один уровень списка (см. примеры).
len(list) Возвращает длину списка.
list_aggregate(list, name) Выполняет агрегатную функцию name над элементами list. Более подробная информация в разделе Агрегации списков.
list_any_value(list) Возвращает первый ненулевой элемент в списке.
list_append(list, element) Добавляет element в конец list.
list_concat(list1, list2) Объединяет два списка. Входные значения NULL пропускаются. Смотрите также ||.
list_contains(list, element) Возвращает true, если список содержит элемент.
list_cosine_similarity(list1, list2) Вычисляет косинусное сходство между двумя списками.
list_cosine_distance(list1, list2) Вычисляет косинусное расстояние между двумя списками. Эквивалентно 1.0 - list_cosine_similarity.
list_distance(list1, list2) Вычисляет евклидово расстояние между двумя точками с координатами, заданными в двух списках одинаковой длины.
list_distinct(list) Удаляет все дубликаты и NULL значения из списка. Не сохраняет исходный порядок.
list_dot_product(list1, list2) Вычисляет скалярное произведение двух списков чисел одинакового размера.
list_negative_dot_product(list1, list2) Вычисляет отрицательное скалярное произведение двух списков чисел одинакового размера. Эквивалентно - list_dot_product.
list_extract(list, index) Извлекает index-й (индексация с 1) элемент из списка.
list_filter(list, lambda) Создаёт список из тех элементов входного списка, для которых лямбда-функция возвращает true. Дополнительная информация на странице Лямбда-функции.
list_grade_up(list) Работает как sort, но результат — это индексы, соответствующие позиции в исходном list, а не сами значения.
list_has_all(list, sub-list) Возвращает true, если все элементы подсписка существуют в списке.
list_has_any(list1, list2) Возвращает true, если в обоих списках существуют общие элементы.
list_intersect(list1, list2) Возвращает список всех элементов, присутствующих как в l1, так и в l2, без дубликатов.
list_position(list, element) Возвращает индекс элемента, если список его содержит. Если элемент не найден, возвращает NULL.
list_prepend(element, list) Добавляет element в начало list.
list_reduce(list, lambda) Возвращает одно значение, являющееся результатом применения лямбда-функции к каждому элементу входного списка. Подробная информация на странице Лямбда-функции.
list_resize(list, size[, value]) Изменяет размер списка на size элементов. Новые элементы инициализируются значением value или NULL, если value не задано.
list_reverse_sort(list) Сортирует элементы списка в обратном порядке. Подробности о порядке сортировки в разделе Сортировка списков.
list_reverse(list) Инвертирует список.
list_select(value_list, index_list) Возвращает список, основанный на элементах, выбранных с помощью index_list.
list_slice(list, begin, end, step) list_slice с добавлением функции step.
list_slice(list, begin, end) Извлечение подсписка с использованием соглашений среза. Принимаются отрицательные значения. См. срез.
list_sort(list) Сортирует элементы списка. Более подробная информация о порядке сортировки и NULL порядке сортировки в разделе Сортировка списков.
list_transform(list, lambda) Возвращает список, полученный применением лямбда-функции к каждому элементу входного списка. Подробная информация на странице Лямбда-функции.
list_unique(list) Считает уникальные элементы списка.
list_value(any, ...) Создаёт LIST, содержащий значения аргументов.
list_where(value_list, mask_list) Возвращает список с BOOLEAN в mask_list применёнными как маска к value_list.
list_zip(list_1, list_2, ...[, truncate]) Объединяет k LIST в новый LIST, длина которого будет равна длине самого длинного списка. Его элементы — структуры из k элементов из каждого списка list_1, …, list_k, отсутствующие элементы заменяются на NULL. Если truncate задан, все списки усекаются до длины наименьшего списка.
unnest(list) Разъединяет список на один уровень. Обратите внимание, что это специальная функция, изменяющая мощность результата. Более подробная информация на странице unnest.

list[index]

Описание Нотация в квадратных скобках используется как псевдоним для list_extract.
Пример [4, 5, 6][3]
Результат 6
Псевдоним list_extract

list[begin:end]

Описание Нотация в квадратных скобках с двоеточием — это псевдоним для list_slice.
Пример [4, 5, 6][2:3]
Результат [5, 6]
Псевдоним list_slice

list[begin:end:step]

Описание list_slice в нотации квадратных скобок с добавлением функции step.
Пример [4, 5, 6][:-:2]
Результат [4, 6]
Псевдоним list_slice

array_pop_back(list)

Описание Возвращает список без последнего элемента.
Пример array_pop_back([4, 5, 6])
Результат [4, 5]

array_pop_front(list)

Описание Возвращает список без первого элемента.
Пример array_pop_front([4, 5, 6])
Результат [5, 6]

flatten(list_of_lists)

Описание Объединяет список списков в один список. Это выполняет сжатие только на один уровень вложенности (см. примеры).
Пример flatten([[1, 2], [3, 4]])
Результат [1, 2, 3, 4]

len(list)

Описание Возвращает длину списка.
Пример len([1, 2, 3])
Результат 3
Псевдоним array_length

list_aggregate(list, name)

Описание Выполняет агрегирующую функцию name над элементами list. Для получения дополнительной информации см. раздел Агрегирующие функции для списков.
Пример list_aggregate([1, 2, NULL], 'min')
Результат 1
Псевдонимы list_aggr, aggregate, array_aggregate, array_aggr

list_any_value(list)

Описание Возвращает первый ненулевой элемент в списке.
Пример list_any_value([NULL, -3])
Результат -3

list_append(list, element)

Описание Добавляет element к list.
Пример list_append([2, 3], 4)
Результат [2, 3, 4]
Псевдонимы array_append, array_push_back

list_concat(list1, list2)

Описание Объединяет два списка. Пустые входные данные пропускаются. См. также ||
Пример list_concat([2, 3], [4, 5, 6])
Результат [2, 3, 4, 5, 6]
Псевдонимы list_cat, array_concat, array_cat

list_contains(list, element)

Описание Возвращает true, если список содержит элемент.
Пример list_contains([1, 2, NULL], 1)
Результат true
Псевдонимы list_has, array_contains, array_has

list_cosine_similarity(list1, list2)

Описание Вычисляет косинусное сходство между двумя списками.
Пример list_cosine_similarity([1, 2, 3], [1, 2, 5])
Результат 0.9759000729485332

list_cosine_distance(list1, list2)

Описание Вычисляет косинусное расстояние между двумя списками. Эквивалентно 1.0 - list_cosine_similarity
Пример list_cosine_distance([1, 2, 3], [1, 2, 5])
Результат 0.007416606

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])
Результат [1, 5, -3]
Псевдоним array_distinct

list_dot_product(list1, list2)

Описание Вычисляет скалярное произведение двух списков чисел одинакового размера.
Пример list_dot_product([1, 2, 3], [1, 2, 5])
Результат 20.0
Псевдоним list_inner_product

list_negative_dot_product(list1, list2)

Описание Вычисляет отрицательное скалярное произведение двух списков чисел одинакового размера. Эквивалентно - list_dot_product
Пример list_negative_dot_product([1, 2, 3], [1, 2, 5])
Результат -20.0
Псевдоним list_negative_inner_product

list_extract(list, index)

Описание Извлечь index-й (1-основанный) элемент из списка.
Пример list_extract([4, 5, 6], 3)
Результат 6
Псевдонимы list_element, array_extract

list_filter(list, lambda)

Описание Создаёт список из тех элементов входного списка, для которых лямбда-функция возвращает значение true. См. страницу Лямбда-функции для получения дополнительной информации.
Пример list_filter([4, 5, 6], x -> x > 4)
Результат [5, 6]
Псевдонимы array_filter, filter

list_grade_up(list)

Описание Действует как сортировка, но результатом являются индексы, соответствующие позиции в исходном list вместо фактических значений.
Пример list_grade_up([30, 10, 40, 20])
Результат [2, 4, 1, 3]
Псевдоним array_grade_up

list_has_all(list, sub-list)

Описание Возвращает true, если все элементы подсписка присутствуют в списке.
Пример list_has_all([4, 5, 6], [4, 6])
Результат true
Псевдоним array_has_all

list_has_any(list1, list2)

Описание Возвращает true, если какие-либо элементы присутствуют в обоих списках.
Пример list_has_any([1, 2, 3], [2, 3, 4])
Результат true
Псевдоним array_has_any

list_intersect(list1, list2)

Описание Возвращает список всех элементов, которые присутствуют как в l1, так и в l2, без дубликатов.
Пример list_intersect([1, 2, 3], [2, 3, 4])
Результат [2, 3]
Псевдоним array_intersect

list_position(list, element)

Описание Возвращает индекс элемента, если список содержит этот элемент. Если элемент не найден, возвращает NULL.
Пример list_position([1, 2, NULL], 2)
Результат 2
Псевдонимы list_indexof, array_position, array_indexof

list_prepend(element, list)

Описание Добавляет element в начало list.
Пример list_prepend(3, [4, 5, 6])
Результат [3, 4, 5, 6]
Псевдонимы array_prepend, array_push_front

list_reduce(list, lambda)

Описание Возвращает одно значение, являющееся результатом применения лямбда-функции к каждому элементу входного списка. Для получения более подробной информации см. страницу Лямбда-функции.
Пример list_reduce([4, 5, 6], (x, y) -> x + y)
Результат 15
Псевдонимы array_reduce, reduce

list_resize(list, size[, value])

Описание Изменяет размер списка на size элементов. Инициализирует новые элементы значением value или NULL, если value не задано.
Пример list_resize([1, 2, 3], 5, 0)
Результат [1, 2, 3, 0, 0]
Псевдоним array_resize

list_reverse_sort(list)

Описание Сортирует элементы списка в обратном порядке. Для получения дополнительной информации о порядке сортировки NULL см. раздел Сортировка списков.
Пример list_reverse_sort([3, 6, 1, 2])
Результат [6, 3, 2, 1]
Псевдоним array_reverse_sort

list_reverse(list)

Описание Инвертирует список.
Пример list_reverse([3, 6, 1, 2])
Результат [2, 1, 6, 3]
Псевдоним array_reverse

list_select(value_list, index_list)

Описание Возвращает список, основанный на элементах, выбранных с помощью index_list.
Пример list_select([10, 20, 30, 40], [1, 4])
Результат [10, 40]
Псевдоним array_select

list_slice(list, begin, end, step)

Описание list_slice с добавленной функцией step.
Пример list_slice([4, 5, 6], 1, 3, 2)
Результат [4, 6]
Псевдоним array_slice

list_slice(list, begin, end)

Описание Извлечение подсписка с использованием правил срезов. Принимаются отрицательные значения. См. срез.
Пример list_slice([4, 5, 6], 2, 3)
Результат [5, 6]
Псевдоним array_slice

list_sort(list)

Описание Сортирует элементы списка. Для получения дополнительной информации о порядке сортировки и порядке сортировки NULL см. раздел Сортировка списков.
Пример list_sort([3, 6, 1, 2])
Результат [1, 2, 3, 6]
Псевдоним array_sort

list_transform(list, lambda)

Описание Возвращает список, являющийся результатом применения лямбда-функции к каждому элементу входного списка. Для получения более подробной информации см. страницу Лямбда-функции.
Пример list_transform([4, 5, 6], x -> x + 1)
Результат [5, 6, 7]
Псевдонимы array_transform, apply, list_apply, array_apply

list_unique(list)

Описание Подсчитывает уникальные элементы списка.
Пример list_unique([1, 1, NULL, -3, 1, 5])
Результат 3
Псевдоним array_unique

list_value(any, ...)

Описание Создаёт LIST, содержащий значения аргументов.
Пример list_value(4, 5, 6)
Результат [4, 5, 6]
Псевдоним list_pack

list_where(value_list, mask_list)

Описание Возвращает список с элементами в BOOLEAN из mask_list, применёнными в качестве маски к value_list.
Пример list_where([10, 20, 30, 40], [true, false, false, true])
Результат [10, 40]
Псевдоним array_where

list_zip(list1, list2, ...)

Описание Комбинирует k LIST в новый LIST, длина которого будет равна длине самого длинного списка. Его элементы — структуры из k элементов каждого списка list_1, …, list_k, пропущенные элементы заменяются на NULL. Если truncate задано, все списки усекаются до длины самого короткого.
Пример list_zip([1, 2], [3, 4], [5, 6])
Результат [(1, 3, 5), (2, 4, 6)]
Псевдоним array_zip

unnest(list)

Описание Разъединяет список на один уровень вложенности. Обратите внимание, что это специальная функция, изменяющая мощность результата. Для получения более подробной информации см. страницу unnest страницу.
Пример unnest([1, 2, 3])
Результат 1, 2, 3

Операторы списков

Для списков поддерживаются следующие операторы:

Оператор Описание Пример Результат
&& Псевдоним для list_has_any. [1, 2, 3, 4, 5] && [2, 5, 5, 6] true
@> Псевдоним для list_has_all, где список справа от оператора является подсписком. [1, 2, 3, 4] @> [3, 4, 3] true
<@ Псевдоним для list_has_all, где список слева от оператора является подсписком. [1, 4] <@ [1, 2, 3, 4] true
|| Аналогично list_concat, за исключением того, что любой NULL вход приводит к NULL. [1, 2, 3] || [4, 5, 6] [1, 2, 3, 4, 5, 6]
<=> Псевдоним для list_cosine_distance. [1, 2, 3] <=> [1, 2, 5] 0.007416606
<-> Псевдоним для list_distance. [1, 2, 3] <-> [1, 2, 5] 2.0

Списки в стиле Python

Списки в стиле Python могут использоваться для вычисления выражений над элементами списка. Например:

SELECT [lower(x) FOR x IN strings] AS strings
FROM (VALUES (['Hello', '', 'World'])) t(strings);
строки
[hello, , world]
SELECT [upper(x) FOR x IN strings IF len(x) > 0] AS strings
FROM (VALUES (['Hello', '', 'World'])) t(strings);
строки
[HELLO, WORLD]

Списки в стиле Python также могут использовать положение элементов списка, добавив второй параметр. В следующем примере используется x, i, где x - значение, а i - позиция:

SELECT [4, 5, 6] AS l, [x FOR x, i IN l IF i != 2] filtered;
l отфильтрованные
[4, 5, 6] [4, 6]

Функции диапазонов

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) генерирует индексы вдоль dim-ой размерности массива arr.

SELECT generate_subscripts([4, 5, 6], 1) AS i;
i
1
2
3

Диапазоны дат

Для значений TIMESTAMP и TIMESTAMP WITH TIME ZONE также поддерживаются диапазоны дат. Обратите внимание, что для этих типов аргументы stop и step необходимо указывать явно (значение по умолчанию не предоставляется).

range для диапазонов дат

SELECT *
FROM range(DATE '1992-01-01', DATE '1992-03-01', INTERVAL '1' MONTH);
диапазон
1992-01-01 00:00:00
1992-02-01 00:00:00

generate_series для диапазонов дат

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, конец ограничен 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 перемещаться в начало или конец списка. Она имеет то же поведение при сортировке, что и ORDER BY в DuckDB. Поэтому (вложенные) значения сравниваются одинаково в 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]

Функции лямбда

DuckDB поддерживает функции лямбда в форме (parameter1, parameter2, ...) -> expression. Подробности см. на странице странице функций лямбда.

Связанные функции

Также существуют функции агрегирования list и histogram, которые создают списки и списки структур. Функция unnest используется для раскрытия списка на один уровень.

© Copyright 2018–2024 Stichting DuckDB Foundation
Licensed under the MIT License.
https://duckdb.org/docs/sql/functions/list.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API