Listenfunktionen

Funktion	Beschreibung
`list[index]`	Extrahiert ein einzelnes Listenelement über einen (1-basierten) `index`.
`list[begin[:end][:step]]`	Extrahiert eine Teilliste nach Slice-Konventionen. Negative Werte sind erlaubt.
`list1 && list2`	Alias für `list_has_any`.
`list1 <-> list2`	Alias für `list_distance`.
`list1 <=> list2`	Alias für `list_cosine_distance`.
`list1 <@ list2`	Alias für `list_has_all`.
`list1 @> list2`	Alias für `list_has_all`.
[`arg1
`aggregate(list, function_name, ...)`	Alias für `list_aggregate`.
`apply(list, lambda(x))`	Alias für `list_transform`.
`array_aggr(list, function_name, ...)`	Alias für `list_aggregate`.
`array_aggregate(list, function_name, ...)`	Alias für `list_aggregate`.
`array_append(list, element)`	Alias für `list_append`.
`array_apply(list, lambda(x))`	Alias für `list_transform`.
`array_cat(list_1, ..., list_n)`	Alias für `list_concat`.
`array_concat(list_1, ..., list_n)`	Alias für `list_concat`.
`array_contains(list, element)`	Alias für `list_contains`.
`array_distinct(list)`	Alias für `list_distinct`.
`array_extract(list, index)`	Extrahiert den `index`-ten (1-basierten) Wert aus der `list`.
`array_filter(list, lambda(x))`	Alias für `list_filter`.
`array_grade_up(list[, col1][, col2])`	Alias für `list_grade_up`.
`array_has(list, element)`	Alias für `list_contains`.
`array_has_all(list1, list2)`	Alias für `list_has_all`.
`array_has_any(list1, list2)`	Alias für `list_has_any`.
`array_indexof(list, element)`	Alias für `list_position`.
`array_intersect(list1, list2)`	Alias für `list_intersect`.
`array_length(list)`	Alias für `length`.
`array_pop_back(list)`	Gibt die `list` ohne das letzte Element zurück.
`array_pop_front(list)`	Gibt die `list` ohne das erste Element zurück.
`array_position(list, element)`	Alias für `list_position`.
`array_prepend(element, list)`	Alias für `list_prepend`.
`array_push_back(list, element)`	Alias für `list_append`.
`array_push_front(list, element)`	Stellt `element` der `list` voran.
`array_reduce(list, lambda(x,y)[, initial_value])`	Alias für `list_reduce`.
`array_resize(list, size[[, value]])`	Alias für `list_resize`.
`array_reverse(list)`	Alias für `list_reverse`.
`array_reverse_sort(list[, col1])`	Alias für `list_reverse_sort`.
`array_select(value_list, index_list)`	Alias für `list_select`.
`array_slice(list, begin, end)`	Alias für `list_slice`.
`array_slice(list, begin, end, step)`	Alias für `list_slice`.
`array_sort(list[, col1][, col2])`	Alias für `list_sort`.
`array_to_string(list, delimiter)`	Verkettet Listen-/Array-Elemente mit einem optionalen `delimiter`.
`array_to_string_comma_default(array)`	Verkettet Listen-/Array-Elemente mit einem Komma als Trennzeichen.
`array_transform(list, lambda(x))`	Alias für `list_transform`.
`array_unique(list)`	Alias für `list_unique`.
`array_where(value_list, mask_list)`	Alias für `list_where`.
`array_zip(list_1, ..., list_n[, truncate])`	Alias für `list_zip`.
`char_length(list)`	Alias für `length`.
`character_length(list)`	Alias für `length`.
`concat(value, ...)`	Verkettet mehrere Zeichenketten oder Listen. `NULL`-Eingaben werden übersprungen. Siehe auch [Operator `
`contains(list, element)`	Gibt `true` zurück, wenn die `list` das `element` enthält.
`filter(list, lambda(x))`	Alias für `list_filter`.
`flatten(nested_list)`	Flacht eine verschachtelte Liste um eine Ebene ab.
`generate_series(start[, stop][, step])`	Erzeugt eine Liste von Werten zwischen `start` und `stop` – der Parameter stop ist inklusive.
`grade_up(list[, col1][, col2])`	Alias für `list_grade_up`.
`len(list)`	Alias für `length`.
`length(list)`	Gibt die Länge der `list` zurück.
`list_aggr(list, function_name, ...)`	Alias für `list_aggregate`.
`list_aggregate(list, function_name, ...)`	Führt die Aggregatfunktion `function_name` auf den Elementen von `list` aus. Details finden Sie im Abschnitt Listenaggregate.
`list_any_value(list)`	Wendet die Aggregatfunktion `any_value` auf die `list` an.
`list_append(list, element)`	Hängt `element` an `list` an.
`list_apply(list, lambda(x))`	Alias für `list_transform`.
`list_approx_count_distinct(list)`	Wendet die Aggregatfunktion `approx_count_distinct` auf die `list` an.
`list_avg(list)`	Wendet die Aggregatfunktion `avg` auf die `list` an.
`list_bit_and(list)`	Wendet die Aggregatfunktion `bit_and` auf die `list` an.
`list_bit_or(list)`	Wendet die Aggregatfunktion `bit_or` auf die `list` an.
`list_bit_xor(list)`	Wendet die Aggregatfunktion `bit_xor` auf die `list` an.
`list_bool_and(list)`	Wendet die Aggregatfunktion `bool_and` auf die `list` an.
`list_bool_or(list)`	Wendet die Aggregatfunktion `bool_or` auf die `list` an.
`list_cat(list_1, ..., list_n)`	Alias für `list_concat`.
`list_concat(list_1, ..., list_n)`	Verkettet Listen. `NULL`-Eingaben werden übersprungen. Siehe auch [Operator `
`list_contains(list, element)`	Gibt wahr zurück, wenn die Liste das Element enthält.
`list_cosine_distance(list1, list2)`	Berechnet die Kosinusdistanz zwischen zwei gleich großen Listen.
`list_cosine_similarity(list1, list2)`	Berechnet die Kosinusähnlichkeit zwischen zwei gleich großen Listen.
`list_count(list)`	Wendet die Aggregatfunktion `count` auf die `list` an.
`list_distance(list1, list2)`	Berechnet die euklidische Distanz zwischen zwei Punkten, deren Koordinaten in zwei Eingabelisten gleicher Länge gegeben sind.
`list_distinct(list)`	Entfernt alle Duplikate und `NULL`-Werte aus einer Liste. Die ursprüngliche Reihenfolge bleibt nicht erhalten.
`list_dot_product(list1, list2)`	Alias für `list_inner_product`.
`list_element(list, index)`	Alias für `list_extract`.
`list_entropy(list)`	Wendet die Aggregatfunktion `entropy` auf die `list` an.
`list_extract(list, index)`	Extrahiert den `index`-ten (1-basierten) Wert aus der Liste.
`list_filter(list, lambda(x))`	Erzeugt eine Liste aus denjenigen Elementen der Eingabe-`list`, für die die `lambda`-Funktion `true` zurückgibt. DuckDB muss den Rückgabetyp der `lambda`-Funktion nach `BOOL` casten können. Der Rückgabetyp von `list_filter` entspricht dem der Eingabeliste. Siehe `list_filter`-Beispiele.
`list_first(list)`	Wendet die Aggregatfunktion `first` auf die `list` an.
`list_grade_up(list[, col1][, col2])`	Verhält sich wie `list_sort`, die Ergebnisse sind jedoch die Indizes der Position in der ursprünglichen Liste statt der eigentlichen Werte.
`list_has(list, element)`	Alias für `list_contains`.
`list_has_all(list1, list2)`	Gibt wahr zurück, wenn alle Elemente von list2 in list1 enthalten sind. NULLs werden ignoriert.
`list_has_any(list1, list2)`	Gibt wahr zurück, wenn die Listen ein gemeinsames Element haben. NULLs werden ignoriert.
`list_histogram(list)`	Wendet die Aggregatfunktion `histogram` auf die `list` an.
`list_indexof(list, element)`	Alias für `list_position`.
`list_inner_product(list1, list2)`	Berechnet das innere Produkt zwischen zwei gleich großen Listen.
`list_intersect(list1, list2)`	Gibt eine Liste aller Elemente zurück, die sowohl in `list1` als auch in `list2` vorkommen, ohne Duplikate.
`list_kurtosis(list)`	Wendet die Aggregatfunktion `kurtosis` auf die `list` an.
`list_kurtosis_pop(list)`	Wendet die Aggregatfunktion `kurtosis_pop` auf die `list` an.
`list_last(list)`	Wendet die Aggregatfunktion `last` auf die `list` an.
`list_mad(list)`	Wendet die Aggregatfunktion `mad` auf die `list` an.
`list_max(list)`	Wendet die Aggregatfunktion `max` auf die `list` an.
`list_median(list)`	Wendet die Aggregatfunktion `median` auf die `list` an.
`list_min(list)`	Wendet die Aggregatfunktion `min` auf die `list` an.
`list_mode(list)`	Wendet die Aggregatfunktion `mode` auf die `list` an.
`list_negative_dot_product(list1, list2)`	Alias für `list_negative_inner_product`.
`list_negative_inner_product(list1, list2)`	Berechnet das negative innere Produkt zwischen zwei gleich großen Listen.
`list_pack(arg, ...)`	Alias für `list_value`.
`list_position(list, element)`	Gibt den Index des `element` zurück, wenn die `list` das `element` enthält. Wird das `element` nicht gefunden, wird `NULL` zurückgegeben.
`list_prepend(element, list)`	Stellt `element` der `list` voran.
`list_product(list)`	Wendet die Aggregatfunktion `product` auf die `list` an.
`list_reduce(list, lambda(x,y)[, initial_value])`	Reduziert alle Elemente der Eingabe-`list` auf einen einzelnen skalaren Wert, indem die `lambda`-Funktion auf ein laufendes Ergebnis und das nächste Listenelement angewendet wird. Die `lambda`-Funktion hat ein optionales Argument `initial_value`. Siehe `list_reduce`-Beispiele.
`list_resize(list, size[[, value]])`	Ändert die Größe der `list` auf `size` Elemente. Neue Elemente werden mit `value` initialisiert oder mit `NULL`, wenn `value` nicht gesetzt ist.
`list_reverse(list)`	Kehrt die `list` um.
`list_reverse_sort(list[, col1])`	Sortiert die Elemente der Liste in umgekehrter Reihenfolge. Details zu Sortierreihenfolge und `NULL`-Werten finden Sie im Abschnitt Listen sortieren.
`list_select(value_list, index_list)`	Gibt eine Liste anhand der durch `index_list` ausgewählten Elemente zurück.
`list_sem(list)`	Wendet die Aggregatfunktion `sem` auf die `list` an.
`list_skewness(list)`	Wendet die Aggregatfunktion `skewness` auf die `list` an.
`list_slice(list, begin, end)`	Extrahiert eine Teilliste oder Teilzeichenkette nach Slice-Konventionen. Negative Werte sind erlaubt.
`list_slice(list, begin, end, step)`	list_slice mit zusätzlicher Schrittweite.
`list_sort(list[, col1][, col2])`	Sortiert die Elemente der Liste. Details zu Sortierreihenfolge und `NULL`-Werten finden Sie im Abschnitt Listen sortieren.
`list_stddev_pop(list)`	Wendet die Aggregatfunktion `stddev_pop` auf die `list` an.
`list_stddev_samp(list)`	Wendet die Aggregatfunktion `stddev_samp` auf die `list` an.
`list_string_agg(list)`	Wendet die Aggregatfunktion `string_agg` auf die `list` an.
`list_sum(list)`	Wendet die Aggregatfunktion `sum` auf die `list` an.
`list_transform(list, lambda(x))`	Gibt eine Liste zurück, die das Ergebnis der Anwendung der `lambda`-Funktion auf jedes Element der Eingabe-`list` ist. Der Rückgabetyp wird durch den Rückgabetyp der `lambda`-Funktion bestimmt. Siehe `list_transform`-Beispiele.
`list_unique(list)`	Zählt die eindeutigen Elemente einer `list`.
`list_value(arg, ...)`	Erzeugt eine LIST mit den Argumentwerten.
`list_var_pop(list)`	Wendet die Aggregatfunktion `var_pop` auf die `list` an.
`list_var_samp(list)`	Wendet die Aggregatfunktion `var_samp` auf die `list` an.
`list_where(value_list, mask_list)`	Gibt eine Liste zurück, bei der die `BOOLEAN`s in `mask_list` als Maske auf die `value_list` angewendet werden.
`list_zip(list_1, ..., list_n[, truncate])`	Zippt n `LIST`s zu einer neuen `LIST`, deren Länge der der längsten Liste entspricht. Ihre Elemente sind Structs aus n Elementen jeder Liste `list_1`, …, `list_n`; fehlende Elemente werden durch `NULL` ersetzt. Ist `truncate` gesetzt, werden alle Listen auf die kleinste Listenlänge gekürzt.
`range(start[, stop][, step])`	Erzeugt eine Liste von Werten zwischen `start` und `stop` – der Parameter stop ist exklusiv.
`reduce(list, lambda(x,y)[, initial_value])`	Alias für `list_reduce`.
`repeat(list, count)`	Wiederholt die `list` `count`-mal.
`unnest(list)`	Entnestet eine Liste um eine Ebene. Beachten Sie, dass dies eine spezielle Funktion ist, die die Kardinalität des Ergebnisses ändert. Details finden Sie auf der Seite unnest.
`unpivot_list(arg, ...)`	Identisch mit list_value, wird aber im Rahmen von unpivot für bessere Fehlermeldungen erzeugt.

`list[index]`

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

`arg1 || arg2`

| Beschreibung | Verkettet zwei Zeichenketten, Listen oder Blobs. Jede NULL-Eingabe ergibt NULL. Siehe auch concat(arg1, arg2, ...) und list_concat(list1, list2, ...). | | Beispiel 1 | 'Duck' || 'DB' | | Ergebnis | DuckDB | | Beispiel 2 | [1, 2, 3] || [4, 5, 6] | | Ergebnis | [1, 2, 3, 4, 5, 6] | | Beispiel 3 | '\xAA'::BLOB || '\xBB'::BLOB | | Ergebnis | \xAA\xBB |

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

| Beschreibung | Verkettet mehrere Zeichenketten oder Listen. NULL-Eingaben werden übersprungen. Siehe auch Operator ||. | | Beispiel 1 | concat('Hello', ' ', 'World') | | Ergebnis | Hello World | | Beispiel 2 | concat([1, 2, 3], NULL, [4, 5, 6]) | | Ergebnis | [1, 2, 3, 4, 5, 6] |

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

| Beschreibung | Verkettet Listen. NULL-Eingaben werden übersprungen. Siehe auch Operator ||. | | Beispiel | list_concat([2, 3], [4, 5, 6], [7]) | | Ergebnis | [2, 3, 4, 5, 6, 7] | | Aliase | list_cat, array_concat, array_cat |

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

| Beschreibung | Erzeugt eine Liste aus denjenigen Elementen der Eingabe-list, für die die lambda-Funktion true zurückgibt. DuckDB muss den Rückgabetyp der lambda-Funktion nach BOOL casten können. Der Rückgabetyp von list_filter entspricht dem der Eingabeliste. Siehe list_filter-Beispiele. | | Beispiel | list_filter([3, 4, 5], lambda x : x > 4) | | Ergebnis | [5] | | Aliase | array_filter, filter |

`list_first(list)`

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

`list_has_all(list1, list2)`

`list_has_any(list1, list2)`

`list_histogram(list)`

| Beschreibung | Wendet die Aggregatfunktion histogram auf die list an. | | Beispiel | list_histogram([3,3,9]) | | Ergebnis | {3=2, 9=1} |

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

| Beschreibung | Reduziert alle Elemente der Eingabe-list auf einen einzelnen skalaren Wert, indem die lambda-Funktion auf ein laufendes Ergebnis und das nächste Listenelement angewendet wird. Die lambda-Funktion hat ein optionales Argument initial_value. Siehe list_reduce-Beispiele. | | Beispiel | list_reduce([1, 2, 3], lambda x, y : x + y) | | Ergebnis | 6 | | Aliase | array_reduce, reduce |

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

| Beschreibung | Gibt eine Liste zurück, die das Ergebnis der Anwendung der lambda-Funktion auf jedes Element der Eingabe-list ist. Der Rückgabetyp wird durch den Rückgabetyp der lambda-Funktion bestimmt. Siehe list_transform-Beispiele. | | Beispiel | list_transform([1, 2, 3], lambda x : x + 1) | | Ergebnis | [2, 3, 4] | | Aliase | apply, array_apply, array_transform, list_apply |

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

| Beschreibung | Entnestet eine Liste um eine Ebene. Beachten Sie, dass dies eine spezielle Funktion ist, die die Kardinalität des Ergebnisses ändert. Details finden Sie auf der Seite unnest. | | Beispiel | unnest([1, 2, 3]) | | Ergebnis | Mehrere Zeilen: '1', '2', '3' |

`unpivot_list(arg, ...)`

Listenoperatoren

Die folgenden Operatoren werden für Listen unterstützt:

Operator	Beschreibung	Beispiel	Ergebnis
`&&`	Alias für `list_has_any`.	`[1, 2, 3, 4, 5] && [2, 5, 5, 6]`	`true`
`@>`	Alias für `list_has_all`, wobei die Liste rechts vom Operator die Teilliste ist.	`[1, 2, 3, 4] @> [3, 4, 3]`	`true`
`<@`	Alias für `list_has_all`, wobei die Liste links vom Operator die Teilliste ist.	`[1, 4] <@ [1, 2, 3, 4]`	`true`
`		`	Ähnlich wie `list_concat`, außer dass jede `NULL`-Eingabe `NULL` ergibt.
`<=>`	Alias für `list_cosine_distance`.	`[1, 2, 3] <=> [1, 2, 5]`	`0.007416606`
`<->`	Alias für `list_distance`.	`[1, 2, 3] <-> [1, 2, 5]`	`2.0`

Listenkomprehension

Python-artige Listenkomprehension kann verwendet werden, um Ausdrücke über Elemente einer Liste zu berechnen. Zum Beispiel:

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]

Listenkomprehensionen können auch die Position der Listenelemente verwenden, indem eine zweite Variable hinzugefügt wird. Im folgenden Beispiel verwenden wir x, i, wobei x der Wert und i die Position ist:

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

l	filtered
[4, 5, 6]	[4, 6]

Intern wird [f(x) FOR x IN l IF g(x)] übersetzt zu:

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)

Bereichsfunktionen

DuckDB bietet zwei Bereichsfunktionen, range(start, stop, step) und generate_series(start, stop, step), sowie ihre Varianten mit Standardargumenten für stop und step. Das Verhalten der beiden Funktionen unterscheidet sich bezüglich des Arguments stop. Das ist unten dokumentiert.

`range`

Die Funktion range erzeugt eine Liste von Werten im Bereich zwischen start und stop. Der Parameter start ist inklusive, der Parameter stop ist exklusiv. Der Standardwert von start ist 0 und der Standardwert von step ist 1.

Je nach Anzahl der Argumente gibt es die folgenden Varianten von 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`

Die Funktion generate_series erzeugt eine Liste von Werten im Bereich zwischen start und stop. Sowohl der Parameter start als auch stop sind inklusive. Der Standardwert von start ist 0 und der Standardwert von step ist 1. Je nach Anzahl der Argumente gibt es die folgenden Varianten von 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)`

Die Funktion generate_subscripts(arr, dim) erzeugt Indizes entlang der dim-ten Dimension des Arrays arr.

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

i
1
2
3

Datumsbereiche

Datumsbereiche werden auch für Werte vom Typ TIMESTAMP und TIMESTAMP WITH TIME ZONE unterstützt. Beachten Sie, dass für diese Typen die Argumente stop und step explizit angegeben werden müssen (ein Standardwert wird nicht bereitgestellt).

`range` für Datumsbereiche

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` für Datumsbereiche

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

Slicing

Die Funktion list_slice kann verwendet werden, um eine Teilliste aus einer Liste zu extrahieren. Es gibt die folgenden Varianten:

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]

Die Argumente sind wie folgt:

list
- Ist die zu slicende Liste
begin
- Ist der Index des ersten Elements, das in den Slice aufgenommen wird
- Bei begin < 0 wird der Index vom Ende der Liste gezählt
- Bei begin < 0 und -begin> length wird begin auf den Anfang der Liste begrenzt
- Bei begin > length ist das Ergebnis eine leere Liste
- Klammerschreibweise: Wird begin weggelassen, ist der Standard der Anfang der Liste
end
- Ist der Index des letzten Elements, das in den Slice aufgenommen wird
- Bei end < 0 wird der Index vom Ende der Liste gezählt
- Bei end > length wird end auf length begrenzt
- Bei end < begin ist das Ergebnis eine leere Liste
- Klammerschreibweise: Wird end weggelassen, ist der Standard das Ende der Liste. Wird end weggelassen und ein step angegeben, muss end durch ein - ersetzt werden
step (optional)
- Ist die Schrittweite zwischen den Elementen im Slice
- Bei step < 0 wird der Slice umgekehrt und begin und end werden vertauscht
- Darf nicht null sein

Beispiele:

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]

Listenaggregate

Die Funktion list_aggregate erlaubt die Ausführung beliebiger vorhandener Aggregatfunktionen auf den Elementen einer Liste. Das erste Argument ist die Liste (Spalte), das zweite der Name der Aggregatfunktion, z. B. min, histogram oder sum.

list_aggregate akzeptiert zusätzliche Argumente nach dem Namen der Aggregatfunktion. Diese Extra-Argumente werden direkt an die Aggregatfunktion weitergegeben, die als zweites Argument von list_aggregate dient.

Reihenfolgeempfindliche Aggregatfunktionen werden in der Reihenfolge der Liste angewendet. Die Klauseln ORDER BY, DISTINCT und FILTER werden von list_aggregate nicht unterstützt. Sie können stattdessen mit list_sort, list_grade_up, list_select, list_distinct und list_filter nachgebildet werden.

SELECT list_aggregate([1, 2, -4, NULL], 'min');

-4

SELECT list_aggregate([2, 4, 8, 42], 'sum');

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

Nachfolgend eine Liste vorhandener Rewrites. Rewrites vereinfachen die Nutzung der Listenaggregatfunktion, indem sie nur die Liste (Spalte) als Argument entgegennehmen. 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 und list_histogram.

SELECT list_min([1, 2, -4, NULL]);

-4

SELECT list_sum([2, 4, 8, 42]);

SELECT list_last([[1, 2], [NULL], [2, 10, 3]]);

[2, 10, 3]

`array_to_string`

Verkettet Listen-/Array-Elemente mit einem optionalen Trennzeichen.

SELECT array_to_string([1, 2, 3], '-') AS str;

1-2-3

Das entspricht dem folgenden SQL:

SELECT list_aggr([1, 2, 3], 'string_agg', '-') AS str;

1-2-3

Listen sortieren

Die Funktion list_sort sortiert die Elemente einer Liste aufsteigend oder absteigend. Zusätzlich lässt sich festlegen, ob NULL-Werte an den Anfang oder ans Ende der Liste verschoben werden sollen. Sie hat dasselbe Sortierverhalten wie die ORDER BY-Klausel von DuckDB. Daher vergleichen (verschachtelte) Werte in list_sort genauso wie in ORDER BY.

Standardmäßig, wenn keine Modifikatoren angegeben sind, sortiert DuckDB ASC NULLS LAST. D. h., die Werte werden aufsteigend sortiert und NULL-Werte werden ans Ende gesetzt. Das entspricht der Standardsortierreihenfolge von SQLite. Die Standardsortierreihenfolge kann mit PRAGMA-Anweisungen geändert werden.

list_sort überlässt es dem Benutzer, ob die Standardsortierreihenfolge oder eine eigene Reihenfolge verwendet werden soll. list_sort nimmt bis zu zwei zusätzliche optionale Parameter entgegen. Der zweite Parameter gibt die Sortierreihenfolge an und kann ASC oder DESC sein. Der dritte Parameter gibt die NULL-Reihenfolge an und kann NULLS FIRST oder NULLS LAST sein.

Diese Abfrage verwendet die Standardsortierreihenfolge und die Standard-NULL-Reihenfolge.

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

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

Diese Abfrage gibt die Sortierreihenfolge an. Die NULL-Reihenfolge verwendet den konfigurierbaren Standardwert.

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

[1, 2, 3, NULL]

Diese Abfrage gibt sowohl die Sortierreihenfolge als auch die NULL-Reihenfolge an.

SELECT list_sort([1, 3, NULL, 2], 'DESC', 'NULLS FIRST');

[NULL, 3, 2, 1]

list_reverse_sort hat einen optionalen zweiten Parameter für die NULL-Sortierreihenfolge. Er kann NULLS FIRST oder NULLS LAST sein.

Diese Abfrage verwendet die Standard-NULL-Sortierreihenfolge.

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

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

Diese Abfrage gibt die NULL-Sortierreihenfolge an.

SELECT list_reverse_sort([1, 3, NULL, 2], 'NULLS LAST');

[3, 2, 1, NULL]

Flattening

Die Funktion flatten ist eine skalare Funktion, die eine Liste von Listen in eine einzelne Liste umwandelt, indem sie jede Unterliste aneinanderhängt. Beachten Sie, dass dabei nur eine Ebene auf einmal abgeflacht wird, nicht alle Ebenen von Unterlisten.

Eine Liste von Listen in eine einzelne Liste umwandeln:

SELECT
    flatten([
        [1, 2],
        [3, 4]
    ]);

[1, 2, 3, 4]

Hat die Liste mehrere Listenebenen, wird nur die erste Ebene der Unterlisten zu einer einzelnen Liste zusammengefügt:

SELECT
    flatten([
        [
            [1, 2],
            [3, 4],
        ],
        [
            [5, 6],
            [7, 8],
        ]
    ]);

[[1, 2], [3, 4], [5, 6], [7, 8]]

Allgemein sollte die Eingabe der Funktion flatten eine Liste von Listen sein (keine einstufige Liste). Die Funktion flatten hat jedoch ein spezifisches Verhalten bei leeren Listen und NULL-Werten.

Ist die Eingabeliste leer, wird eine leere Liste zurückgegeben:

SELECT flatten([]);

[]

Ist die gesamte Eingabe von flatten NULL, wird NULL zurückgegeben:

SELECT flatten(NULL);

NULL

Wird eine Liste, deren einziger Eintrag NULL ist, abgeflacht, wird eine leere Liste zurückgegeben:

SELECT flatten([NULL]);

[]

Enthält die Unterliste in einer Liste von Listen nur NULL, wird die Unterliste nicht verändert:

-- (Note the extra set of parentheses vs. the prior example)
SELECT flatten([[NULL]]);

[NULL]

Auch wenn der einzige Inhalt jeder Unterliste NULL ist, werden sie trotzdem aneinandergehängt. Beachten Sie, dass beim Flattening keine Deduplizierung erfolgt. Siehe die Funktion list_distinct zur Deduplizierung:

SELECT flatten([[NULL], [NULL]]);

[NULL, NULL]

Lambda-Funktionen

DuckDB unterstützt Lambda-Funktionen in der Form lambda parameter1, parameter2, ...: expression. Details finden Sie auf der Seite Lambda-Funktionen.