should be it

external/duckdb/test/sql/function/CMakeLists.txt

@@ -0,0 +1,5 @@
+add_subdirectory(table)
+
+set(ALL_OBJECT_FILES
+    ${ALL_OBJECT_FILES}
+    PARENT_SCOPE)

external/duckdb/test/sql/function/array/array_and_map.test

@@ -0,0 +1,20 @@
+# name: test/sql/function/array/array_and_map.test
+# description: Test flattening ARRAY types inside the MAP function.
+# group: [array]
+
+query I
+SELECT MAP([MAP([ARRAY_VALUE('1', NULL), ARRAY_VALUE(NULL, '2')], [1, 2])], [1]);
+----
+{{[1, NULL]=1, [NULL, 2]=2}=1}
+
+query I
+SELECT MAP([2], [{'key1': MAP([ARRAY_VALUE('1', NULL), ARRAY_VALUE(NULL, '2')], [1, 2])}]);
+----
+{2={'key1': {[1, NULL]=1, [NULL, 2]=2}}}
+
+# Issue https://github.com/duckdb/duckdb/issues/12007.
+
+query I
+SELECT [MAP([2], [{'key1': MAP([ARRAY_VALUE('1', NULL), ARRAY_VALUE(NULL, '2')], [1, 2]), 'key2': 2}])];
+----
+[{2={'key1': {[1, NULL]=1, [NULL, 2]=2}, 'key2': 2}}]

external/duckdb/test/sql/function/array/array_cosine_distance.test

@@ -0,0 +1,50 @@
+# name: test/sql/function/array/array_cosine_distance.test
+# group: [array]
+
+foreach type FLOAT DOUBLE
+
+# The distance between a vector and itself should be 0
+query I
+SELECT array_cosine_distance([1, 2, 3]::${type}[3], [1, 2, 3]::${type}[3]);
+----
+0.0
+
+# Opposite vectors should have a distance of 2
+query I
+SELECT array_cosine_distance([2, 2, 2]::${type}[3], [-2, -2, -2]::${type}[3]);
+----
+2.0
+
+statement ok
+CREATE OR REPLACE TABLE arrays (l ${type}[3]);
+
+statement ok
+INSERT INTO arrays VALUES ([1, 2, 3]), ([4, 5, 6]), ([7, 8, 9]), ([-1, -2, -3]), (NULL);
+
+query I
+SELECT array_cosine_distance(l, [1, 2, 3]::${type}[3]) FROM arrays;
+----
+0.0
+0.02536815
+0.04058805
+2.0
+NULL
+
+statement error
+SELECT array_cosine_distance([1, NULL, 3]::${type}[3], [1, 2, 3]::${type}[3]);
+----
+left argument can not contain NULL values
+
+statement error
+SELECT array_cosine_distance([1, 2, 3]::${type}[3], [1, NULL, 3]::${type}[3]);
+----
+right argument can not contain NULL values
+
+statement error
+SELECT array_cosine_distance([1, 2, 3]::${type}[3], [1, 2, 3, 4]::${type}[4]);
+----
+array_cosine_distance: Array arguments must be of the same size
+
+
+
+endloop

external/duckdb/test/sql/function/array/array_cosine_similarity.test

@@ -0,0 +1,43 @@
+# name: test/sql/function/array/array_cosine_similarity.test
+# group: [array]
+
+foreach type FLOAT DOUBLE
+
+query I
+SELECT array_cosine_similarity([1, 2, 3]::${type}[3], [1, 2, 3]::${type}[3]);
+----
+1.0
+
+statement ok
+CREATE OR REPLACE TABLE arrays (l ${type}[3]);
+
+statement ok
+INSERT INTO arrays VALUES ([1, 2, 3]), ([4, 5, 6]), ([7, 8, 9]), ([-1, -2, -3]), (NULL);
+
+query I
+SELECT array_cosine_similarity(l, [1, 2, 3]::${type}[3]) FROM arrays;
+----
+0.99999994
+0.9746318
+0.95941186
+-0.99999994
+NULL
+
+statement error
+SELECT array_cosine_similarity([1, NULL, 3]::${type}[3], [1, 2, 3]::${type}[3]);
+----
+left argument can not contain NULL values
+
+statement error
+SELECT array_cosine_similarity([1, 2, 3]::${type}[3], [1, NULL, 3]::${type}[3]);
+----
+right argument can not contain NULL values
+
+statement error
+SELECT array_cosine_similarity([1, 2, 3]::${type}[3], [1, 2, 3, 4]::${type}[4]);
+----
+array_cosine_similarity: Array arguments must be of the same size
+
+
+
+endloop

external/duckdb/test/sql/function/array/array_cross_product.test

@@ -0,0 +1,52 @@
+# name: test/sql/function/array/array_cross_product.test
+# group: [array]
+
+# This tests the vector cross product
+
+foreach TYPE DOUBLE FLOAT
+
+query I rowsort
+SELECT array_cross_product(l, r) FROM (VALUES
+	([-1, -2, 3]::${TYPE}[3], [4, 0, -8]::${TYPE}[3]),
+	([1,2,3]::${TYPE}[3], [1,5,7]::${TYPE}[3]),
+	([1,2,3]::${TYPE}[3], NULL::${TYPE}[3]),
+	(NULL::${TYPE}[3], [1,5,7]::${TYPE}[3]),
+	(NULL::${TYPE}[3], NULL::${TYPE}[3])
+) as t(l,r);
+----
+NULL
+NULL
+NULL
+[-1.0, -4.0, 3.0]
+[16.0, 4.0, 8.0]
+
+
+# Constant case
+query I
+SELECT array_cross_product([1,2,3]::${TYPE}[3], [1,5,7]::${TYPE}[3]);
+----
+[-1.0, -4.0, 3.0]
+
+# Constant Null case
+query I
+SELECT array_cross_product([1,2,3]::${TYPE}[3], NULL::${TYPE}[3]);
+----
+NULL
+
+statement error
+SELECT array_cross_product([1,NULL,3]::${TYPE}[3], [1,5,7]::${TYPE}[3]);
+----
+array_cross_product: left argument can not contain NULL values
+
+statement error
+SELECT array_cross_product([1,5,7]::${TYPE}[3], [1,NULL,3]::${TYPE}[3]);
+----
+array_cross_product: right argument can not contain NULL values
+
+# Now we can also try implict casts
+query I
+SELECT array_cross_product(array_value(1,2,3), array_value(1.0,5.0,7.0)::${TYPE}[3]);
+----
+[-1.0, -4.0, 3.0]
+
+endloop

external/duckdb/test/sql/function/array/array_distance.test

@@ -0,0 +1,43 @@
+# name: test/sql/function/array/array_distance.test
+# group: [array]
+
+foreach type FLOAT
+
+query I
+SELECT array_distance([1, 2, 3]::${type}[3], [1, 2, 3]::${type}[3]);
+----
+0.0
+
+statement ok
+CREATE OR REPLACE TABLE arrays (l ${type}[3]);
+
+statement ok
+INSERT INTO arrays VALUES ([1, 2, 3]), ([1, 2, 4]), ([7, 8, 9]), ([-1, -2, -3]), (NULL);
+
+query I
+SELECT array_distance(l, [1, 2, 3]::${type}[3]) FROM arrays;
+----
+0.0
+1.0
+10.392304
+7.483315
+NULL
+
+
+statement error
+SELECT array_distance([1, NULL, 3]::${type}[3], [1, 2, 3]::${type}[3]);
+----
+left argument can not contain NULL values
+
+statement error
+SELECT array_distance([1, 2, 3]::${type}[3], [1, NULL, 3]::${type}[3]);
+----
+right argument can not contain NULL values
+
+statement error
+SELECT array_distance([1, 2, 3]::${type}[3], [1, 2, 3, 4]::${type}[4]);
+----
+array_distance: Array arguments must be of the same size
+
+
+endloop

external/duckdb/test/sql/function/array/array_flatten.test

@@ -0,0 +1,13 @@
+# name: test/sql/function/array/array_flatten.test
+# description: Test array flatten function
+# group: [array]
+
+statement error
+select flatten(['a', 'b', 'c']::varchar[3]);
+----
+No function matches the given name and argument types
+
+query I
+select flatten([['a'], ['b'], ['c']]::varchar[1][3]);
+----
+[a, b, c]

external/duckdb/test/sql/function/array/array_inner_product.test

@@ -0,0 +1,60 @@
+# name: test/sql/function/array/array_inner_product.test
+# group: [array]
+
+# Error message coverage test
+statement error
+SELECT array_inner_product('foo', 'bar');
+----
+Could not choose a best candidate function
+
+statement error
+SELECT array_inner_product([1,2,3]::INT[3], ['a','b','c']::VARCHAR[3]);
+----
+Binder Error: No function matches the given name and argument types
+
+statement error
+SELECT array_distance(['a','b']::VARCHAR[2],['foo','bar']::VARCHAR[2]);
+----
+Binder Error: No function matches the given name and argument types
+
+# Tests for supported types
+foreach type FLOAT DOUBLE
+
+query I
+SELECT array_inner_product([1, 1, 1]::${type}[3], [1, 1, 1]::${type}[3]);
+----
+3.0
+
+statement ok
+CREATE OR REPLACE TABLE arrays (l ${type}[3]);
+
+statement ok
+INSERT INTO arrays VALUES ([1, 2, 3]), ([1, 2, 4]), ([7, 8, 9]), ([-1, -2, -3]), (NULL);
+
+query I
+SELECT array_inner_product(l, [1, 2, 3]::${type}[3]) FROM arrays;
+----
+14.0
+17.0
+50.0
+-14.0
+NULL
+
+
+statement error
+SELECT array_inner_product([1, NULL, 3]::${type}[3], [1, 2, 3]::${type}[3]);
+----
+left argument can not contain NULL values
+
+statement error
+SELECT array_inner_product([1, 2, 3]::${type}[3], [1, NULL, 3]::${type}[3]);
+----
+right argument can not contain NULL values
+
+statement error
+SELECT array_inner_product([1, 2, 3]::${type}[3], [1, 2, 3, 4]::${type}[4]);
+----
+array_inner_product: Array arguments must be of the same size
+
+
+endloop

external/duckdb/test/sql/function/array/array_length.test

@@ -0,0 +1,59 @@
+# name: test/sql/function/array/array_length.test
+# group: [array]
+
+# Array length
+query I
+SELECT length(array_value(1, 2, 3));
+----
+3
+
+# array length for NULL values
+statement ok
+create table arrays(a int[3]);
+
+statement ok
+insert into arrays values ([1, 2, 3]), ([4, 5, 6])
+
+query I
+select length(a) from arrays;
+----
+3
+3
+
+query I
+select length(NULL::int[3]) from arrays;
+----
+NULL
+NULL
+
+statement ok
+insert into arrays values (NULL);
+
+query I
+select length(a) from arrays;
+----
+3
+3
+NULL
+
+# Array length with dimension argument
+query I
+SELECT array_length(array_value(array_value(1, 2, 2), array_value(3, 4, 3)), 1);
+----
+2
+
+query I
+SELECT array_length(array_value(array_value(1, 2, 2), array_value(3, 4, 3)), 2);
+----
+3
+
+statement error
+SELECT array_length(array_value(array_value(1, 2, 2), array_value(3, 4, 3)), 3);
+----
+Out of Range Error: array_length dimension '3' out of range (min: '1', max: '2')
+
+statement error
+SELECT array_length(array_value(array_value(1, 2, 2), array_value(3, 4, 3)), 0);
+----
+Out of Range Error: array_length dimension '0' out of range (min: '1', max: '2')
+

external/duckdb/test/sql/function/array/array_list_functions.test

@@ -0,0 +1,89 @@
+# name: test/sql/function/array/array_list_functions.test
+# group: [array]
+
+# Just test that arrays are propely cast to lists when calling some list functions with special binding logic
+# Aggregate example
+query I
+SELECT list_distinct(array_value(1,1,2,3,3)) = list_distinct([1,1,2,3,3]);
+----
+true
+
+# Sort example:
+query I
+SELECT list_sort(array_value(3,2,1)) = list_sort([3,2,1]);
+----
+true
+
+# Slice example:
+query I
+SELECT list_slice(array_value(1,2,3,4,5), 1, 3) = list_slice([1,2,3,4,5], 1, 3);
+----
+true
+
+# Transform example
+query I
+SELECT list_transform(array_value(3,2,1), lambda x: x + 1) = list_transform([3,2,1], lambda x: x + 1);
+----
+true
+
+# Filter example
+query I
+SELECT list_filter(array_value(3,2,1), lambda x: x > 1) = list_filter([3,2,1], lambda x: x > 1);
+----
+true
+
+# Concat example(s)
+query I
+SELECT list_concat(array_value(1,2,3), array_value(4,5,6));
+----
+[1, 2, 3, 4, 5, 6]
+
+query II
+SELECT list_concat(array_value(1,2,3), NULL), list_concat(NULL, array_value(4,5,6));
+----
+[1, 2, 3]	[4, 5, 6]
+
+query I
+SELECT list_resize(array_value(1,2), 3);
+----
+[1, 2, NULL]
+
+query I
+SELECT list_resize(array_value(1,2), 1);
+----
+[1]
+
+query I
+SELECT list_resize(array_value(1,2), 0);
+----
+[]
+
+query I
+SELECT list_position(array_value(1,2,3), 2);
+----
+2
+
+query I
+SELECT list_position(array_value(1,2,3), 4);
+----
+NULL
+
+query I
+SELECT list_contains(array_value(1,2,3), 2);
+----
+true
+
+query I
+SELECT list_contains(array_value(1,2,3), 4);
+----
+false
+
+query I
+SELECT list_extract(array_value(4,5,6), 2);
+----
+5
+
+query I
+SELECT list_extract(array_value(4,5,6), 4);
+----
+NULL

external/duckdb/test/sql/function/autocomplete/alter_table.test

@@ -0,0 +1,24 @@
+# name: test/sql/function/autocomplete/alter_table.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+statement ok
+CREATE TABLE my_table(first_column bigint);
+
+query II
+FROM sql_auto_complete('ALTER TABLE my_table DROP COLUMN fi') LIMIT 1;
+----
+first_column	33
+
+query II
+FROM sql_auto_complete('ALTER TABLE my_table ALTER COLUMN fi') LIMIT 1;
+----
+first_column	34
+
+query II
+FROM sql_auto_complete('ALTER TABLE my_table RENAME COLUMN fi') LIMIT 1;
+----
+first_column	35
+

external/duckdb/test/sql/function/autocomplete/copy.test

@@ -0,0 +1,28 @@
+# name: test/sql/function/autocomplete/copy.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+query II
+FROM sql_auto_complete('COP') LIMIT 1;
+----
+COPY 	0
+
+query II
+FROM sql_auto_complete('COPY tbl FRO') LIMIT 1;
+----
+FROM 	9
+
+query II
+FROM sql_auto_complete('COPY tbl FROM ''file.csv'' HEAD') LIMIT 1;
+----
+HEADER 	25
+
+statement ok
+CREATE TABLE my_table(my_column INTEGER);
+
+query II
+FROM sql_auto_complete('COPY my_') LIMIT 1;
+----
+my_table	5

external/duckdb/test/sql/function/autocomplete/create_function.test

@@ -0,0 +1,35 @@
+# name: test/sql/function/autocomplete/create_function.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+query II
+FROM sql_auto_complete('CREATE MA') LIMIT 1;
+----
+MACRO 	7
+
+query II
+FROM sql_auto_complete('CREATE F') LIMIT 1;
+----
+FUNCTION 	7
+
+query II
+FROM sql_auto_complete('CREATE MACRO name(a) A') LIMIT 1;
+----
+AS 	21
+
+query II
+FROM sql_auto_complete('CREATE MACRO name(a) AS a+1, (b) A') LIMIT 1;
+----
+AS 	33
+
+query II
+FROM sql_auto_complete('CREATE MACRO name (a) AS TA') LIMIT 1;
+----
+TABLE 	25
+
+query II
+FROM sql_auto_complete('CREATE MACRO name (a) AS TABLE SEL') LIMIT 1;
+----
+SELECT 	31

external/duckdb/test/sql/function/autocomplete/create_schema.test

@@ -0,0 +1,35 @@
+# name: test/sql/function/autocomplete/create_schema.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+query II
+FROM sql_auto_complete('CREATE SCH') LIMIT 1;
+----
+SCHEMA 	7
+
+query II
+FROM sql_auto_complete('CREATE SCHEMA I') LIMIT 1;
+----
+IF 	14
+
+query II
+FROM sql_auto_complete('CREATE SCHEMA IF NO') LIMIT 1;
+----
+NOT 	17
+
+query II
+FROM sql_auto_complete('CREATE SCHEMA IF NOT EX') LIMIT 1;
+----
+EXISTS 	21
+
+# attached database
+# suggest a catalog
+statement ok
+ATTACH ':memory:' AS attached_in_memory;
+
+query II
+FROM sql_auto_complete('CREATE SCHEMA attac') LIMIT 1;
+----
+attached_in_memory.	14

external/duckdb/test/sql/function/autocomplete/create_secret.test

@@ -0,0 +1,3 @@
+# name: test/sql/function/autocomplete/create_secret.test
+# group: [autocomplete]
+

external/duckdb/test/sql/function/autocomplete/create_sequence.test

@@ -0,0 +1,20 @@
+# name: test/sql/function/autocomplete/create_sequence.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+query II
+FROM sql_auto_complete('CREATE SEQ') LIMIT 1;
+----
+SEQUENCE 	7
+
+query II
+FROM sql_auto_complete('CREATE SEQUENCE seq CYC') LIMIT 1;
+----
+CYCLE 	20
+
+query II
+FROM sql_auto_complete('CREATE SEQUENCE seq INC') LIMIT 1;
+----
+INCREMENT 	20

external/duckdb/test/sql/function/autocomplete/create_table.test

@@ -0,0 +1,129 @@
+# name: test/sql/function/autocomplete/create_table.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+# CREATE
+query II
+FROM sql_auto_complete('CR') LIMIT 1;
+----
+CREATE 	0
+
+# match case
+query II
+FROM sql_auto_complete('cr') LIMIT 1;
+----
+create 	0
+
+query II
+FROM sql_auto_complete('CREATE TA') LIMIT 1;
+----
+TABLE 	7
+
+query II
+FROM sql_auto_complete('CREATE T') LIMIT 1;
+----
+TABLE 	7
+
+query II
+FROM sql_auto_complete('CREATE OR RE') LIMIT 1;
+----
+REPLACE 	10
+
+query II
+FROM sql_auto_complete('create ta') LIMIT 1;
+----
+table 	7
+
+# suggest a type
+query II
+FROM sql_auto_complete('create table tbl(i INTE') LIMIT 1;
+----
+INTEGER	19
+
+# suggest a type in a list
+query II
+FROM sql_auto_complete('create table tbl(i INTEGER, j INTE') LIMIT 1;
+----
+INTEGER	30
+
+# suggest a constraint
+query II
+FROM sql_auto_complete('create table tbl(i INTEGER PRI') LIMIT 1;
+----
+PRIMARY 	27
+
+query II
+FROM sql_auto_complete('create table tbl(i INTEGER PRIMARY KE') LIMIT 1;
+----
+KEY 	35
+
+query II
+FROM sql_auto_complete('create table tbl(i INTEGER UNIQ') LIMIT 1;
+----
+UNIQUE 	27
+
+query II
+FROM sql_auto_complete('create table tbl(i INTEGER UNIQUE NO') LIMIT 1;
+----
+NOT 	34
+
+query II
+FROM sql_auto_complete('create table tbl(i INTEGER UNIQUE NOT N') LIMIT 1;
+----
+NULL 	38
+
+# top-level constraints
+query II
+FROM sql_auto_complete('create table tbl(i INTEGER, PRI') LIMIT 1;
+----
+PRIMARY 	28
+
+statement ok
+CREATE SCHEMA abcdefgh;
+
+# suggest a schema name
+query II
+FROM sql_auto_complete('CREATE TABLE abcd') LIMIT 1;
+----
+abcdefgh.	13
+
+query II
+FROM sql_auto_complete('CREATE TABLE abcdefgh.') LIMIT 1;
+----
+.	21
+
+# we suggest the original schema
+query II
+FROM sql_auto_complete('CREATE TABLE ABCD') LIMIT 1;
+----
+abcdefgh.	13
+
+# what if the schema is a keyword?
+statement ok
+CREATE SCHEMA "SCHEMA";
+
+query II
+FROM sql_auto_complete('CREATE TABLE SC') LIMIT 1;
+----
+"SCHEMA".	13
+
+# suggest a catalog
+statement ok
+ATTACH ':memory:' AS attached_in_memory;
+
+query II
+FROM sql_auto_complete('CREATE TABLE attac') LIMIT 1;
+----
+attached_in_memory.	13
+
+query II
+FROM sql_auto_complete('CREATE TABLE attached_in_memory.a') LIMIT 1;
+----
+abcdefgh.	32
+
+statement error
+FROM sql_auto_complete(NULL);
+----
+Binder Error: sql_auto_complete first parameter cannot be NULL

external/duckdb/test/sql/function/autocomplete/create_type.test

@@ -0,0 +1,25 @@
+# name: test/sql/function/autocomplete/create_type.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+query II
+FROM sql_auto_complete('CREATE TY') LIMIT 1;
+----
+TYPE 	7
+
+query II
+FROM sql_auto_complete('CREATE TYPE my_type AS ENU') LIMIT 1;
+----
+ENUM	23
+
+query II
+FROM sql_auto_complete('CREATE TYPE my_type AS TIME WITH TI') LIMIT 1;
+----
+TIME 	33
+
+query II
+FROM sql_auto_complete('CREATE TYPE my_type AS ROW(ts TIMESTAMP WITH TIME ZON') LIMIT 1;
+----
+ZONE 	50

external/duckdb/test/sql/function/autocomplete/drop.test

@@ -0,0 +1,54 @@
+# name: test/sql/function/autocomplete/drop.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+query II
+FROM sql_auto_complete('DRO') LIMIT 1;
+----
+DROP 	0
+
+query II
+FROM sql_auto_complete('DROP TA') LIMIT 1;
+----
+TABLE 	5
+
+query II
+FROM sql_auto_complete('DROP VI') LIMIT 1;
+----
+VIEW 	5
+
+query II
+FROM sql_auto_complete('DROP TABLE IF EX') LIMIT 1;
+----
+EXISTS 	14
+
+query II
+FROM sql_auto_complete('DROP TABLE tbl CAS') LIMIT 1;
+----
+CASCADE 	15
+
+statement ok
+CREATE TABLE my_table(my_column INTEGER);
+
+query II
+FROM sql_auto_complete('DROP TABLE my_') LIMIT 1;
+----
+my_table	11
+
+statement ok
+CREATE SCHEMA my_schema;
+
+statement ok
+CREATE TABLE my_schema.table_in_schema(my_column INTEGER)
+
+query II
+FROM sql_auto_complete('DROP TABLE my_s') LIMIT 1;
+----
+my_schema.	11
+
+query II
+FROM sql_auto_complete('DROP TABLE my_schema.t') LIMIT 1;
+----
+table_in_schema	21

external/duckdb/test/sql/function/autocomplete/expressions.test

@@ -0,0 +1,101 @@
+# name: test/sql/function/autocomplete/expressions.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+# literal
+query II
+FROM sql_auto_complete('SELECT NULL FR') LIMIT 1;
+----
+FROM 	12
+
+# cast
+query II
+FROM sql_auto_complete('SELECT CAST(a AS INTE') LIMIT 1;
+----
+INTEGER	17
+
+query II
+FROM sql_auto_complete('SELECT a::INTE') LIMIT 1;
+----
+INTEGER	10
+
+# distinct
+query II
+FROM sql_auto_complete('SELECT col IS DIST') LIMIT 1;
+----
+DISTINCT 	14
+
+query II
+FROM sql_auto_complete('SELECT col IS DISTINCT FRO') LIMIT 1;
+----
+FROM 	23
+
+# collate
+query II
+FROM sql_auto_complete('SELECT col COLL') LIMIT 1;
+----
+COLLATE 	11
+
+# between
+query II
+FROM sql_auto_complete('SELECT col BETW') LIMIT 1;
+----
+BETWEEN 	11
+
+# case
+query II
+FROM sql_auto_complete('SELECT CASE WH') LIMIT 1;
+----
+WHEN 	12
+
+# functions
+query II
+FROM sql_auto_complete('SELECT sum(42) IS NOT NUL') LIMIT 1;
+----
+NULL 	22
+
+query II
+FROM sql_auto_complete('SELECT sum(disti') LIMIT 1;
+----
+distinct 	11
+
+query II
+FROM sql_auto_complete('SELECT sum(a, b orde') LIMIT 1;
+----
+order 	16
+
+query II
+FROM sql_auto_complete('SELECT sum(a) filt') LIMIT 1;
+----
+filter 	14
+
+query II
+FROM sql_auto_complete('SELECT CASE WHEN a=1 THEN 1 WHEN a=2 THEN 2 WHEN a=3 THEN 3 END FR') LIMIT 1;
+----
+FROM 	64
+
+# slice
+query II
+FROM sql_auto_complete('SELECT col[1:2] FR') LIMIT 1;
+----
+FROM 	16
+
+# test parsing of many expressions
+query II
+FROM sql_auto_complete('SELECT col BETWEEN 1 AND 2, col > col2, col AND (col2 OR col3), col4 IS NOT DISTINCT FROM col5, col6 IN (SELECT * FROM tbl) FR') LIMIT 1;
+----
+FROM 	124
+
+# literals
+query II
+FROM sql_auto_complete('SELECT 42, 83.5, -125, 1.25e375, [1, 2, 3, 4], {''name'': 42}, ARRAY[col, col2 + 1] FR') LIMIT 1;
+----
+FROM 	82
+
+# complex types
+query II
+FROM sql_auto_complete('SELECT a::DECIMAL(42), b::INT[3], []::INT[][][], d::ROW(i INT[], c ROW(d INTE') LIMIT 1;
+----
+INTEGER	73

external/duckdb/test/sql/function/autocomplete/identical_schema_table.test

@@ -0,0 +1,16 @@
+# name: test/sql/function/autocomplete/identical_schema_table.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+statement ok
+CREATE SCHEMA my_catalog_entry;
+
+statement ok
+CREATE TABLE my_catalog_entry(i INT);
+
+query II
+FROM sql_auto_complete('FROM my_c') LIMIT 1;
+----
+my_catalog_entry	5

external/duckdb/test/sql/function/autocomplete/insert_into.test

@@ -0,0 +1,41 @@
+# name: test/sql/function/autocomplete/insert_into.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+query II
+FROM sql_auto_complete('INS') LIMIT 1;
+----
+INSERT 	0
+
+query II
+FROM sql_auto_complete('INSERT IN') LIMIT 1;
+----
+INTO 	7
+
+query II
+FROM sql_auto_complete('INSERT INTO tbl VAL') LIMIT 1;
+----
+VALUES 	16
+
+query II
+FROM sql_auto_complete('INSERT INTO tbl(c1, c2) VAL') LIMIT 1;
+----
+VALUES 	24
+
+query II
+FROM sql_auto_complete('INSERT INTO tbl(c1, c2) SEL') LIMIT 1;
+----
+SELECT 	24
+
+# on conflict actions
+query II
+FROM sql_auto_complete('INSERT OR IG') LIMIT 1;
+----
+IGNORE 	10
+
+query II
+FROM sql_auto_complete('INSERT OR REP') LIMIT 1;
+----
+REPLACE 	10

external/duckdb/test/sql/function/autocomplete/pragma.test

@@ -0,0 +1,29 @@
+# name: test/sql/function/autocomplete/pragma.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+# main keywords
+query II
+FROM sql_auto_complete('PRAGMA show_t') LIMIT 1;
+----
+show_tables	7
+
+# main keywords
+query II
+FROM sql_auto_complete('PRAGMA enable_che') LIMIT 1;
+----
+enable_checkpoint_on_shutdown	7
+
+# main keywords
+query II
+FROM sql_auto_complete('PRAGMA disable_che') LIMIT 1;
+----
+disable_checkpoint_on_shutdown	7
+
+# main keywords
+query II
+FROM sql_auto_complete('PRAGMA thre') LIMIT 1;
+----
+threads	7

external/duckdb/test/sql/function/autocomplete/scalar_functions.test

@@ -0,0 +1,20 @@
+# name: test/sql/function/autocomplete/scalar_functions.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+query II
+FROM sql_auto_complete('select gam') LIMIT 1;
+----
+gamma	7
+
+query II
+FROM sql_auto_complete('select nexta') LIMIT 1;
+----
+nextafter	7
+
+query II
+FROM sql_auto_complete('select bit_l') LIMIT 1;
+----
+bit_length	7

external/duckdb/test/sql/function/autocomplete/select.test

@@ -0,0 +1,255 @@
+# name: test/sql/function/autocomplete/select.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+# main keywords
+query II
+FROM sql_auto_complete('SEL') LIMIT 1;
+----
+SELECT 	0
+
+query II
+FROM sql_auto_complete('WI') LIMIT 1;
+----
+WITH 	0
+
+query II
+FROM sql_auto_complete('SELECT * FR') LIMIT 1;
+----
+FROM 	9
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl WH') LIMIT 1;
+----
+WHERE 	18
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl A') LIMIT 1;
+----
+AS 	18
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl OR') LIMIT 1;
+----
+ORDER 	18
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl ORDER B') LIMIT 1;
+----
+BY 	24
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl ORDER BY AL') LIMIT 1;
+----
+ALL 	27
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl GR') LIMIT 1;
+----
+GROUP 	18
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl GROUP B') LIMIT 1;
+----
+BY 	24
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl GROUP BY AL') LIMIT 1;
+----
+ALL 	27
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl GROUP BY ALL HAV') LIMIT 1;
+----
+HAVING 	31
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl LIM') LIMIT 1;
+----
+LIMIT 	18
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl LIMIT 5 OF') LIMIT 1;
+----
+OFFSET 	26
+
+# joins
+query II
+FROM sql_auto_complete('SELECT * FROM tbl INN') LIMIT 1;
+----
+INNER 	18
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl INNER JO') LIMIT 1;
+----
+JOIN 	24
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl JOIN tbl2 USING (i) WH') LIMIT 1;
+----
+WHERE 	38
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl LEF') LIMIT 1;
+----
+LEFT 	18
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl LEFT OUT') LIMIT 1;
+----
+OUTER 	23
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl NAT') LIMIT 1;
+----
+NATURAL 	18
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl NATURAL FU') LIMIT 1;
+----
+FULL 	26
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl NATURAL FULL OUT') LIMIT 1;
+----
+OUTER 	31
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl POS') LIMIT 1;
+----
+POSITIONAL 	18
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl NATURAL JOIN tbl2 WH') LIMIT 1;
+----
+WHERE 	36
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl NATURAL JOIN tbl2 NAT') LIMIT 1;
+----
+NATURAL 	36
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl JOIN tbl2 US') LIMIT 1;
+----
+USING 	28
+
+# cross product
+query II
+FROM sql_auto_complete('SELECT * FROM tbl, tbl2 WH') LIMIT 1;
+----
+WHERE 	24
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl, tbl2 LEFT OUT') LIMIT 1;
+----
+OUTER 	29
+
+# from first
+query II
+FROM sql_auto_complete('FR') LIMIT 1;
+----
+FROM 	0
+
+query II
+FROM sql_auto_complete('FROM tbl SEL') LIMIT 1;
+----
+SELECT 	9
+
+query II
+FROM sql_auto_complete('FROM tbl OR') LIMIT 1;
+----
+ORDER 	9
+
+# set ops
+query II
+FROM sql_auto_complete('SELECT * FROM tbl UN') LIMIT 1;
+----
+UNION 	18
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl UNION AL') LIMIT 1;
+----
+ALL 	24
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl EX') LIMIT 1;
+----
+EXCEPT 	18
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl INT') LIMIT 1;
+----
+INTERSECT 	18
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl UNION ALL SEL') LIMIT 1;
+----
+SELECT 	28
+
+# qualify
+query II
+FROM sql_auto_complete('SELECT * FROM tbl QUAL') LIMIT 1;
+----
+QUALIFY 	18
+
+query II
+FROM sql_auto_complete('SELECT * FROM tbl QUALIFY row_number() OVER () ORD') LIMIT 1;
+----
+ORDER 	47
+
+# operators with quotes
+query II
+FROM sql_auto_complete('SELECT col=''world'' FR') LIMIT 1;
+----
+FROM 	19
+
+query II
+FROM sql_auto_complete('SELECT col="quoted col2" FR') LIMIT 1;
+----
+FROM 	25
+
+query II
+FROM sql_auto_complete('SELECT "quoted col1"="quoted col2" + "quoted col3" FR') LIMIT 1;
+----
+FROM 	51
+
+# quoted identifiers
+query II
+FROM sql_auto_complete('SELECT ''ORDER'' "WHERE" FR') LIMIT 1;
+----
+FROM 	23
+
+# escaped quoted identifiers
+query II
+FROM sql_auto_complete('SELECT ''OR''''DER'' "WHE""RE" FR') LIMIT 1;
+----
+FROM 	27
+
+statement ok
+CREATE TABLE my_table(my_column INTEGER);
+
+query II
+SELECT * FROM sql_auto_complete('SELECT my_') LIMIT 1;
+----
+my_column	7
+
+query II
+SELECT * FROM sql_auto_complete('UP') LIMIT 1;
+----
+UPDATE 	0
+
+query II
+SELECT * FROM sql_auto_complete('UPDATE my_table SET m') LIMIT 1;
+----
+my_column	20
+
+statement ok
+CREATE TABLE MyTable(MyColumn Varchar);
+
+query II
+SELECT * FROM sql_auto_complete('SELECT My') LIMIT 1;
+----
+MyColumn	7

external/duckdb/test/sql/function/autocomplete/setting.test

@@ -0,0 +1,39 @@
+# name: test/sql/function/autocomplete/setting.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+require icu
+
+require no_extension_autoloading "FIXME: ICU is not autoloaded on 'Set timez'"
+
+query II
+FROM sql_auto_complete('SET e_directory') LIMIT 1;
+----
+home_directory	4
+
+query II
+from sql_auto_complete('SET timez') LIMIT 1;
+----
+TimeZone	4
+
+query II
+FROM sql_auto_complete('SET memory') LIMIT 1;
+----
+memory_limit	4
+
+# main keywords
+query II
+FROM sql_auto_complete('set thr') LIMIT 1;
+----
+threads	4
+
+# main keywords
+query II
+FROM sql_auto_complete('set allowe') LIMIT 1;
+----
+allowed_paths	4
+
+
+

external/duckdb/test/sql/function/autocomplete/show.test

@@ -0,0 +1,34 @@
+# name: test/sql/function/autocomplete/show.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+query II
+FROM sql_auto_complete('DESCR') LIMIT 1;
+----
+DESCRIBE 	0
+
+statement ok
+CREATE TABLE my_table(my_column INTEGER);
+
+query II
+FROM sql_auto_complete('SHOW my_') LIMIT 1;
+----
+my_table	5
+
+statement ok
+CREATE SCHEMA my_schema;
+
+statement ok
+CREATE TABLE my_schema.table_in_schema(my_column INTEGER)
+
+query II
+FROM sql_auto_complete('SHOW my_s') LIMIT 1;
+----
+my_schema.	5
+
+query II
+FROM sql_auto_complete('DESCRIBE my_schema.t') LIMIT 1;
+----
+table_in_schema	19

external/duckdb/test/sql/function/autocomplete/suggest_file.test

@@ -0,0 +1,18 @@
+# name: test/sql/function/autocomplete/suggest_file.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require notwindows
+
+require autocomplete
+
+# test file auto complete
+query II
+FROM sql_auto_complete('COPY tbl FROM ''data/parq') LIMIT 1;
+----
+parquet-testing/	20
+
+query II
+FROM sql_auto_complete('COPY tbl FROM ''data/csv/all_quote') LIMIT 1;
+----
+all_quotes.csv'	24

external/duckdb/test/sql/function/autocomplete/table_functions.test

@@ -0,0 +1,50 @@
+# name: test/sql/function/autocomplete/table_functions.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+query II
+FROM sql_auto_complete('call histo') LIMIT 1;
+----
+histogram	5
+
+query II
+FROM sql_auto_complete('call histogram_') LIMIT 1;
+----
+histogram_values	5
+
+query II
+FROM sql_auto_complete('call duckdb_t') LIMIT 1;
+----
+duckdb_types	5
+
+query II
+FROM sql_auto_complete('FROM duckdb_c') LIMIT 1;
+----
+duckdb_columns	5
+
+query II
+FROM sql_auto_complete('call read_cs') LIMIT 1;
+----
+read_csv	5
+
+query II
+FROM sql_auto_complete('FROM read_csv_a') LIMIT 1;
+----
+read_csv_auto	5
+
+query II
+FROM sql_auto_complete('call unnes') LIMIT 1;
+----
+unnest	5
+
+query II
+FROM sql_auto_complete('CALL glo') LIMIT 1;
+----
+"glob"	5
+
+query II
+FROM sql_auto_complete('from ran') LIMIT 1;
+----
+"range"	5

external/duckdb/test/sql/function/autocomplete/tpch.test

@@ -0,0 +1,158 @@
+# name: test/sql/function/autocomplete/tpch.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+require tpch
+
+# column names
+statement ok
+CALL dbgen(sf=0);
+
+query II
+FROM sql_auto_complete('SELECT l_ord') LIMIT 1;
+----
+l_orderkey	7
+
+# arithmetic
+query II
+FROM sql_auto_complete('SELECT 1 + l_ord') LIMIT 1;
+----
+l_orderkey	11
+
+# function calls
+query II
+FROM sql_auto_complete('SELECT min(l_ord') LIMIT 1;
+----
+l_orderkey	11
+
+query II
+FROM sql_auto_complete('SELECT min(42, l_ord') LIMIT 1;
+----
+l_orderkey	15
+
+# like
+query II
+FROM sql_auto_complete('SELECT ''test_string'' LIKE l_c') LIMIT 1;
+----
+l_comment	26
+
+query II
+FROM sql_auto_complete('SELECT l_orderkey FROM lin') LIMIT 1;
+----
+lineitem	23
+
+query II
+FROM sql_auto_complete('SELECT l_orderkey FROM lineitem, ord') LIMIT 1;
+----
+orders	33
+
+query II
+FROM sql_auto_complete('SELECT l_orderkey FROM lineitem JOIN ord') LIMIT 1;
+----
+orders	37
+
+query II
+FROM sql_auto_complete('SELECT (SELECT SUM(l_orderkey) FROM lineit') LIMIT 1;
+----
+lineitem	36
+
+query II
+FROM sql_auto_complete('SELECT * FROM (FROM lineit') LIMIT 1;
+----
+lineitem	20
+
+query II
+FROM sql_auto_complete('INSERT INTO lin') LIMIT 1;
+----
+lineitem	12
+
+query II
+FROM sql_auto_complete('DROP TABLE lin') LIMIT 1;
+----
+lineitem	11
+
+query II
+FROM sql_auto_complete('COPY lin') LIMIT 1;
+----
+lineitem	5
+
+query II
+FROM sql_auto_complete('DROP TABLE na') LIMIT 1;
+----
+nation	11
+
+query II
+SELECT * FROM sql_auto_complete('SELECT * FROM partsupp JOIN supplier USING (ps_su') LIMIT 1;
+----
+ps_suppkey	44
+
+# more complex queries
+query II
+FROM sql_auto_complete($$
+SELECT
+    nation,
+    o_year,
+    sum(amount) AS sum_profit
+FROM (
+    SELECT
+        n_name AS nation,
+        extract(year FROM o_orderdate) AS o_year,
+        l_extendedprice * (1 - l_discount) - ps_supplycost * l_quantity AS amount
+    FROM
+        part,
+        supplier,
+        lineitem,
+        partsupp,
+        orders,
+        nation
+    WHERE
+        s_suppkey = l_suppkey
+        AND ps_suppkey = l_suppkey
+        AND ps_partkey = l_partkey
+        AND p_partkey = l_partkey
+        AND o_orderkey = l_orderkey
+        AND s_nationkey = n_nat$$) LIMIT 1;
+----
+n_nationkey	552
+
+query II
+FROM sql_auto_complete($$
+SELECT
+    l_returnflag,
+    l_linestatus,
+    sum(l_quantity) AS sum_qty,
+    sum(l_extendedprice) AS sum_base_price,
+    sum(l_extendedprice * (1 - l_discount)) AS sum_disc_price,
+    sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) AS sum_charge,
+    avg(l_quantity) AS avg_qty,
+    avg(l_extendedprice) AS avg_price,
+    avg(l_discount) AS avg_disc,
+    count(*) AS count_order
+FROM
+    lineitem
+WHERE
+    l_shipdate <= CAST('1998-09-02' AS date)
+GROUP BY
+    l_ret$$) LIMIT 1;
+----
+l_returnflag	470
+
+query II
+FROM sql_auto_complete($$
+SELECT
+    nation,
+    o_year,
+    sum(amount) AS sum_profit
+FROM (
+    SELECT
+        n_name AS nation,
+        extract(year FROM o_orderdate) AS o_year,
+        l_extendedprice * (1 - l_discount) - ps_supplycost * l_quantity AS amount
+    FROM
+        part,
+        supplier,
+        line$$) LIMIT 1;
+----
+lineitem	287

external/duckdb/test/sql/function/autocomplete/window.test

@@ -0,0 +1,57 @@
+# name: test/sql/function/autocomplete/window.test
+# description: Test sql_auto_complete
+# group: [autocomplete]
+
+require autocomplete
+
+# literal
+query II
+FROM sql_auto_complete('SELECT row_number() OVER (RANG') LIMIT 1;
+----
+RANGE 	26
+
+query II
+FROM sql_auto_complete('SELECT row_number() OVER (RANGE BETWE') LIMIT 1;
+----
+BETWEEN 	32
+
+query II
+FROM sql_auto_complete('SELECT row_number() OVER (RANGE BETWEEN UNBOU') LIMIT 1;
+----
+UNBOUNDED 	40
+
+query II
+FROM sql_auto_complete('SELECT row_number() OVER (RANGE BETWEEN UNBOUNDED PREC') LIMIT 1;
+----
+PRECEDING 	50
+
+query II
+FROM sql_auto_complete('SELECT row_number() OVER (RANGE BETWEEN CURRENT ROW AND 5 PREC') LIMIT 1;
+----
+PRECEDING 	58
+
+query II
+FROM sql_auto_complete('SELECT row_number() OVER (PART') LIMIT 1;
+----
+PARTITION 	26
+
+query II
+FROM sql_auto_complete('SELECT lag(col1) OVER (PARTITION BY col1, col2 ORD') LIMIT 1;
+----
+ORDER 	47
+
+query II
+FROM sql_auto_complete('SELECT sum(42) OVER (PARTITION BY col1, col2 ORDER BY col3 ROW') LIMIT 1;
+----
+ROWS 	59
+
+# window clause
+query II
+FROM sql_auto_complete('SELECT lead(l_orderkey) OVER win FR') LIMIT 1;
+----
+FROM 	33
+
+query II
+FROM sql_auto_complete('SELECT lead(l_orderkey) OVER (win) FROM tbl WINDOW win AS (PART') LIMIT 1;
+----
+PARTITION 	59

external/duckdb/test/sql/function/blob/base64.test

@@ -0,0 +1,96 @@
+# name: test/sql/function/blob/base64.test
+# description: Test blob base64 functions
+# group: [blob]
+
+statement ok
+PRAGMA enable_verification
+
+# test base64 encoding
+query I
+SELECT base64(encode(''))
+----
+(empty)
+
+query I
+SELECT base64(encode('a'))
+----
+YQ==
+
+query I
+SELECT base64(encode('ab'))
+----
+YWI=
+
+query I
+SELECT base64(encode('abc'))
+----
+YWJj
+
+query I
+SELECT base64(encode('üäabcdef'))
+----
+w7zDpGFiY2RlZg==
+
+query I
+SELECT base64(encode('iJWERiuhjruhwuiehr8493231'))
+----
+aUpXRVJpdWhqcnVod3VpZWhyODQ5MzIzMQ==
+
+query I
+SELECT base64(encode('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'))
+----
+YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWjEyMzQ1Njc4OTA=
+
+query I
+SELECT to_base64(encode('base64 encoded string'));
+----
+YmFzZTY0IGVuY29kZWQgc3RyaW5n
+
+# test base64 decoding round-trip
+query I
+SELECT from_base64(base64(encode('')))
+----
+(empty)
+
+query I
+SELECT from_base64(base64(encode('a')))
+----
+a
+
+query I
+SELECT from_base64(base64(encode('ab')))
+----
+ab
+
+query I
+SELECT from_base64(base64(encode('abc')))
+----
+abc
+
+query I
+SELECT from_base64(base64(encode('iJWERiuhjruhwuiehr8493231')))
+----
+iJWERiuhjruhwuiehr8493231
+
+query I
+SELECT from_base64(base64(encode('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')))
+----
+abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890
+
+query I
+select from_base64('AAAA');
+----
+\x00\x00\x00
+
+# malformed base64
+# must be multiple of 4
+statement error
+SELECT from_base64('ab');
+----
+<REGEX>:.*Conversion Error: Could not decode string.*
+
+# unknown bytes
+statement error
+SELECT from_base64('üab');
+----
+<REGEX>:.*Conversion Error: Could not decode string.*

external/duckdb/test/sql/function/blob/create_sort_key.test

@@ -0,0 +1,351 @@
+# name: test/sql/function/blob/create_sort_key.test
+# description: Test create_sort_key function
+# group: [blob]
+
+statement ok
+PRAGMA enable_verification
+
+# test integer types with all modifiers
+statement ok
+CREATE TABLE integers(i INTEGER);
+
+statement ok
+INSERT INTO integers VALUES (1), (2), (3), (NULL)
+
+query I
+SELECT * FROM integers ORDER BY create_sort_key(i, 'ASC NULLS LAST')
+----
+1
+2
+3
+NULL
+
+query I
+SELECT * FROM integers ORDER BY create_sort_key(i, 'ASC NULLS FIRST')
+----
+NULL
+1
+2
+3
+
+query I
+SELECT * FROM integers ORDER BY create_sort_key(i, 'DESC NULLS LAST')
+----
+3
+2
+1
+NULL
+
+query I
+SELECT * FROM integers ORDER BY create_sort_key(i, 'DESC NULLS FIRST')
+----
+NULL
+3
+2
+1
+
+# test varchar types
+statement ok
+CREATE TABLE varchars(v VARCHAR);
+
+statement ok
+INSERT INTO varchars VALUES ('hello'), ('hello' || chr(0) || chr(0)), ('world'), (''), (NULL)
+
+query I
+SELECT * FROM varchars ORDER BY create_sort_key(v, 'ASC NULLS LAST')
+----
+(empty)
+hello
+hello\0\0
+world
+NULL
+
+query I
+SELECT * FROM varchars ORDER BY create_sort_key(v, 'ASC NULLS FIRST')
+----
+NULL
+(empty)
+hello
+hello\0\0
+world
+
+query I
+SELECT * FROM varchars ORDER BY create_sort_key(v, 'DESC NULLS LAST')
+----
+world
+hello\0\0
+hello
+(empty)
+NULL
+
+query I
+SELECT * FROM varchars ORDER BY create_sort_key(v, 'DESC NULLS FIRST')
+----
+NULL
+world
+hello\0\0
+hello
+(empty)
+
+# test list types
+statement ok
+CREATE TABLE int_list(l INT[]);
+
+statement ok
+INSERT INTO int_list VALUES ([1, 2, 3]), ([]), ([1]), ([2]), ([NULL]), (NULL);
+
+query I
+SELECT l FROM int_list ORDER BY create_sort_key(l, 'ASC NULLS LAST')
+----
+[]
+[1]
+[1, 2, 3]
+[2]
+[NULL]
+NULL
+
+query I
+SELECT l FROM int_list ORDER BY create_sort_key(l, 'DESC NULLS LAST')
+----
+[NULL]
+[2]
+[1, 2, 3]
+[1]
+[]
+NULL
+
+query I
+SELECT l FROM int_list ORDER BY create_sort_key(l, 'ASC NULLS FIRST')
+----
+NULL
+[]
+[1]
+[1, 2, 3]
+[2]
+[NULL]
+
+query I
+SELECT l FROM int_list ORDER BY create_sort_key(l, 'DESC NULLS FIRST')
+----
+NULL
+[NULL]
+[2]
+[1, 2, 3]
+[1]
+[]
+
+
+# test struct types
+statement ok
+CREATE TABLE structs(s ROW(i INT, v VARCHAR));
+
+statement ok
+INSERT INTO structs VALUES ({'i': 42, v: 'hello'}), ({'i': 42, v: 'hello' || chr(0)}), ({'i': 43, v: ''}), (NULL), ({'i': 42, v: NULL}), ({'i': NULL, v: ''})
+
+query I
+SELECT * FROM structs ORDER BY create_sort_key(s, 'ASC NULLS LAST')
+----
+{'i': 42, 'v': hello}
+{'i': 42, 'v': hello\0}
+{'i': 42, 'v': NULL}
+{'i': 43, 'v': ''}
+{'i': NULL, 'v': ''}
+NULL
+
+query II
+SELECT s.i, s.v FROM structs ORDER BY create_sort_key(s.i, 'ASC NULLS LAST', s.v, 'ASC NULLS LAST')
+----
+42	hello
+42	hello\0
+42	NULL
+43	(empty)
+NULL	(empty)
+NULL	NULL
+
+query I
+SELECT * FROM structs ORDER BY create_sort_key(s, 'DESC NULLS FIRST')
+----
+NULL
+{'i': NULL, 'v': ''}
+{'i': 43, 'v': ''}
+{'i': 42, 'v': NULL}
+{'i': 42, 'v': hello\0}
+{'i': 42, 'v': hello}
+
+query II
+SELECT s.i, s.v FROM structs ORDER BY create_sort_key(s.i, 'DESC NULLS FIRST', s.v, 'DESC NULLS FIRST')
+----
+NULL	NULL
+NULL	(empty)
+43	(empty)
+42	NULL
+42	hello\0
+42	hello
+
+# test struct types
+statement ok
+CREATE TABLE list_of_structs(s ROW(i INT, v VARCHAR)[]);
+
+statement ok
+INSERT INTO list_of_structs VALUES
+([{'i': 42, v: 'hello'}]),
+([]),
+([{'i': 42, v: 'hello'}, {'i': 84, v: ''}]),
+([{'i': 43, v: ''}]),
+(NULL),
+([NULL]),
+([{'i': 42, v: NULL}]),
+([{'i': NULL, v: ''}]),
+([{'i': 42, v: 'hello'}, {'i': 84, v: chr(0)}]),
+([{'i': 42, v: 'hello'}, NULL, {'i': 84, v: ''}])
+
+query I
+SELECT * FROM list_of_structs ORDER BY create_sort_key(s, 'ASC NULLS LAST')
+----
+[]
+[{'i': 42, 'v': hello}]
+[{'i': 42, 'v': hello}, {'i': 84, 'v': ''}]
+[{'i': 42, 'v': hello}, {'i': 84, 'v': \0}]
+[{'i': 42, 'v': hello}, NULL, {'i': 84, 'v': ''}]
+[{'i': 42, 'v': NULL}]
+[{'i': 43, 'v': ''}]
+[{'i': NULL, 'v': ''}]
+[NULL]
+NULL
+
+query I
+SELECT * FROM list_of_structs ORDER BY create_sort_key(s, 'DESC NULLS FIRST')
+----
+NULL
+[NULL]
+[{'i': NULL, 'v': ''}]
+[{'i': 43, 'v': ''}]
+[{'i': 42, 'v': NULL}]
+[{'i': 42, 'v': hello}, NULL, {'i': 84, 'v': ''}]
+[{'i': 42, 'v': hello}, {'i': 84, 'v': \0}]
+[{'i': 42, 'v': hello}, {'i': 84, 'v': ''}]
+[{'i': 42, 'v': hello}]
+[]
+
+
+# test nested lists
+statement ok
+CREATE TABLE nested_lists(s INT[][]);
+
+statement ok
+INSERT INTO nested_lists VALUES
+([]),
+([[], []]),
+(NULL),
+([NULL]),
+([[NULL]]),
+([[42, 84]]),
+([[42], [84]]),
+([[42], NULL, [84]]),
+([[42], [NULL], [84]]),
+([[1, 2, 3, 4, 5, 6, 7, 8, 9]])
+
+query I
+SELECT * FROM nested_lists ORDER BY create_sort_key(s, 'ASC NULLS LAST')
+----
+[]
+[[], []]
+[[1, 2, 3, 4, 5, 6, 7, 8, 9]]
+[[42], [84]]
+[[42], [NULL], [84]]
+[[42], NULL, [84]]
+[[42, 84]]
+[[NULL]]
+[NULL]
+NULL
+
+query I
+SELECT * FROM nested_lists ORDER BY create_sort_key(s, 'DESC NULLS FIRST')
+----
+NULL
+[NULL]
+[[NULL]]
+[[42, 84]]
+[[42], NULL, [84]]
+[[42], [NULL], [84]]
+[[42], [84]]
+[[1, 2, 3, 4, 5, 6, 7, 8, 9]]
+[[], []]
+[]
+
+
+# test blobs
+statement ok
+CREATE TABLE blobs(b BLOB, c BLOB);
+
+statement ok
+INSERT INTO blobs VALUES (NULL, NULL), ('hello\x00\x00\x00\x00\x00', NULL), ('hello', 'world'), ('hello\x01\x01\x01', 'world'), ('', ''), ('hello\x00\x00\x00\x00\x00', 'world'), ('hello\x00', NULL)
+
+query I
+SELECT b FROM blobs ORDER BY create_sort_key(b, 'ASC NULLS LAST')
+----
+(empty)
+hello
+hello\x00
+hello\x00\x00\x00\x00\x00
+hello\x00\x00\x00\x00\x00
+hello\x01\x01\x01
+NULL
+
+query I
+SELECT b FROM blobs ORDER BY create_sort_key(b, 'DESC NULLS FIRST')
+----
+NULL
+hello\x01\x01\x01
+hello\x00\x00\x00\x00\x00
+hello\x00\x00\x00\x00\x00
+hello\x00
+hello
+(empty)
+
+query II
+SELECT * FROM blobs ORDER BY create_sort_key(b, 'ASC NULLS LAST', c, 'ASC NULLS LAST')
+----
+(empty)	(empty)
+hello	world
+hello\x00	NULL
+hello\x00\x00\x00\x00\x00	world
+hello\x00\x00\x00\x00\x00	NULL
+hello\x01\x01\x01	world
+NULL	NULL
+
+query II
+SELECT * FROM blobs ORDER BY create_sort_key(b, 'DESC NULLS FIRST', c, 'DESC NULLS FIRST')
+----
+NULL	NULL
+hello\x01\x01\x01	world
+hello\x00\x00\x00\x00\x00	NULL
+hello\x00\x00\x00\x00\x00	world
+hello\x00	NULL
+hello	world
+(empty)	(empty)
+
+# test array type
+statement ok
+CREATE TABLE arrays(l INT[3]);
+
+statement ok
+INSERT INTO arrays VALUES ([1, 2, 3]), (NULL), ([NULL, NULL, NULL]), ([1, NULL, 3]), ([2, 3, 4]);
+
+query I
+SELECT l FROM arrays ORDER BY create_sort_key(l, 'ASC NULLS LAST')
+----
+[1, 2, 3]
+[1, NULL, 3]
+[2, 3, 4]
+[NULL, NULL, NULL]
+NULL
+
+query I
+SELECT l FROM arrays ORDER BY create_sort_key(l, 'DESC NULLS FIRST')
+----
+NULL
+[NULL, NULL, NULL]
+[2, 3, 4]
+[1, NULL, 3]
+[1, 2, 3]

external/duckdb/test/sql/function/blob/encode.test

@@ -0,0 +1,41 @@
+# name: test/sql/function/blob/encode.test
+# description: Test blob encode/decode functions
+# group: [blob]
+
+statement ok
+PRAGMA enable_verification
+
+# test basic encode/decode usage
+query I
+SELECT encode('ü')
+----
+\xC3\xBC
+
+query I
+SELECT decode(encode('ü'))
+----
+ü
+
+query I
+SELECT decode('\xF0\x9F\xA6\x86'::BLOB)
+----
+🦆
+
+# null byte
+query I
+SELECT decode('\x00'::BLOB)
+----
+\0
+
+# test invalid decodes
+statement error
+SELECT decode('\xFF'::BLOB)
+----
+
+query I
+SELECT decode(encode(a)) || a from (values ('hello'), ('world')) tbl(a);
+----
+hellohello
+worldworld
+
+

external/duckdb/test/sql/function/blob/test_blob_array_slice.test

@@ -0,0 +1,71 @@
+# name: test/sql/function/blob/test_blob_array_slice.test
+# description: Blob slicing test
+# group: [blob]
+
+statement ok
+PRAGMA enable_verification
+
+query I
+select array_slice(blob '\x00\x01\x02\x03\x04\x05', 2, 4)
+----
+\x01\x02\x03
+
+# zero-offset works fine, too
+query I
+select array_slice(blob '\x00\x01\x02\x03\x04\x05', 0, 2)
+----
+\x00\x01
+
+# other syntax works, too
+query I
+select (blob '\x00\x01\x02\x03\x04\x05'::BLOB)[2:4]
+----
+\x01\x02\x03
+
+# we can have offsets bigger than length
+query I
+select array_slice(blob '\x00\x01\x02\x03\x04\x05', 4, 10)
+----
+\x03\x04\x05
+
+# nonsensical offsets lead to empty BLOB
+query I
+select octet_length(array_slice(blob '\x00\x01\x02\x03\x04\x05', 4, 3))
+----
+0
+
+# we can have negative offsets from back, this is somehow consistent with strings
+query I
+select array_slice(blob  '\x00\x01\x02\x03\x04\x05', 2,-2)
+----
+\x01\x02\x03\x04
+
+# both can be negative
+# we can have negative offsets from back, this is somehow consistent with strings
+query I
+select array_slice(blob '\x00\x01\x02\x03\x04\x05', -4, -2)
+----
+\x02\x03\x04
+
+# we can subset utf characters when they're blobs
+query I
+select array_slice(blob '\x00\xF0\x9F\xA6\x86\x00', 2, 3)
+----
+\xF0\x9F
+
+# we can subset utf characters when they're blobs
+query I
+select array_slice(blob '\x00\xF0\x9F\xA6\x86\x00', 4, 6)
+----
+\xA6\x86\x00
+
+# we can slice blob NULL
+query I
+select array_slice(NULL::BLOB, 4, 6)
+----
+NULL
+
+statement error
+select array_slice('hello world', 1, 8, 2);
+----
+Slice with steps has not been implemented for string types

external/duckdb/test/sql/function/blob/test_concat_blob.test

@@ -0,0 +1,28 @@
+# name: test/sql/function/blob/test_concat_blob.test
+# description: Test concat of blobs function
+# group: [blob]
+
+statement ok
+PRAGMA enable_verification
+
+# concat operator works with blobs
+query I
+SELECT blob 'aaa\x80' || blob 'aaa\x80'
+----
+aaa\x80aaa\x80
+
+query I
+SELECT typeof(blob 'aaa\x80' || blob 'aaa\x80')
+----
+BLOB
+
+# concat function works - but it converts to varchar
+query I
+SELECT concat(blob 'aaa\x80', blob 'aaa\x80')
+----
+aaa\x80aaa\x80
+
+query I
+SELECT typeof(concat(blob 'aaa\x80', blob 'aaa\x80'))
+----
+VARCHAR

external/duckdb/test/sql/function/date/date_add.test

@@ -0,0 +1,23 @@
+# name: test/sql/function/date/date_add.test
+# description: Test date_add/date_sub
+# group: [date]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+CREATE TABLE dates(d DATE);
+
+statement ok
+INSERT INTO dates VALUES (DATE '1992-01-01')
+
+# date_add, bigquery
+query I
+SELECT DATE_ADD(DATE '2008-12-25', INTERVAL 5 DAY) AS five_days_later;
+----
+2008-12-30 00:00:00
+
+query I
+SELECT DATE_ADD(TIMESTAMP '2008-12-25 00:00:00', INTERVAL 5 DAY) AS five_days_later;
+----
+2008-12-30 00:00:00

external/duckdb/test/sql/function/date/date_part_stats.test

@@ -0,0 +1,201 @@
+# name: test/sql/function/date/date_part_stats.test
+# description: Test date part stats on empty table
+# group: [date]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+CREATE TABLE dates(d DATE);
+
+# test stats propagation from empty table
+query I
+SELECT EXTRACT(year FROM d) FROM dates;
+----
+
+query I
+SELECT EXTRACT(month FROM d) FROM dates;
+----
+
+query I
+SELECT EXTRACT(day FROM d) FROM dates;
+----
+
+query I
+SELECT EXTRACT(decade FROM d) FROM dates;
+----
+
+query I
+SELECT EXTRACT(century FROM d) FROM dates;
+----
+
+query I
+SELECT EXTRACT(millennium FROM d) FROM dates;
+----
+
+query I
+SELECT EXTRACT(microseconds FROM d) FROM dates;
+----
+
+query I
+SELECT EXTRACT(milliseconds FROM d) FROM dates;
+----
+
+query I
+SELECT EXTRACT(second FROM d) FROM dates;
+----
+
+query I
+SELECT EXTRACT(minute FROM d) FROM dates;
+----
+
+query I
+SELECT EXTRACT(hour FROM d) FROM dates;
+----
+
+query I
+SELECT EXTRACT(epoch FROM d) FROM dates;
+----
+
+query I
+SELECT EXTRACT(dow FROM d) FROM dates;
+----
+
+query I
+SELECT EXTRACT(isodow FROM d) FROM dates;
+----
+
+query I
+SELECT EXTRACT(week FROM d) FROM dates;
+----
+
+query I
+SELECT EXTRACT(doy FROM d) FROM dates;
+----
+
+query I
+SELECT EXTRACT(quarter FROM d) FROM dates;
+----
+
+query I
+SELECT YEARWEEK(d) FROM dates;
+----
+
+query I
+SELECT DAYOFMONTH(d) FROM dates;
+----
+
+query I
+SELECT WEEKDAY(d) FROM dates;
+----
+
+query I
+SELECT WEEKOFYEAR(d) FROM dates;
+----
+
+statement ok
+PRAGMA disable_verification
+
+statement ok
+INSERT INTO dates VALUES (DATE '1992-01-01'), (DATE '2000-12-31');
+
+query I
+SELECT stats(EXTRACT(YEAR FROM d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*1992.*2000.*
+
+query I
+SELECT stats(EXTRACT(month FROM d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*1.*12.*
+
+query I
+SELECT stats(EXTRACT(day FROM d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*1.*31.*
+
+query I
+SELECT stats(EXTRACT(decade FROM d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*199.*200.*
+
+query I
+SELECT stats(EXTRACT(century FROM d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*20.*20.*
+
+query I
+SELECT stats(EXTRACT(millennium FROM d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*2.*2.*
+
+query I
+SELECT stats(EXTRACT(microseconds FROM d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*0.*60000000.*
+
+query I
+SELECT stats(EXTRACT(milliseconds FROM d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*0.*60000.*
+
+query I
+SELECT stats(EXTRACT(second FROM d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*0.*60.*
+
+query I
+SELECT stats(EXTRACT(minute FROM d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*0.*60.*
+
+query I
+SELECT stats(EXTRACT(hour FROM d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*0.*24.*
+
+query I
+SELECT stats(EXTRACT(dow FROM d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*0.*6.*
+
+query I
+SELECT stats(EXTRACT(isodow FROM d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*1.*7.*
+
+query I
+SELECT stats(EXTRACT(week FROM d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*1.*54.*
+
+query I
+SELECT stats(EXTRACT(doy FROM d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*1.*366.*
+
+query I
+SELECT stats(EXTRACT(quarter FROM d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*1.*4.*
+
+query I
+SELECT stats(YEARWEEK(d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*199201.*200052.*
+
+query I
+SELECT stats(DAYOFMONTH(d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*1.*31.*
+
+query I
+SELECT stats(WEEKDAY(d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*0.*6.*
+
+query I
+SELECT stats(WEEKOFYEAR(d)) FROM dates LIMIT 1;
+----
+<REGEX>:.*1.*54.*
+

external/duckdb/test/sql/function/date/date_trunc_4202.test

@@ -0,0 +1,28 @@
+# name: test/sql/function/date/date_trunc_4202.test
+# description: Issue #4202: Suspect behavior when comparing dates and timestamps
+# group: [date]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+create table t1 (date timestamp);
+
+statement ok
+insert into t1 values ('2016-12-16T00:00:00.000Z');
+
+statement ok
+insert into t1 values ('2020-02-17T23:59:59.998Z');
+
+statement ok
+insert into t1 values ('2020-02-17T23:59:59.999Z');
+
+statement ok
+insert into t1 values ('2020-02-18T00:00:00.000Z');
+
+query I
+select * from t1 WHERE (date_trunc('DAY', T1.date) < ('2020-02-17T23:59:59.999Z'::timestamp)) ORDER BY 1;
+----
+2016-12-16 00:00:00
+2020-02-17 23:59:59.998
+2020-02-17 23:59:59.999

external/duckdb/test/sql/function/date/date_trunc_stats.test

@@ -0,0 +1,18 @@
+# name: test/sql/function/date/date_trunc_stats.test
+# description: Test date part stats on empty table
+# group: [date]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+CREATE table T1(A0 TIMESTAMP)
+
+statement ok
+SELECT date_trunc('DAY', A0) FROM T1
+
+# Statistics typing for DATE => TIMESTAMP
+statement error
+SELECT datetrunc('milliseconds', DATE '-2005205-7-28');
+----
+<REGEX>:.*Conversion Error.*not in timestamp range.*

external/duckdb/test/sql/function/date/test_date_part.test

@@ -0,0 +1,634 @@
+# name: test/sql/function/date/test_date_part.test
+# description: DATE_PART test
+# group: [date]
+
+statement ok
+SET default_null_order='nulls_first';
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+CREATE TABLE dates(d DATE, s VARCHAR);
+
+statement ok
+INSERT INTO dates VALUES
+	('1992-01-01', 'year'),
+	('1992-03-03', 'month'),
+	('1992-05-05', 'day'),
+	('2022-01-01', 'isoyear'),
+	('044-03-15 (BC)', 'millennium'),
+	('infinity', 'century'),
+	('-infinity', 'decade'),
+	(NULL, 'weekday'),
+;
+
+statement ok
+CREATE TABLE specifiers (specifier VARCHAR);
+
+foreach specifier era millennium century decade year quarter month day week weekday isodow dayofyear isoyear yearweek
+
+statement ok
+INSERT INTO specifiers VALUES ('${partcode}');
+
+endloop
+
+# test date_part with different combinations of constant/non-constant columns
+query I
+SELECT date_part(NULL::VARCHAR, NULL::TIMESTAMP) FROM dates;
+----
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+
+query I
+SELECT date_part(s, NULL::TIMESTAMP) FROM dates;
+----
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+
+# dates
+query I
+SELECT date_part(NULL, d) FROM dates;
+----
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+
+query I
+SELECT date_part(s, DATE '1992-01-01') FROM dates;
+----
+1992
+1
+1
+1992
+2
+20
+199
+3
+
+query I
+SELECT date_part('year', d) FROM dates;
+----
+1992
+1992
+1992
+2022
+-43
+NULL
+NULL
+NULL
+
+query I
+SELECT date_part('isoyear', d) FROM dates;
+----
+1992
+1992
+1992
+2021
+-43
+NULL
+NULL
+NULL
+
+query I
+SELECT date_part(s, d) FROM dates;
+----
+1992
+3
+5
+2021
+-1
+NULL
+NULL
+NULL
+
+query I
+SELECT date_part('era', d) FROM dates;
+----
+1
+1
+1
+1
+0
+NULL
+NULL
+NULL
+
+query I
+SELECT date_part('julian', d) FROM dates;
+----
+2448623
+2448685
+2448748
+2459581
+1705428
+NULL
+NULL
+NULL
+
+statement error
+SELECT date_part('timezone', d) FROM dates;
+----
+
+statement error
+SELECT date_part('timezone_hour', d) FROM dates;
+----
+
+statement error
+SELECT date_part('timezone_minute', d) FROM dates;
+----
+
+# timestamps
+query I
+SELECT date_part(NULL, d::TIMESTAMP) FROM dates;
+----
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+
+query I
+SELECT date_part(s, TIMESTAMP '1992-01-01') FROM dates;
+----
+1992
+1
+1
+1992
+2
+20
+199
+3
+
+query I
+SELECT date_part('year', d::TIMESTAMP) FROM dates;
+----
+1992
+1992
+1992
+2022
+-43
+NULL
+NULL
+NULL
+
+query I
+SELECT date_part('isoyear', d::TIMESTAMP) FROM dates;
+----
+1992
+1992
+1992
+2021
+-43
+NULL
+NULL
+NULL
+
+query I
+SELECT date_part(s, d::TIMESTAMP) FROM dates;
+----
+1992
+3
+5
+2021
+-1
+NULL
+NULL
+NULL
+
+query I
+SELECT date_part('era', d::TIMESTAMP) FROM dates;
+----
+1
+1
+1
+1
+0
+NULL
+NULL
+NULL
+
+query I
+SELECT date_part('timezone', d::TIMESTAMP) FROM dates;
+----
+0
+0
+0
+0
+0
+NULL
+NULL
+NULL
+
+query I
+SELECT date_part('timezone_hour', d::TIMESTAMP) FROM dates;
+----
+0
+0
+0
+0
+0
+NULL
+NULL
+NULL
+
+query I
+SELECT date_part('timezone_minute', d::TIMESTAMP) FROM dates;
+----
+0
+0
+0
+0
+0
+NULL
+NULL
+NULL
+
+# Cache upper bound
+query I
+select date_part('year', dt::DATE) * 10,
+from generate_series('2050-01-01'::date,'2051-12-31'::date,interval 1 day) t(dt)
+where dt = '2050-12-31';
+----
+20500
+
+#
+# Two-argument timezone
+#
+
+# Normalise to +00:00, add interval, then set offset
+query I
+select timezone(interval '4 minute', '12:15:37.123456-08'::TIMETZ);
+----
+20:19:37.123456+00:04
+
+#  last_day
+query TTT
+SELECT LAST_DAY(DATE '1900-02-12'), LAST_DAY(DATE '1992-02-12'), LAST_DAY(DATE '2000-02-12');
+----
+1900-02-28	1992-02-29	2000-02-29
+
+query T
+SELECT LAST_DAY(d) FROM dates;
+----
+1992-01-31
+1992-03-31
+1992-05-31
+2022-01-31
+0044-03-31 (BC)
+NULL
+NULL
+NULL
+
+query T
+SELECT LAST_DAY(d::timestamp) FROM dates;
+----
+1992-01-31
+1992-03-31
+1992-05-31
+2022-01-31
+0044-03-31 (BC)
+NULL
+NULL
+NULL
+
+#  monthname
+query T
+SELECT MONTHNAME(d) FROM dates;
+----
+January
+March
+May
+January
+March
+NULL
+NULL
+NULL
+
+#  dayname
+query T
+SELECT DAYNAME(d) FROM dates;
+----
+Wednesday
+Tuesday
+Tuesday
+Saturday
+Friday
+NULL
+NULL
+NULL
+
+#  yearweek
+query I
+SELECT YEARWEEK(d) FROM dates;
+----
+199201
+199210
+199219
+202152
+-4311
+NULL
+NULL
+NULL
+
+#  aliases
+query I
+SELECT DAYOFMONTH(d) FROM dates;
+----
+1
+3
+5
+1
+15
+NULL
+NULL
+NULL
+
+query I
+SELECT WEEKDAY(d) FROM dates;
+----
+3
+2
+2
+6
+5
+NULL
+NULL
+NULL
+
+query I
+SELECT WEEKOFYEAR(d) FROM dates;
+----
+1
+10
+19
+52
+11
+NULL
+NULL
+NULL
+
+query I
+SELECT JULIAN(d) FROM dates;
+----
+2448623
+2448685
+2448748
+2459581
+1705428
+NULL
+NULL
+NULL
+
+query IIIIIIIIIIII
+select
+date_part('quarter', DATE '1992-01-20'),
+date_part('quarter', DATE '1992-02-20'),
+date_part('quarter', DATE '1992-03-20'),
+date_part('quarter', DATE '1992-04-20'),
+date_part('quarter', DATE '1992-05-20'),
+date_part('quarter', DATE '1992-06-20'),
+date_part('quarter', DATE '1992-07-20'),
+date_part('quarter', DATE '1992-08-20'),
+date_part('quarter', DATE '1992-09-20'),
+date_part('quarter', DATE '1992-10-20'),
+date_part('quarter', DATE '1992-11-20'),
+date_part('quarter', DATE '1992-12-20')
+----
+1	1	1	2	2	2	3	3	3	4	4	4
+
+# Correctness: Compare date_part values with scalar values
+foreach partcode era millennium century decade year quarter month day week weekday isodow dayofyear isoyear yearweek julian
+
+query III
+SELECT d, DATE_PART('${partcode}', d) AS p, ${partcode}(d) AS f
+FROM dates
+WHERE p IS DISTINCT FROM f;
+----
+
+endloop
+
+# Function-only parts
+query II
+SELECT d, epoch_ns(d) 
+FROM dates 
+WHERE d != '0044-03-15 (BC)' OR d IS NULL
+ORDER BY ALL;
+----
+NULL	NULL
+-infinity	NULL
+1992-01-01	694224000000000000
+1992-03-03	699580800000000000
+1992-05-05	705024000000000000
+2022-01-01	1640995200000000000
+infinity	NULL
+
+query II
+SELECT d, epoch_us(d) FROM dates ORDER BY ALL;
+----
+NULL	NULL
+-infinity	NULL
+0044-03-15 (BC)	-63517824000000000
+1992-01-01	694224000000000
+1992-03-03	699580800000000
+1992-05-05	705024000000000
+2022-01-01	1640995200000000
+infinity	NULL
+
+query II
+SELECT d, epoch_ms(d) FROM dates ORDER BY ALL;
+----
+NULL	NULL
+-infinity	NULL
+0044-03-15 (BC)	-63517824000000
+1992-01-01	694224000000
+1992-03-03	699580800000
+1992-05-05	705024000000
+2022-01-01	1640995200000
+infinity	NULL
+
+query II
+SELECT d, nanosecond(d) FROM dates ORDER BY ALL;
+----
+NULL	NULL
+-infinity	NULL
+0044-03-15 (BC)	0
+1992-01-01	0
+1992-03-03	0
+1992-05-05	0
+2022-01-01	0
+infinity	NULL
+
+#
+# Structs
+#
+
+# Correctness: Compare struct values with scalar values
+foreach partcode era millennium century decade year quarter month day week weekday isodow doy isoyear yearweek
+
+query III
+SELECT d, DATE_PART('${partcode}', d) AS p, DATE_PART(['${partcode}'], d) AS st
+FROM dates
+WHERE p IS DISTINCT FROM st['${partcode}'];
+----
+
+endloop
+
+# Date parts
+query II
+SELECT d, DATE_PART(['year', 'month', 'day', 'epoch'], d) AS parts
+FROM dates
+ORDER BY 1;
+----
+NULL	NULL
+-infinity	{'year': NULL, 'month': NULL, 'day': NULL, 'epoch': NULL}
+0044-03-15 (BC)	{'year': -43, 'month': 3, 'day': 15, 'epoch': -63517824000.0}
+1992-01-01	{'year': 1992, 'month': 1, 'day': 1, 'epoch': 694224000.0}
+1992-03-03	{'year': 1992, 'month': 3, 'day': 3, 'epoch': 699580800.0}
+1992-05-05	{'year': 1992, 'month': 5, 'day': 5, 'epoch': 705024000.0}
+2022-01-01	{'year': 2022, 'month': 1, 'day': 1, 'epoch': 1640995200.0}
+infinity	{'year': NULL, 'month': NULL, 'day': NULL, 'epoch': NULL}
+
+# Year parts
+query II
+SELECT d, DATE_PART(['era', 'millennium', 'century', 'decade', 'quarter'], d) AS parts
+FROM dates
+ORDER BY 1;
+----
+NULL	NULL
+-infinity	{'era': NULL, 'millennium': NULL, 'century': NULL, 'decade': NULL, 'quarter': NULL}
+0044-03-15 (BC)	{'era': 0, 'millennium': -1, 'century': -1, 'decade': -4, 'quarter': 1}
+1992-01-01	{'era': 1, 'millennium': 2, 'century': 20, 'decade': 199, 'quarter': 1}
+1992-03-03	{'era': 1, 'millennium': 2, 'century': 20, 'decade': 199, 'quarter': 1}
+1992-05-05	{'era': 1, 'millennium': 2, 'century': 20, 'decade': 199, 'quarter': 2}
+2022-01-01	{'era': 1, 'millennium': 3, 'century': 21, 'decade': 202, 'quarter': 1}
+infinity	{'era': NULL, 'millennium': NULL, 'century': NULL, 'decade': NULL, 'quarter': NULL}
+
+# Day parts
+query II
+SELECT d, DATE_PART(['weekday', 'isodow', 'doy', 'julian'], d) AS parts
+FROM dates
+ORDER BY 1;
+----
+NULL	NULL
+-infinity	{'weekday': NULL, 'isodow': NULL, 'doy': NULL, 'julian': NULL}
+0044-03-15 (BC)	{'weekday': 5, 'isodow': 5, 'doy': 74, 'julian': 1705428.0}
+1992-01-01	{'weekday': 3, 'isodow': 3, 'doy': 1, 'julian': 2448623.0}
+1992-03-03	{'weekday': 2, 'isodow': 2, 'doy': 63, 'julian': 2448685.0}
+1992-05-05	{'weekday': 2, 'isodow': 2, 'doy': 126, 'julian': 2448748.0}
+2022-01-01	{'weekday': 6, 'isodow': 6, 'doy': 1, 'julian': 2459581.0}
+infinity	{'weekday': NULL, 'isodow': NULL, 'doy': NULL, 'julian': NULL}
+
+query I
+SELECT DATE_PART(['weekday', 'isodow', 'doy', 'julian'], '2022-01-01'::DATE) AS parts
+----
+{'weekday': 6, 'isodow': 6, 'doy': 1, 'julian': 2459581.0}
+
+# ISO parts
+query II
+SELECT d, DATE_PART(['isoyear', 'week', 'yearweek'], d) AS parts
+FROM dates
+ORDER BY 1;
+----
+NULL	NULL
+-infinity	{'isoyear': NULL, 'week': NULL, 'yearweek': NULL}
+0044-03-15 (BC)	{'isoyear': -43, 'week': 11, 'yearweek': -4311}
+1992-01-01	{'isoyear': 1992, 'week': 1, 'yearweek': 199201}
+1992-03-03	{'isoyear': 1992, 'week': 10, 'yearweek': 199210}
+1992-05-05	{'isoyear': 1992, 'week': 19, 'yearweek': 199219}
+2022-01-01	{'isoyear': 2021, 'week': 52, 'yearweek': 202152}
+infinity	{'isoyear': NULL, 'week': NULL, 'yearweek': NULL}
+
+# Selective filtering (Issue #5342)
+query II
+SELECT d, DATE_PART(['year', 'month', 'day'], d) AS parts
+FROM dates
+WHERE s = 'day'
+ORDER BY 1;
+----
+1992-05-05	{'year': 1992, 'month': 5, 'day': 5}
+
+# Invalid parts
+
+foreach datepart hour minute second millisecond microsecond timezone timezone_hour timezone_minute
+
+statement error
+SELECT d, DATE_PART(['${datepart}'], d) AS parts
+FROM dates
+ORDER BY 1;
+----
+not recognized
+
+endloop
+
+statement error
+SELECT DATE_PART(['hour', 'minute'], '2023-09-17'::DATE) AS parts
+----
+not recognized
+
+#
+# Infinities
+#
+# PG returns numeric ±Infinity, but we have to return an integer,
+# so instead we return NULL, which is what PG used to do.
+
+foreach datatype DATE TIMESTAMP
+
+foreach special infinity -infinity
+
+# Binary function
+query I
+SELECT DATE_PART(specifier, '${special}'::${datatype}) AS result
+FROM specifiers
+WHERE result IS NOT NULL
+----
+
+foreach unary year month day decade century millennium quarter dayofweek isodow dayofyear week isoyear era timezone timezone_hour timezone_minute epoch microsecond millisecond second minute hour yearweek dayofmonth weekday weekofyear last_day monthname dayname
+
+# Unary functions
+query I
+SELECT ${unary}('${special}'::${datatype});
+----
+NULL
+
+endloop
+
+# Struct entries should be NULL
+query I
+SELECT DATE_PART(['year', 'month', 'day', 'epoch'], '${special}'::${datatype}) AS parts
+----
+{'year': NULL, 'month': NULL, 'day': NULL, 'epoch': NULL}
+
+endloop
+
+endloop
+
+query T
+WITH cte AS (
+    SELECT NULL::VARCHAR part
+    FROM range(1)
+)
+SELECT date_part(part, TIMESTAMP '2019-01-06 04:03:02')
+FROM cte
+----
+NULL

external/duckdb/test/sql/function/date/test_date_trunc.test

@@ -0,0 +1,320 @@
+# name: test/sql/function/date/test_date_trunc.test
+# description: Test date truncate functionality
+# group: [date]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+CREATE TABLE dates(d DATE, s VARCHAR);
+
+statement ok
+CREATE TABLE timestamps(d TIMESTAMP, s VARCHAR);
+
+statement ok
+INSERT INTO dates VALUES
+	('1992-12-02', 'year'),
+	('1993-03-03', 'month'),
+	('1994-05-05', 'day'),
+	('2022-01-01', 'isoyear')
+;
+
+statement ok
+INSERT INTO timestamps VALUES
+	('-infinity', 'year'),
+	('1992-02-02 02:02:03', 'millennium'),
+	('1992-02-02 02:02:03', 'century'),
+	('1992-02-02 02:02:03', 'decade'),
+	('1992-02-02 02:02:03', 'year'),
+	('1992-02-02 02:02:03', 'quarter'),
+	('1992-02-02 02:02:03', 'month'),
+	('1992-02-02 02:02:03', 'week'),
+	('1992-02-02 02:02:03', 'day'),
+	('1992-02-02 02:02:03', 'hour'),
+	('1992-02-02 02:02:03', 'minute'),
+	('1992-02-02 02:02:03', 'second'),
+	('1992-02-02 02:02:03', 'milliseconds'),
+	('1992-02-02 02:02:03', 'microseconds'),
+	('infinity', 'month'),
+;
+
+# test date_trunc with different combinations of constant/non-constant columns on both dates and timestamps
+query T
+SELECT date_trunc(NULL::VARCHAR, NULL::TIMESTAMP) FROM dates;
+----
+NULL
+NULL
+NULL
+NULL
+
+query T
+SELECT date_trunc(s, NULL::TIMESTAMP) FROM dates;
+----
+NULL
+NULL
+NULL
+NULL
+
+query T
+SELECT date_trunc(NULL, d) FROM dates;
+----
+NULL
+NULL
+NULL
+NULL
+
+query T
+SELECT date_trunc(NULL::VARCHAR, NULL::TIMESTAMP) FROM timestamps LIMIT 3;
+----
+NULL
+NULL
+NULL
+
+query T
+SELECT date_trunc(s, NULL::TIMESTAMP) FROM timestamps LIMIT 3;
+----
+NULL
+NULL
+NULL
+
+query T
+SELECT date_trunc(NULL, d) FROM timestamps LIMIT 3;
+----
+NULL
+NULL
+NULL
+
+# dates should be cast to timestamp
+query T
+SELECT date_trunc('month', DATE '1992-02-02') FROM dates LIMIT 1;
+----
+1992-02-01
+
+query T
+SELECT date_trunc(s, d) FROM dates;
+----
+1992-01-01 00:00:00
+1993-03-01 00:00:00
+1994-05-05 00:00:00
+2021-01-04 00:00:00
+
+# Issue #4388: Verify DATE results for all timestamp types
+foreach temporal TIMESTAMP TIMESTAMP_MS TIMESTAMP_NS TIMESTAMP_S
+
+foreach datepart day doy dow isodow julian
+
+query I
+select date_trunc('${datepart}', '2022-08-15 07:52:55'::${temporal});
+----
+2022-08-15
+
+endloop
+
+query I
+select date_trunc('hour', '2022-08-15 07:52:55'::${temporal});
+----
+2022-08-15 07:00:00
+
+endloop
+
+# Timestamps should return timestamp type
+query T
+SELECT date_trunc('minute', TIMESTAMP '1992-02-02 04:03:02') FROM timestamps LIMIT 1;
+----
+1992-02-02 04:03:00
+
+# Test all truncate operators on timestamps
+query T
+SELECT date_trunc(s, d) FROM timestamps;
+----
+-infinity
+1000-01-01 00:00:00
+1900-01-01 00:00:00
+1990-01-01 00:00:00
+1992-01-01 00:00:00
+1992-01-01 00:00:00
+1992-02-01 00:00:00
+1992-01-27 00:00:00
+1992-02-02 00:00:00
+1992-02-02 02:00:00
+1992-02-02 02:02:00
+1992-02-02 02:02:03
+1992-02-02 02:02:03
+1992-02-02 02:02:03
+infinity
+
+# Redo previous test but with casting to date first
+query T
+SELECT date_trunc(s, CAST(d as DATE)) FROM timestamps;
+----
+-infinity
+1000-01-01 00:00:00
+1900-01-01 00:00:00
+1990-01-01 00:00:00
+1992-01-01 00:00:00
+1992-01-01 00:00:00
+1992-02-01 00:00:00
+1992-01-27 00:00:00
+1992-02-02 00:00:00
+1992-02-02 00:00:00
+1992-02-02 00:00:00
+1992-02-02 00:00:00
+1992-02-02 00:00:00
+1992-02-02 00:00:00
+infinity
+
+# Test week operator special cases
+query T
+SELECT date_trunc('week', TIMESTAMP '2020-01-01 04:03:02') FROM timestamps LIMIT 1;
+----
+2019-12-30
+
+query T
+SELECT date_trunc('week', TIMESTAMP '2019-01-06 04:03:02') FROM timestamps LIMIT 1;
+----
+2018-12-31
+
+query T
+SELECT date_trunc('yearweek', TIMESTAMP '2020-01-01 04:03:02') FROM timestamps LIMIT 1;
+----
+2019-12-30
+
+query T
+SELECT date_trunc('yearweek', TIMESTAMP '2019-01-06 04:03:02') FROM timestamps LIMIT 1;
+----
+2018-12-31
+
+# Test quarter operator more thoroughly
+query T
+SELECT date_trunc('quarter', TIMESTAMP '2020-12-02 04:03:02') FROM timestamps LIMIT 1;
+----
+2020-10-01
+
+query T
+SELECT date_trunc('quarter', TIMESTAMP '2019-01-06 04:03:02') FROM timestamps LIMIT 1;
+----
+2019-01-01
+
+query T
+SELECT date_trunc('millennium', TIMESTAMP '1996-01-06 04:03:02') FROM timestamps LIMIT 1;
+----
+1000-01-01
+
+query T
+SELECT date_trunc('century', TIMESTAMP '2019-01-06 04:03:02') FROM timestamps LIMIT 1;
+----
+2000-01-01
+
+query T
+SELECT date_trunc('decade', TIMESTAMP '2019-01-06 04:03:02') FROM timestamps LIMIT 1;
+----
+2010-01-01
+
+query T
+SELECT date_trunc('year', TIMESTAMP '2019-01-06 04:03:02') FROM timestamps LIMIT 1;
+----
+2019-01-01
+
+query T
+SELECT date_trunc('day', TIMESTAMP '2019-01-06 04:03:02') FROM timestamps LIMIT 1;
+----
+2019-01-06
+
+query T
+SELECT date_trunc('hour', TIMESTAMP '2019-01-06 04:03:02') FROM timestamps LIMIT 1;
+----
+2019-01-06 04:00:00
+
+query T
+SELECT date_trunc('milliseconds', TIMESTAMP '2019-01-06 04:03:02.123456') FROM timestamps LIMIT 1;
+----
+2019-01-06 04:03:02.123
+
+query T
+SELECT date_trunc('microseconds', TIMESTAMP '2019-01-06 04:03:02.123456');
+----
+2019-01-06 04:03:02.123456
+
+# Synonym for second
+query T
+SELECT date_trunc('epoch', TIMESTAMP '2019-01-06 04:03:02.5') FROM timestamps LIMIT 1;
+----
+2019-01-06 04:03:02
+
+query II
+SELECT d::DATE, DATE_TRUNC('isoyear', d)::DATE
+FROM generate_series('2000-01-01'::TIMESTAMP, '2023-01-01'::TIMESTAMP, INTERVAL 1 YEAR) tbl(d);
+----
+2000-01-01	1999-01-04
+2001-01-01	2001-01-01
+2002-01-01	2001-12-31
+2003-01-01	2002-12-30
+2004-01-01	2003-12-29
+2005-01-01	2003-12-29
+2006-01-01	2005-01-03
+2007-01-01	2007-01-01
+2008-01-01	2007-12-31
+2009-01-01	2008-12-29
+2010-01-01	2008-12-29
+2011-01-01	2010-01-04
+2012-01-01	2011-01-03
+2013-01-01	2012-12-31
+2014-01-01	2013-12-30
+2015-01-01	2014-12-29
+2016-01-01	2014-12-29
+2017-01-01	2016-01-04
+2018-01-01	2018-01-01
+2019-01-01	2018-12-31
+2020-01-01	2019-12-30
+2021-01-01	2019-12-30
+2022-01-01	2021-01-04
+2023-01-01	2022-01-03
+
+# Unknown specifier should fail
+statement error
+SELECT date_trunc('duck', TIMESTAMP '2019-01-06 04:03:02') FROM timestamps LIMIT 1;
+----
+
+# Statistics should propagate
+
+statement ok
+PRAGMA disable_verification
+
+query I
+SELECT stats(date_trunc('year', d)) FROM dates LIMIT 1;
+----
+[Min: 1992-01-01, Max: 2022-01-01][Has Null: false, Has No Null: true]
+
+query I
+SELECT stats(date_trunc('quarter', d)) FROM dates LIMIT 1;
+----
+[Min: 1992-10-01, Max: 2022-01-01][Has Null: false, Has No Null: true]
+
+query I
+SELECT stats(date_trunc('month', d)) FROM dates LIMIT 1;
+----
+[Min: 1992-12-01, Max: 2022-01-01][Has Null: false, Has No Null: true]
+
+query I
+SELECT stats(date_trunc('day', d)) FROM dates LIMIT 1;
+----
+[Min: 1992-12-02, Max: 2022-01-01][Has Null: false, Has No Null: true]
+
+foreach daypart millennium century decade year quarter month week day
+
+query I
+SELECT stats(date_trunc('${daypart}', d)) FROM timestamps LIMIT 1;
+----
+[Min: -infinity, Max: infinity][Has Null: false, Has No Null: true]
+
+endloop
+
+query T
+WITH cte AS (
+    SELECT NULL::VARCHAR part
+    FROM range(1)
+)
+SELECT date_trunc(part, TIMESTAMP '2019-01-06 04:03:02')
+FROM cte
+----
+NULL

external/duckdb/test/sql/function/date/test_extract.test

@@ -0,0 +1,135 @@
+# name: test/sql/function/date/test_extract.test
+# description: Extract function
+# group: [date]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+CREATE TABLE dates(i DATE)
+
+statement ok
+INSERT INTO dates VALUES ('1993-08-14'), (NULL)
+
+# extract various parts of the date
+# year
+query I
+SELECT EXTRACT(year FROM i) FROM dates
+----
+1993
+NULL
+
+# month
+query I
+SELECT EXTRACT(month FROM i) FROM dates
+----
+8
+NULL
+
+# quarter
+query I
+SELECT EXTRACT(quarter FROM i) FROM dates
+----
+3
+NULL
+
+# day
+query I
+SELECT EXTRACT(day FROM i) FROM dates
+----
+14
+NULL
+
+# decade
+query I
+SELECT EXTRACT(decade FROM i) FROM dates
+----
+199
+NULL
+
+# century
+query I
+SELECT EXTRACT(century FROM i) FROM dates
+----
+20
+NULL
+
+# day of the week (Sunday = 0, Saturday = 6)
+query I
+SELECT EXTRACT(DOW FROM i) FROM dates
+----
+6
+NULL
+
+# day of the year (1 - 365/366)
+query I
+SELECT EXTRACT(DOY FROM i) FROM dates
+----
+226
+NULL
+
+# epoch
+query I
+SELECT EXTRACT(epoch FROM i) FROM dates
+----
+745286400
+NULL
+
+# isodow (Monday = 1, Sunday = 7)
+query I
+SELECT EXTRACT(ISODOW FROM i) FROM dates
+----
+6
+NULL
+
+# week (1-53)
+query I
+SELECT EXTRACT(WEEK FROM i) FROM dates
+----
+32
+NULL
+
+# yearweek (YYYYWW)
+query I
+SELECT EXTRACT(YEARWEEK FROM i) FROM dates
+----
+199332
+NULL
+
+# millennium (change of millennium is January 1, X001)
+query I
+SELECT EXTRACT(millennium FROM i) FROM dates
+----
+2
+NULL
+
+# timestamp variants all give 0 for date
+query I
+SELECT EXTRACT(second FROM i) FROM dates
+----
+0
+NULL
+
+query I
+SELECT EXTRACT(minute FROM i) FROM dates
+----
+0
+NULL
+
+query I
+SELECT EXTRACT(hour FROM i) FROM dates
+----
+0
+NULL
+
+query I
+SELECT EXTRACT(milliseconds FROM i) FROM dates
+----
+0
+NULL
+
+query I
+SELECT EXTRACT(microsecond FROM i) FROM dates
+----
+0
+NULL

external/duckdb/test/sql/function/date/test_extract_edge_cases.test

@@ -0,0 +1,341 @@
+# name: test/sql/function/date/test_extract_edge_cases.test
+# description: Extract function edge cases
+# group: [date]
+
+# century changes in the year 1
+query I
+SELECT EXTRACT(century FROM cast('2000-10-10' AS DATE));
+----
+20
+
+query I
+SELECT EXTRACT(century FROM cast('2001-10-10' AS DATE));
+----
+21
+
+# millennium changes in the year 1
+query I
+SELECT EXTRACT(millennium FROM cast('2000-10-10' AS DATE));
+----
+2
+
+query I
+SELECT EXTRACT(millennium FROM cast('2001-10-10' AS DATE));
+----
+3
+
+# check DOW
+# start from the epoch and go up/down, every time the day should go up/down
+# one as well
+query I
+SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) + 0);
+----
+4
+
+query I
+SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) - 0);
+----
+4
+
+query I
+SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) + 1);
+----
+5
+
+query I
+SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) - 1);
+----
+3
+
+query I
+SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) + 2);
+----
+6
+
+query I
+SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) - 2);
+----
+2
+
+query I
+SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) + 3);
+----
+0
+
+query I
+SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) - 3);
+----
+1
+
+query I
+SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) + 4);
+----
+1
+
+query I
+SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) - 4);
+----
+0
+
+query I
+SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) + 5);
+----
+2
+
+query I
+SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) - 5);
+----
+6
+
+query I
+SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) + 6);
+----
+3
+
+query I
+SELECT EXTRACT(dow FROM cast('1970-01-01' AS DATE) - 6);
+----
+5
+
+query I
+SELECT EXTRACT(dow FROM cast('1793-05-26' AS DATE));
+----
+0
+
+query I
+SELECT EXTRACT(isodow FROM cast('1793-05-26' AS DATE));
+----
+7
+
+# week numbers are weird
+query I
+SELECT EXTRACT(week FROM cast('2005-01-01' AS DATE));
+----
+53
+
+query I
+SELECT EXTRACT(week FROM cast('2006-01-01' AS DATE));
+----
+52
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE));
+----
+1
+
+query I
+SELECT EXTRACT(week FROM cast('2008-01-01' AS DATE));
+----
+1
+
+query I
+SELECT EXTRACT(week FROM cast('2009-01-01' AS DATE));
+----
+1
+
+query I
+SELECT EXTRACT(week FROM cast('2010-01-01' AS DATE));
+----
+53
+
+# every 7 days the week number should go up by 7
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 0);
+----
+1
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 7);
+----
+2
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 14);
+----
+3
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 21);
+----
+4
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 28);
+----
+5
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 35);
+----
+6
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 42);
+----
+7
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 49);
+----
+8
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 56);
+----
+9
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 63);
+----
+10
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 70);
+----
+11
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 77);
+----
+12
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 84);
+----
+13
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 91);
+----
+14
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 98);
+----
+15
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 105);
+----
+16
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 112);
+----
+17
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 119);
+----
+18
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 126);
+----
+19
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 133);
+----
+20
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 140);
+----
+21
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 147);
+----
+22
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 154);
+----
+23
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 161);
+----
+24
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 168);
+----
+25
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 175);
+----
+26
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 182);
+----
+27
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 189);
+----
+28
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 196);
+----
+29
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 203);
+----
+30
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 210);
+----
+31
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 217);
+----
+32
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 224);
+----
+33
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 231);
+----
+34
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 238);
+----
+35
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 245);
+----
+36
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 252);
+----
+37
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 259);
+----
+38
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 266);
+----
+39
+
+query I
+SELECT EXTRACT(week FROM cast('2007-01-01' AS DATE) + 273);
+----
+40
+

external/duckdb/test/sql/function/date/test_extract_month.test

@@ -0,0 +1,746 @@
+# name: test/sql/function/date/test_extract_month.test
+# description: Extract month function
+# group: [date]
+
+statement ok
+PRAGMA enable_verification
+
+query II
+select date '1992-01-01' + interval (i) days, month(date '1992-01-01' + interval (i) days) from range(0, 366) tbl(i);
+----
+1992-01-01 00:00:00	1
+1992-01-02 00:00:00	1
+1992-01-03 00:00:00	1
+1992-01-04 00:00:00	1
+1992-01-05 00:00:00	1
+1992-01-06 00:00:00	1
+1992-01-07 00:00:00	1
+1992-01-08 00:00:00	1
+1992-01-09 00:00:00	1
+1992-01-10 00:00:00	1
+1992-01-11 00:00:00	1
+1992-01-12 00:00:00	1
+1992-01-13 00:00:00	1
+1992-01-14 00:00:00	1
+1992-01-15 00:00:00	1
+1992-01-16 00:00:00	1
+1992-01-17 00:00:00	1
+1992-01-18 00:00:00	1
+1992-01-19 00:00:00	1
+1992-01-20 00:00:00	1
+1992-01-21 00:00:00	1
+1992-01-22 00:00:00	1
+1992-01-23 00:00:00	1
+1992-01-24 00:00:00	1
+1992-01-25 00:00:00	1
+1992-01-26 00:00:00	1
+1992-01-27 00:00:00	1
+1992-01-28 00:00:00	1
+1992-01-29 00:00:00	1
+1992-01-30 00:00:00	1
+1992-01-31 00:00:00	1
+1992-02-01 00:00:00	2
+1992-02-02 00:00:00	2
+1992-02-03 00:00:00	2
+1992-02-04 00:00:00	2
+1992-02-05 00:00:00	2
+1992-02-06 00:00:00	2
+1992-02-07 00:00:00	2
+1992-02-08 00:00:00	2
+1992-02-09 00:00:00	2
+1992-02-10 00:00:00	2
+1992-02-11 00:00:00	2
+1992-02-12 00:00:00	2
+1992-02-13 00:00:00	2
+1992-02-14 00:00:00	2
+1992-02-15 00:00:00	2
+1992-02-16 00:00:00	2
+1992-02-17 00:00:00	2
+1992-02-18 00:00:00	2
+1992-02-19 00:00:00	2
+1992-02-20 00:00:00	2
+1992-02-21 00:00:00	2
+1992-02-22 00:00:00	2
+1992-02-23 00:00:00	2
+1992-02-24 00:00:00	2
+1992-02-25 00:00:00	2
+1992-02-26 00:00:00	2
+1992-02-27 00:00:00	2
+1992-02-28 00:00:00	2
+1992-02-29 00:00:00	2
+1992-03-01 00:00:00	3
+1992-03-02 00:00:00	3
+1992-03-03 00:00:00	3
+1992-03-04 00:00:00	3
+1992-03-05 00:00:00	3
+1992-03-06 00:00:00	3
+1992-03-07 00:00:00	3
+1992-03-08 00:00:00	3
+1992-03-09 00:00:00	3
+1992-03-10 00:00:00	3
+1992-03-11 00:00:00	3
+1992-03-12 00:00:00	3
+1992-03-13 00:00:00	3
+1992-03-14 00:00:00	3
+1992-03-15 00:00:00	3
+1992-03-16 00:00:00	3
+1992-03-17 00:00:00	3
+1992-03-18 00:00:00	3
+1992-03-19 00:00:00	3
+1992-03-20 00:00:00	3
+1992-03-21 00:00:00	3
+1992-03-22 00:00:00	3
+1992-03-23 00:00:00	3
+1992-03-24 00:00:00	3
+1992-03-25 00:00:00	3
+1992-03-26 00:00:00	3
+1992-03-27 00:00:00	3
+1992-03-28 00:00:00	3
+1992-03-29 00:00:00	3
+1992-03-30 00:00:00	3
+1992-03-31 00:00:00	3
+1992-04-01 00:00:00	4
+1992-04-02 00:00:00	4
+1992-04-03 00:00:00	4
+1992-04-04 00:00:00	4
+1992-04-05 00:00:00	4
+1992-04-06 00:00:00	4
+1992-04-07 00:00:00	4
+1992-04-08 00:00:00	4
+1992-04-09 00:00:00	4
+1992-04-10 00:00:00	4
+1992-04-11 00:00:00	4
+1992-04-12 00:00:00	4
+1992-04-13 00:00:00	4
+1992-04-14 00:00:00	4
+1992-04-15 00:00:00	4
+1992-04-16 00:00:00	4
+1992-04-17 00:00:00	4
+1992-04-18 00:00:00	4
+1992-04-19 00:00:00	4
+1992-04-20 00:00:00	4
+1992-04-21 00:00:00	4
+1992-04-22 00:00:00	4
+1992-04-23 00:00:00	4
+1992-04-24 00:00:00	4
+1992-04-25 00:00:00	4
+1992-04-26 00:00:00	4
+1992-04-27 00:00:00	4
+1992-04-28 00:00:00	4
+1992-04-29 00:00:00	4
+1992-04-30 00:00:00	4
+1992-05-01 00:00:00	5
+1992-05-02 00:00:00	5
+1992-05-03 00:00:00	5
+1992-05-04 00:00:00	5
+1992-05-05 00:00:00	5
+1992-05-06 00:00:00	5
+1992-05-07 00:00:00	5
+1992-05-08 00:00:00	5
+1992-05-09 00:00:00	5
+1992-05-10 00:00:00	5
+1992-05-11 00:00:00	5
+1992-05-12 00:00:00	5
+1992-05-13 00:00:00	5
+1992-05-14 00:00:00	5
+1992-05-15 00:00:00	5
+1992-05-16 00:00:00	5
+1992-05-17 00:00:00	5
+1992-05-18 00:00:00	5
+1992-05-19 00:00:00	5
+1992-05-20 00:00:00	5
+1992-05-21 00:00:00	5
+1992-05-22 00:00:00	5
+1992-05-23 00:00:00	5
+1992-05-24 00:00:00	5
+1992-05-25 00:00:00	5
+1992-05-26 00:00:00	5
+1992-05-27 00:00:00	5
+1992-05-28 00:00:00	5
+1992-05-29 00:00:00	5
+1992-05-30 00:00:00	5
+1992-05-31 00:00:00	5
+1992-06-01 00:00:00	6
+1992-06-02 00:00:00	6
+1992-06-03 00:00:00	6
+1992-06-04 00:00:00	6
+1992-06-05 00:00:00	6
+1992-06-06 00:00:00	6
+1992-06-07 00:00:00	6
+1992-06-08 00:00:00	6
+1992-06-09 00:00:00	6
+1992-06-10 00:00:00	6
+1992-06-11 00:00:00	6
+1992-06-12 00:00:00	6
+1992-06-13 00:00:00	6
+1992-06-14 00:00:00	6
+1992-06-15 00:00:00	6
+1992-06-16 00:00:00	6
+1992-06-17 00:00:00	6
+1992-06-18 00:00:00	6
+1992-06-19 00:00:00	6
+1992-06-20 00:00:00	6
+1992-06-21 00:00:00	6
+1992-06-22 00:00:00	6
+1992-06-23 00:00:00	6
+1992-06-24 00:00:00	6
+1992-06-25 00:00:00	6
+1992-06-26 00:00:00	6
+1992-06-27 00:00:00	6
+1992-06-28 00:00:00	6
+1992-06-29 00:00:00	6
+1992-06-30 00:00:00	6
+1992-07-01 00:00:00	7
+1992-07-02 00:00:00	7
+1992-07-03 00:00:00	7
+1992-07-04 00:00:00	7
+1992-07-05 00:00:00	7
+1992-07-06 00:00:00	7
+1992-07-07 00:00:00	7
+1992-07-08 00:00:00	7
+1992-07-09 00:00:00	7
+1992-07-10 00:00:00	7
+1992-07-11 00:00:00	7
+1992-07-12 00:00:00	7
+1992-07-13 00:00:00	7
+1992-07-14 00:00:00	7
+1992-07-15 00:00:00	7
+1992-07-16 00:00:00	7
+1992-07-17 00:00:00	7
+1992-07-18 00:00:00	7
+1992-07-19 00:00:00	7
+1992-07-20 00:00:00	7
+1992-07-21 00:00:00	7
+1992-07-22 00:00:00	7
+1992-07-23 00:00:00	7
+1992-07-24 00:00:00	7
+1992-07-25 00:00:00	7
+1992-07-26 00:00:00	7
+1992-07-27 00:00:00	7
+1992-07-28 00:00:00	7
+1992-07-29 00:00:00	7
+1992-07-30 00:00:00	7
+1992-07-31 00:00:00	7
+1992-08-01 00:00:00	8
+1992-08-02 00:00:00	8
+1992-08-03 00:00:00	8
+1992-08-04 00:00:00	8
+1992-08-05 00:00:00	8
+1992-08-06 00:00:00	8
+1992-08-07 00:00:00	8
+1992-08-08 00:00:00	8
+1992-08-09 00:00:00	8
+1992-08-10 00:00:00	8
+1992-08-11 00:00:00	8
+1992-08-12 00:00:00	8
+1992-08-13 00:00:00	8
+1992-08-14 00:00:00	8
+1992-08-15 00:00:00	8
+1992-08-16 00:00:00	8
+1992-08-17 00:00:00	8
+1992-08-18 00:00:00	8
+1992-08-19 00:00:00	8
+1992-08-20 00:00:00	8
+1992-08-21 00:00:00	8
+1992-08-22 00:00:00	8
+1992-08-23 00:00:00	8
+1992-08-24 00:00:00	8
+1992-08-25 00:00:00	8
+1992-08-26 00:00:00	8
+1992-08-27 00:00:00	8
+1992-08-28 00:00:00	8
+1992-08-29 00:00:00	8
+1992-08-30 00:00:00	8
+1992-08-31 00:00:00	8
+1992-09-01 00:00:00	9
+1992-09-02 00:00:00	9
+1992-09-03 00:00:00	9
+1992-09-04 00:00:00	9
+1992-09-05 00:00:00	9
+1992-09-06 00:00:00	9
+1992-09-07 00:00:00	9
+1992-09-08 00:00:00	9
+1992-09-09 00:00:00	9
+1992-09-10 00:00:00	9
+1992-09-11 00:00:00	9
+1992-09-12 00:00:00	9
+1992-09-13 00:00:00	9
+1992-09-14 00:00:00	9
+1992-09-15 00:00:00	9
+1992-09-16 00:00:00	9
+1992-09-17 00:00:00	9
+1992-09-18 00:00:00	9
+1992-09-19 00:00:00	9
+1992-09-20 00:00:00	9
+1992-09-21 00:00:00	9
+1992-09-22 00:00:00	9
+1992-09-23 00:00:00	9
+1992-09-24 00:00:00	9
+1992-09-25 00:00:00	9
+1992-09-26 00:00:00	9
+1992-09-27 00:00:00	9
+1992-09-28 00:00:00	9
+1992-09-29 00:00:00	9
+1992-09-30 00:00:00	9
+1992-10-01 00:00:00	10
+1992-10-02 00:00:00	10
+1992-10-03 00:00:00	10
+1992-10-04 00:00:00	10
+1992-10-05 00:00:00	10
+1992-10-06 00:00:00	10
+1992-10-07 00:00:00	10
+1992-10-08 00:00:00	10
+1992-10-09 00:00:00	10
+1992-10-10 00:00:00	10
+1992-10-11 00:00:00	10
+1992-10-12 00:00:00	10
+1992-10-13 00:00:00	10
+1992-10-14 00:00:00	10
+1992-10-15 00:00:00	10
+1992-10-16 00:00:00	10
+1992-10-17 00:00:00	10
+1992-10-18 00:00:00	10
+1992-10-19 00:00:00	10
+1992-10-20 00:00:00	10
+1992-10-21 00:00:00	10
+1992-10-22 00:00:00	10
+1992-10-23 00:00:00	10
+1992-10-24 00:00:00	10
+1992-10-25 00:00:00	10
+1992-10-26 00:00:00	10
+1992-10-27 00:00:00	10
+1992-10-28 00:00:00	10
+1992-10-29 00:00:00	10
+1992-10-30 00:00:00	10
+1992-10-31 00:00:00	10
+1992-11-01 00:00:00	11
+1992-11-02 00:00:00	11
+1992-11-03 00:00:00	11
+1992-11-04 00:00:00	11
+1992-11-05 00:00:00	11
+1992-11-06 00:00:00	11
+1992-11-07 00:00:00	11
+1992-11-08 00:00:00	11
+1992-11-09 00:00:00	11
+1992-11-10 00:00:00	11
+1992-11-11 00:00:00	11
+1992-11-12 00:00:00	11
+1992-11-13 00:00:00	11
+1992-11-14 00:00:00	11
+1992-11-15 00:00:00	11
+1992-11-16 00:00:00	11
+1992-11-17 00:00:00	11
+1992-11-18 00:00:00	11
+1992-11-19 00:00:00	11
+1992-11-20 00:00:00	11
+1992-11-21 00:00:00	11
+1992-11-22 00:00:00	11
+1992-11-23 00:00:00	11
+1992-11-24 00:00:00	11
+1992-11-25 00:00:00	11
+1992-11-26 00:00:00	11
+1992-11-27 00:00:00	11
+1992-11-28 00:00:00	11
+1992-11-29 00:00:00	11
+1992-11-30 00:00:00	11
+1992-12-01 00:00:00	12
+1992-12-02 00:00:00	12
+1992-12-03 00:00:00	12
+1992-12-04 00:00:00	12
+1992-12-05 00:00:00	12
+1992-12-06 00:00:00	12
+1992-12-07 00:00:00	12
+1992-12-08 00:00:00	12
+1992-12-09 00:00:00	12
+1992-12-10 00:00:00	12
+1992-12-11 00:00:00	12
+1992-12-12 00:00:00	12
+1992-12-13 00:00:00	12
+1992-12-14 00:00:00	12
+1992-12-15 00:00:00	12
+1992-12-16 00:00:00	12
+1992-12-17 00:00:00	12
+1992-12-18 00:00:00	12
+1992-12-19 00:00:00	12
+1992-12-20 00:00:00	12
+1992-12-21 00:00:00	12
+1992-12-22 00:00:00	12
+1992-12-23 00:00:00	12
+1992-12-24 00:00:00	12
+1992-12-25 00:00:00	12
+1992-12-26 00:00:00	12
+1992-12-27 00:00:00	12
+1992-12-28 00:00:00	12
+1992-12-29 00:00:00	12
+1992-12-30 00:00:00	12
+1992-12-31 00:00:00	12
+
+query II
+select date '1993-01-01' + interval (i) days, month(date '1993-01-01' + interval (i) days) from range(0, 366) tbl(i);
+----
+1993-01-01 00:00:00	1
+1993-01-02 00:00:00	1
+1993-01-03 00:00:00	1
+1993-01-04 00:00:00	1
+1993-01-05 00:00:00	1
+1993-01-06 00:00:00	1
+1993-01-07 00:00:00	1
+1993-01-08 00:00:00	1
+1993-01-09 00:00:00	1
+1993-01-10 00:00:00	1
+1993-01-11 00:00:00	1
+1993-01-12 00:00:00	1
+1993-01-13 00:00:00	1
+1993-01-14 00:00:00	1
+1993-01-15 00:00:00	1
+1993-01-16 00:00:00	1
+1993-01-17 00:00:00	1
+1993-01-18 00:00:00	1
+1993-01-19 00:00:00	1
+1993-01-20 00:00:00	1
+1993-01-21 00:00:00	1
+1993-01-22 00:00:00	1
+1993-01-23 00:00:00	1
+1993-01-24 00:00:00	1
+1993-01-25 00:00:00	1
+1993-01-26 00:00:00	1
+1993-01-27 00:00:00	1
+1993-01-28 00:00:00	1
+1993-01-29 00:00:00	1
+1993-01-30 00:00:00	1
+1993-01-31 00:00:00	1
+1993-02-01 00:00:00	2
+1993-02-02 00:00:00	2
+1993-02-03 00:00:00	2
+1993-02-04 00:00:00	2
+1993-02-05 00:00:00	2
+1993-02-06 00:00:00	2
+1993-02-07 00:00:00	2
+1993-02-08 00:00:00	2
+1993-02-09 00:00:00	2
+1993-02-10 00:00:00	2
+1993-02-11 00:00:00	2
+1993-02-12 00:00:00	2
+1993-02-13 00:00:00	2
+1993-02-14 00:00:00	2
+1993-02-15 00:00:00	2
+1993-02-16 00:00:00	2
+1993-02-17 00:00:00	2
+1993-02-18 00:00:00	2
+1993-02-19 00:00:00	2
+1993-02-20 00:00:00	2
+1993-02-21 00:00:00	2
+1993-02-22 00:00:00	2
+1993-02-23 00:00:00	2
+1993-02-24 00:00:00	2
+1993-02-25 00:00:00	2
+1993-02-26 00:00:00	2
+1993-02-27 00:00:00	2
+1993-02-28 00:00:00	2
+1993-03-01 00:00:00	3
+1993-03-02 00:00:00	3
+1993-03-03 00:00:00	3
+1993-03-04 00:00:00	3
+1993-03-05 00:00:00	3
+1993-03-06 00:00:00	3
+1993-03-07 00:00:00	3
+1993-03-08 00:00:00	3
+1993-03-09 00:00:00	3
+1993-03-10 00:00:00	3
+1993-03-11 00:00:00	3
+1993-03-12 00:00:00	3
+1993-03-13 00:00:00	3
+1993-03-14 00:00:00	3
+1993-03-15 00:00:00	3
+1993-03-16 00:00:00	3
+1993-03-17 00:00:00	3
+1993-03-18 00:00:00	3
+1993-03-19 00:00:00	3
+1993-03-20 00:00:00	3
+1993-03-21 00:00:00	3
+1993-03-22 00:00:00	3
+1993-03-23 00:00:00	3
+1993-03-24 00:00:00	3
+1993-03-25 00:00:00	3
+1993-03-26 00:00:00	3
+1993-03-27 00:00:00	3
+1993-03-28 00:00:00	3
+1993-03-29 00:00:00	3
+1993-03-30 00:00:00	3
+1993-03-31 00:00:00	3
+1993-04-01 00:00:00	4
+1993-04-02 00:00:00	4
+1993-04-03 00:00:00	4
+1993-04-04 00:00:00	4
+1993-04-05 00:00:00	4
+1993-04-06 00:00:00	4
+1993-04-07 00:00:00	4
+1993-04-08 00:00:00	4
+1993-04-09 00:00:00	4
+1993-04-10 00:00:00	4
+1993-04-11 00:00:00	4
+1993-04-12 00:00:00	4
+1993-04-13 00:00:00	4
+1993-04-14 00:00:00	4
+1993-04-15 00:00:00	4
+1993-04-16 00:00:00	4
+1993-04-17 00:00:00	4
+1993-04-18 00:00:00	4
+1993-04-19 00:00:00	4
+1993-04-20 00:00:00	4
+1993-04-21 00:00:00	4
+1993-04-22 00:00:00	4
+1993-04-23 00:00:00	4
+1993-04-24 00:00:00	4
+1993-04-25 00:00:00	4
+1993-04-26 00:00:00	4
+1993-04-27 00:00:00	4
+1993-04-28 00:00:00	4
+1993-04-29 00:00:00	4
+1993-04-30 00:00:00	4
+1993-05-01 00:00:00	5
+1993-05-02 00:00:00	5
+1993-05-03 00:00:00	5
+1993-05-04 00:00:00	5
+1993-05-05 00:00:00	5
+1993-05-06 00:00:00	5
+1993-05-07 00:00:00	5
+1993-05-08 00:00:00	5
+1993-05-09 00:00:00	5
+1993-05-10 00:00:00	5
+1993-05-11 00:00:00	5
+1993-05-12 00:00:00	5
+1993-05-13 00:00:00	5
+1993-05-14 00:00:00	5
+1993-05-15 00:00:00	5
+1993-05-16 00:00:00	5
+1993-05-17 00:00:00	5
+1993-05-18 00:00:00	5
+1993-05-19 00:00:00	5
+1993-05-20 00:00:00	5
+1993-05-21 00:00:00	5
+1993-05-22 00:00:00	5
+1993-05-23 00:00:00	5
+1993-05-24 00:00:00	5
+1993-05-25 00:00:00	5
+1993-05-26 00:00:00	5
+1993-05-27 00:00:00	5
+1993-05-28 00:00:00	5
+1993-05-29 00:00:00	5
+1993-05-30 00:00:00	5
+1993-05-31 00:00:00	5
+1993-06-01 00:00:00	6
+1993-06-02 00:00:00	6
+1993-06-03 00:00:00	6
+1993-06-04 00:00:00	6
+1993-06-05 00:00:00	6
+1993-06-06 00:00:00	6
+1993-06-07 00:00:00	6
+1993-06-08 00:00:00	6
+1993-06-09 00:00:00	6
+1993-06-10 00:00:00	6
+1993-06-11 00:00:00	6
+1993-06-12 00:00:00	6
+1993-06-13 00:00:00	6
+1993-06-14 00:00:00	6
+1993-06-15 00:00:00	6
+1993-06-16 00:00:00	6
+1993-06-17 00:00:00	6
+1993-06-18 00:00:00	6
+1993-06-19 00:00:00	6
+1993-06-20 00:00:00	6
+1993-06-21 00:00:00	6
+1993-06-22 00:00:00	6
+1993-06-23 00:00:00	6
+1993-06-24 00:00:00	6
+1993-06-25 00:00:00	6
+1993-06-26 00:00:00	6
+1993-06-27 00:00:00	6
+1993-06-28 00:00:00	6
+1993-06-29 00:00:00	6
+1993-06-30 00:00:00	6
+1993-07-01 00:00:00	7
+1993-07-02 00:00:00	7
+1993-07-03 00:00:00	7
+1993-07-04 00:00:00	7
+1993-07-05 00:00:00	7
+1993-07-06 00:00:00	7
+1993-07-07 00:00:00	7
+1993-07-08 00:00:00	7
+1993-07-09 00:00:00	7
+1993-07-10 00:00:00	7
+1993-07-11 00:00:00	7
+1993-07-12 00:00:00	7
+1993-07-13 00:00:00	7
+1993-07-14 00:00:00	7
+1993-07-15 00:00:00	7
+1993-07-16 00:00:00	7
+1993-07-17 00:00:00	7
+1993-07-18 00:00:00	7
+1993-07-19 00:00:00	7
+1993-07-20 00:00:00	7
+1993-07-21 00:00:00	7
+1993-07-22 00:00:00	7
+1993-07-23 00:00:00	7
+1993-07-24 00:00:00	7
+1993-07-25 00:00:00	7
+1993-07-26 00:00:00	7
+1993-07-27 00:00:00	7
+1993-07-28 00:00:00	7
+1993-07-29 00:00:00	7
+1993-07-30 00:00:00	7
+1993-07-31 00:00:00	7
+1993-08-01 00:00:00	8
+1993-08-02 00:00:00	8
+1993-08-03 00:00:00	8
+1993-08-04 00:00:00	8
+1993-08-05 00:00:00	8
+1993-08-06 00:00:00	8
+1993-08-07 00:00:00	8
+1993-08-08 00:00:00	8
+1993-08-09 00:00:00	8
+1993-08-10 00:00:00	8
+1993-08-11 00:00:00	8
+1993-08-12 00:00:00	8
+1993-08-13 00:00:00	8
+1993-08-14 00:00:00	8
+1993-08-15 00:00:00	8
+1993-08-16 00:00:00	8
+1993-08-17 00:00:00	8
+1993-08-18 00:00:00	8
+1993-08-19 00:00:00	8
+1993-08-20 00:00:00	8
+1993-08-21 00:00:00	8
+1993-08-22 00:00:00	8
+1993-08-23 00:00:00	8
+1993-08-24 00:00:00	8
+1993-08-25 00:00:00	8
+1993-08-26 00:00:00	8
+1993-08-27 00:00:00	8
+1993-08-28 00:00:00	8
+1993-08-29 00:00:00	8
+1993-08-30 00:00:00	8
+1993-08-31 00:00:00	8
+1993-09-01 00:00:00	9
+1993-09-02 00:00:00	9
+1993-09-03 00:00:00	9
+1993-09-04 00:00:00	9
+1993-09-05 00:00:00	9
+1993-09-06 00:00:00	9
+1993-09-07 00:00:00	9
+1993-09-08 00:00:00	9
+1993-09-09 00:00:00	9
+1993-09-10 00:00:00	9
+1993-09-11 00:00:00	9
+1993-09-12 00:00:00	9
+1993-09-13 00:00:00	9
+1993-09-14 00:00:00	9
+1993-09-15 00:00:00	9
+1993-09-16 00:00:00	9
+1993-09-17 00:00:00	9
+1993-09-18 00:00:00	9
+1993-09-19 00:00:00	9
+1993-09-20 00:00:00	9
+1993-09-21 00:00:00	9
+1993-09-22 00:00:00	9
+1993-09-23 00:00:00	9
+1993-09-24 00:00:00	9
+1993-09-25 00:00:00	9
+1993-09-26 00:00:00	9
+1993-09-27 00:00:00	9
+1993-09-28 00:00:00	9
+1993-09-29 00:00:00	9
+1993-09-30 00:00:00	9
+1993-10-01 00:00:00	10
+1993-10-02 00:00:00	10
+1993-10-03 00:00:00	10
+1993-10-04 00:00:00	10
+1993-10-05 00:00:00	10
+1993-10-06 00:00:00	10
+1993-10-07 00:00:00	10
+1993-10-08 00:00:00	10
+1993-10-09 00:00:00	10
+1993-10-10 00:00:00	10
+1993-10-11 00:00:00	10
+1993-10-12 00:00:00	10
+1993-10-13 00:00:00	10
+1993-10-14 00:00:00	10
+1993-10-15 00:00:00	10
+1993-10-16 00:00:00	10
+1993-10-17 00:00:00	10
+1993-10-18 00:00:00	10
+1993-10-19 00:00:00	10
+1993-10-20 00:00:00	10
+1993-10-21 00:00:00	10
+1993-10-22 00:00:00	10
+1993-10-23 00:00:00	10
+1993-10-24 00:00:00	10
+1993-10-25 00:00:00	10
+1993-10-26 00:00:00	10
+1993-10-27 00:00:00	10
+1993-10-28 00:00:00	10
+1993-10-29 00:00:00	10
+1993-10-30 00:00:00	10
+1993-10-31 00:00:00	10
+1993-11-01 00:00:00	11
+1993-11-02 00:00:00	11
+1993-11-03 00:00:00	11
+1993-11-04 00:00:00	11
+1993-11-05 00:00:00	11
+1993-11-06 00:00:00	11
+1993-11-07 00:00:00	11
+1993-11-08 00:00:00	11
+1993-11-09 00:00:00	11
+1993-11-10 00:00:00	11
+1993-11-11 00:00:00	11
+1993-11-12 00:00:00	11
+1993-11-13 00:00:00	11
+1993-11-14 00:00:00	11
+1993-11-15 00:00:00	11
+1993-11-16 00:00:00	11
+1993-11-17 00:00:00	11
+1993-11-18 00:00:00	11
+1993-11-19 00:00:00	11
+1993-11-20 00:00:00	11
+1993-11-21 00:00:00	11
+1993-11-22 00:00:00	11
+1993-11-23 00:00:00	11
+1993-11-24 00:00:00	11
+1993-11-25 00:00:00	11
+1993-11-26 00:00:00	11
+1993-11-27 00:00:00	11
+1993-11-28 00:00:00	11
+1993-11-29 00:00:00	11
+1993-11-30 00:00:00	11
+1993-12-01 00:00:00	12
+1993-12-02 00:00:00	12
+1993-12-03 00:00:00	12
+1993-12-04 00:00:00	12
+1993-12-05 00:00:00	12
+1993-12-06 00:00:00	12
+1993-12-07 00:00:00	12
+1993-12-08 00:00:00	12
+1993-12-09 00:00:00	12
+1993-12-10 00:00:00	12
+1993-12-11 00:00:00	12
+1993-12-12 00:00:00	12
+1993-12-13 00:00:00	12
+1993-12-14 00:00:00	12
+1993-12-15 00:00:00	12
+1993-12-16 00:00:00	12
+1993-12-17 00:00:00	12
+1993-12-18 00:00:00	12
+1993-12-19 00:00:00	12
+1993-12-20 00:00:00	12
+1993-12-21 00:00:00	12
+1993-12-22 00:00:00	12
+1993-12-23 00:00:00	12
+1993-12-24 00:00:00	12
+1993-12-25 00:00:00	12
+1993-12-26 00:00:00	12
+1993-12-27 00:00:00	12
+1993-12-28 00:00:00	12
+1993-12-29 00:00:00	12
+1993-12-30 00:00:00	12
+1993-12-31 00:00:00	12
+1994-01-01 00:00:00	1

external/duckdb/test/sql/function/date/test_extract_year.test

@@ -0,0 +1,650 @@
+# name: test/sql/function/date/test_extract_year.test
+# description: Extract year function
+# group: [date]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+CREATE TABLE dates AS SELECT date '1970-01-01' + concat(i, ' years')::interval AS d from range(0, 430) tbl(i);
+
+statement ok
+CREATE TABLE dates2 AS SELECT date '1970-01-01' + concat(i * 6, ' months')::interval AS d from range(0, 200) tbl(i);
+
+query I
+SELECT EXTRACT(year FROM d) FROM dates ORDER BY 1
+----
+1970
+1971
+1972
+1973
+1974
+1975
+1976
+1977
+1978
+1979
+1980
+1981
+1982
+1983
+1984
+1985
+1986
+1987
+1988
+1989
+1990
+1991
+1992
+1993
+1994
+1995
+1996
+1997
+1998
+1999
+2000
+2001
+2002
+2003
+2004
+2005
+2006
+2007
+2008
+2009
+2010
+2011
+2012
+2013
+2014
+2015
+2016
+2017
+2018
+2019
+2020
+2021
+2022
+2023
+2024
+2025
+2026
+2027
+2028
+2029
+2030
+2031
+2032
+2033
+2034
+2035
+2036
+2037
+2038
+2039
+2040
+2041
+2042
+2043
+2044
+2045
+2046
+2047
+2048
+2049
+2050
+2051
+2052
+2053
+2054
+2055
+2056
+2057
+2058
+2059
+2060
+2061
+2062
+2063
+2064
+2065
+2066
+2067
+2068
+2069
+2070
+2071
+2072
+2073
+2074
+2075
+2076
+2077
+2078
+2079
+2080
+2081
+2082
+2083
+2084
+2085
+2086
+2087
+2088
+2089
+2090
+2091
+2092
+2093
+2094
+2095
+2096
+2097
+2098
+2099
+2100
+2101
+2102
+2103
+2104
+2105
+2106
+2107
+2108
+2109
+2110
+2111
+2112
+2113
+2114
+2115
+2116
+2117
+2118
+2119
+2120
+2121
+2122
+2123
+2124
+2125
+2126
+2127
+2128
+2129
+2130
+2131
+2132
+2133
+2134
+2135
+2136
+2137
+2138
+2139
+2140
+2141
+2142
+2143
+2144
+2145
+2146
+2147
+2148
+2149
+2150
+2151
+2152
+2153
+2154
+2155
+2156
+2157
+2158
+2159
+2160
+2161
+2162
+2163
+2164
+2165
+2166
+2167
+2168
+2169
+2170
+2171
+2172
+2173
+2174
+2175
+2176
+2177
+2178
+2179
+2180
+2181
+2182
+2183
+2184
+2185
+2186
+2187
+2188
+2189
+2190
+2191
+2192
+2193
+2194
+2195
+2196
+2197
+2198
+2199
+2200
+2201
+2202
+2203
+2204
+2205
+2206
+2207
+2208
+2209
+2210
+2211
+2212
+2213
+2214
+2215
+2216
+2217
+2218
+2219
+2220
+2221
+2222
+2223
+2224
+2225
+2226
+2227
+2228
+2229
+2230
+2231
+2232
+2233
+2234
+2235
+2236
+2237
+2238
+2239
+2240
+2241
+2242
+2243
+2244
+2245
+2246
+2247
+2248
+2249
+2250
+2251
+2252
+2253
+2254
+2255
+2256
+2257
+2258
+2259
+2260
+2261
+2262
+2263
+2264
+2265
+2266
+2267
+2268
+2269
+2270
+2271
+2272
+2273
+2274
+2275
+2276
+2277
+2278
+2279
+2280
+2281
+2282
+2283
+2284
+2285
+2286
+2287
+2288
+2289
+2290
+2291
+2292
+2293
+2294
+2295
+2296
+2297
+2298
+2299
+2300
+2301
+2302
+2303
+2304
+2305
+2306
+2307
+2308
+2309
+2310
+2311
+2312
+2313
+2314
+2315
+2316
+2317
+2318
+2319
+2320
+2321
+2322
+2323
+2324
+2325
+2326
+2327
+2328
+2329
+2330
+2331
+2332
+2333
+2334
+2335
+2336
+2337
+2338
+2339
+2340
+2341
+2342
+2343
+2344
+2345
+2346
+2347
+2348
+2349
+2350
+2351
+2352
+2353
+2354
+2355
+2356
+2357
+2358
+2359
+2360
+2361
+2362
+2363
+2364
+2365
+2366
+2367
+2368
+2369
+2370
+2371
+2372
+2373
+2374
+2375
+2376
+2377
+2378
+2379
+2380
+2381
+2382
+2383
+2384
+2385
+2386
+2387
+2388
+2389
+2390
+2391
+2392
+2393
+2394
+2395
+2396
+2397
+2398
+2399
+
+query I
+SELECT EXTRACT(year FROM d) FROM dates2 ORDER BY 1
+----
+1970
+1970
+1971
+1971
+1972
+1972
+1973
+1973
+1974
+1974
+1975
+1975
+1976
+1976
+1977
+1977
+1978
+1978
+1979
+1979
+1980
+1980
+1981
+1981
+1982
+1982
+1983
+1983
+1984
+1984
+1985
+1985
+1986
+1986
+1987
+1987
+1988
+1988
+1989
+1989
+1990
+1990
+1991
+1991
+1992
+1992
+1993
+1993
+1994
+1994
+1995
+1995
+1996
+1996
+1997
+1997
+1998
+1998
+1999
+1999
+2000
+2000
+2001
+2001
+2002
+2002
+2003
+2003
+2004
+2004
+2005
+2005
+2006
+2006
+2007
+2007
+2008
+2008
+2009
+2009
+2010
+2010
+2011
+2011
+2012
+2012
+2013
+2013
+2014
+2014
+2015
+2015
+2016
+2016
+2017
+2017
+2018
+2018
+2019
+2019
+2020
+2020
+2021
+2021
+2022
+2022
+2023
+2023
+2024
+2024
+2025
+2025
+2026
+2026
+2027
+2027
+2028
+2028
+2029
+2029
+2030
+2030
+2031
+2031
+2032
+2032
+2033
+2033
+2034
+2034
+2035
+2035
+2036
+2036
+2037
+2037
+2038
+2038
+2039
+2039
+2040
+2040
+2041
+2041
+2042
+2042
+2043
+2043
+2044
+2044
+2045
+2045
+2046
+2046
+2047
+2047
+2048
+2048
+2049
+2049
+2050
+2050
+2051
+2051
+2052
+2052
+2053
+2053
+2054
+2054
+2055
+2055
+2056
+2056
+2057
+2057
+2058
+2058
+2059
+2059
+2060
+2060
+2061
+2061
+2062
+2062
+2063
+2063
+2064
+2064
+2065
+2065
+2066
+2066
+2067
+2067
+2068
+2068
+2069
+2069

external/duckdb/test/sql/function/date/test_strftime.test

@@ -0,0 +1,172 @@
+# name: test/sql/function/date/test_strftime.test
+# description: Test strftime function
+# group: [date]
+
+statement ok
+SET default_null_order='nulls_first';
+
+statement ok
+PRAGMA enable_verification
+
+# simple single specifier
+query I
+SELECT strftime(DATE '1992-01-01', '%Y');
+----
+1992
+
+# flip the order
+query I
+SELECT strftime('%Y', DATE '1992-01-01');
+----
+1992
+
+query I
+SELECT strftime('%Y', TIMESTAMP '1992-01-01');
+----
+1992
+
+# some literals
+query I
+SELECT strftime(DATE '1992-01-01', '(%Y)');
+----
+(1992)
+
+# escapes
+query I
+SELECT strftime(DATE '1992-01-01', '%% %Y %%');
+----
+% 1992 %
+
+# many consecutive escapes
+query I
+SELECT strftime(DATE '1992-01-01', '%%%%%% %Y %%%%%%');
+----
+%%% 1992 %%%
+
+# multiple specifiers
+query I
+SELECT strftime(DATE '1992-02-01', '%d/%m/%Y');
+----
+01/02/1992
+
+# we can repeat the same specifier many times
+query I
+SELECT strftime(DATE '1992-02-01', '%Y %Y %Y %Y');
+----
+1992 1992 1992 1992
+
+# test on a table
+statement ok
+CREATE TABLE dates(d DATE);
+INSERT INTO dates VALUES ('1992-01-01'), ('1993-03-20'), (NULL);
+
+query I
+SELECT strftime(d, '%d/%m/%Y') FROM dates ORDER BY d;
+----
+NULL
+01/01/1992
+20/03/1993
+
+# null date
+query I
+SELECT strftime(NULL::DATE, '%d/%m/%Y') FROM dates ORDER BY d;
+----
+NULL
+NULL
+NULL
+
+# null format
+query I
+SELECT strftime(d, NULL) FROM dates ORDER BY d;
+----
+NULL
+NULL
+NULL
+
+query I
+SELECT strftime(NULL::TIMESTAMP, NULL) FROM range(3);
+----
+NULL
+NULL
+NULL
+
+query I
+SELECT strftime(NULL::TIMESTAMP, '%%%%%% %Y %%%%%%') FROM range(3);
+----
+NULL
+NULL
+NULL
+
+# no specifiers, only constant
+query I
+SELECT strftime(DATE '1992-01-01', 'hello world');
+----
+hello world
+
+query I
+SELECT strftime('2019-01-23'::DATE, '42');
+----
+42
+
+#
+# Infinities
+#
+
+foreach datatype DATE TIMESTAMP
+
+# PG to_char returns NULL here
+# but we can do better.
+query I
+SELECT strftime('infinity'::${datatype}, '%Y-%m-%d');
+----
+infinity
+
+query I
+SELECT strftime('-infinity'::${datatype}, '%Y-%m-%d');
+----
+-infinity
+
+endloop
+
+# non-constant format not supported
+statement error
+SELECT strftime(d, d::VARCHAR) FROM dates ORDER BY d;
+----
+<REGEX>:.*Invalid Input Error.*must be a constant.*
+
+# unterminated escape
+statement error
+SELECT strftime(DATE '1992-01-01', '%');
+----
+<REGEX>:.*Invalid Input Error.*Failed to parse format.*
+
+# unrecognized code
+statement error
+SELECT strftime(DATE '1992-01-01', '%R');
+----
+<REGEX>:.*Invalid Input Error.*Failed to parse format.*
+
+# millisecond specifier %g
+query IIII
+select strftime(strptime('023', '%g'), '%g'), strftime(strptime('0', '%g'), '%g'), strftime(strptime('000', '%g'), '%g'), strftime(strptime('999', '%g'), '%g');
+----
+023
+000
+000
+999
+
+statement error
+SELECT strptime('-1', '%g');
+----
+<REGEX>:.*Invalid Input Error.*Could not parse string.*
+
+statement error
+SELECT strptime('1000', '%g');
+----
+<REGEX>:.*Invalid Input Error.*Could not parse string.*
+
+# this won't work without explicit casts
+statement error
+SELECT strftime('%Y', '1992-01-01');
+----
+<REGEX>:.*Binder Error.*Could not choose a best candidate.*

external/duckdb/test/sql/function/date/test_strftime_exhaustive.test

@@ -0,0 +1,417 @@
+# name: test/sql/function/date/test_strftime_exhaustive.test
+# description: Test all strftime % codes with the date type
+# group: [date]
+
+statement ok
+SET default_null_order='nulls_first';
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+CREATE TABLE dates(d DATE);
+INSERT INTO dates VALUES ('1992-01-01'), ('1993-03-20'), ('2020-08-09'), ('2020-08-10'), (NULL);
+
+# %a: Abbreviated weekday name
+query I
+SELECT strftime(d, '%a') FROM dates ORDER BY d;
+----
+NULL
+Wed
+Sat
+Sun
+Mon
+
+# %A: Full weekday name
+query I
+SELECT strftime(d, '%A') FROM dates ORDER BY d;
+----
+NULL
+Wednesday
+Saturday
+Sunday
+Monday
+
+# %w - Weekday as a decimal number.
+query I
+SELECT strftime(d, '%w') FROM dates ORDER BY d;
+----
+NULL
+3
+6
+0
+1
+
+# %u - ISO Weekday as a decimal number (1-7)
+query I
+SELECT strftime(d, '%u') FROM dates ORDER BY d;
+----
+NULL
+3
+6
+7
+1
+
+# %d - Day of the month as a zero-padded decimal.
+query I
+SELECT strftime(d, '%d') FROM dates ORDER BY d;
+----
+NULL
+01
+20
+09
+10
+
+# %-d - Day of the month as a decimal number.
+query I
+SELECT strftime(d, '%-d') FROM dates ORDER BY d;
+----
+NULL
+1
+20
+9
+10
+
+# %b - Abbreviated month name.
+query I
+SELECT strftime(d, '%b') FROM dates ORDER BY d;
+----
+NULL
+Jan
+Mar
+Aug
+Aug
+
+# %h - alias for %b
+query I
+SELECT strftime(d, '%h') FROM dates ORDER BY d;
+----
+NULL
+Jan
+Mar
+Aug
+Aug
+
+# %B - Full month name
+query I
+SELECT strftime(d, '%B') FROM dates ORDER BY d;
+----
+NULL
+January
+March
+August
+August
+
+# %m - Month as a zero-padded decimal number
+query I
+SELECT strftime(d, '%m') FROM dates ORDER BY d;
+----
+NULL
+01
+03
+08
+08
+
+# %-m - Month as a decimal number. (1, 2, ..., 12)
+query I
+SELECT strftime(d, '%-m') FROM dates ORDER BY d;
+----
+NULL
+1
+3
+8
+8
+
+# %y - Year without century as a zero-padded decimal number.
+query I
+SELECT strftime(d, '%y') FROM dates ORDER BY d;
+----
+NULL
+92
+93
+20
+20
+
+# %-y - Year without century as a decimal number.
+query I
+SELECT strftime(d, '%-y') FROM dates ORDER BY d;
+----
+NULL
+92
+93
+20
+20
+
+query I
+SELECT strftime(DATE '2001-01-01', '%-y')
+----
+1
+
+# %Y - Year with century as a decimal number.
+query I
+SELECT strftime(d, '%Y') FROM dates ORDER BY d;
+----
+NULL
+1992
+1993
+2020
+2020
+
+# %G - ISO Year as a decimal number.
+query I
+SELECT strftime(d, '%G') FROM dates ORDER BY d;
+----
+NULL
+1992
+1993
+2020
+2020
+
+# %H - Hour (24-hour clock) as a zero-padded decimal number.
+query I
+SELECT strftime(d, '%H') FROM dates ORDER BY d;
+----
+NULL
+00
+00
+00
+00
+
+# %-H - Hour (24-hour clock) as a decimal number. (0, 1, ..., 23)
+query I
+SELECT strftime(d, '%-H') FROM dates ORDER BY d;
+----
+NULL
+0
+0
+0
+0
+
+# %I - Hour (12-hour clock) as a zero-padded decimal number.
+query I
+SELECT strftime(d, '%I') FROM dates ORDER BY d;
+----
+NULL
+12
+12
+12
+12
+
+# %-I - Hour (12-hour clock) as a decimal number. (1, 2, ... 12)
+query I
+SELECT strftime(d, '%-I') FROM dates ORDER BY d;
+----
+NULL
+12
+12
+12
+12
+
+# %p - Locale’s AM or PM.
+query I
+SELECT strftime(d, '%p') FROM dates ORDER BY d;
+----
+NULL
+AM
+AM
+AM
+AM
+
+# %M - Minute as a zero-padded decimal number.
+query I
+SELECT strftime(d, '%M') FROM dates ORDER BY d;
+----
+NULL
+00
+00
+00
+00
+
+# %-M - Minute as a decimal number. (0, 1, ..., 59)
+query I
+SELECT strftime(d, '%-M') FROM dates ORDER BY d;
+----
+NULL
+0
+0
+0
+0
+
+# %S - Second as a zero-padded decimal number.
+query I
+SELECT strftime(d, '%S') FROM dates ORDER BY d;
+----
+NULL
+00
+00
+00
+00
+
+# %-S - Second as a decimal number. (0, 1, ..., 59)
+query I
+SELECT strftime(d, '%-S') FROM dates ORDER BY d;
+----
+NULL
+0
+0
+0
+0
+
+# %f - Microsecond as a decimal number, zero-padded on the left.
+query I
+SELECT strftime(d, '%f') FROM dates ORDER BY d;
+----
+NULL
+000000
+000000
+000000
+000000
+
+# %z - UTC offset in the form +HHMM or -HHMM.
+query I
+SELECT strftime(d, '%z') FROM dates ORDER BY d;
+----
+NULL
++00
++00
++00
++00
+
+# %Z - Time zone name.
+query I
+SELECT strftime(d, '%Z') FROM dates ORDER BY d;
+----
+NULL
+(empty)
+(empty)
+(empty)
+(empty)
+
+# %j - Day of the year as a zero-padded decimal number.
+query I
+SELECT strftime(d, '%j') FROM dates ORDER BY d;
+----
+NULL
+001
+079
+222
+223
+
+# %-j - Day of the year as a decimal number. (1, 2, ..., 366)
+query I
+SELECT strftime(d, '%-j') FROM dates ORDER BY d;
+----
+NULL
+1
+79
+222
+223
+
+# %U - Week number of the year (Sunday as the first day of the week).
+query I
+SELECT strftime(d, '%U') FROM dates ORDER BY d;
+----
+NULL
+00
+11
+32
+32
+
+# %W - Week number of the year (Monday as the first day of the week).
+query I
+SELECT strftime(d, '%W') FROM dates ORDER BY d;
+----
+NULL
+00
+11
+31
+32
+
+# %V - ISO Week number of the year (First week contains Jan 4).
+query I
+SELECT strftime(d, '%V') FROM dates ORDER BY d;
+----
+NULL
+01
+11
+32
+33
+
+# %c - Locale’s appropriate date and time representation.
+query I
+SELECT strftime(d, '%c') FROM dates ORDER BY d;
+----
+NULL
+1992-01-01 00:00:00
+1993-03-20 00:00:00
+2020-08-09 00:00:00
+2020-08-10 00:00:00
+
+query I
+SELECT strftime(d, 'XX%cXX') FROM dates ORDER BY d;
+----
+NULL
+XX1992-01-01 00:00:00XX
+XX1993-03-20 00:00:00XX
+XX2020-08-09 00:00:00XX
+XX2020-08-10 00:00:00XX
+
+# %x - Locale’s appropriate date representation.
+query I
+SELECT strftime(d, '%x') FROM dates ORDER BY d;
+----
+NULL
+1992-01-01
+1993-03-20
+2020-08-09
+2020-08-10
+
+# X - Locale’s appropriate time representation.
+query I
+SELECT strftime(d, '%X') FROM dates ORDER BY d;
+----
+NULL
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+
+query I
+SELECT strftime(d, 'XX%cXX%xXX%XXX') FROM dates ORDER BY d;
+----
+NULL
+XX1992-01-01 00:00:00XX1992-01-01XX00:00:00XX
+XX1993-03-20 00:00:00XX1993-03-20XX00:00:00XX
+XX2020-08-09 00:00:00XX2020-08-09XX00:00:00XX
+XX2020-08-10 00:00:00XX2020-08-10XX00:00:00XX
+
+# large year
+query I
+SELECT strftime(date '-99999-01-01', '%Y')
+----
+-99999
+
+query I
+SELECT strftime(date '99999-01-01', '%Y')
+----
+99999
+
+query I
+SELECT strftime(date '99999-01-01', '%y')
+----
+99
+
+query I
+SELECT strftime(date '-99999-01-01', '%y')
+----
+99
+
+query I
+SELECT strftime(DATE '-4869706-10-11','%-yi');
+----
+6i
+
+statement error
+SELECT strftime(date '-99999-01-01', random()::varchar)
+----
+<REGEX>:.*Invalid Input Error.*must be a constant.*

external/duckdb/test/sql/function/date/test_time_bucket_date.test

@@ -0,0 +1,603 @@
+# name: test/sql/function/date/test_time_bucket_date.test
+# description: Test time bucket functionality
+# group: [date]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+CREATE TABLE dates(w INTERVAL, d DATE, shift INTERVAL, origin DATE);
+
+statement ok
+INSERT INTO dates VALUES ('10 days', '-infinity', '0 days', '1970-01-05'),
+	('10 days', '3000-01-02 (BC)', '3 days', '3000-01-01 (BC)'),
+	('2 months', '1024-04-10 (BC)', '10 days', '1024-03-01 (BC)'),
+	('10 days', '0044-06-15 (BC)', '6 days', '0044-02-01 (BC)'),
+	('10 days', '0794-11-15', '1 week', '0790-11-01'),
+	('10 days', '1700-01-01', '0 days', '1700-01-05'),
+	('1 week', '1832-05-03', '0 days', '1970-05-05'),
+	('10 days', '1897-07-05', '2 days', '1970-06-07'),
+	('10 days', '1906-02-08', '-2 days', '1970-10-03'),
+	('2 months', '1946-09-14', '0 months', '1970-07-05'),
+	('2 months', '2000-01-01', '1 month 1 week', '1970-05-01'),
+	('2 months', '2000-01-03', '-1 month 1 week', '1970-08-20'),
+	('2 year', '2004-05-20', '6 months', '1970-12-31'),
+	('2 year', '2032-12-06', '-6 months', '1969-07-01'),
+	('10 days', 'infinity', '0 days', '1970-01-01'),
+;
+
+query II
+select d, time_bucket('3 days'::interval, d) from dates;
+----
+-infinity	-infinity
+3000-01-02 (BC)	3000-01-02 (BC)
+1024-04-10 (BC)	1024-04-10 (BC)
+0044-06-15 (BC)	0044-06-14 (BC)
+0794-11-15	0794-11-15
+1700-01-01	1699-12-31
+1832-05-03	1832-05-01
+1897-07-05	1897-07-04
+1906-02-08	1906-02-06
+1946-09-14	1946-09-13
+2000-01-01	1999-12-31
+2000-01-03	2000-01-03
+2004-05-20	2004-05-20
+2032-12-06	2032-12-04
+infinity	infinity
+
+query II
+select d, time_bucket('3 years'::interval, d) from dates;
+----
+-infinity	-infinity
+3000-01-02 (BC)	3002-01-01 (BC)
+1024-04-10 (BC)	1025-01-01 (BC)
+0044-06-15 (BC)	0044-01-01 (BC)
+0794-11-15	0794-01-01
+1700-01-01	1700-01-01
+1832-05-03	1832-01-01
+1897-07-05	1895-01-01
+1906-02-08	1904-01-01
+1946-09-14	1946-01-01
+2000-01-01	2000-01-01
+2000-01-03	2000-01-01
+2004-05-20	2003-01-01
+2032-12-06	2030-01-01
+infinity	infinity
+
+query II
+select d, time_bucket(null::interval, d) from dates;
+----
+-infinity	NULL
+3000-01-02 (BC)	NULL
+1024-04-10 (BC)	NULL
+0044-06-15 (BC)	NULL
+0794-11-15	NULL
+1700-01-01	NULL
+1832-05-03	NULL
+1897-07-05	NULL
+1906-02-08	NULL
+1946-09-14	NULL
+2000-01-01	NULL
+2000-01-03	NULL
+2004-05-20	NULL
+2032-12-06	NULL
+infinity	NULL
+
+query III
+select w, d, time_bucket(w, d) from dates;
+----
+10 days	-infinity	-infinity
+10 days	3000-01-02 (BC)	3001-12-31 (BC)
+2 months	1024-04-10 (BC)	1024-03-01 (BC)
+10 days	0044-06-15 (BC)	0044-06-12 (BC)
+10 days	0794-11-15	0794-11-11
+10 days	1700-01-01	1699-12-26
+7 days	1832-05-03	1832-04-30
+10 days	1897-07-05	1897-07-01
+10 days	1906-02-08	1906-02-05
+2 months	1946-09-14	1946-09-01
+2 months	2000-01-01	2000-01-01
+2 months	2000-01-03	2000-01-01
+2 years	2004-05-20	2004-01-01
+2 years	2032-12-06	2032-01-01
+10 days	infinity	infinity
+
+query II
+select d, time_bucket('4 days'::interval, d, '6 hours'::interval) from dates;
+----
+-infinity	-infinity
+3000-01-02 (BC)	3001-12-29 (BC)
+1024-04-10 (BC)	1024-04-08 (BC)
+0044-06-15 (BC)	0044-06-14 (BC)
+0794-11-15	0794-11-13
+1700-01-01	1699-12-30
+1832-05-03	1832-04-29
+1897-07-05	1897-07-01
+1906-02-08	1906-02-05
+1946-09-14	1946-09-11
+2000-01-01	1999-12-30
+2000-01-03	1999-12-30
+2004-05-20	2004-05-17
+2032-12-06	2032-12-04
+infinity	infinity
+
+query II
+select d, time_bucket('2 weeks'::interval, d, '6 days'::interval) from dates;
+----
+-infinity	-infinity
+3000-01-02 (BC)	3001-12-21 (BC)
+1024-04-10 (BC)	1024-04-06 (BC)
+0044-06-15 (BC)	0044-06-02 (BC)
+0794-11-15	0794-11-13
+1700-01-01	1699-12-20
+1832-05-03	1832-04-29
+1897-07-05	1897-06-27
+1906-02-08	1906-01-28
+1946-09-14	1946-09-01
+2000-01-01	1999-12-26
+2000-01-03	1999-12-26
+2004-05-20	2004-05-09
+2032-12-06	2032-11-28
+infinity	infinity
+
+query II
+select d, time_bucket('3 months'::interval, d, '6 days'::interval) from dates;
+----
+-infinity	-infinity
+3000-01-02 (BC)	3001-10-07 (BC)
+1024-04-10 (BC)	1024-04-07 (BC)
+0044-06-15 (BC)	0044-04-07 (BC)
+0794-11-15	0794-10-07
+1700-01-01	1699-10-07
+1832-05-03	1832-04-07
+1897-07-05	1897-04-07
+1906-02-08	1906-01-07
+1946-09-14	1946-07-07
+2000-01-01	1999-10-07
+2000-01-03	1999-10-07
+2004-05-20	2004-04-07
+2032-12-06	2032-10-07
+infinity	infinity
+
+query II
+select d, time_bucket(null::interval, d, '6 days'::interval) from dates;
+----
+-infinity	NULL
+3000-01-02 (BC)	NULL
+1024-04-10 (BC)	NULL
+0044-06-15 (BC)	NULL
+0794-11-15	NULL
+1700-01-01	NULL
+1832-05-03	NULL
+1897-07-05	NULL
+1906-02-08	NULL
+1946-09-14	NULL
+2000-01-01	NULL
+2000-01-03	NULL
+2004-05-20	NULL
+2032-12-06	NULL
+infinity	NULL
+
+query I
+select time_bucket('3 months'::interval, null::date, '6 days'::interval) from dates;
+----
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+
+query II
+select d, time_bucket('3 months'::interval, d, null::interval) from dates;
+----
+-infinity	NULL
+3000-01-02 (BC)	NULL
+1024-04-10 (BC)	NULL
+0044-06-15 (BC)	NULL
+0794-11-15	NULL
+1700-01-01	NULL
+1832-05-03	NULL
+1897-07-05	NULL
+1906-02-08	NULL
+1946-09-14	NULL
+2000-01-01	NULL
+2000-01-03	NULL
+2004-05-20	NULL
+2032-12-06	NULL
+infinity	NULL
+
+query IIII
+select w, d, shift, time_bucket(w, d, shift) from dates;
+----
+10 days	-infinity	00:00:00	-infinity
+10 days	3000-01-02 (BC)	3 days	3001-12-24 (BC)
+2 months	1024-04-10 (BC)	10 days	1024-03-11 (BC)
+10 days	0044-06-15 (BC)	6 days	0044-06-08 (BC)
+10 days	0794-11-15	7 days	0794-11-08
+10 days	1700-01-01	00:00:00	1699-12-26
+7 days	1832-05-03	00:00:00	1832-04-30
+10 days	1897-07-05	2 days	1897-07-03
+10 days	1906-02-08	-2 days	1906-02-03
+2 months	1946-09-14	00:00:00	1946-09-01
+2 months	2000-01-01	1 month 7 days	1999-12-08
+2 months	2000-01-03	-1 month 7 days	1999-12-08
+2 years	2004-05-20	6 months	2002-07-01
+2 years	2032-12-06	-6 months	2031-07-01
+10 days	infinity	00:00:00	infinity
+
+query II
+select d, time_bucket('5 days'::interval, d, '1970-01-04'::date) from dates;
+----
+-infinity	-infinity
+3000-01-02 (BC)	3001-12-30 (BC)
+1024-04-10 (BC)	1024-04-09 (BC)
+0044-06-15 (BC)	0044-06-11 (BC)
+0794-11-15	0794-11-15
+1700-01-01	1699-12-30
+1832-05-03	1832-05-02
+1897-07-05	1897-07-05
+1906-02-08	1906-02-04
+1946-09-14	1946-09-12
+2000-01-01	1999-12-28
+2000-01-03	2000-01-02
+2004-05-20	2004-05-20
+2032-12-06	2032-12-04
+infinity	infinity
+
+query II
+select d, time_bucket('3 months'::interval, d, '1970-01-04'::date) from dates;
+----
+-infinity	-infinity
+3000-01-02 (BC)	3000-01-01 (BC)
+1024-04-10 (BC)	1024-04-01 (BC)
+0044-06-15 (BC)	0044-04-01 (BC)
+0794-11-15	0794-10-01
+1700-01-01	1700-01-01
+1832-05-03	1832-04-01
+1897-07-05	1897-07-01
+1906-02-08	1906-01-01
+1946-09-14	1946-07-01
+2000-01-01	2000-01-01
+2000-01-03	2000-01-01
+2004-05-20	2004-04-01
+2032-12-06	2032-10-01
+infinity	infinity
+
+query II
+select d, time_bucket('3 years'::interval, d, '1970-01-04'::date) from dates;
+----
+-infinity	-infinity
+3000-01-02 (BC)	3002-01-01 (BC)
+1024-04-10 (BC)	1025-01-01 (BC)
+0044-06-15 (BC)	0044-01-01 (BC)
+0794-11-15	0794-01-01
+1700-01-01	1700-01-01
+1832-05-03	1832-01-01
+1897-07-05	1895-01-01
+1906-02-08	1904-01-01
+1946-09-14	1946-01-01
+2000-01-01	2000-01-01
+2000-01-03	2000-01-01
+2004-05-20	2003-01-01
+2032-12-06	2030-01-01
+infinity	infinity
+
+query II
+select d, time_bucket(null::interval, d, '1970-01-04'::date) from dates;
+----
+-infinity	NULL
+3000-01-02 (BC)	NULL
+1024-04-10 (BC)	NULL
+0044-06-15 (BC)	NULL
+0794-11-15	NULL
+1700-01-01	NULL
+1832-05-03	NULL
+1897-07-05	NULL
+1906-02-08	NULL
+1946-09-14	NULL
+2000-01-01	NULL
+2000-01-03	NULL
+2004-05-20	NULL
+2032-12-06	NULL
+infinity	NULL
+
+query I
+select time_bucket('3 years'::interval, null::date, '1970-01-04'::date) from dates;
+----
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+
+query II
+select d, time_bucket('3 years'::interval, d, null::date) from dates;
+----
+-infinity	NULL
+3000-01-02 (BC)	NULL
+1024-04-10 (BC)	NULL
+0044-06-15 (BC)	NULL
+0794-11-15	NULL
+1700-01-01	NULL
+1832-05-03	NULL
+1897-07-05	NULL
+1906-02-08	NULL
+1946-09-14	NULL
+2000-01-01	NULL
+2000-01-03	NULL
+2004-05-20	NULL
+2032-12-06	NULL
+infinity	NULL
+
+query IIII
+select w, d, origin, time_bucket(w, d, origin) from dates;
+----
+10 days	-infinity	1970-01-05	-infinity
+10 days	3000-01-02 (BC)	3000-01-01 (BC)	3000-01-01 (BC)
+2 months	1024-04-10 (BC)	1024-03-01 (BC)	1024-03-01 (BC)
+10 days	0044-06-15 (BC)	0044-02-01 (BC)	0044-06-11 (BC)
+10 days	0794-11-15	0790-11-01	0794-11-10
+10 days	1700-01-01	1700-01-05	1699-12-26
+7 days	1832-05-03	1970-05-05	1832-05-01
+10 days	1897-07-05	1970-06-07	1897-06-29
+10 days	1906-02-08	1970-10-03	1906-02-01
+2 months	1946-09-14	1970-07-05	1946-09-01
+2 months	2000-01-01	1970-05-01	2000-01-01
+2 months	2000-01-03	1970-08-20	1999-12-01
+2 years	2004-05-20	1970-12-31	2002-12-01
+2 years	2032-12-06	1969-07-01	2031-07-01
+10 days	infinity	1970-01-01	infinity
+
+statement error
+select time_bucket('-3 hours'::interval, '2019-04-05'::date);
+----
+
+statement error
+select time_bucket('-3 hours'::interval, '2019-04-05'::date, '1 hour 30 minutes'::interval);
+----
+
+statement error
+select time_bucket('-3 hours'::interval, '2019-04-05'::date, '2019-04-05'::date);
+----
+
+statement error
+select time_bucket('-1 month'::interval, '2019-04-05'::date);
+----
+
+statement error
+select time_bucket('-1 month'::interval, '2019-04-05'::date, '1 week'::interval);
+----
+
+statement error
+select time_bucket('-1 month'::interval, '2019-04-05'::date, '2019-04-05'::date);
+----
+
+statement error
+select time_bucket('1 day - 172800 seconds'::interval, '2018-05-05'::date);
+----
+
+statement error
+select time_bucket('1 day - 172800 seconds'::interval, '2018-05-05'::date, '1 hour 30 minutes'::interval);
+----
+
+statement error
+select time_bucket('1 day - 172800 seconds'::interval, '2018-05-05'::date, '2018-05-05'::date);
+----
+
+statement error
+select time_bucket('1 month 1 day'::interval, '2018-05-05'::date);
+----
+
+statement error
+select time_bucket('1 month 1 day'::interval, '2018-05-05'::date, '1 week'::interval);
+----
+
+statement error
+select time_bucket('1 month 1 day'::interval, '2019-05-05'::date, '2019-05-05'::date);
+----
+
+statement error
+select time_bucket('3 days'::interval, '2019-05-05'::date, '2000000000 months'::interval);
+----
+
+statement error
+select time_bucket('3 days'::interval, '2019-05-05'::date, '-2000000000 months'::interval);
+----
+
+statement error
+select time_bucket('3 months'::interval, '2019-05-05'::date, '2000000000 months'::interval);
+----
+
+statement error
+select time_bucket('3 months'::interval, '2019-05-05'::date, '-2000000000 months'::interval);
+----
+
+statement error
+select time_bucket('1 month'::interval, '5877642-06-25 (BC)'::date);
+----
+
+query I
+select time_bucket('1 month'::interval, '5877642-07-01 (BC)'::date);
+----
+5877642-07-01 (BC)
+
+statement error
+select time_bucket('1 week'::interval, '5877642-07-01 (BC)'::date);
+----
+
+statement error
+select time_bucket('1 month'::interval, '5881580-07-10'::date, '-1 day'::interval);
+----
+
+query I
+select time_bucket('1 month'::interval, '5881580-07-10'::date);
+----
+5881580-07-01
+
+statement error
+select time_bucket('1 week'::interval, '290309-12-21 (BC)'::date);
+----
+
+statement error
+select time_bucket('1 week'::interval, '290309-12-22 (BC)'::date);
+----
+
+statement error
+select time_bucket('1 day'::interval, '290309-12-21 (BC)'::date);
+----
+
+query I
+select time_bucket('1 day'::interval, '290309-12-22 (BC)'::date);
+----
+290309-12-22 (BC)
+
+statement error
+select time_bucket('1 week'::interval, '294247-01-11'::date);
+----
+
+query I
+select time_bucket('1 week'::interval, '294247-01-10'::date);
+----
+294247-01-04
+
+statement error
+select time_bucket('1 day'::interval, '294247-01-11'::date);
+----
+
+query I
+select time_bucket('1 day'::interval, '294247-01-10'::date);
+----
+294247-01-10
+
+query I
+select time_bucket('1 month 1 day'::interval, null::date);
+----
+NULL
+
+query I
+select time_bucket('1 month 1 day'::interval, null::date, '6 days'::interval);
+----
+NULL
+
+query I
+select time_bucket('1 month 1 day'::interval, null::date, '2022-12-20'::date);
+----
+NULL
+
+query I
+select time_bucket('-1 month'::interval, null::date);
+----
+NULL
+
+query I
+select time_bucket('-1 month'::interval, null::date, '6 days'::interval);
+----
+NULL
+
+query I
+select time_bucket('-1 month'::interval, '2022-12-22'::date, null::interval);
+----
+NULL
+
+query I
+select time_bucket('-1 month'::interval, null::date, '2022-12-20'::date);
+----
+NULL
+
+query I
+select time_bucket('-1 month'::interval, '2022-12-22'::date, null::date);
+----
+NULL
+
+# non-foldable NULL testing
+query T
+WITH cte AS (
+    SELECT NULL::INTERVAL i,
+           NULL::DATE d,
+           NULL::TIMESTAMP t
+    FROM range(1)
+)
+SELECT time_bucket(i, d)
+FROM cte
+----
+NULL
+
+query T
+WITH cte AS (
+    SELECT NULL::INTERVAL i,
+           NULL::DATE d,
+           NULL::TIMESTAMP t
+    FROM range(1)
+)
+SELECT time_bucket(i, t)
+FROM cte
+----
+NULL
+
+query T
+WITH cte AS (
+    SELECT NULL::INTERVAL i,
+           NULL::DATE d,
+           NULL::TIMESTAMP t
+    FROM range(1)
+)
+SELECT time_bucket(i, d, i)
+FROM cte
+----
+NULL
+
+query T
+WITH cte AS (
+    SELECT NULL::INTERVAL i,
+           NULL::DATE d,
+           NULL::TIMESTAMP t
+    FROM range(1)
+)
+SELECT time_bucket(i, t, i)
+FROM cte
+----
+NULL
+
+query T
+WITH cte AS (
+    SELECT NULL::INTERVAL i,
+           NULL::DATE d,
+           NULL::TIMESTAMP t
+    FROM range(1)
+)
+SELECT time_bucket(i, d, d)
+FROM cte
+----
+NULL
+
+query T
+WITH cte AS (
+    SELECT NULL::INTERVAL i,
+           NULL::DATE d,
+           NULL::TIMESTAMP t
+    FROM range(1)
+)
+SELECT time_bucket(i, t, t)
+FROM cte
+----
+NULL

external/duckdb/test/sql/function/enum/test_enum_code.test

@@ -0,0 +1,46 @@
+# name: test/sql/function/enum/test_enum_code.test
+# description: Enum Code Function
+# group: [enum]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy', 'anxious')
+
+statement ok
+CREATE TABLE test (x mood)
+
+statement ok
+INSERT INTO test VALUES ('ok'), ('sad'), ('anxious'), ('happy')
+
+query I
+SELECT enum_code(x) FROM test
+----
+1
+0
+3
+2
+
+statement error
+SELECT enum_code('bla')
+----
+
+statement ok
+PREPARE p1 as SELECT enum_code(x) FROM test
+
+query I
+EXECUTE p1
+----
+1
+0
+3
+2
+
+statement ok
+PREPARE p2 as SELECT enum_code(?);
+
+query I
+EXECUTE p2('happy'::mood)
+----
+2

external/duckdb/test/sql/function/enum/test_enum_first.test

@@ -0,0 +1,19 @@
+# name: test/sql/function/enum/test_enum_first.test
+# description: Enum First Function
+# group: [enum]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+CREATE TYPE rainbow AS ENUM ('red', 'orange', 'yellow', 'green', 'blue', 'purple');
+
+query I
+SELECT enum_first(null::rainbow)
+----
+red
+
+statement error
+SELECT enum_first('bla')
+----
+<REGEX>:.*Binder Error.*This function needs an ENUM.*

external/duckdb/test/sql/function/enum/test_enum_last.test

@@ -0,0 +1,19 @@
+# name: test/sql/function/enum/test_enum_last.test
+# description: Enum First Function
+# group: [enum]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+CREATE TYPE rainbow AS ENUM ('red', 'orange', 'yellow', 'green', 'blue', 'purple');
+
+query I
+SELECT enum_last(null::rainbow)
+----
+purple
+
+statement error
+SELECT enum_last('bla')
+----
+<REGEX>:.*Binder Error.*This function needs an ENUM.*

external/duckdb/test/sql/function/enum/test_enum_range.test

@@ -0,0 +1,63 @@
+# name: test/sql/function/enum/test_enum_range.test
+# description: Enum Range Function
+# group: [enum]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+CREATE TYPE rainbow AS ENUM ('red', 'orange', 'yellow', 'green', 'blue', 'purple');
+
+statement ok
+CREATE TYPE currency AS ENUM ('usd', 'brl', 'eur');
+
+query I
+SELECT enum_range(null::rainbow)
+----
+[red, orange, yellow, green, blue, purple]
+
+query I
+SELECT enum_range_boundary('orange'::rainbow, 'green'::rainbow)
+----
+[orange, yellow, green]
+
+
+query I
+SELECT enum_range_boundary('green'::rainbow, 'orange'::rainbow)
+----
+[]
+
+query I
+SELECT enum_range_boundary(NULL, 'green'::rainbow)
+----
+[red, orange, yellow, green]
+
+query I
+SELECT enum_range_boundary('orange'::rainbow, NULL)
+----
+[orange, yellow, green, blue, purple]
+
+statement error
+SELECT enum_range_boundary('orange'::rainbow, 'brl'::currency)
+----
+<REGEX>:.*Binder Error.*parameters need to link.*
+
+statement error
+SELECT enum_range_boundary(NULL, NULL)
+----
+<REGEX>:.*Binder Error.*This function needs an ENUM.*
+
+statement error
+SELECT enum_last('bla')
+----
+<REGEX>:.*Binder Error.*This function needs an ENUM.*
+
+statement error
+SELECT enum_range_boundary('orange'::rainbow, 1)
+----
+<REGEX>:.*Binder Error.*This function needs an ENUM.*
+
+statement error
+SELECT enum_range_boundary(1, 'orange'::rainbow)
+----
+<REGEX>:.*Binder Error.*This function needs an ENUM.*

external/duckdb/test/sql/function/generic/can_cast_implicitly.test

@@ -0,0 +1,28 @@
+# name: test/sql/function/generic/can_cast_implicitly.test
+# description: Test the can cast implicitly function
+# group: [generic]
+
+statement ok
+CREATE TABLE tbl AS SELECT * FROM range(10) tbl(i)
+
+# can cast bigint -> bigint implicitly
+query I
+SELECT can_cast_implicitly(i, NULL::BIGINT) FROM tbl LIMIT 1
+----
+true
+
+query I
+SELECT can_cast_implicitly(i, NULL::HUGEINT) FROM tbl LIMIT 1
+----
+true
+
+# cannot cast bigint -> int implicitly
+query I
+SELECT can_cast_implicitly(i, NULL::INTEGER) FROM tbl LIMIT 1
+----
+false
+
+query I
+SELECT can_cast_implicitly(i, NULL::VARCHAR) FROM tbl LIMIT 1
+----
+false

external/duckdb/test/sql/function/generic/case_condition.test

@@ -0,0 +1,17 @@
+# name: test/sql/function/generic/case_condition.test
+# description: Test CASE in a conditional statement
+# group: [generic]
+
+statement ok
+CREATE TABLE tbl AS SELECT * FROM range(10) tbl(i)
+
+query I
+SELECT * FROM tbl
+WHERE
+CASE WHEN i%2=0 THEN 1 ELSE 0 END
+AND
+CASE WHEN i<5 THEN 1 ELSE 0 END
+----
+0
+2
+4

external/duckdb/test/sql/function/generic/case_short_circuit.test

@@ -0,0 +1,20 @@
+# name: test/sql/function/generic/case_short_circuit.test
+# description: Test correct CASE statement short circuiting
+# group: [generic]
+
+statement ok
+create table t (n text);
+
+statement ok
+insert into t values ('1'),('0'),('');
+
+query II
+select n, case 
+when n <> '' and cast(substr(n, 1, 1) as int) <= 0 then '0' 
+when n <> '' and cast(substr(n, 1, 1) as int) > 0 then '1' 
+else '2'end as x from t
+ORDER BY n;
+----
+(empty)	2
+0	0
+1	1

external/duckdb/test/sql/function/generic/case_varchar.test

@@ -0,0 +1,34 @@
+# name: test/sql/function/generic/case_varchar.test
+# description: Test case statement with VARCHAR columns
+# group: [generic]
+
+statement ok
+CREATE TABLE tbl AS SELECT i, 'thisisalongstring' || i::VARCHAR s FROM range(10) tbl(i)
+
+query III
+SELECT i, s, CASE WHEN i%2=0 THEN s ELSE s END FROM tbl
+----
+0	thisisalongstring0	thisisalongstring0
+1	thisisalongstring1	thisisalongstring1
+2	thisisalongstring2	thisisalongstring2
+3	thisisalongstring3	thisisalongstring3
+4	thisisalongstring4	thisisalongstring4
+5	thisisalongstring5	thisisalongstring5
+6	thisisalongstring6	thisisalongstring6
+7	thisisalongstring7	thisisalongstring7
+8	thisisalongstring8	thisisalongstring8
+9	thisisalongstring9	thisisalongstring9
+
+query III
+SELECT i, s, CASE WHEN i%2=0 THEN s ELSE s END FROM (SELECT i, s||'_suffix' FROM tbl) tbl(i, s)
+----
+0	thisisalongstring0_suffix	thisisalongstring0_suffix
+1	thisisalongstring1_suffix	thisisalongstring1_suffix
+2	thisisalongstring2_suffix	thisisalongstring2_suffix
+3	thisisalongstring3_suffix	thisisalongstring3_suffix
+4	thisisalongstring4_suffix	thisisalongstring4_suffix
+5	thisisalongstring5_suffix	thisisalongstring5_suffix
+6	thisisalongstring6_suffix	thisisalongstring6_suffix
+7	thisisalongstring7_suffix	thisisalongstring7_suffix
+8	thisisalongstring8_suffix	thisisalongstring8_suffix
+9	thisisalongstring9_suffix	thisisalongstring9_suffix

external/duckdb/test/sql/function/generic/cast_to_type.test

@@ -0,0 +1,53 @@
+# name: test/sql/function/generic/cast_to_type.test
+# description: Test cast_to_type function
+# group: [generic]
+
+query I
+SELECT cast_to_type('  42', NULL::INT)
+----
+42
+
+statement error
+SELECT cast_to_type('hello', NULL::INT)
+----
+Conversion Error
+
+statement ok
+CREATE OR REPLACE MACRO try_trim_null(s) AS CASE WHEN typeof(s)=='VARCHAR' THEN cast_to_type(nullif(trim(s::VARCHAR), ''), s) ELSE s END;
+
+query III
+SELECT try_trim_null(42) as trim_int, try_trim_null('  col  ') as trim_varchar, try_trim_null('') as trim_empty;
+----
+42	col	NULL
+
+statement ok
+create table tbl(i int, v varchar);
+
+statement ok
+insert into tbl values (42, ' hello '), (100, '   ');
+
+query II
+SELECT try_trim_null(COLUMNS(*)) FROM tbl
+----
+42	hello
+100	NULL
+
+# prepared statements
+statement ok
+PREPARE v1 AS SELECT cast_to_type(' 42', ?);
+
+query I
+EXECUTE v1(NULL::INT)
+----
+42
+
+query I
+EXECUTE v1(NULL::VARCHAR)
+----
+ 42
+
+# cast to NULL
+statement error
+SELECT cast_to_type(42, NULL);
+----
+cannot be used to cast to NULL

external/duckdb/test/sql/function/generic/constant_or_null.test

@@ -0,0 +1,37 @@
+# name: test/sql/function/generic/constant_or_null.test
+# description: Test constant or null
+# group: [generic]
+
+statement ok
+PRAGMA enable_verification
+
+query II
+SELECT constant_or_null(1, NULL), constant_or_null(1, 10)
+----
+NULL	1
+
+query I
+SELECT constant_or_null(1, case when i%2=0 then null else i end) from range(5) tbl(i)
+----
+NULL
+1
+NULL
+1
+NULL
+
+query I
+SELECT constant_or_null(1, case when i%2=0 then null else i end, case when i%2=1 then null else i end) from range(5) tbl(i)
+----
+NULL
+NULL
+NULL
+NULL
+NULL
+
+statement error
+SELECT constant_or_null(1);
+----
+
+statement error
+SELECT constant_or_null();
+----

external/duckdb/test/sql/function/generic/error.test

@@ -0,0 +1,44 @@
+# name: test/sql/function/generic/error.test
+# description: Error test
+# group: [generic]
+
+statement error
+SELECT error('test')
+----
+test
+
+statement error
+SELECT
+  CASE
+    WHEN value = 'foo' THEN 'Value is foo.'
+    ELSE ERROR(CONCAT('Found unexpected value: ', value))
+  END AS new_value
+FROM (
+  SELECT 'foo' AS value UNION ALL
+  SELECT 'baz' AS value);
+----
+Found unexpected value: baz
+
+query I
+SELECT *
+FROM (SELECT 4 AS x)
+WHERE IF(x % 2 = 0, true, ERROR(FORMAT('x must be even number but is {}', x)));
+----
+4
+
+statement error
+SELECT *
+FROM (SELECT 3 AS x)
+WHERE IF(x % 2 = 0, true, ERROR(FORMAT('x must be even but is {}', x)));
+----
+x must be even but is 3
+
+statement error
+SELECT 42=error('hello world')
+----
+hello world
+
+statement error
+SELECT error('hello world') IS NULL
+----
+hello world

external/duckdb/test/sql/function/generic/hash_func.test

@@ -0,0 +1,253 @@
+# name: test/sql/function/generic/hash_func.test
+# description: Test HASH function
+# group: [generic]
+
+# Unsupported types
+
+foreach datatype ANY HASH POINTER
+
+statement error
+SELECT HASH(NULL::${datatype});
+----
+
+endloop
+
+# NULLS of all scalar types should produce the same value on all platforms
+
+foreach datatype <alltypes> CHAR BLOB DATE TIME TIMETZ TIMESTAMP TIMESTAMPTZ DECIMAL(16,4) UUID
+
+query I
+SELECT HASH(NULL::${datatype});
+----
+13787848793156543929
+
+endloop
+
+#
+# Nested types
+#
+
+# Structs
+statement ok
+CREATE TABLE structs AS
+	SELECT * FROM (VALUES
+		({'i': 5, 's': 'string'}),
+		({'i': -2, 's': NULL}),
+		({'i': NULL, 's': 'not null'}),
+		({'i': NULL, 's': NULL}),
+		(NULL)
+) tbl(s);
+
+query II
+SELECT s, HASH(s) FROM structs
+----
+{'i': 5, 's': string}	312378390946197788
+{'i': -2, 's': NULL}	13311620765177879553
+{'i': NULL, 's': not null}	12187543307399756733
+{'i': NULL, 's': NULL}	18212156630472451589
+NULL	18212156630472451589
+
+# Lists
+statement ok
+CREATE TABLE lists AS
+	SELECT * FROM (VALUES
+		([1], ['TGTA']),
+		([1, 2], ['CGGT']),
+		([], ['CCTC']),
+		([1, 2, 3], ['TCTA']),
+		([1, 2, 3, 4, 5], ['AGGG']),
+		(NULL, NULL)
+) tbl(li, lg);
+
+query II
+SELECT li, HASH(li) FROM lists
+----
+[1]	4717996019076358352
+[1, 2]	6530802887144669425
+[]	13787848793156543929
+[1, 2, 3]	12722334483198565868
+[1, 2, 3, 4, 5]	6649915151332802727
+NULL	13787848793156543929
+
+# These should all be different
+query II
+SELECT lg, HASH(lg) FROM lists
+----
+[TGTA]	2473061308111828075
+[CGGT]	17252230290449032892
+[CCTC]	12469451733100292545
+[TCTA]	16441147910138644840
+[AGGG]	6734708784738468094
+NULL	13787848793156543929
+
+# Maps
+statement ok
+CREATE TABLE maps AS
+	SELECT * FROM (VALUES
+		(MAP([1], ['TGTA'])),
+		(MAP([1, 2], ['CGGT', 'CCTC'])),
+		(MAP([], [])),
+		(MAP([1, 2, 3], ['TCTA', NULL, 'CGGT'])),
+		(MAP([1, 2, 3, 4, 5], ['TGTA', 'CGGT', 'CCTC', 'TCTA', 'AGGG'])),
+		(NULL)
+) tbl(m);
+
+query II
+SELECT m, HASH(m) FROM maps
+----
+{1=TGTA}	7235425910004250312
+{1=CGGT, 2=CCTC}	1011047862598495049
+{}	13787848793156543929
+{1=TCTA, 2=NULL, 3=CGGT}	6001596667924474868
+{1=TGTA, 2=CGGT, 3=CCTC, 4=TCTA, 5=AGGG}	16287978232011168685
+NULL	13787848793156543929
+
+statement ok
+CREATE TABLE map_as_list AS
+	SELECT * FROM (VALUES
+		([{'key':1, 'value':'TGTA'}]),
+		([{'key':1, 'value':'CGGT'}, {'key':2, 'value':'CCTC'}]),
+		([]),
+		([{'key':1, 'value':'TCTA'}, {'key':2, 'value':NULL}, {'key':3, 'value':'CGGT'}]),
+		([{'key':1, 'value':'TGTA'}, {'key':2, 'value':'CGGT'}, {'key':3, 'value':'CCTC'}, {'key':4, 'value':'TCTA'}, {'key':5, 'value':'AGGG'}]),
+		(NULL)
+) tbl(m);
+
+# Because the map has physical type LIST, it creates an identical hash when the same values are stored as list of key/val structs
+query I nosort map_hashes
+SELECT HASH(m) FROM maps
+
+query I nosort map_hashes
+SELECT HASH(m) FROM map_as_list
+
+
+# Enums
+statement ok
+CREATE TYPE resistor AS ENUM (
+	'black',
+	'brown',
+	'red',
+	'orange',
+	'yellow',
+	'green',
+	'blue',
+	'violet',
+	'grey',
+	'white'
+);
+
+statement ok
+CREATE TABLE enums (r resistor);
+
+statement ok
+INSERT INTO enums VALUES
+	('black'),
+	('brown'),
+	('red'),
+	('orange'),
+	('yellow'),
+	('green'),
+	('blue'),
+	('violet'),
+	('grey'),
+	('white'),
+	(NULL)
+;
+
+query II
+SELECT r, HASH(r) FROM enums;
+----
+black	0
+brown	4717996019076358352
+red	2060787363917578834
+orange	8131803788478518982
+yellow	8535942711051191036
+green	4244145009296420692
+blue	8888402906861678137
+violet	8736873150706563146
+grey	14111048738911615569
+white	17319221087726947361
+NULL	13787848793156543929
+
+#
+# Variadic arguments
+#
+
+# Zero arguments are not allowed
+statement error
+SELECT HASH();
+----
+
+statement error
+SELECT r, HASH() FROM enums;
+----
+
+# Multiple arguments of any kind are accepted
+query II
+SELECT r, HASH(r, 'capacitor') FROM enums;
+----
+black	16797622758688705282
+brown	12620868779234625953
+red	17584344400128560708
+orange	268160620305560594
+yellow	895888387990267895
+green	16089427619650030004
+blue	10156864916169405730
+violet	3549084991787980581
+grey	17281098274178594641
+white	1655957553588749778
+NULL	12320705626460735678
+
+query II
+SELECT r, HASH('2022-02-12'::DATE, r) FROM enums;
+----
+black	4250466044961212059
+brown	8900520483163022923
+red	2766849995292148937
+orange	5342755900462846045
+yellow	5515065604690625639
+green	7471453529827791
+blue	4730260654388144290
+violet	4882794310426623697
+grey	17953657405078846666
+white	14602512259699608250
+NULL	9630093706189153058
+
+query II
+SELECT r, HASH(r, r) FROM enums;
+----
+black	0
+brown	523193599206204019
+red	111573794787247892
+orange	11131893570948557270
+yellow	10594212293773127177
+green	914862583577390562
+blue	2211471294594404377
+violet	11628961430775669869
+grey	14203064203985765890
+white	1133846801649713905
+NULL	18212156630472451589
+
+#
+# Bugs
+#
+
+# Issue #2498: Identical nested lists should have the same hash
+statement ok
+CREATE TABLE issue2498 AS SELECT * FROM (VALUES
+	(24, {'x': [{'l4': [52, 53]}, {'l4': [54, 55]}]}),
+	(34, {'x': [{'l4': [52, 53]}, {'l4': [54, 55]}]})
+) tbl(v, k);
+
+query II
+SELECT k, HASH(k) FROM issue2498
+----
+{'x': [{'l4': [52, 53]}, {'l4': [54, 55]}]}	14225696893928945203
+{'x': [{'l4': [52, 53]}, {'l4': [54, 55]}]}	14225696893928945203
+
+# CombineHashScalar used to have an issue that made combining a hash with itself yield hashes that all have
+# a similar number of trailing zero's, so approx_count_distinct was off by a lot (and we had more collisions in HTs)
+query I
+select approx_count_distinct((range, range)) > 800_000 from range(1_000_000)
+----
+1

external/duckdb/test/sql/function/generic/least_greatest_enum.test

@@ -0,0 +1,14 @@
+# name: test/sql/function/generic/least_greatest_enum.test
+# description: Test LEAST/GREATEST with enum values
+# group: [generic]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+CREATE TYPE t AS ENUM ('z','y','x');
+
+query II
+SELECT greatest('x'::t, 'z'::t), 'x'::t > 'z'::t;
+----
+x	1

external/duckdb/test/sql/function/generic/least_greatest_types.test

@@ -0,0 +1,20 @@
+# name: test/sql/function/generic/least_greatest_types.test
+# description: Test LEAST/GREATEST with all types
+# group: [generic]
+
+statement ok
+CREATE TABLE all_types AS FROM test_all_types()
+
+foreach col <all_types_columns>
+
+query I
+SELECT LEAST((SELECT MAX("${col}") FROM all_types), (SELECT MIN("${col}") FROM all_types)) IS NOT DISTINCT FROM (SELECT MIN("${col}") FROM all_types)
+----
+true
+
+query I
+SELECT GREATEST((SELECT MAX("${col}") FROM all_types), (SELECT MIN("${col}") FROM all_types)) IS NOT DISTINCT FROM (SELECT MAX("${col}") FROM all_types)
+----
+true
+
+endloop

external/duckdb/test/sql/function/generic/replace_type.test

@@ -0,0 +1,81 @@
+# name: test/sql/function/generic/replace_type.test
+# description: Test replace_type function
+# group: [generic]
+
+statement ok
+PRAGMA enable_verification
+
+# start off with mirrorring all cast_to_type tests as these functions are so similar
+query I
+SELECT replace_type('  42', NULL::VARCHAR, NULL::INT)
+----
+42
+
+statement error
+SELECT replace_type('hello', NULL::VARCHAR, NULL::INT)
+----
+Conversion Error
+
+statement ok
+CREATE OR REPLACE MACRO try_trim_null(s) AS CASE WHEN typeof(s)=='VARCHAR' THEN replace_type(nullif(trim(s::VARCHAR), ''), NULL::VARCHAR, s) ELSE s END;
+
+query III
+SELECT try_trim_null(42) as trim_int, try_trim_null('  col  ') as trim_varchar, try_trim_null('') as trim_empty;
+----
+42	col	NULL
+
+statement ok
+create table tbl(i int, v varchar);
+
+statement ok
+insert into tbl values (42, ' hello '), (100, '   ');
+
+query II
+SELECT try_trim_null(COLUMNS(*)) FROM tbl
+----
+42	hello
+100	NULL
+
+# prepared statements
+statement ok
+PREPARE v1 AS SELECT replace_type(' 42', NULL::VARCHAR, ?);
+
+query I
+EXECUTE v1(NULL::INT)
+----
+42
+
+query I
+EXECUTE v1(NULL::VARCHAR)
+----
+ 42
+
+# cast to NULL
+statement error
+SELECT replace_type(42, NULL::INTEGER, NULL);
+----
+cannot be used to replace type with NULL
+
+# works within struct
+query I
+select replace_type({duck: 3.141592653589793::DOUBLE, goose: 2.718281828459045::DOUBLE}, NULL::DOUBLE, NULL::DECIMAL(15,2))
+----
+{'duck': 3.14, 'goose': 2.72}
+
+# map
+query I
+select replace_type(map {'duck': 3.141592653589793::DOUBLE, 'goose': 2.718281828459045::DOUBLE}, NULL::DOUBLE, NULL::DECIMAL(15,2))
+----
+{duck=3.14, goose=2.72}
+
+# list
+query I
+select replace_type([3.141592653589793, 2.718281828459045]::DOUBLE[], NULL::DOUBLE, NULL::DECIMAL(15,2))
+----
+[3.14, 2.72]
+
+# array
+query I
+select replace_type([3.141592653589793, 2.718281828459045]::DOUBLE[2], NULL::DOUBLE, NULL::DECIMAL(15,2))
+----
+[3.14, 2.72]

external/duckdb/test/sql/function/generic/table_func_varargs.test

@@ -0,0 +1,11 @@
+# name: test/sql/function/generic/table_func_varargs.test
+# description: VarArgs with a Table Function
+# group: [generic]
+
+query III
+SELECT * FROM repeat_row(1, 2, 'foo', num_rows=3)
+----
+1	2	foo
+1	2	foo
+1	2	foo
+

external/duckdb/test/sql/function/generic/test_approx_database_count.test

@@ -0,0 +1,20 @@
+# name: test/sql/function/generic/test_approx_database_count.test
+# description: Test the approx_database_count table function.
+# group: [generic]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+ATTACH '__TEST_DIR__/board1.db' AS b1;
+
+statement ok
+ATTACH '__TEST_DIR__/board2.db' AS b2;
+
+statement ok
+ATTACH '__TEST_DIR__/board3.db' AS b3;
+
+query I
+SELECT approx_count >= 3 FROM duckdb_approx_database_count();
+----
+True

external/duckdb/test/sql/function/generic/test_between.test

@@ -0,0 +1,251 @@
+# name: test/sql/function/generic/test_between.test
+# description: Test between statement
+# group: [generic]
+
+statement ok
+SET default_null_order='nulls_first';
+
+# test constant BETWEEN statement
+# simple between
+query T
+SELECT 10 BETWEEN 10 AND 20
+----
+1
+
+query T
+SELECT 9 BETWEEN 10 AND 20
+----
+0
+
+# now with NULL values
+query T
+SELECT 10 BETWEEN NULL AND 20
+----
+NULL
+
+query T
+SELECT 30 BETWEEN NULL AND 20
+----
+0
+
+query T
+SELECT 10 BETWEEN 10 AND NULL
+----
+NULL
+
+query T
+SELECT 9 BETWEEN 10 AND NULL
+----
+0
+
+query T
+SELECT NULL BETWEEN 10 AND 20
+----
+NULL
+
+query T
+SELECT NULL BETWEEN NULL AND 20
+----
+NULL
+
+query T
+SELECT NULL BETWEEN 10 AND NULL
+----
+NULL
+
+query T
+SELECT NULL BETWEEN NULL AND NULL
+----
+NULL
+
+# between with table
+statement ok
+CREATE TABLE integers(i INTEGER);
+
+statement ok
+INSERT INTO integers VALUES (1), (2), (3), (NULL)
+
+query T
+SELECT i BETWEEN 1 AND 2 FROM integers ORDER BY i
+----
+NULL
+1
+1
+0
+
+query T
+SELECT i BETWEEN NULL AND 2 FROM integers ORDER BY i
+----
+NULL
+NULL
+NULL
+0
+
+query T
+SELECT i BETWEEN 2 AND NULL FROM integers ORDER BY i
+----
+NULL
+0
+NULL
+NULL
+
+# between in WHERE clause
+query I
+SELECT COUNT(*) FROM integers WHERE 10 BETWEEN 10 AND 20
+----
+4
+
+query I
+SELECT COUNT(*) FROM integers WHERE 9 BETWEEN 10 AND 20
+----
+0
+
+query I
+SELECT COUNT(*) FROM integers WHERE 10 BETWEEN NULL AND 20
+----
+0
+
+query I
+SELECT COUNT(*) FROM integers WHERE 30 BETWEEN NULL AND 20
+----
+0
+
+query I
+SELECT COUNT(*) FROM integers WHERE 10 BETWEEN 10 AND NULL
+----
+0
+
+query I
+SELECT COUNT(*) FROM integers WHERE 9 BETWEEN 10 AND NULL
+----
+0
+
+query I
+SELECT COUNT(*) FROM integers WHERE NULL BETWEEN 10 AND 20
+----
+0
+
+query I
+SELECT COUNT(*) FROM integers WHERE NULL BETWEEN NULL AND 20
+----
+0
+
+query I
+SELECT COUNT(*) FROM integers WHERE NULL BETWEEN 10 AND NULL
+----
+0
+
+query I
+SELECT COUNT(*) FROM integers WHERE NULL BETWEEN NULL AND NULL
+----
+0
+
+query I
+SELECT COUNT(*) FROM integers WHERE i BETWEEN 1 AND 2
+----
+2
+
+query I
+SELECT COUNT(*) FROM integers WHERE i BETWEEN NULL AND 2
+----
+0
+
+query I
+SELECT COUNT(*) FROM integers WHERE i BETWEEN 2 AND NULL
+----
+0
+
+query I
+SELECT COUNT(*) FROM integers WHERE NULL BETWEEN -1 AND +1
+----
+0
+
+query I
+SELECT COUNT(*) FROM integers WHERE 0 BETWEEN -1 AND +1
+----
+4
+
+query I
+SELECT COUNT(*) FROM integers WHERE i BETWEEN i-1 AND i+1
+----
+3
+
+query I
+SELECT COUNT(*) FROM integers WHERE i BETWEEN i-1 AND 10
+----
+3
+
+query I
+SELECT COUNT(*) FROM integers WHERE i BETWEEN NULL AND NULL
+----
+0
+
+query I
+SELECT COUNT(*) FROM integers WHERE i BETWEEN i-1 AND NULL
+----
+0
+
+query I
+SELECT COUNT(*) FROM integers WHERE i BETWEEN 0 AND i+1
+----
+3
+
+query I
+SELECT COUNT(*) FROM integers WHERE i BETWEEN NULL AND i+1
+----
+0
+
+query I
+SELECT COUNT(*) FROM integers WHERE 1 BETWEEN i-1 AND i+1
+----
+2
+
+query I
+SELECT COUNT(*) FROM integers WHERE NULL BETWEEN i-1 AND i+1
+----
+0
+
+query I
+SELECT COUNT(*) FROM integers WHERE NULL BETWEEN i-1 AND NULL
+----
+0
+
+query I
+SELECT COUNT(*) FROM integers WHERE 1 BETWEEN i-1 AND 100
+----
+2
+
+query I
+SELECT COUNT(*) FROM integers WHERE 1 BETWEEN 0 AND i-1
+----
+2
+
+query I
+SELECT * FROM integers WHERE i >= 1 AND i < 2
+----
+1
+
+query I
+SELECT * FROM integers WHERE i > 1 AND i <= 2
+----
+2
+
+query I
+SELECT * FROM range(4) tbl(i) WHERE i >= 1 AND i < 2
+----
+1
+
+query I
+SELECT * FROM range(4) tbl(i) WHERE i > 1 AND i <= 2
+----
+2
+
+# Issue #3588 - only one constant bounds
+statement ok
+CREATE TABLE issue3588(c0 INT);
+
+statement ok
+SELECT *
+FROM issue3588
+WHERE (SELECT 0) BETWEEN 0 AND issue3588.c0;
+

external/duckdb/test/sql/function/generic/test_between_sideeffects.test

@@ -0,0 +1,53 @@
+# name: test/sql/function/generic/test_between_sideeffects.test
+# description: Test between statement with expressions that have side effects
+# group: [generic]
+
+require icu
+
+require no_extension_autoloading "FIXME: ICU is not autoloaded on '-(TIMESTAMP WITH TIME ZONE, INTERVAL)"
+
+# prepared statement with BETWEEN
+statement ok
+PREPARE v1 AS SELECT ? BETWEEN 1 AND 2
+
+query I
+EXECUTE v1(1)
+----
+true
+
+query I
+EXECUTE v1(3)
+----
+false
+
+statement error
+EXECUTE v1(1, 2)
+----
+
+statement ok
+PREPARE v2 AS SELECT 1 WHERE ? BETWEEN now() - INTERVAL '1 minute' AND now() + INTERVAL '1 minute';
+
+query I
+EXECUTE v2(now())
+----
+1
+
+query I
+EXECUTE v2(now() - INTERVAL '10 minute')
+----
+
+loop i 0 10
+
+# this should always be false
+query I
+SELECT (RANDOM() * 10)::INT BETWEEN 6 AND 5
+----
+false
+
+# this should always be true
+query I
+SELECT (RANDOM() * 10)::INT NOT BETWEEN 6 AND 5
+----
+true
+
+endloop

external/duckdb/test/sql/function/generic/test_boolean_test.test

@@ -0,0 +1,93 @@
+# name: test/sql/function/generic/test_boolean_test.test
+# description: Test NULL IF statement
+# group: [generic]
+
+query I
+select true is true
+----
+true
+
+query I
+select false is true
+----
+false
+
+query I
+select null is true
+----
+false
+
+query I
+select 42 is true
+----
+true
+
+query I
+select 0 is true
+----
+false
+
+query I
+select true is not true
+----
+false
+
+query I
+select false is not true
+----
+true
+
+query I
+select null is not true
+----
+true
+
+query I
+select 42 is not true
+----
+false
+
+query I
+select 0 is not true
+----
+true
+
+query I
+select null is null
+----
+true
+
+query I
+select 42 is null
+----
+false
+
+query I
+select null is not null
+----
+false
+
+query I
+select 42 is not null
+----
+true
+
+query I
+select null is unknown
+----
+true
+
+query I
+select 42 is unknown
+----
+false
+
+query I
+select null is not unknown
+----
+false
+
+query I
+select 42 is not unknown
+----
+true

external/duckdb/test/sql/function/generic/test_case.test_slow

@@ -0,0 +1,103 @@
+# name: test/sql/function/generic/test_case.test_slow
+# description: Test case statement
+# group: [generic]
+
+statement ok
+PRAGMA enable_verification
+
+foreach type <numeric> DECIMAL(4,0) DECIMAL(9,0) DECIMAL(18,0) DECIMAL(38,0)
+
+statement ok
+DROP TABLE IF EXISTS test
+
+statement ok
+CREATE TABLE test (a ${type}, b ${type});
+
+statement ok
+INSERT INTO test VALUES (11, 22), (13, 22), (12, 21)
+
+query I
+SELECT CASE WHEN test.a=11 THEN b ELSE NULL END FROM test
+----
+22
+NULL
+NULL
+
+# constant case statements
+# all constant
+query I
+SELECT CASE WHEN 1=1 THEN 1 ELSE NULL END FROM test ORDER BY b
+----
+1
+1
+1
+
+# check + res_if_false constant
+query I
+SELECT CASE WHEN 1=1 THEN b ELSE NULL END FROM test ORDER BY b
+----
+21
+22
+22
+
+# check + res_if_true constant
+query I
+SELECT CASE WHEN 3>2 THEN NULL ELSE b+1 END FROM test ORDER BY b
+----
+NULL
+NULL
+NULL
+
+# check constant
+query I
+SELECT CASE WHEN 1=0 THEN b ELSE b+1 END FROM test ORDER BY b
+----
+22
+23
+23
+
+# res_if_true and res_if_false constant
+query I
+SELECT CASE WHEN b=22 THEN NULL ELSE 1 END FROM test ORDER BY b
+----
+1
+NULL
+NULL
+
+# res_if_false constant
+query I
+SELECT CASE WHEN b=22 THEN b+1 ELSE 1 END FROM test ORDER BY b
+----
+1
+23
+23
+
+# res_if_true constant
+query I
+SELECT CASE WHEN b=22 THEN NULL ELSE b+1 END FROM test ORDER BY b
+----
+22
+NULL
+NULL
+
+# fail case on types that can't be cast to boolean
+statement error
+SELECT CASE WHEN 'hello' THEN b ELSE a END FROM test
+----
+
+# but only when cast cannot be performed
+query I
+SELECT CASE WHEN 'true' THEN NULL ELSE b+1 END FROM test ORDER BY b
+----
+NULL
+NULL
+NULL
+
+query I
+SELECT CASE WHEN 'false' THEN NULL ELSE b+1 END FROM test ORDER BY b
+----
+22
+23
+23
+
+endloop

external/duckdb/test/sql/function/generic/test_connection_count.test

@@ -0,0 +1,17 @@
+# name: test/sql/function/generic/test_connection_count.test
+# description: Test the connection_count table function.
+# group: [generic]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok con1
+BEGIN
+
+statement ok con2
+BEGIN
+
+query I
+SELECT count FROM duckdb_connection_count();
+----
+3

external/duckdb/test/sql/function/generic/test_if.test

@@ -0,0 +1,29 @@
+# name: test/sql/function/generic/test_if.test
+# description: IF test
+# group: [generic]
+
+query III
+SELECT IF(true, 1, 10), IF(false, 1, 10), IF(NULL, 1, 10)
+----
+1	10	10
+
+query III
+SELECT IF(true, 20, 2000), IF(false, 20, 2000), IF(NULL, 20, 2000)
+----
+20	2000	2000
+
+query RRR
+SELECT IF(true, 20.5, 2000), IF(false, 20, 2000.5), IF(NULL, 20, 2000.5)
+----
+20.500000	2000.500000	2000.500000
+
+query TTT
+SELECT IF(true, '2020-05-05'::date, '1996-11-05 10:11:56'::timestamp), IF(false, '2020-05-05'::date, '1996-11-05 10:11:56'::timestamp), IF(NULL, '2020-05-05'::date, '1996-11-05 10:11:56'::timestamp)
+----
+2020-05-05 00:00:00	1996-11-05 10:11:56	1996-11-05 10:11:56
+
+query TTT
+SELECT IF(true, 'true', 'false'), IF(false, 'true', 'false'), IF(NULL, 'true', 'false')
+----
+true	false	false
+

external/duckdb/test/sql/function/generic/test_if_null.test

@@ -0,0 +1,24 @@
+# name: test/sql/function/generic/test_if_null.test
+# description: IFNULL test
+# group: [generic]
+
+query III
+SELECT IFNULL(NULL, NULL), IFNULL(NULL, 10), IFNULL(1, 10)
+----
+NULL	10	1
+
+query IR
+SELECT IFNULL(NULL, 2000), IFNULL(20.5, 2000)
+----
+2000	20.500000
+
+query TT
+SELECT IFNULL(NULL, '1996-11-05 10:11:56'::timestamp), IFNULL('2020-05-05'::date, '1996-11-05 10:11:56'::timestamp)
+----
+1996-11-05 10:11:56	2020-05-05 00:00:00
+
+query TT
+SELECT IFNULL(NULL, 'not NULL'), IFNULL('NULL', 'not NULL')
+----
+not NULL	NULL
+

external/duckdb/test/sql/function/generic/test_in.test

@@ -0,0 +1,238 @@
+# name: test/sql/function/generic/test_in.test
+# description: Test IN statement
+# group: [generic]
+
+statement ok
+SET default_null_order='nulls_first';
+
+statement ok
+CREATE TABLE integers(i INTEGER)
+
+statement ok
+INSERT INTO integers VALUES (1), (2), (3), (NULL);
+
+query I
+SELECT * FROM integers WHERE i IN (1, 2) ORDER BY i
+----
+1
+2
+
+query I
+SELECT * FROM integers WHERE i IN (1, 2, 3, 4, 5, 6, 7, 8) ORDER BY i
+----
+1
+2
+3
+
+query IT
+SELECT i, i IN (1, 2, 3, 4, 5, 6, 7, 8) FROM integers ORDER BY i
+----
+NULL	NULL
+1	1
+2	1
+3	1
+
+query IT
+SELECT i, i NOT IN (1, 3, 4, 5, 6, 7, 8) FROM integers ORDER BY i
+----
+NULL	NULL
+1	0
+2	1
+3	0
+
+query II
+SELECT i, i IN (1, 2, NULL, 4, 5, 6, 7, 8) FROM integers ORDER BY i
+----
+NULL	NULL
+1	1
+2	1
+3	NULL
+
+query IT
+SELECT i, i IN (i + 1) FROM integers ORDER BY i
+----
+NULL	NULL
+1	0
+2	0
+3	0
+
+query IT
+SELECT i, i IN (i + 1, 42, i) FROM integers ORDER BY i
+----
+NULL	NULL
+1	1
+2	1
+3	1
+
+query IT
+SELECT i, 1 IN (i - 1, i, i + 1) FROM integers ORDER BY i
+----
+NULL	NULL
+1	1
+2	1
+3	0
+
+query IT
+SELECT i, 1 NOT IN (i - 1, i, i + 1) FROM integers ORDER BY i
+----
+NULL	NULL
+1	0
+2	0
+3	1
+
+query IT
+SELECT i, i IN (11, 12, 13, 14, 15, 16, 17, 18, 1, i) FROM integers ORDER BY i
+----
+NULL	NULL
+1	1
+2	1
+3	1
+
+query IT
+SELECT i, i NOT IN (11, 12, 13, 14, 15, 16, 17, 18, 1, i) FROM integers ORDER BY i
+----
+NULL	NULL
+1	0
+2	0
+3	0
+
+query IT
+SELECT i, 1 IN (11, 12, 13, 14, 15, 16, 17, 18, 1, i) FROM integers ORDER BY i
+----
+NULL	1
+1	1
+2	1
+3	1
+
+query IT
+SELECT i, 1 NOT IN (11, 12, 13, 14, 15, 16, 17, 18, 1, i) FROM integers ORDER BY i
+----
+NULL	0
+1	0
+2	0
+3	0
+
+query IT
+SELECT i, i IN ((SELECT MAX(i) FROM integers), (SELECT MIN(i) FROM integers)) FROM integers ORDER BY i
+----
+NULL	NULL
+1	1
+2	0
+3	1
+
+query III
+SELECT i, (SELECT MAX(i) FROM integers WHERE i <> i1.i), (SELECT MIN(i) FROM integers WHERE i <= i1.i) FROM integers i1 ORDER BY i
+----
+NULL	NULL	NULL
+1	3	1
+2	3	1
+3	2	1
+
+query IT
+SELECT i, i IN ((SELECT MAX(i) FROM integers WHERE i <> i1.i), (SELECT MIN(i) FROM integers WHERE i <= i1.i)) FROM integers i1 ORDER BY i
+----
+NULL	NULL
+1	1
+2	0
+3	0
+
+query I
+SELECT 1 IN [1, 2, 3];
+----
+true
+
+query I
+SELECT 1 IN [2, 2, 3];
+----
+false
+
+statement ok
+PREPARE v1 AS SELECT 1 IN ?
+
+query I
+EXECUTE v1([]);
+----
+false
+
+query I
+SELECT 1 IN [];
+----
+false
+
+query I
+EXECUTE v1([1, 2, 3]);
+----
+true
+
+query I
+EXECUTE v1([2, 2, 3]);
+----
+false
+
+# Test <expr> IN <column_ref>
+
+query I
+with list_provider as (
+	select [1, 2] as lst
+)
+SELECT i FROM (
+	from integers, list_provider
+) t(i, lst) WHERE i IN lst ORDER BY i
+----
+1
+2
+
+query I
+with list_provider as (
+	select [1, 2, 3, 4, 5, 6, 7, 8] as lst
+)
+SELECT i FROM (
+	from integers, list_provider
+) t(i, lst) WHERE i IN lst ORDER BY i
+----
+1
+2
+3
+
+query II
+with list_provider as (
+	select [1, 2, 3, 4, 5, 6, 7, 8] as lst
+)
+SELECT i, i IN lst FROM (
+	from integers, list_provider
+) t(i, lst) order by i
+----
+NULL	NULL
+1	1
+2	1
+3	1
+
+query II
+with list_provider as (
+	select [1, 3, 4, 5, 6, 7, 8] as lst
+)
+SELECT i, i NOT IN lst FROM (
+	from integers, list_provider
+) t(i, lst) order by i
+----
+NULL	NULL
+1	0
+2	1
+3	0
+
+query II
+with list_provider as (
+	select [1, 2, NULL, 4, 5, 6, 7, 8] as lst
+)
+SELECT i, i IN lst FROM (
+	from integers, list_provider
+) t(i, lst) order by i
+----
+NULL	NULL
+1	1
+2	1
+3	0
+
+# ^ Note the '0' on the last row
+# This is different from regular IN behavior
+

external/duckdb/test/sql/function/generic/test_least_greatest.test

@@ -0,0 +1,176 @@
+# name: test/sql/function/generic/test_least_greatest.test
+# description: Test LEAST/GREATEST
+# group: [generic]
+
+# scalar usage
+query I
+SELECT LEAST(1)
+----
+1
+
+query I
+SELECT LEAST('hello world')
+----
+hello world
+
+query I
+SELECT LEAST(1, 3)
+----
+1
+
+query I
+SELECT LEAST(1, 3, 0)
+----
+0
+
+query I
+SELECT LEAST(1, 3, 0, 2, 7, 8, 10, 11, -100, 30)
+----
+-100
+
+query I
+SELECT LEAST(1, 3, 0, 2, 7, 8, 10, 11, -100, 30, NULL)
+----
+-100
+
+query I
+SELECT LEAST(NULL, 3, 0, 2, 7, 8, 10, 11, -100, 30, 1)
+----
+-100
+
+query I
+SELECT GREATEST(NULL, 1.0::FLOAT)
+----
+1
+
+# double
+query R
+SELECT LEAST(1.0, 10.0)
+----
+1.000000
+
+# strings
+query T
+SELECT LEAST('hello', 'world')
+----
+hello
+
+query T
+SELECT LEAST('hello', 'world', 'blabla', 'tree')
+----
+blabla
+
+query T
+SELECT LEAST('hello', 'world', 'blabla', 'tree')
+----
+blabla
+
+# dates
+query T
+SELECT LEAST(DATE '1992-01-01', DATE '1994-02-02', DATE '1991-01-01')
+----
+1991-01-01
+
+query T
+SELECT LEAST(DATE '1992-01-01', DATE '1994-02-02', DATE '1991-01-01', NULL)
+----
+1991-01-01
+
+query T
+SELECT LEAST(DATE '1992-01-01', DATE '1994-02-02', DATE '1991-01-01', DATE 'infinity', DATE '-infinity')
+----
+-infinity
+
+query T
+SELECT GREATEST(DATE '1992-01-01', DATE '1994-02-02', DATE '1991-01-01', DATE 'infinity', DATE '-infinity')
+----
+infinity
+
+# timestamps
+query T
+SELECT LEAST(TIMESTAMP '1992-01-01 13:45:21.890123', TIMESTAMP '1994-02-02 05:43:21', TIMESTAMP '1991-01-01 01:23:45')
+----
+1991-01-01 01:23:45
+
+query T
+SELECT LEAST(TIMESTAMP '1992-01-01 13:45:21.890123', TIMESTAMP '1994-02-02 05:43:21', TIMESTAMP '1991-01-01 01:23:45', NULL)
+----
+1991-01-01 01:23:45
+
+query T
+SELECT LEAST(TIMESTAMP '1992-01-01 13:45:21.890123', TIMESTAMP '1994-02-02 05:43:21', TIMESTAMP '1991-01-01 01:23:45', TIMESTAMP 'infinity', TIMESTAMP '-infinity')
+----
+-infinity
+
+query T
+SELECT GREATEST(TIMESTAMP '1992-01-01 13:45:21.890123', TIMESTAMP '1994-02-02 05:43:21', TIMESTAMP '1991-01-01 01:23:45', TIMESTAMP 'infinity', TIMESTAMP '-infinity')
+----
+infinity
+
+# test mix of types
+statement error
+SELECT LEAST(DATE '1992-01-01', 'hello', 123)
+----
+Cannot combine types
+
+# tables
+statement ok
+CREATE TABLE t1(i INTEGER, j INTEGER);
+
+statement ok
+INSERT INTO t1 VALUES (1, NULL), (2, 1), (3, 7);
+
+query II
+SELECT LEAST(i, j), GREATEST(i, j) FROM t1 ORDER BY i;
+----
+1	1
+1	2
+3	7
+
+query II
+SELECT LEAST(i, i + 1, j), GREATEST(i, i - 1, j) FROM t1 ORDER BY i;
+----
+1	1
+1	2
+3	7
+
+query II
+SELECT LEAST(i, 800, i + 1, 1000, j), GREATEST(i, -1000, i - 1, -700, j, -800) FROM t1 ORDER BY i;
+----
+1	1
+1	2
+3	7
+
+query II
+SELECT LEAST(i, 800, i + 1, 1000, j, NULL), GREATEST(i, -1000, i - 1, -700, j, -800) FROM t1 ORDER BY i;
+----
+1	1
+1	2
+3	7
+
+# selection vectors
+query II
+SELECT LEAST(i, j), GREATEST(i, j) FROM t1 WHERE j IS NOT NULL ORDER BY i;
+----
+1	2
+3	7
+
+# row ids
+query II
+SELECT LEAST(rowid + 10, i, j), GREATEST(i, rowid + 4, j) FROM t1 WHERE j IS NOT NULL ORDER BY i;
+----
+1	5
+3	7
+
+# generated strings
+query T
+SELECT LEAST(REPEAT(i::VARCHAR, 20), j::VARCHAR) FROM t1;
+----
+11111111111111111111
+1
+33333333333333333333
+
+query I
+SELECT greatest(CAST(52392441565678.308 AS DECIMAL(17,3)), CAST(52392441565678.308 AS DECIMAL(17,3)));
+----
+52392441565678.308

external/duckdb/test/sql/function/generic/test_null_if.test

@@ -0,0 +1,54 @@
+# name: test/sql/function/generic/test_null_if.test
+# description: Test NULL IF statement
+# group: [generic]
+
+# NULL IF
+query T
+SELECT NULLIF(NULLIF ('hello', 'world'), 'blabla');
+----
+hello
+
+# NULL IF with subquery
+statement ok
+CREATE TABLE test (a STRING);
+
+statement ok
+INSERT INTO test VALUES ('hello'), ('world'), ('test')
+
+statement ok
+CREATE TABLE test2 (a STRING, b STRING);
+
+statement ok
+INSERT INTO test2 VALUES ('blabla', 'b'), ('blabla2', 'c'), ('blabla3', 'd')
+
+query T
+SELECT NULLIF(NULLIF ((SELECT a FROM test LIMIT 1 offset 1), a), b) FROM test2
+----
+world
+world
+world
+
+statement ok
+DROP TABLE test;
+
+# NULL IF with strings
+statement ok
+CREATE TABLE test3 (a INTEGER, b INTEGER);
+
+statement ok
+INSERT INTO test3 VALUES (11, 22), (13, 22), (12, 21)
+
+query T
+SELECT NULLIF(CAST(a AS VARCHAR), '11') FROM test3;
+----
+NULL
+13
+12
+
+query IT
+SELECT a, CASE WHEN a>11 THEN CAST(a AS VARCHAR) ELSE CAST(b AS VARCHAR) END FROM test3 ORDER BY 1;
+----
+11	22
+12	12
+13	13
+

external/duckdb/test/sql/function/generic/test_set.test

@@ -0,0 +1,66 @@
+# name: test/sql/function/generic/test_set.test
+# description: Test SET function
+# group: [generic]
+
+# unrecognized configuration parameter
+statement error
+SELECT CURRENT_SETTING('a');
+----
+
+statement error
+SELECT CURRENT_SETTING('memori_limit');
+----
+
+statement ok
+SELECT CURRENT_SETTING('default_null_order');
+
+statement ok
+SET default_null_order = 'nulls_last';
+
+# set from a function
+statement ok
+SET default_null_order = concat('nulls', '_', 'last');
+
+query I
+SELECT CURRENT_SETTING('default_null_order');
+----
+NULLS_LAST
+
+query I
+SELECT CURRENT_SETTING('DEFAULT_NULL_ORDER');
+----
+NULLS_LAST
+
+query I
+SELECT * FROM range(3) UNION ALL SELECT NULL ORDER BY 1
+----
+0
+1
+2
+NULL
+
+statement error
+SELECT CURRENT_SETTING(i::VARCHAR) FROM range(1) tbl(i)
+----
+
+statement error
+SELECT CURRENT_SETTING(NULL)
+----
+
+statement error
+SELECT CURRENT_SETTING(CAST(NULL AS TEXT))
+----
+
+statement error
+SELECT CURRENT_SETTING('')
+----
+
+statement error
+SET default_null_order = colref || '_last';
+----
+cannot contain column names
+
+statement error
+SET default_null_order = (SELECT 'nulls_last')
+----
+cannot contain subqueries

external/duckdb/test/sql/function/generic/test_stats.test

@@ -0,0 +1,85 @@
+# name: test/sql/function/generic/test_stats.test
+# description: Test stats function
+# group: [generic]
+
+statement ok
+select 1=1
+
+# scalar stats
+query I
+SELECT STATS(5);
+----
+<REGEX>:.*5.*5.*
+
+query I
+SELECT STATS(7);
+----
+<REGEX>:.*7.*7.*
+
+query I
+SELECT STATS('hello');
+----
+<REGEX>:.*hello.*hello.*
+
+query I
+SELECT STATS('1234567ü');
+----
+<REGEX>:.*1234567.*1234567.*
+
+# arithmetic
+query I
+SELECT STATS(5+2);
+----
+<REGEX>:.*7.*7.*
+
+# non-scalar stats
+statement ok
+CREATE TABLE integers(i INTEGER);
+
+statement ok
+INSERT INTO integers VALUES (1), (2), (3);
+
+# read stats
+query I
+SELECT STATS(i) FROM integers LIMIT 1;
+----
+<REGEX>:.*1.*3.*
+
+# arithmetic
+query I
+SELECT STATS(i+2) FROM integers LIMIT 1;
+----
+<REGEX>:.*3.*5.*
+
+query I
+SELECT STATS(i-5) FROM integers LIMIT 1;
+----
+<REGEX>:.*-4.*-2.*
+
+query I
+SELECT STATS(i*2) FROM integers LIMIT 1;
+----
+<REGEX>:.*2.*6.*
+
+query I
+SELECT STATS(i*-1) FROM integers LIMIT 1;
+----
+<REGEX>:.*-3.*-1.*
+
+# disabling statistics propagation means there will be no stats
+statement ok
+PRAGMA disable_optimizer
+
+query I
+SELECT STATS(i+1) FROM integers LIMIT 1;
+----
+No statistics
+
+# we can enable the optimizer again
+statement ok
+PRAGMA enable_optimizer
+
+query I
+SELECT STATS(i*-1) FROM integers LIMIT 1;
+----
+<REGEX>:.*-3.*-1.*

external/duckdb/test/sql/function/generic/test_table_param.test

@@ -0,0 +1,33 @@
+# name: test/sql/function/generic/test_table_param.test
+# description: Test stats function
+# group: [generic]
+
+# scalar stats
+
+statement ok
+create table a (i double, j double);
+
+statement ok
+insert into a values (1, 10), (42, 420);
+
+statement ok
+EXPLAIN SELECT * FROM summary((SELECT * FROM a))
+
+query III
+SELECT * FROM summary((SELECT * FROM a))
+----
+[1.0, 10.0]	1.0	10.0
+[42.0, 420.0]	42.0	420.0
+
+
+statement ok
+pragma threads=4
+
+statement ok
+pragma verify_parallelism
+
+query III
+SELECT * FROM summary((SELECT * FROM a))
+----
+[1.0, 10.0]	1.0	10.0
+[42.0, 420.0]	42.0	420.0

external/duckdb/test/sql/function/interval/test_date_part.test

@@ -0,0 +1,226 @@
+# name: test/sql/function/interval/test_date_part.test
+# description: Extract function
+# group: [interval]
+
+statement ok
+CREATE TABLE intervals(i INTERVAL, s VARCHAR);
+
+statement ok
+INSERT INTO intervals VALUES ('2 years', 'year'), ('16 months', 'quarter'), ('42 days', 'day'), ('2066343400 microseconds', 'minute');
+
+# test date_part with different combinations of constant/non-constant columns
+query I
+SELECT date_part(NULL::VARCHAR, NULL::INTERVAL) FROM intervals;
+----
+NULL
+NULL
+NULL
+NULL
+
+query I
+SELECT date_part(s, NULL::INTERVAL) FROM intervals;
+----
+NULL
+NULL
+NULL
+NULL
+
+# intervals
+query I
+SELECT date_part(NULL, i) FROM intervals;
+----
+NULL
+NULL
+NULL
+NULL
+
+query I
+SELECT date_part(s, INTERVAL '4 years 5 months 18 days 128 seconds') FROM intervals;
+----
+4
+2
+18
+2
+
+query I
+SELECT date_part('seconds', i) FROM intervals;
+----
+0
+0
+0
+26
+
+query I
+SELECT date_part('epoch', i) FROM intervals;
+----
+63115200.0
+41925600.0
+3628800.0
+2066.3434
+
+
+query I
+SELECT date_part(s, i) FROM intervals;
+----
+2
+2
+42
+34
+
+
+# interval gives errors for date-only parts
+statement error
+SELECT dayofweek(i) FROM intervals
+----
+
+statement error
+SELECT isodow(i) FROM intervals
+----
+
+statement error
+SELECT dayofyear(i) FROM intervals
+----
+
+statement error
+SELECT week(i) FROM intervals
+----
+
+statement error
+SELECT era(i) FROM intervals;
+----
+
+statement error
+SELECT julian(i) FROM intervals;
+----
+
+statement error
+SELECT extract(era from i) FROM intervals;
+----
+
+statement error
+SELECT extract(julian from i) FROM intervals;
+----
+
+statement error
+SELECT date_part('era', i) FROM intervals;
+----
+
+statement error
+SELECT date_part('julian', i) FROM intervals;
+----
+
+statement error
+SELECT date_part('offset', i) FROM intervals;
+----
+
+# Correctness: Compare date_part values with function values
+foreach partcode millennium century decade year quarter month day hour minute second millisecond microsecond epoch
+
+query III
+SELECT i, DATE_PART('${partcode}', i) AS p, ${partcode}(i) AS f
+FROM intervals
+WHERE p <> f;
+----
+
+endloop
+
+#
+# Structs
+#
+
+# Correctness: Compare struct values with scalar values
+foreach partcode millennium century decade year quarter month day hour minute second millisecond microsecond epoch
+
+query III
+SELECT i, DATE_PART('${partcode}', i) AS p, DATE_PART(['${partcode}'], i) AS st
+FROM intervals
+WHERE p <> st['${partcode}'];
+----
+
+endloop
+
+# Day parts
+query II
+SELECT i, DATE_PART(['year', 'month', 'day'], i) AS parts
+FROM intervals
+ORDER BY 1;
+----
+00:34:26.3434	{'year': 0, 'month': 0, 'day': 0}
+42 days	{'year': 0, 'month': 0, 'day': 42}
+1 year 4 months	{'year': 1, 'month': 4, 'day': 0}
+2 years	{'year': 2, 'month': 0, 'day': 0}
+
+# Year parts
+query II
+SELECT i, DATE_PART(['millennium', 'century', 'decade', 'quarter'], i) AS parts
+FROM intervals
+ORDER BY 1;
+----
+00:34:26.3434	{'millennium': 0, 'century': 0, 'decade': 0, 'quarter': 1}
+42 days	{'millennium': 0, 'century': 0, 'decade': 0, 'quarter': 1}
+1 year 4 months	{'millennium': 0, 'century': 0, 'decade': 0, 'quarter': 2}
+2 years	{'millennium': 0, 'century': 0, 'decade': 0, 'quarter': 1}
+
+# Time parts
+query II
+SELECT i, DATE_PART(['hour', 'minute', 'second', 'epoch'], i) AS parts
+FROM intervals
+ORDER BY 1;
+----
+00:34:26.3434	{'hour': 0, 'minute': 34, 'second': 26, 'epoch': 2066.3434}
+42 days	{'hour': 0, 'minute': 0, 'second': 0, 'epoch': 3628800.0}
+1 year 4 months	{'hour': 0, 'minute': 0, 'second': 0, 'epoch': 41925600.0}
+2 years	{'hour': 0, 'minute': 0, 'second': 0, 'epoch': 63115200.0}
+
+# Function-only parts
+query II
+SELECT i, epoch_ns(i) AS parts
+FROM intervals
+ORDER BY 1;
+----
+00:34:26.3434	2066343400000
+42 days	3628800000000000
+1 year 4 months	41472000000000000
+2 years	62208000000000000
+
+query II
+SELECT i, epoch_us(i) AS parts
+FROM intervals
+ORDER BY 1;
+----
+00:34:26.3434	2066343400
+42 days	3628800000000
+1 year 4 months	41472000000000
+2 years	62208000000000
+
+query II
+SELECT i, epoch_ms(i) AS parts
+FROM intervals
+ORDER BY 1;
+----
+00:34:26.3434	2066343
+42 days	3628800000
+1 year 4 months	41472000000
+2 years	62208000000
+
+query II
+SELECT i, nanosecond(i) AS parts
+FROM intervals
+ORDER BY 1;
+----
+00:34:26.3434	26343400000
+42 days	0
+1 year 4 months	0
+2 years	0
+
+# Invalid parts
+
+foreach datepart dow isodow doy week isoyear yearweek era timezone timezone_hour timezone_minute
+
+statement error
+SELECT i, DATE_PART(['${datepart}'], i) AS parts
+FROM intervals
+ORDER BY 1;
+----
+
+endloop

external/duckdb/test/sql/function/interval/test_extract.test

@@ -0,0 +1,201 @@
+# name: test/sql/function/interval/test_extract.test
+# description: Extract function
+# group: [interval]
+
+statement ok
+CREATE TABLE intervals(i INTERVAL);
+
+statement ok
+INSERT INTO intervals VALUES ('2 years'), ('16 months'), ('42 days'), ('2066343400 microseconds'), (NULL);
+
+# extract various parts of the intervals
+query I
+SELECT EXTRACT(year FROM i) FROM intervals
+----
+2
+1
+0
+0
+NULL
+
+query I
+SELECT EXTRACT(month FROM i) FROM intervals
+----
+0
+4
+0
+0
+NULL
+
+query I
+SELECT EXTRACT(day FROM i) FROM intervals
+----
+0
+0
+42
+0
+NULL
+
+query I
+SELECT EXTRACT(decade FROM i) FROM intervals
+----
+0
+0
+0
+0
+NULL
+
+query I
+SELECT EXTRACT(century FROM i) FROM intervals
+----
+0
+0
+0
+0
+NULL
+
+query I
+SELECT EXTRACT(millennium FROM i) FROM intervals
+----
+0
+0
+0
+0
+NULL
+
+query I
+SELECT EXTRACT(quarter FROM i) FROM intervals
+----
+1
+2
+1
+1
+NULL
+
+statement error
+SELECT EXTRACT(dayofweek FROM i) FROM intervals
+----
+
+statement error
+SELECT EXTRACT(isodow FROM i) FROM intervals
+----
+
+statement error
+SELECT EXTRACT(dayofyear FROM i) FROM intervals
+----
+
+statement error
+SELECT EXTRACT(week FROM i) FROM intervals
+----
+
+statement error
+SELECT EXTRACT(yearweek FROM i) FROM intervals
+----
+
+query I
+SELECT EXTRACT(epoch FROM i) FROM intervals
+----
+63115200.0
+41925600.0
+3628800.0
+2066.3434
+NULL
+
+query I
+SELECT EXTRACT(microsecond FROM i) FROM intervals
+----
+0
+0
+0
+26343400
+NULL
+
+query I
+SELECT EXTRACT(millisecond FROM i) FROM intervals
+----
+0
+0
+0
+26343
+NULL
+
+query I
+SELECT EXTRACT(second FROM i) FROM intervals
+----
+0
+0
+0
+26
+NULL
+
+query I
+SELECT EXTRACT(minute FROM i) FROM intervals
+----
+0
+0
+0
+34
+NULL
+
+query I
+SELECT EXTRACT(hour FROM i) FROM intervals
+----
+0
+0
+0
+0
+NULL
+
+# negative intervals with months are strange in Postgres
+query I
+SELECT EXTRACT(year FROM interval '14 months ago')
+----
+-1
+
+query I
+SELECT EXTRACT(month FROM interval '14 months ago')
+----
+-2
+
+query I
+SELECT EXTRACT(day FROM interval '157 days ago')
+----
+-157
+
+query I
+SELECT EXTRACT(decade FROM interval '140 months ago')
+----
+-1
+
+query I
+SELECT EXTRACT(century FROM interval '1400 months ago')
+----
+-1
+
+query I
+SELECT EXTRACT(millennium FROM interval '14000 months ago')
+----
+-1
+
+query I
+SELECT EXTRACT(quarter FROM interval '14 months ago')
+----
+1
+
+query I
+SELECT EXTRACT(quarter FROM interval '21 months ago')
+----
+-2
+
+query I
+SELECT EXTRACT(epoch FROM interval '6 months ago')
+----
+-15552000
+
+statement error
+SELECT EXTRACT(doy FROM interval '6 months ago')
+----
+
+statement error
+SELECT EXTRACT(dow FROM interval '6 months ago')
+----

external/duckdb/test/sql/function/interval/test_interval_muldiv.test

@@ -0,0 +1,100 @@
+# name: test/sql/function/interval/test_interval_muldiv.test
+# description: Test PG INTERVAL DOUBLE multiply and divide.
+# group: [interval]
+
+# From src/test/regress/sql/interval.sql
+# Test multiplication and division with intervals.
+# Floating point arithmetic rounding errors can lead to unexpected results,
+# though the code attempts to do the right thing and round up to days and
+# minutes to avoid results such as '3 days 24:00 hours' or '14:20:60'.
+# Note that it is expected for some day components to be greater than 29 and
+# some time components be greater than 23:59:59 due to how intervals are
+# stored internally.
+statement ok
+CREATE TABLE INTERVAL_MULDIV_TBL (span interval);
+
+statement ok
+INSERT INTO INTERVAL_MULDIV_TBL VALUES
+    ('41 months 12 days 360:00'),
+    ('-41 months -12 days 360:00'),
+    ('-12 days'),
+    ('9 months -27 days 12:34:56'),
+    ('-3 years 482 days 76:54:32.189'),
+    ('4 months'),
+    ('14 months'),
+    ('999 months 999 days'),
+;
+
+query I
+SELECT span * 0.3 AS product
+FROM INTERVAL_MULDIV_TBL;
+----
+1 year 12 days 122:24:00
+-1 year -12 days 93:36:00
+-3 days -14:24:00
+2 months 13 days 01:22:28.8
+-10 months 120 days 37:28:21.6567
+1 month 6 days
+4 months 6 days
+24 years 11 months 320 days 16:48:00
+
+query I
+SELECT span * 8.2 AS product
+FROM INTERVAL_MULDIV_TBL;
+----
+28 years 104 days 2961:36:00
+-28 years -104 days 2942:24:00
+-98 days -09:36:00
+6 years 1 month -197 days 93:34:27.2
+-24 years -7 months 3946 days 640:15:11.9498
+2 years 8 months 24 days
+9 years 6 months 24 days
+682 years 7 months 8215 days 19:12:00
+
+query I
+SELECT span / 10 AS quotient
+FROM INTERVAL_MULDIV_TBL;
+----
+4 months 4 days 40:48:00
+-4 months -4 days 31:12:00
+-1 day -04:48:00
+25 days -15:32:30.4
+-3 months 30 days 12:29:27.2189
+12 days
+1 month 12 days
+8 years 3 months 126 days 21:36:00
+
+query I
+SELECT span / 100 AS quotient
+FROM INTERVAL_MULDIV_TBL;
+----
+12 days 13:40:48
+-12 days -06:28:48
+-02:52:48
+2 days 10:26:44.96
+-6 days 01:14:56.72189
+1 day 04:48:00
+4 days 04:48:00
+9 months 39 days 16:33:36
+
+# Commutativity
+query I
+select (interval '1 days') * 0.5::DOUBLE;
+----
+12:00:00
+
+query I
+select 0.5::DOUBLE * (interval '1 days');
+----
+12:00:00
+
+query I
+select 2::BIGINT * (interval '1 days');
+----
+2 days
+
+query I
+select (interval '1 days') * 2::BIGINT;
+----
+2 days
+

external/duckdb/test/sql/function/interval/test_interval_trunc.test

@@ -0,0 +1,491 @@
+# name: test/sql/function/interval/test_interval_trunc.test
+# description: Extract function
+# group: [interval]
+
+statement ok
+CREATE TABLE intervals(i INTERVAL, s VARCHAR);
+
+statement ok
+INSERT INTO intervals VALUES
+	('1247 years 4 months', 'millennium'),
+	('-1448 years -5 months', 'millennium'),
+	('548 years 7 months', 'century'),
+	('-118 years -3 months', 'century'),
+	('45 years 1 months', 'decade'),
+	('-97 years -11 months', 'decade'),
+	('5 years 6 months', 'year'),
+	('-4 years -8 months', 'year'),
+	('2 years 2 months', 'quarter'),
+	('-3 years -10 months', 'quarter'),
+	('3 years 4 months 5 days', 'month'),
+	('-7 years -3 months 29 days', 'month'),
+	('4 months 22 days', 'week'),
+	('-3 months -3 days', 'week'),
+	('5 months 7 days 12:34:56.789012', 'day'),
+	('-3 months -3 days 12:34:56.789012', 'day'),
+	('1 month 11 days 12:34:56.789012', 'hour'),
+	('-1 month -2 days 12:34:56.789012', 'hour'),
+	('1 month 16 days 12:34:56.789012', 'minute'),
+	('-1 month -9 days 12:34:56.789012', 'minute'),
+	('1 month 24 days 12:34:56.789012', 'second'),
+	('-1 month -17 days 12:34:56.789012', 'second'),
+	('1 month 29 days 12:34:56.789012', 'milliseconds'),
+	('-1 month -26 days 12:34:56.789012', 'milliseconds'),
+	('1 month 7 days 12:34:56.789012', 'microseconds'),
+	('-1 month -29 days 12:34:56.789012', 'microseconds'),
+	(NULL, NULL),
+;
+
+query I
+SELECT i FROM intervals;
+----
+1247 years 4 months
+-1448 years -5 months
+548 years 7 months
+-118 years -3 months
+45 years 1 month
+-97 years -11 months
+5 years 6 months
+-4 years -8 months
+2 years 2 months
+-3 years -10 months
+3 years 4 months 5 days
+-7 years -3 months 29 days
+4 months 22 days
+-3 months -3 days
+5 months 7 days 12:34:56.789012
+-3 months -3 days 12:34:56.789012
+1 month 11 days 12:34:56.789012
+-1 month -2 days 12:34:56.789012
+1 month 16 days 12:34:56.789012
+-1 month -9 days 12:34:56.789012
+1 month 24 days 12:34:56.789012
+-1 month -17 days 12:34:56.789012
+1 month 29 days 12:34:56.789012
+-1 month -26 days 12:34:56.789012
+1 month 7 days 12:34:56.789012
+-1 month -29 days 12:34:56.789012
+NULL
+
+query I
+SELECT DATE_TRUNC('millennium', i) FROM intervals
+----
+1000 years
+-1000 years
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+NULL
+
+query I
+SELECT DATE_TRUNC('century', i) FROM intervals
+----
+1200 years
+-1400 years
+500 years
+-100 years
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+NULL
+
+query I
+SELECT DATE_TRUNC('decade', i) FROM intervals
+----
+1240 years
+-1440 years
+540 years
+-110 years
+40 years
+-90 years
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+NULL
+
+foreach datepart year isoyear
+
+query I
+SELECT DATE_TRUNC('${datepart}', i) FROM intervals
+----
+1247 years
+-1448 years
+548 years
+-118 years
+45 years
+-97 years
+5 years
+-4 years
+2 years
+-3 years
+3 years
+-7 years
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+00:00:00
+NULL
+
+endloop
+
+foreach datepart week yearweek
+
+query I
+SELECT DATE_TRUNC('${datepart}', i) FROM intervals
+----
+1247 years 4 months
+-1448 years -5 months
+548 years 7 months
+-118 years -3 months
+45 years 1 month
+-97 years -11 months
+5 years 6 months
+-4 years -8 months
+2 years 2 months
+-3 years -10 months
+3 years 4 months
+-7 years -3 months 28 days
+4 months 21 days
+-3 months
+5 months 7 days
+-3 months
+1 month 7 days
+-1 month
+1 month 14 days
+-1 month -7 days
+1 month 21 days
+-1 month -14 days
+1 month 28 days
+-1 month -21 days
+1 month 7 days
+-1 month -28 days
+NULL
+
+endloop
+
+foreach datepart dayofmonth dayofweek isodow dayofyear
+
+query I
+SELECT DATE_TRUNC('${datepart}', i) FROM intervals
+----
+1247 years 4 months
+-1448 years -5 months
+548 years 7 months
+-118 years -3 months
+45 years 1 month
+-97 years -11 months
+5 years 6 months
+-4 years -8 months
+2 years 2 months
+-3 years -10 months
+3 years 4 months 5 days
+-7 years -3 months 29 days
+4 months 22 days
+-3 months -3 days
+5 months 7 days
+-3 months -3 days
+1 month 11 days
+-1 month -2 days
+1 month 16 days
+-1 month -9 days
+1 month 24 days
+-1 month -17 days
+1 month 29 days
+-1 month -26 days
+1 month 7 days
+-1 month -29 days
+NULL
+
+endloop
+
+query I
+SELECT DATE_TRUNC('hour', i) FROM intervals
+----
+1247 years 4 months
+-1448 years -5 months
+548 years 7 months
+-118 years -3 months
+45 years 1 month
+-97 years -11 months
+5 years 6 months
+-4 years -8 months
+2 years 2 months
+-3 years -10 months
+3 years 4 months 5 days
+-7 years -3 months 29 days
+4 months 22 days
+-3 months -3 days
+5 months 7 days 12:00:00
+-3 months -3 days 12:00:00
+1 month 11 days 12:00:00
+-1 month -2 days 12:00:00
+1 month 16 days 12:00:00
+-1 month -9 days 12:00:00
+1 month 24 days 12:00:00
+-1 month -17 days 12:00:00
+1 month 29 days 12:00:00
+-1 month -26 days 12:00:00
+1 month 7 days 12:00:00
+-1 month -29 days 12:00:00
+NULL
+
+query I
+SELECT DATE_TRUNC('minute', i) FROM intervals
+----
+1247 years 4 months
+-1448 years -5 months
+548 years 7 months
+-118 years -3 months
+45 years 1 month
+-97 years -11 months
+5 years 6 months
+-4 years -8 months
+2 years 2 months
+-3 years -10 months
+3 years 4 months 5 days
+-7 years -3 months 29 days
+4 months 22 days
+-3 months -3 days
+5 months 7 days 12:34:00
+-3 months -3 days 12:34:00
+1 month 11 days 12:34:00
+-1 month -2 days 12:34:00
+1 month 16 days 12:34:00
+-1 month -9 days 12:34:00
+1 month 24 days 12:34:00
+-1 month -17 days 12:34:00
+1 month 29 days 12:34:00
+-1 month -26 days 12:34:00
+1 month 7 days 12:34:00
+-1 month -29 days 12:34:00
+NULL
+
+foreach datepart second epoch
+
+query I
+SELECT DATE_TRUNC('${datepart}', i) FROM intervals
+----
+1247 years 4 months
+-1448 years -5 months
+548 years 7 months
+-118 years -3 months
+45 years 1 month
+-97 years -11 months
+5 years 6 months
+-4 years -8 months
+2 years 2 months
+-3 years -10 months
+3 years 4 months 5 days
+-7 years -3 months 29 days
+4 months 22 days
+-3 months -3 days
+5 months 7 days 12:34:56
+-3 months -3 days 12:34:56
+1 month 11 days 12:34:56
+-1 month -2 days 12:34:56
+1 month 16 days 12:34:56
+-1 month -9 days 12:34:56
+1 month 24 days 12:34:56
+-1 month -17 days 12:34:56
+1 month 29 days 12:34:56
+-1 month -26 days 12:34:56
+1 month 7 days 12:34:56
+-1 month -29 days 12:34:56
+NULL
+
+endloop
+
+query I
+SELECT DATE_TRUNC('millisecond', i) FROM intervals
+----
+1247 years 4 months
+-1448 years -5 months
+548 years 7 months
+-118 years -3 months
+45 years 1 month
+-97 years -11 months
+5 years 6 months
+-4 years -8 months
+2 years 2 months
+-3 years -10 months
+3 years 4 months 5 days
+-7 years -3 months 29 days
+4 months 22 days
+-3 months -3 days
+5 months 7 days 12:34:56.789
+-3 months -3 days 12:34:56.789
+1 month 11 days 12:34:56.789
+-1 month -2 days 12:34:56.789
+1 month 16 days 12:34:56.789
+-1 month -9 days 12:34:56.789
+1 month 24 days 12:34:56.789
+-1 month -17 days 12:34:56.789
+1 month 29 days 12:34:56.789
+-1 month -26 days 12:34:56.789
+1 month 7 days 12:34:56.789
+-1 month -29 days 12:34:56.789
+NULL
+
+query I
+SELECT DATE_TRUNC('microsecond', i) FROM intervals
+----
+1247 years 4 months
+-1448 years -5 months
+548 years 7 months
+-118 years -3 months
+45 years 1 month
+-97 years -11 months
+5 years 6 months
+-4 years -8 months
+2 years 2 months
+-3 years -10 months
+3 years 4 months 5 days
+-7 years -3 months 29 days
+4 months 22 days
+-3 months -3 days
+5 months 7 days 12:34:56.789012
+-3 months -3 days 12:34:56.789012
+1 month 11 days 12:34:56.789012
+-1 month -2 days 12:34:56.789012
+1 month 16 days 12:34:56.789012
+-1 month -9 days 12:34:56.789012
+1 month 24 days 12:34:56.789012
+-1 month -17 days 12:34:56.789012
+1 month 29 days 12:34:56.789012
+-1 month -26 days 12:34:56.789012
+1 month 7 days 12:34:56.789012
+-1 month -29 days 12:34:56.789012
+NULL
+
+# Variable part name
+query I
+SELECT DATE_TRUNC(s, i) FROM intervals
+----
+1000 years
+-1000 years
+500 years
+-100 years
+40 years
+-90 years
+5 years
+-4 years
+2 years
+-3 years -9 months
+3 years 4 months
+-7 years -3 months
+4 months 21 days
+-3 months
+5 months 7 days
+-3 months -3 days
+1 month 11 days 12:00:00
+-1 month -2 days 12:00:00
+1 month 16 days 12:34:00
+-1 month -9 days 12:34:00
+1 month 24 days 12:34:56
+-1 month -17 days 12:34:56
+1 month 29 days 12:34:56.789
+-1 month -26 days 12:34:56.789
+1 month 7 days 12:34:56.789012
+-1 month -29 days 12:34:56.789012
+NULL
+
+# NULL part name
+query I
+SELECT DATE_TRUNC(NULL, i) FROM intervals
+----
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+
+

external/duckdb/test/sql/function/list/aggregates/any_value.test

@@ -0,0 +1,115 @@
+# name: test/sql/function/list/aggregates/any_value.test
+# description: Test the list_any_value aggregate function
+# group: [aggregates]
+
+query I
+SELECT list_aggr([NULL, 1, 2], 'any_value')
+----
+1
+
+# incorrect usage
+statement error
+SELECT list_any_value()
+----
+
+# different types
+
+# numerics
+foreach type <numeric>
+
+statement ok
+CREATE TABLE five AS SELECT LIST(i::${type}) AS i FROM range(1, 6, 1) t1(i)
+
+statement ok
+INSERT INTO five VALUES (NULL), ([NULL]), ([]), ([NULL, 1, 2])
+
+query I
+SELECT list_any_value(i) FROM five
+----
+1
+NULL
+NULL
+NULL
+1
+
+statement ok
+DROP TABLE five
+
+endloop
+
+# temporal
+statement ok
+CREATE TABLE five_dates AS
+	SELECT
+		LIST(NULLIF(i,0)::integer) AS i,
+		LIST('2021-08-20'::DATE + NULLIF(i,0)::INTEGER) AS d,
+		LIST('2021-08-20'::TIMESTAMP + INTERVAL (NULLIF(i,0)) HOUR) AS dt,
+		LIST('14:59:37'::TIME + INTERVAL (NULLIF(i,0)) MINUTE) AS t,
+		LIST(INTERVAL (NULLIF(i,0)) SECOND) AS s
+	FROM range(0, 6, 1) t1(i)
+
+query IIII
+SELECT list_any_value(d), list_any_value(dt), list_any_value(t), list_any_value(s) FROM five_dates
+----
+2021-08-21	2021-08-20 01:00:00	15:00:37	00:00:01
+
+statement ok
+DROP TABLE five_dates
+
+# with time zone
+statement ok
+CREATE TABLE five_dates_tz AS
+	SELECT
+		LIST(('2021-08-20'::TIMESTAMP + INTERVAL (NULLIF(i,0)) HOUR)::TIMESTAMPTZ) AS dt,
+		LIST(('14:59:37'::TIME + INTERVAL (NULLIF(i,0)) MINUTE)::TIMETZ) AS t,
+	FROM range(0, 6, 1) t1(i)
+
+query II
+SELECT list_any_value(dt), list_any_value(t) FROM five_dates_tz
+----
+2021-08-20 01:00:00+00	15:00:37+00
+
+statement ok
+DROP TABLE five_dates_tz
+
+# complex types
+statement ok
+CREATE TABLE five_complex AS
+	SELECT
+		LIST(NULLIF(i,0)::integer) AS i,
+		LIST(NULLIF(i,0)::VARCHAR) AS s,
+		LIST([NULLIF(i,0)]) AS l,
+		LIST({'a': NULLIF(i,0)}) AS r
+	FROM range(0, 6, 1) t1(i)
+
+query III
+SELECT list_any_value(s), list_any_value(l), list_any_value(r)
+FROM five_complex
+----
+1	[NULL]	{'a': NULL}
+
+statement ok
+DROP TABLE five_complex
+
+# decimals
+foreach type decimal(4,1) decimal(8,1) decimal(12,1) decimal(18,1)
+
+statement ok
+CREATE TABLE five AS SELECT LIST(i::${type}) AS i FROM range(1, 6, 1) t1(i)
+
+statement ok
+INSERT INTO five VALUES (NULL), ([NULL]), ([]), ([NULL, 1, 2])
+
+query I
+SELECT list_any_value(i) FROM five
+----
+1.0
+NULL
+NULL
+NULL
+1.0
+
+statement ok
+DROP TABLE five
+
+endloop

external/duckdb/test/sql/function/list/aggregates/approx_count_distinct.test

@@ -0,0 +1,98 @@
+# name: test/sql/function/list/aggregates/approx_count_distinct.test
+# description: Test the list_approx_count_distinct aggregate function
+# group: [aggregates]
+
+statement ok
+CREATE TABLE list_ints (l INTEGER[]);
+
+statement ok
+INSERT INTO list_ints SELECT LIST(i) FROM range(100) tbl(i);
+
+query II
+select list_approx_count_distinct([10]), list_approx_count_distinct(['hello']) from list_ints;
+----
+1	1
+
+query II
+select list_approx_count_distinct(l), list_approx_count_distinct(['hello']) from list_ints;
+----
+98	1
+
+query I
+select list_approx_count_distinct([]) from list_ints;
+----
+0
+
+statement ok
+INSERT INTO list_ints VALUES ([]), (NULL), ([NULL]);
+
+query I
+select list_approx_count_distinct(l) from list_ints;
+----
+98
+0
+NULL
+0
+
+# dates
+statement ok
+CREATE TABLE IF NOT EXISTS dates (t date[]);
+
+statement ok
+INSERT INTO dates VALUES (['2008-01-01', NULL, '2007-01-01', '2008-02-01', '2008-01-02', '2008-01-01', '2008-01-01', '2008-01-01'])
+
+query II
+SELECT list_count(t), list_approx_count_distinct(t) from dates
+----
+7	4
+
+# timestamps
+statement ok
+CREATE TABLE IF NOT EXISTS timestamp (t TIMESTAMP[]);
+
+statement ok
+INSERT INTO timestamp VALUES (['2008-01-01 00:00:01', NULL, '2007-01-01 00:00:01', '2008-02-01 00:00:01', '2008-01-02 00:00:01', '2008-01-01 10:00:00', '2008-01-01 00:10:00', '2008-01-01 00:00:10'])
+
+query II
+SELECT list_count(t), list_approx_count_distinct(t) from timestamp
+----
+7	6
+
+# strings
+statement ok
+CREATE TABLE IF NOT EXISTS names (t string[]);
+
+statement ok
+INSERT INTO names VALUES (['Pedro', NULL, 'Pedro', 'Pedro', 'Mark', 'Mark', 'Mark', 'Hannes-Muehleisen', 'Hannes-Muehleisen'])
+
+query II
+SELECT list_count(t), list_approx_count_distinct(t) from names
+----
+8	3
+
+# test approximate count on different (long) lists
+statement ok
+CREATE TABLE list_ints_2 (a INTEGER[], b INTEGER[]);
+
+statement ok
+INSERT INTO list_ints_2 SELECT LIST(a), LIST(mod(a, 10)) FROM range(2000) tbl(a);
+
+query III
+SELECT list_count(a), list_approx_count_distinct(a), list_approx_count_distinct(b) from list_ints_2
+----
+2000	2322	11
+
+statement ok
+DELETE FROM list_ints_2
+
+statement ok
+INSERT INTO list_ints_2 SELECT LIST(a), NULL FROM range(2000) tbl(a, b) WHERE a % 2 = 0;
+
+statement ok
+INSERT INTO list_ints_2 SELECT LIST(a), NULL FROM range(2000) tbl(a, b) WHERE a % 2 = 1;
+
+query I
+SELECT list_approx_count_distinct(a) from list_ints_2;
+----
+1006
+1230

external/duckdb/test/sql/function/list/aggregates/avg.test

@@ -0,0 +1,81 @@
+# name: test/sql/function/list/aggregates/avg.test
+# description: Test the list_avg aggregate function
+# group: [aggregates]
+
+# list_avg on a sequence
+statement ok
+CREATE SEQUENCE seq;
+
+query I
+SELECT list_avg([nextval('seq')]);
+----
+1
+
+query I
+SELECT list_avg([nextval('seq')]);
+----
+2
+
+# multiple list entries
+statement ok
+CREATE TABLE integers(i INTEGER[]);
+
+statement ok
+INSERT INTO integers VALUES ([1, 2, 3]), ([6, 3, 2, 5]), ([]), ([NULL]), (NULL), ([1, NULL, 2, 3]);
+
+query I
+SELECT list_avg(i) FROM integers;
+----
+2
+4
+NULL
+NULL
+NULL
+2
+
+# incorrect use
+statement error
+SELECT list_avg()
+----
+
+# NULL average
+statement ok
+CREATE TABLE vals(i INTEGER[], j HUGEINT[]);
+
+statement ok
+INSERT INTO vals VALUES ([NULL, NULL], [NULL, NULL, NULL])
+
+query II
+SELECT list_avg(i), list_avg(j) FROM vals;
+----
+NULL	NULL
+
+# test list_avg on integers with no exact float64 representation
+
+statement ok
+CREATE TABLE bigints(n HUGEINT[]);
+
+statement ok
+INSERT INTO bigints (n) VALUES (['9007199254740992'::HUGEINT, 1::HUGEINT, 0::HUGEINT]);
+
+# this would give the wrong result with 'double' precision
+require longdouble
+
+query R
+SELECT list_avg(n)::DOUBLE - '3002399751580331'::DOUBLE FROM bigints;
+----
+0
+
+# test list_avg in which the intermediate sums are not exact (favg)
+
+statement ok
+CREATE TABLE doubles(n DOUBLE[]);
+
+statement ok
+INSERT INTO doubles (n) VALUES (['9007199254740992'::DOUBLE, 1::DOUBLE, 1::DOUBLE, 0::DOUBLE]);
+
+# this would give the wrong result with a simple sum-and-divide
+query R
+SELECT list_aggr(n, 'favg') - '2251799813685248.5'::DOUBLE FROM doubles;
+----
+0

external/duckdb/test/sql/function/list/aggregates/bigints_sum_avg.test

@@ -0,0 +1,117 @@
+# name: test/sql/function/list/aggregates/bigints_sum_avg.test
+# description: Test list_sum and list_avg with bigints
+# group: [aggregates]
+
+statement ok
+CREATE TABLE bigints (i BIGINT[]);
+
+statement ok
+INSERT INTO bigints VALUES ([1, 2, 3]);
+
+# sum
+query I
+SELECT list_sum(i) FROM bigints;
+----
+6
+
+# avg
+query I
+SELECT list_avg(i) FROM bigints;
+----
+2
+
+statement ok
+DELETE FROM bigints;
+
+# sum no longer fits in int64
+statement ok
+INSERT INTO bigints VALUES ([1, 2, 3, 9223372036854775806]);
+
+# sum
+query I
+SELECT list_sum(i) FROM bigints;
+----
+9223372036854775812
+
+# avg
+query I
+SELECT list_avg(i) FROM bigints;
+----
+2305843009213693952
+
+statement ok
+DELETE FROM bigints;
+
+statement ok
+INSERT INTO bigints VALUES ([-1, -2, -3]);
+
+# sum
+query I
+SELECT list_sum(i) FROM bigints;
+----
+-6
+
+# avg
+query I
+SELECT list_avg(i) FROM bigints;
+----
+-2
+
+statement ok
+DELETE FROM bigints;
+
+# sum no longer fits in int64 [negative]
+statement ok
+INSERT INTO bigints VALUES ([-1, -2, -3, -9223372036854775806]);
+
+# sum
+query I
+SELECT list_sum(i) FROM bigints;
+----
+-9223372036854775812
+
+# avg
+query I
+SELECT list_avg(i) FROM bigints;
+----
+-2305843009213693952
+
+# now with decimals
+
+statement ok
+CREATE TABLE decimals (i DECIMAL(18,1)[]);
+
+statement ok
+INSERT INTO decimals VALUES ([1, 2, 3]);
+
+# sum
+query I
+SELECT list_sum(i) FROM decimals;
+----
+6.0
+
+# avg
+query I
+SELECT list_avg(i) FROM decimals;
+----
+2.0
+
+statement ok
+DELETE FROM decimals;
+
+# sum no longer fits in int64
+statement ok
+INSERT INTO decimals VALUES ([99999999999999999.9, 99999999999999999.9, 99999999999999999.9,
+    99999999999999999.9, 99999999999999999.9, 99999999999999999.9, 99999999999999999.9,
+    99999999999999999.9, 99999999999999999.9, 99999999999999999.9, 1.0, 2.0, 3.0]);
+
+# sum
+query I
+SELECT list_sum(i) FROM decimals;
+----
+1000000000000000005.0
+
+query I
+SELECT list_avg(i) FROM decimals;
+----
+76923076923076923

external/duckdb/test/sql/function/list/aggregates/bit_and.test

@@ -0,0 +1,48 @@
+# name: test/sql/function/list/aggregates/bit_and.test
+# description: Test the list_bit_and aggregate function
+# group: [aggregates]
+
+# bit_and on a sequence
+statement ok
+CREATE SEQUENCE seq;
+
+query I
+SELECT list_bit_and([nextval('seq')])
+----
+1
+
+query I
+SELECT list_bit_and([nextval('seq')])
+----
+2
+
+# list of integers
+statement ok
+CREATE TABLE integers(i INTEGER[]);
+
+statement ok
+INSERT INTO integers VALUES ([3, 7, 15, 31, 3, 15]);
+
+# empty list
+query I
+SELECT list_bit_and([]) FROM integers
+----
+NULL
+
+statement ok
+INSERT INTO integers VALUES ([]), (NULL), ([NULL]), ([3, 7, NULL, 15, 31, 3, 15, NULL]);
+
+query III
+SELECT list_bit_and(i), list_bit_and([1, 1, 1, 1, 1, 1]), list_bit_and(NULL) FROM integers
+----
+3	1	NULL
+NULL	1	NULL
+NULL	1	NULL
+NULL	1	NULL
+3	1	NULL
+
+# incorrect usage
+statement error
+SELECT list_bit_and()
+----
+<REGEX>:.*Binder Error.*does not support the supplied arguments.*

external/duckdb/test/sql/function/list/aggregates/bit_or.test

@@ -0,0 +1,48 @@
+# name: test/sql/function/list/aggregates/bit_or.test
+# description: Test the list_bit_or aggregate function
+# group: [aggregates]
+
+# bit_or on a sequence
+statement ok
+CREATE SEQUENCE seq;
+
+query I
+SELECT list_bit_or([nextval('seq')])
+----
+1
+
+query I
+SELECT list_bit_or([nextval('seq')])
+----
+2
+
+# list of integers
+statement ok
+CREATE TABLE integers(i INTEGER[]);
+
+statement ok
+INSERT INTO integers VALUES ([3, 7, 15, 31, 3, 15])
+
+# empty list
+query I
+SELECT list_bit_or([]) FROM integers
+----
+NULL
+
+statement ok
+INSERT INTO integers VALUES ([]), (NULL), ([NULL]), ([3, 7, NULL, 15, 31, 3, 15, NULL]);
+
+query III
+SELECT list_bit_or(i), list_bit_or([1, 1, 1, 1, 1, 1]), list_bit_or(NULL) FROM integers
+----
+31	1	NULL
+NULL	1	NULL
+NULL	1	NULL
+NULL	1	NULL
+31	1	NULL
+
+# incorrect usage
+statement error
+SELECT list_bit_or()
+----
+<REGEX>:.*Binder Error.*does not support the supplied arguments.*

external/duckdb/test/sql/function/list/aggregates/bit_xor.test

@@ -0,0 +1,48 @@
+# name: test/sql/function/list/aggregates/bit_xor.test
+# description: Test the list_bit_xor aggregate function
+# group: [aggregates]
+
+# bit_xor on a sequence
+statement ok
+CREATE SEQUENCE seq;
+
+query I
+SELECT list_bit_xor([nextval('seq')])
+----
+1
+
+query I
+SELECT list_bit_xor([nextval('seq')])
+----
+2
+
+# list of integers
+statement ok
+CREATE TABLE integers (i INTEGER[]);
+
+statement ok
+INSERT INTO integers VALUES ([3, 7, 15, 31, 3, 15]);
+
+# empty list
+query I
+SELECT list_bit_xor([]) FROM integers
+----
+NULL
+
+statement ok
+INSERT INTO integers VALUES ([]), (NULL), ([NULL]), ([3, 7, NULL, 15, 31, 3, 15, NULL]);
+
+query III
+SELECT list_bit_xor(i), list_bit_xor([1, 1, 1, 1, 1, 1]), list_bit_xor(NULL) FROM integers
+----
+24	0	NULL
+NULL	0	NULL
+NULL	0	NULL
+NULL	0	NULL
+24	0	NULL
+
+# incorrect usage
+statement error
+SELECT list_bit_xor()
+----
+<REGEX>:.*Binder Error.*does not support the supplied arguments.*

external/duckdb/test/sql/function/list/aggregates/bool_and_or.test

@@ -0,0 +1,50 @@
+# name: test/sql/function/list/aggregates/bool_and_or.test
+# description: Test the list_bool_and, list_bool_or aggregate functions
+# group: [aggregates]
+
+# incorrect usage
+statement error
+select list_bool_or()
+----
+
+statement error
+select list_bool_and()
+----
+
+# list of booleans
+statement ok
+CREATE TABLE bools (l BOOLEAN[]);
+
+statement ok
+INSERT INTO bools SELECT LIST(True) FROM range(100) tbl(i);
+
+statement ok
+INSERT INTO bools SELECT LIST(False) FROM range(100) tbl(i);
+
+statement ok
+INSERT INTO bools VALUES ([True, False]);
+
+statement ok
+INSERT INTO bools VALUES ([]), ([NULL]), (NULL), ([NULL, True, False, NULL]);
+
+query I
+SELECT list_bool_or(l) FROM bools;
+----
+1
+0
+1
+NULL
+NULL
+NULL
+1
+
+query I
+SELECT list_bool_and(l) FROM bools;
+----
+1
+0
+0
+NULL
+NULL
+NULL
+0

external/duckdb/test/sql/function/list/aggregates/count.test

@@ -0,0 +1,37 @@
+# name: test/sql/function/list/aggregates/count.test
+# description: Test the list_count aggregate function
+# group: [aggregates]
+
+query I
+SELECT list_count([1, 2, 3])
+----
+3
+
+query I
+SELECT list_count([1]) FROM range(3)
+----
+1
+1
+1
+
+statement ok
+CREATE TABLE lists (l INTEGER[]);
+
+statement ok
+INSERT INTO lists VALUES ([1, 2]), ([NULL]), (NULL), ([]), ([3, 4, 5, 6, 7]), ([1, 2, NULL, 1, NULL]);
+
+query I
+SELECT list_count(l) FROM lists
+----
+2
+0
+NULL
+0
+5
+3
+
+# incorrect usage
+statement error
+select list_count()
+----
+<REGEX>:.*Binder Error.*does not support the supplied arguments.*

external/duckdb/test/sql/function/list/aggregates/entropy.test

@@ -0,0 +1,68 @@
+# name: test/sql/function/list/aggregates/entropy.test
+# description: Test the list_entropy aggregate function
+# group: [aggregates]
+
+# incorrect usage
+statement error
+select list_entropy()
+----
+
+query I
+select list_entropy([1])
+----
+0
+
+statement ok
+create table aggr(k int[]);
+
+statement ok
+insert into aggr values ([0, 1, 1, 1, 4, 0, 3, 3, 2, 2, 4, 4, 2, 4, 0, 0, 0, 1, 2, 3, 4, 2, 3, 3, 1]);
+
+statement ok
+insert into aggr values ([]), ([NULL]), (NULL), ([0, 1, 1, 1, 4, NULL, 0, 3, 3, 2, NULL, 2, 4, 4, 2, 4, 0, 0, 0, 1, NULL, 2, 3, 4, 2, 3, 3, 1]);
+
+query I
+select list_entropy(k) from aggr;
+----
+2.321928
+0
+0
+NULL
+2.321928
+
+statement ok
+CREATE TABLE entr (l INTEGER[]);
+
+statement ok
+INSERT INTO entr SELECT LIST(2) FROM range(100) tbl(i);
+
+query I
+SELECT list_entropy(l) FROM entr;
+----
+0
+
+statement ok
+create table aggr2 (k int[]);
+
+statement ok
+INSERT INTO aggr2 VALUES ([0, 4, 0, 2, 2, 4, 4, 2, 4, 0, 0, 0, 2, 4, 2]);
+
+statement ok
+INSERT INTO aggr2 VALUES ([1, 1, 1, 3, 3, 1, 3, 3, 3, 1]);
+
+query I
+select list_entropy(k) from aggr2
+----
+1.584963
+1.000000
+
+statement ok
+create table names (name string[])
+
+statement ok
+insert into names values (['pedro', 'pedro', 'pedro', 'hannes', 'hannes', 'mark', null]);
+
+query I
+select list_entropy(name) from names;
+----
+1.459148

external/duckdb/test/sql/function/list/aggregates/first.test

@@ -0,0 +1,115 @@
+# name: test/sql/function/list/aggregates/first.test
+# description: Test the list_first aggregate function
+# group: [aggregates]
+
+query I
+SELECT list_aggr([1, 2], 'arbitrary')
+----
+1
+
+# incorrect usage
+statement error
+SELECT list_first()
+----
+
+# different types
+
+# numerics
+foreach type <numeric>
+
+statement ok
+CREATE TABLE five AS SELECT LIST(i::${type}) AS i FROM range(1, 6, 1) t1(i)
+
+statement ok
+INSERT INTO five VALUES (NULL), ([NULL]), ([]), ([NULL, 1, 2])
+
+query I
+SELECT list_first(i) FROM five
+----
+1
+NULL
+NULL
+NULL
+NULL
+
+statement ok
+DROP TABLE five
+
+endloop
+
+# temporal
+statement ok
+CREATE TABLE five_dates AS
+	SELECT
+		LIST(i::integer) AS i,
+		LIST('2021-08-20'::DATE + i::INTEGER) AS d,
+		LIST('2021-08-20'::TIMESTAMP + INTERVAL (i) HOUR) AS dt,
+		LIST('14:59:37'::TIME + INTERVAL (i) MINUTE) AS t,
+		LIST(INTERVAL (i) SECOND) AS s
+	FROM range(1, 6, 1) t1(i)
+
+query IIII
+SELECT list_first(d), list_first(dt), list_first(t), list_first(s) FROM five_dates
+----
+2021-08-21	2021-08-20 01:00:00	15:00:37	00:00:01
+
+statement ok
+DROP TABLE five_dates
+
+# with time zone
+statement ok
+CREATE TABLE five_dates_tz AS
+	SELECT
+		LIST(('2021-08-20'::TIMESTAMP + INTERVAL (i) HOUR)::TIMESTAMPTZ) AS dt,
+		LIST(('14:59:37'::TIME + INTERVAL (i) MINUTE)::TIMETZ) AS t,
+	FROM range(1, 6, 1) t1(i)
+
+query II
+SELECT list_first(dt), list_first(t) FROM five_dates_tz
+----
+2021-08-20 01:00:00+00	15:00:37+00
+
+statement ok
+DROP TABLE five_dates_tz
+
+# complex types
+statement ok
+CREATE TABLE five_complex AS
+	SELECT
+		LIST(i::integer) AS i,
+		LIST(i::VARCHAR) AS s,
+		LIST([i]) AS l,
+		LIST({'a': i}) AS r
+	FROM range(1, 6, 1) t1(i)
+
+query III
+SELECT list_first(s), list_first(l), list_first(r)
+FROM five_complex
+----
+1	[1]	{'a': 1}
+
+statement ok
+DROP TABLE five_complex
+
+# decimals
+foreach type decimal(4,1) decimal(8,1) decimal(12,1) decimal(18,1)
+
+statement ok
+CREATE TABLE five AS SELECT LIST(i::${type}) AS i FROM range(1, 6, 1) t1(i)
+
+statement ok
+INSERT INTO five VALUES (NULL), ([NULL]), ([]), ([NULL, 1, 2])
+
+query I
+SELECT list_first(i) FROM five
+----
+1.0
+NULL
+NULL
+NULL
+NULL
+
+statement ok
+DROP TABLE five
+
+endloop

external/duckdb/test/sql/function/list/aggregates/histogram.test

@@ -0,0 +1,105 @@
+# name: test/sql/function/list/aggregates/histogram.test
+# description: Test list_histogram aggregate function
+# group: [aggregates]
+
+statement ok
+CREATE TABLE const AS SELECT LIST(2) AS i FROM range(200) t1(i)
+
+query I
+SELECT list_histogram(i) FROM const
+----
+{2=200}
+
+query I
+select list_histogram([1])
+----
+{1=1}
+
+# integers
+statement ok
+CREATE TABLE hist_data (g INTEGER[])
+
+statement ok
+INSERT INTO hist_data VALUES ([1, 1, 2, 2, 2, 3, 5]), ([1, 2, 3, 4, 5, 6, NULL]), ([]), (NULL), ([NULL]);
+
+query T
+SELECT list_histogram(g) from hist_data
+----
+{1=2, 2=3, 3=1, 5=1}
+{1=1, 2=1, 3=1, 4=1, 5=1, 6=1}
+NULL
+NULL
+NULL
+
+# strings
+statement ok
+create table names (name string[])
+
+statement ok
+insert into names values (['pedro', 'pedro', 'pedro', 'hannes', 'hannes', 'mark', NULL, 'Hubert Blaine Wolfeschlegelsteinhausenbergerdorff Sr.']);
+
+query I
+select list_histogram(name) from names;
+----
+{Hubert Blaine Wolfeschlegelsteinhausenbergerdorff Sr.=1, hannes=2, mark=1, pedro=3}
+
+# incorrect usage
+statement error
+select list_histogram()
+----
+
+# temporal types
+
+# timestamp
+query I
+SELECT list_histogram(['2021-08-20'::TIMESTAMP])
+----
+{'2021-08-20 00:00:00'=1}
+
+# timestamp_s
+query I
+SELECT list_histogram(['2021-08-20'::TIMESTAMP_S])
+----
+{'2021-08-20 00:00:00'=1}
+
+# timestamp_ms
+query I
+SELECT list_histogram(['2021-08-20'::TIMESTAMP_MS])
+----
+{'2021-08-20 00:00:00'=1}
+
+# timestamp_ns
+query I
+SELECT list_histogram(['2021-08-20'::TIMESTAMP_NS])
+----
+{'2021-08-20 00:00:00'=1}
+
+# timestamp with time zone
+query I
+SELECT list_histogram(['2021-08-20'::TIMESTAMPTZ])
+----
+{'2021-08-20 00:00:00+00'=1}
+
+# date
+query I
+SELECT list_histogram(['2022-01-02'::DATE])
+----
+{2022-01-02=1}
+
+# time
+query I
+SELECT list_histogram(['15:00:07'::TIME])
+----
+{'15:00:07'=1}
+
+# timetz
+query I
+SELECT list_histogram(['15:00:07'::TIMETZ])
+----
+{'15:00:07+00'=1}
+
+# interval
+query I
+SELECT list_histogram([INTERVAL 1 YEAR])
+----
+{1 year=1}

external/duckdb/test/sql/function/list/aggregates/histogram_decimal.test

@@ -0,0 +1,20 @@
+# name: test/sql/function/list/aggregates/histogram_decimal.test
+# description: Test histogram for decimals
+# group: [aggregates]
+
+statement ok
+PRAGMA enable_verification
+
+query II
+WITH cte AS (FROM (VALUES (0.0), (9.9)) df(l_orderkey)) SELECT * FROM histogram_values(cte, l_orderkey)
+----
+1.0	1
+2.0	0
+3.0	0
+4.0	0
+5.0	0
+6.0	0
+7.0	0
+8.0	0
+9.0	0
+10.0	1

external/duckdb/test/sql/function/list/aggregates/hugeint.test

@@ -0,0 +1,29 @@
+# name: test/sql/function/list/aggregates/hugeint.test
+# description: Test hugeint aggregates
+# group: [aggregates]
+
+statement ok
+CREATE TABLE hugeints(h HUGEINT[])
+
+statement ok
+INSERT INTO hugeints VALUES ([NULL, 1, 2]), (NULL), ([]), ([NULL]), ([1, 2, 3])
+
+query III
+SELECT list_first(h), list_last(h), list_sum(h) FROM hugeints
+----
+NULL	2	3
+NULL	NULL	NULL
+NULL	NULL	NULL
+NULL	NULL	NULL
+1	3	6
+
+statement ok
+DELETE FROM hugeints
+
+statement ok
+INSERT INTO hugeints VALUES ([42.0, 1267650600228229401496703205376, -439847238974238975238975, '-12']);
+
+query IIIII
+SELECT list_min(h), list_max(h), list_sum(h), list_first(h), list_last(h) FROM hugeints;
+----
+-439847238974238975238975	1267650600228229401496703205376	1267650160380990427257727966431	42	-12

external/duckdb/test/sql/function/list/aggregates/incorrect.test

@@ -0,0 +1,143 @@
+# name: test/sql/function/list/aggregates/incorrect.test
+# description: Test incorrect and incompatible aggregate functions for lists
+# group: [aggregates]
+
+# incorrect syntax
+
+statement error
+SELECT list_aggr([1], 2)
+----
+
+statement error
+SELECT list_aggr([1], True)
+----
+
+statement error
+SELECT list_aggr([1], NULL)
+----
+
+foreach func_name approx_count_distinct avg favg bit_and bit_or bit_xor bool_and bool_or count entropy first arbitrary histogram kurtosis last mad max median min mode array_agg list product sem skewness string_agg group_concat sum fsum sumKahan kahan_sum var_samp var_pop stddev stddev_pop variance stddev_samp
+
+statement error
+SELECT list_aggr('${func_name}')
+----
+
+statement error
+SELECT list_aggr(*, '${func_name}')
+----
+
+statement error
+SELECT list_aggr('hello', '${func_name}')
+----
+
+statement error
+SELECT list_aggr(1, 2, '${func_name}')
+----
+
+foreach type boolean varchar tinyint smallint integer bigint hugeint utinyint usmallint uinteger ubigint uhugeint float double decimal(4,1) decimal(9,4) decimal(18,6) decimal(38,10) date time timestamp timestamp_s timestamp_ms timestamp_ns timetz timestamptz interval blob
+
+statement error
+SELECT list_aggr(NULL::${type}, '${func_name}')
+----
+
+endloop
+
+endloop
+
+# incompatible aggregate functions (more than one column)
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'count_star');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'corr');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'covar_pop');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'covar_samp');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'regr_intercept');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'regr_sxy');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'regr_sxx');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'regr_syy');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'regr_r2');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'regr_slope');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'regr_count');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'regr_avgy');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'regr_avgx');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'reservoir_quantile');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'approx_quantile');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'quantile');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'quantile_cont');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'quantile_disc');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'arg_max');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'max_by');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'argmax');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'arg_min');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'min_by');
+----
+
+statement error
+SELECT list_aggr([1, 2, NULL], 'argmin');
+----