should be it

external/duckdb/benchmark/micro/lambdas/list_filter_where.benchmark

@@ -0,0 +1,13 @@
+# name: benchmark/micro/lambdas/list_filter_where.benchmark
+# description: Simulate a where-function with lambda functions on 100K values
+# group: [lambdas]
+
+name Benchmark list_filter
+group lambdas
+
+load
+CREATE TABLE tbl (l INTEGER[], where_l BOOLEAN[]);
+INSERT INTO tbl VALUES (range(100000), [x % 13 != 0 for x in range(100000)]);
+
+run
+SELECT list_filter(l, (x, x_i) -> where_l[x_i]) FROM tbl;

external/duckdb/benchmark/micro/lambdas/list_reduce/complex_expression.benchmark

@@ -0,0 +1,13 @@
+# name: benchmark/micro/lambdas/list_reduce/complex_expression.benchmark
+# description: list_reduce with a complex expression
+# group: [list_reduce]
+
+name list complex expression
+group micro
+subgroup lambdas
+
+load
+CREATE TABLE tbl AS SELECT range(i, i + 1) || range(i + 1, i + 2) || range(i + 2, i + 3) || range(i + 3, i + 4) || range(i, i + 1) || range(i + 1, i + 2) || range(i + 2, i + 3) || range(i + 3, i + 4) || range(i + 1, i + 2) || range(i + 2, i + 3) AS l FROM range(500000) t(i);
+
+run
+SELECT list_reduce(l, (x, y) -> list_reduce(l, (a, b) -> x + y + a + b)) FROM tbl;

external/duckdb/benchmark/micro/lambdas/list_reduce/list_length_2.benchmark

@@ -0,0 +1,13 @@
+# name: benchmark/micro/lambdas/list_reduce/list_length_2.benchmark
+# description: list_reduce with lists that have a length of 2 benchmark
+# group: [list_reduce]
+
+name list length 2
+group micro
+subgroup lambdas
+
+load
+CREATE TABLE tbl AS SELECT range(i, i + 1) || range(i + 1, i + 2) AS l FROM range(5000000) t(i); 
+
+run
+SELECT list_reduce(l, (x, y) -> x + y) FROM tbl;

external/duckdb/benchmark/micro/lambdas/list_reduce/list_length_5000.benchmark

@@ -0,0 +1,13 @@
+# name: benchmark/micro/lambdas/list_reduce/list_length_5000.benchmark
+# description: list_reduce with lists that have a length of 5000 benchmark
+# group: [list_reduce]
+
+name list length 5000
+group micro
+subgroup lambdas
+
+load
+CREATE TABLE t2 AS SELECT range(5000) as l FROM range(10000);
+
+run
+SELECT list_reduce(l, (x, y) -> x + y) FROM t2;

external/duckdb/benchmark/micro/lambdas/list_reduce/list_variable_length.benchmark

@@ -0,0 +1,13 @@
+# name: benchmark/micro/lambdas/list_reduce/list_variable_length.benchmark
+# description: list_reduce with list of variable length
+# group: [list_reduce]
+
+name list variable length
+group micro
+subgroup lambdas
+
+load
+CREATE TABLE tbl AS SELECT range((i * 95823983533) % 100000 + 1) AS l from range(5000) t(i);
+
+run
+SELECT list_reduce(l, (x, y) -> x + y) FROM tbl;

external/duckdb/benchmark/micro/lambdas/list_reduce/varchar.benchmark

@@ -0,0 +1,19 @@
+# name: benchmark/micro/lambdas/list_reduce/varchar.benchmark
+# description: list_reduce on varchars
+# group: [list_reduce]
+
+name list reduce on varchars
+group micro
+subgroup lambdas
+
+load
+CREATE TEMPORARY TABLE strings_temp AS
+    SELECT ((i * 95823983533) % 100000)::VARCHAR AS s1,
+           ((i * 547892347987) % 1000)::VARCHAR AS s2,
+            ((i * 847892347987) % 100)::VARCHAR AS s3,
+        FROM range(10000) tbl(i);
+CREATE TEMPORARY TABLE concat_strings_tmp AS SELECT 'a' || s1 || repeat(s2, s2::INT) || s2 || 'c' || s3 AS l FROM strings_temp;
+CREATE TABLE tbl AS SELECT string_split(l, '1') || string_split(l, '0') || string_split(l, '2') AS l FROM concat_strings_tmp;
+
+run
+SELECT list_reduce(l, (a, b) -> a || b) FROM tbl;

external/duckdb/benchmark/micro/lambdas/list_transform_select.benchmark

@@ -0,0 +1,13 @@
+# name: benchmark/micro/lambdas/list_transform_select.benchmark
+# description: Simulate a select-function with lambda functions on 100K values
+# group: [lambdas]
+
+name Benchmark list_transform
+group lambdas
+
+load
+CREATE TABLE tbl (l INTEGER[], sel INTEGER[]);
+INSERT INTO tbl VALUES (range(100000), range(100000));
+
+run
+SELECT list_transform(sel, x -> l[x]) FROM tbl;

external/duckdb/benchmark/micro/lambdas/list_transform_zip.benchmark

@@ -0,0 +1,13 @@
+# name: benchmark/micro/lambdas/list_transform_zip.benchmark
+# description: Simulate a zip-function with lambda functions on 100K values
+# group: [lambdas]
+
+name Benchmark list_transform
+group lambdas
+
+load
+CREATE TABLE tbl (l INTEGER[], zip VARCHAR[]);
+INSERT INTO tbl VALUES (range(100000), [x::VARCHAR || (x + 1)::VARCHAR for x in range(100000)]);
+
+run
+SELECT list_transform(l, (x, x_i) -> (x, zip[x_i])) FROM tbl;