duckdb 1.1.3 → 1.1.4-dev11.0

package/src/duckdb/src/{core_functions/scalar/blob → function/scalar}/create_sort_key.cpp

@@ -1,10 +1,11 @@
-#include "duckdb/core_functions/scalar/blob_functions.hpp"
-#include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/function/create_sort_key.hpp"
+
 #include "duckdb/common/enums/order_type.hpp"
 #include "duckdb/common/radix.hpp"
+#include "duckdb/function/scalar/generic_functions.hpp"
+#include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/core_functions/create_sort_key.hpp"
 
 namespace duckdb {
 
@@ -729,6 +730,15 @@ void CreateSortKeyHelpers::CreateSortKey(Vector &input, idx_t input_count, Order
 	CreateSortKeyInternal(sort_key_data, modifiers, result, input_count);
 }
 
+void CreateSortKeyHelpers::CreateSortKey(DataChunk &input, const vector<OrderModifiers> &modifiers, Vector &result) {
+	vector<unique_ptr<SortKeyVectorData>> sort_key_data;
+	D_ASSERT(modifiers.size() == input.ColumnCount());
+	for (idx_t r = 0; r < modifiers.size(); r++) {
+		sort_key_data.push_back(make_uniq<SortKeyVectorData>(input.data[r], input.size(), modifiers[r]));
+	}
+	CreateSortKeyInternal(sort_key_data, modifiers, result, input.size());
+}
+
 void CreateSortKeyHelpers::CreateSortKeyWithValidity(Vector &input, Vector &result, const OrderModifiers &modifiers,
                                                      const idx_t count) {
 	CreateSortKey(input, count, modifiers, result);
@@ -762,23 +772,65 @@ static void CreateSortKeyFunction(DataChunk &args, ExpressionState &state, Vecto
 //===--------------------------------------------------------------------===//
 // Decode Sort Key
 //===--------------------------------------------------------------------===//
+struct DecodeSortKeyVectorData {
+	DecodeSortKeyVectorData(const LogicalType &type, OrderModifiers modifiers)
+	    : flip_bytes(modifiers.order_type == OrderType::DESCENDING) {
+		null_byte = SortKeyVectorData::NULL_FIRST_BYTE;
+		valid_byte = SortKeyVectorData::NULL_LAST_BYTE;
+		if (modifiers.null_type == OrderByNullType::NULLS_LAST) {
+			std::swap(null_byte, valid_byte);
+		}
+
+		// NULLS FIRST/NULLS LAST passed in by the user are only respected at the top level
+		// within nested types NULLS LAST/NULLS FIRST is dependent on ASC/DESC order instead
+		// don't blame me this is what Postgres does
+		auto child_null_type =
+		    modifiers.order_type == OrderType::ASCENDING ? OrderByNullType::NULLS_LAST : OrderByNullType::NULLS_FIRST;
+		OrderModifiers child_modifiers(modifiers.order_type, child_null_type);
+		switch (type.InternalType()) {
+		case PhysicalType::STRUCT: {
+			auto &children = StructType::GetChildTypes(type);
+			for (auto &child_type : children) {
+				child_data.emplace_back(child_type.second, child_modifiers);
+			}
+			break;
+		}
+		case PhysicalType::ARRAY: {
+			auto &child_type = ArrayType::GetChildType(type);
+			child_data.emplace_back(child_type, child_modifiers);
+			break;
+		}
+		case PhysicalType::LIST: {
+			auto &child_type = ListType::GetChildType(type);
+			child_data.emplace_back(child_type, child_modifiers);
+			break;
+		}
+		default:
+			break;
+		}
+	}
+
+	data_t null_byte;
+	data_t valid_byte;
+	vector<DecodeSortKeyVectorData> child_data;
+	bool flip_bytes;
+};
+
 struct DecodeSortKeyData {
-	explicit DecodeSortKeyData(OrderModifiers modifiers, string_t &sort_key)
-	    : data(const_data_ptr_cast(sort_key.GetData())), size(sort_key.GetSize()), position(0),
-	      flip_bytes(modifiers.order_type == OrderType::DESCENDING) {
+	explicit DecodeSortKeyData(string_t &sort_key)
+	    : data(const_data_ptr_cast(sort_key.GetData())), size(sort_key.GetSize()), position(0) {
 	}
 
 	const_data_ptr_t data;
 	idx_t size;
 	idx_t position;
-	bool flip_bytes;
 };
 
-void DecodeSortKeyRecursive(DecodeSortKeyData &decode_data, SortKeyVectorData &vector_data, Vector &result,
+void DecodeSortKeyRecursive(DecodeSortKeyData &decode_data, DecodeSortKeyVectorData &vector_data, Vector &result,
                             idx_t result_idx);
 
 template <class OP>
-void TemplatedDecodeSortKey(DecodeSortKeyData &decode_data, SortKeyVectorData &vector_data, Vector &result,
+void TemplatedDecodeSortKey(DecodeSortKeyData &decode_data, DecodeSortKeyVectorData &vector_data, Vector &result,
                             idx_t result_idx) {
 	auto validity_byte = decode_data.data[decode_data.position];
 	decode_data.position++;
@@ -787,11 +839,11 @@ void TemplatedDecodeSortKey(DecodeSortKeyData &decode_data, SortKeyVectorData &v
 		FlatVector::Validity(result).SetInvalid(result_idx);
 		return;
 	}
-	idx_t increment = OP::Decode(decode_data.data + decode_data.position, result, result_idx, decode_data.flip_bytes);
+	idx_t increment = OP::Decode(decode_data.data + decode_data.position, result, result_idx, vector_data.flip_bytes);
 	decode_data.position += increment;
 }
 
-void DecodeSortKeyStruct(DecodeSortKeyData &decode_data, SortKeyVectorData &vector_data, Vector &result,
+void DecodeSortKeyStruct(DecodeSortKeyData &decode_data, DecodeSortKeyVectorData &vector_data, Vector &result,
                          idx_t result_idx) {
 	// check if the top-level is valid or not
 	auto validity_byte = decode_data.data[decode_data.position];
@@ -805,11 +857,11 @@ void DecodeSortKeyStruct(DecodeSortKeyData &decode_data, SortKeyVectorData &vect
 	auto &child_entries = StructVector::GetEntries(result);
 	for (idx_t c = 0; c < child_entries.size(); c++) {
 		auto &child_entry = child_entries[c];
-		DecodeSortKeyRecursive(decode_data, *vector_data.child_data[c], *child_entry, result_idx);
+		DecodeSortKeyRecursive(decode_data, vector_data.child_data[c], *child_entry, result_idx);
 	}
 }
 
-void DecodeSortKeyList(DecodeSortKeyData &decode_data, SortKeyVectorData &vector_data, Vector &result,
+void DecodeSortKeyList(DecodeSortKeyData &decode_data, DecodeSortKeyVectorData &vector_data, Vector &result,
                        idx_t result_idx) {
 	// check if the top-level is valid or not
 	auto validity_byte = decode_data.data[decode_data.position];
@@ -823,7 +875,7 @@ void DecodeSortKeyList(DecodeSortKeyData &decode_data, SortKeyVectorData &vector
 	// we don't know how many there will be
 	// decode child elements until we encounter the list delimiter
 	auto list_delimiter = SortKeyVectorData::LIST_DELIMITER;
-	if (decode_data.flip_bytes) {
+	if (vector_data.flip_bytes) {
 		list_delimiter = ~list_delimiter;
 	}
 	auto list_data = FlatVector::GetData<list_entry_t>(result);
@@ -839,7 +891,7 @@ void DecodeSortKeyList(DecodeSortKeyData &decode_data, SortKeyVectorData &vector
 		ListVector::Reserve(result, new_list_size);
 
 		// now decode the entry
-		DecodeSortKeyRecursive(decode_data, *vector_data.child_data[0], child_vector, new_list_size - 1);
+		DecodeSortKeyRecursive(decode_data, vector_data.child_data[0], child_vector, new_list_size - 1);
 	}
 	// skip the list delimiter
 	decode_data.position++;
@@ -849,7 +901,7 @@ void DecodeSortKeyList(DecodeSortKeyData &decode_data, SortKeyVectorData &vector
 	ListVector::SetListSize(result, new_list_size);
 }
 
-void DecodeSortKeyArray(DecodeSortKeyData &decode_data, SortKeyVectorData &vector_data, Vector &result,
+void DecodeSortKeyArray(DecodeSortKeyData &decode_data, DecodeSortKeyVectorData &vector_data, Vector &result,
                         idx_t result_idx) {
 	// check if the top-level is valid or not
 	auto validity_byte = decode_data.data[decode_data.position];
@@ -864,7 +916,7 @@ void DecodeSortKeyArray(DecodeSortKeyData &decode_data, SortKeyVectorData &vecto
 	// however the decoded data still contains a list delimiter
 	// we use this delimiter to verify we successfully decoded the entire array
 	auto list_delimiter = SortKeyVectorData::LIST_DELIMITER;
-	if (decode_data.flip_bytes) {
+	if (vector_data.flip_bytes) {
 		list_delimiter = ~list_delimiter;
 	}
 	auto &child_vector = ArrayVector::GetEntry(result);
@@ -880,7 +932,7 @@ void DecodeSortKeyArray(DecodeSortKeyData &decode_data, SortKeyVectorData &vecto
 			break;
 		}
 		// now decode the entry
-		DecodeSortKeyRecursive(decode_data, *vector_data.child_data[0], child_vector, child_start + found_elements - 1);
+		DecodeSortKeyRecursive(decode_data, vector_data.child_data[0], child_vector, child_start + found_elements - 1);
 	}
 	// skip the list delimiter
 	decode_data.position++;
@@ -890,7 +942,7 @@ void DecodeSortKeyArray(DecodeSortKeyData &decode_data, SortKeyVectorData &vecto
 	}
 }
 
-void DecodeSortKeyRecursive(DecodeSortKeyData &decode_data, SortKeyVectorData &vector_data, Vector &result,
+void DecodeSortKeyRecursive(DecodeSortKeyData &decode_data, DecodeSortKeyVectorData &vector_data, Vector &result,
                             idx_t result_idx) {
 	switch (result.GetType().InternalType()) {
 	case PhysicalType::BOOL:
@@ -936,7 +988,7 @@ void DecodeSortKeyRecursive(DecodeSortKeyData &decode_data, SortKeyVectorData &v
 		TemplatedDecodeSortKey<SortKeyConstantOperator<hugeint_t>>(decode_data, vector_data, result, result_idx);
 		break;
 	case PhysicalType::VARCHAR:
-		if (vector_data.vec.GetType().id() == LogicalTypeId::VARCHAR) {
+		if (result.GetType().id() == LogicalTypeId::VARCHAR) {
 			TemplatedDecodeSortKey<SortKeyVarcharOperator>(decode_data, vector_data, result, result_idx);
 		} else {
 			TemplatedDecodeSortKey<SortKeyBlobOperator>(decode_data, vector_data, result, result_idx);
@@ -952,17 +1004,28 @@ void DecodeSortKeyRecursive(DecodeSortKeyData &decode_data, SortKeyVectorData &v
 		DecodeSortKeyArray(decode_data, vector_data, result, result_idx);
 		break;
 	default:
-		throw NotImplementedException("Unsupported type %s in DecodeSortKey", vector_data.vec.GetType());
+		throw NotImplementedException("Unsupported type %s in DecodeSortKey", result.GetType());
 	}
 }
 
 void CreateSortKeyHelpers::DecodeSortKey(string_t sort_key, Vector &result, idx_t result_idx,
                                          OrderModifiers modifiers) {
-	SortKeyVectorData sort_key_data(result, 0, modifiers);
-	DecodeSortKeyData decode_data(modifiers, sort_key);
+	DecodeSortKeyVectorData sort_key_data(result.GetType(), modifiers);
+	DecodeSortKeyData decode_data(sort_key);
 	DecodeSortKeyRecursive(decode_data, sort_key_data, result, result_idx);
 }
 
+void CreateSortKeyHelpers::DecodeSortKey(string_t sort_key, DataChunk &result, idx_t result_idx,
+                                         const vector<OrderModifiers> &modifiers) {
+	DecodeSortKeyData decode_data(sort_key);
+	D_ASSERT(modifiers.size() == result.ColumnCount());
+	for (idx_t c = 0; c < result.ColumnCount(); c++) {
+		auto &vec = result.data[c];
+		DecodeSortKeyVectorData vector_data(vec.GetType(), modifiers[c]);
+		DecodeSortKeyRecursive(decode_data, vector_data, vec, result_idx);
+	}
+}
+
 ScalarFunction CreateSortKeyFun::GetFunction() {
 	ScalarFunction sort_key_function("create_sort_key", {LogicalType::ANY}, LogicalType::BLOB, CreateSortKeyFunction,
 	                                 CreateSortKeyBind);

package/src/duckdb/src/{core_functions → function}/scalar/date/strftime.cpp

@@ -4,7 +4,7 @@
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/core_functions/scalar/date_functions.hpp"
+#include "duckdb/function/scalar/date_functions.hpp"
 
 #include <cctype>
 #include <utility>
@@ -94,7 +94,7 @@ static void StrfTimeFunctionTimestampNS(DataChunk &args, ExpressionState &state,
 }
 
 ScalarFunctionSet StrfTimeFun::GetFunctions() {
-	ScalarFunctionSet strftime;
+	ScalarFunctionSet strftime("strftime");
 
 	strftime.AddFunction(ScalarFunction({LogicalType::DATE, LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	                                    StrfTimeFunctionDate<false>, StrfTimeBindFunction<false>));
@@ -296,23 +296,25 @@ struct StrpTimeFunction {
 };
 
 ScalarFunctionSet StrpTimeFun::GetFunctions() {
-	ScalarFunctionSet strptime;
+	ScalarFunctionSet strptime("strptime");
 
 	const auto list_type = LogicalType::LIST(LogicalType::VARCHAR);
 	auto fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::TIMESTAMP,
 	                          StrpTimeFunction::Parse<timestamp_t>, StrpTimeFunction::Bind);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	BaseScalarFunction::SetReturnsError(fun);
 	strptime.AddFunction(fun);
 
 	fun = ScalarFunction({LogicalType::VARCHAR, list_type}, LogicalType::TIMESTAMP,
 	                     StrpTimeFunction::Parse<timestamp_t>, StrpTimeFunction::Bind);
+	BaseScalarFunction::SetReturnsError(fun);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	strptime.AddFunction(fun);
 	return strptime;
 }
 
 ScalarFunctionSet TryStrpTimeFun::GetFunctions() {
-	ScalarFunctionSet try_strptime;
+	ScalarFunctionSet try_strptime("try_strptime");
 
 	const auto list_type = LogicalType::LIST(LogicalType::VARCHAR);
 	auto fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::TIMESTAMP,

package/src/duckdb/src/function/scalar/generic/constant_or_null.cpp

@@ -1,3 +1,4 @@
+#include "duckdb/function/scalar/generic_common.hpp"
 #include "duckdb/function/scalar/generic_functions.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
 #include "duckdb/execution/expression_executor.hpp"
@@ -65,10 +66,6 @@ static void ConstantOrNullFunction(DataChunk &args, ExpressionState &state, Vect
 	}
 }
 
-ScalarFunction ConstantOrNull::GetFunction(const LogicalType &return_type) {
-	return ScalarFunction("constant_or_null", {return_type, LogicalType::ANY}, return_type, ConstantOrNullFunction);
-}
-
 unique_ptr<FunctionData> ConstantOrNull::Bind(Value value) {
 	return make_uniq<ConstantOrNullBindData>(std::move(value));
 }
@@ -97,11 +94,12 @@ unique_ptr<FunctionData> ConstantOrNullBind(ClientContext &context, ScalarFuncti
 	return make_uniq<ConstantOrNullBindData>(std::move(value));
 }
 
-void ConstantOrNull::RegisterFunction(BuiltinFunctions &set) {
-	auto fun = ConstantOrNull::GetFunction(LogicalType::ANY);
+ScalarFunction ConstantOrNullFun::GetFunction() {
+	auto fun = ScalarFunction("constant_or_null", {LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY,
+	                          ConstantOrNullFunction);
 	fun.bind = ConstantOrNullBind;
 	fun.varargs = LogicalType::ANY;
-	set.AddFunction(fun);
+	return fun;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{core_functions → function}/scalar/generic/error.cpp

@@ -1,4 +1,5 @@
-#include "duckdb/core_functions/scalar/generic_functions.hpp"
+#include "duckdb/function/scalar/generic_functions.hpp"
+
 #include <iostream>
 
 namespace duckdb {
@@ -15,6 +16,7 @@ ScalarFunction ErrorFun::GetFunction() {
 	                          ScalarFunction::UnaryFunction<string_t, int32_t, ErrorOperator>);
 	// Set the function with side effects to avoid the optimization.
 	fun.stability = FunctionStability::VOLATILE;
+	BaseScalarFunction::SetReturnsError(fun);
 	return fun;
 }
 

package/src/duckdb/src/function/scalar/generic/getvariable.cpp

@@ -49,10 +49,10 @@ unique_ptr<Expression> BindGetVariableExpression(FunctionBindExpressionInput &in
 	return make_uniq<BoundConstantExpression>(bind_data.value);
 }
 
-void GetVariableFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction GetVariableFun::GetFunction() {
 	ScalarFunction getvar("getvariable", {LogicalType::VARCHAR}, LogicalType::ANY, nullptr, GetVariableBind, nullptr);
 	getvar.bind_expression = BindGetVariableExpression;
-	set.AddFunction(getvar);
+	return getvar;
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/scalar/list/contains_or_position.cpp

@@ -1,3 +1,4 @@
+#include "duckdb/function/scalar/list_functions.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
@@ -66,11 +67,4 @@ ScalarFunction ListPositionFun::GetFunction() {
 	                      ListSearchFunction<true>, ListSearchBind);
 }
 
-void ListContainsFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"list_contains", "array_contains", "list_has", "array_has"}, GetFunction());
-}
-
-void ListPositionFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"list_position", "list_indexof", "array_position", "array_indexof"}, GetFunction());
-}
 } // namespace duckdb

package/src/duckdb/src/function/scalar/list/list_extract.cpp

@@ -4,7 +4,8 @@
 #include "duckdb/common/uhugeint.hpp"
 #include "duckdb/common/vector_operations/binary_executor.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/function/scalar/string_common.hpp"
+#include "duckdb/function/scalar/list_functions.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
@@ -105,9 +106,8 @@ static void ExecuteListExtract(Vector &result, Vector &list, Vector &offsets, co
 
 static void ExecuteStringExtract(Vector &result, Vector &input_vector, Vector &subscript_vector, const idx_t count) {
 	BinaryExecutor::Execute<string_t, int64_t, string_t>(
-	    input_vector, subscript_vector, result, count, [&](string_t input_string, int64_t subscript) {
-		    return SubstringFun::SubstringUnicode(result, input_string, subscript, 1);
-	    });
+	    input_vector, subscript_vector, result, count,
+	    [&](string_t input_string, int64_t subscript) { return SubstringUnicode(result, input_string, subscript, 1); });
 }
 
 static void ListExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
@@ -156,29 +156,35 @@ static unique_ptr<BaseStatistics> ListExtractStats(ClientContext &context, Funct
 	return child_copy.ToUnique();
 }
 
-void ListExtractFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunctionSet ListExtractFun::GetFunctions() {
+	ScalarFunctionSet list_extract_set("list_extract");
+
+	// the arguments and return types are actually set in the binder function
+	ScalarFunction lfun({LogicalType::LIST(LogicalType::ANY), LogicalType::BIGINT}, LogicalType::ANY,
+	                    ListExtractFunction, ListExtractBind, nullptr, ListExtractStats);
+
+	ScalarFunction sfun({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR, ListExtractFunction);
+	BaseScalarFunction::SetReturnsError(lfun);
+	BaseScalarFunction::SetReturnsError(sfun);
+	list_extract_set.AddFunction(lfun);
+	list_extract_set.AddFunction(sfun);
+	return list_extract_set;
+}
+
+ScalarFunctionSet ArrayExtractFun::GetFunctions() {
+	ScalarFunctionSet array_extract_set("array_extract");
+
 	// the arguments and return types are actually set in the binder function
 	ScalarFunction lfun({LogicalType::LIST(LogicalType::ANY), LogicalType::BIGINT}, LogicalType::ANY,
 	                    ListExtractFunction, ListExtractBind, nullptr, ListExtractStats);
 
 	ScalarFunction sfun({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR, ListExtractFunction);
 
-	ScalarFunctionSet list_extract("list_extract");
-	list_extract.AddFunction(lfun);
-	list_extract.AddFunction(sfun);
-	set.AddFunction(list_extract);
-
-	ScalarFunctionSet list_element("list_element");
-	list_element.AddFunction(lfun);
-	list_element.AddFunction(sfun);
-	set.AddFunction(list_element);
-
-	ScalarFunctionSet array_extract("array_extract");
-	array_extract.AddFunction(lfun);
-	array_extract.AddFunction(sfun);
-	array_extract.AddFunction(StructExtractFun::KeyExtractFunction());
-	array_extract.AddFunction(StructExtractFun::IndexExtractFunction());
-	set.AddFunction(array_extract);
+	array_extract_set.AddFunction(lfun);
+	array_extract_set.AddFunction(sfun);
+	array_extract_set.AddFunction(GetKeyExtractFunction());
+	array_extract_set.AddFunction(GetIndexExtractFunction());
+	return array_extract_set;
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/scalar/list/list_resize.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/function/scalar/list_functions.hpp"
 #include "duckdb/function/scalar_function.hpp"
 #include "duckdb/function/built_in_functions.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
@@ -154,24 +155,19 @@ static unique_ptr<FunctionData> ListResizeBind(ClientContext &context, ScalarFun
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
-void ListResizeFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunctionSet ListResizeFun::GetFunctions() {
 	ScalarFunction simple_fun({LogicalType::LIST(LogicalTypeId::ANY), LogicalTypeId::ANY},
 	                          LogicalType::LIST(LogicalTypeId::ANY), ListResizeFunction, ListResizeBind);
 	simple_fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-
+	BaseScalarFunction::SetReturnsError(simple_fun);
 	ScalarFunction default_value_fun({LogicalType::LIST(LogicalTypeId::ANY), LogicalTypeId::ANY, LogicalTypeId::ANY},
 	                                 LogicalType::LIST(LogicalTypeId::ANY), ListResizeFunction, ListResizeBind);
 	default_value_fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-
-	ScalarFunctionSet list_resize("list_resize");
-	list_resize.AddFunction(simple_fun);
-	list_resize.AddFunction(default_value_fun);
-	set.AddFunction(list_resize);
-
-	ScalarFunctionSet array_resize("array_resize");
-	array_resize.AddFunction(simple_fun);
-	array_resize.AddFunction(default_value_fun);
-	set.AddFunction(array_resize);
+	BaseScalarFunction::SetReturnsError(default_value_fun);
+	ScalarFunctionSet list_resize_set("list_resize");
+	list_resize_set.AddFunction(simple_fun);
+	list_resize_set.AddFunction(default_value_fun);
+	return list_resize_set;
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/scalar/list/list_select.cpp

@@ -4,6 +4,7 @@
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/function/scalar/list_functions.hpp"
 
 namespace duckdb {
 
@@ -179,8 +180,4 @@ ScalarFunction ListSelectFun::GetFunction() {
 	return fun;
 }
 
-void ListSelectFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"list_select", "array_select"}, ListSelectFun::GetFunction());
-	set.AddFunction({"list_where", "array_where"}, ListWhereFun::GetFunction());
-}
 } // namespace duckdb

package/src/duckdb/src/function/scalar/list/list_zip.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/function/scalar/list_functions.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
@@ -111,7 +112,7 @@ static void ListZipFunction(DataChunk &args, ExpressionState &state, Vector &res
 		offset += len;
 	}
 	for (idx_t child_idx = 0; child_idx < args_size; child_idx++) {
-		if (!(args.data[child_idx].GetType() == LogicalType::SQLNULL)) {
+		if (args.data[child_idx].GetType() != LogicalType::SQLNULL) {
 			struct_entries[child_idx]->Slice(ListVector::GetEntry(args.data[child_idx]), selections[child_idx],
 			                                 result_size);
 		}
@@ -131,7 +132,9 @@ static unique_ptr<FunctionData> ListZipBind(ClientContext &context, ScalarFuncti
 		throw BinderException("Provide at least one argument to " + bound_function.name);
 	}
 	if (arguments[size - 1]->return_type.id() == LogicalTypeId::BOOLEAN) {
-		size--;
+		if (--size == 0) {
+			throw BinderException("Provide at least one list argument to " + bound_function.name);
+		}
 	}
 
 	case_insensitive_set_t struct_names;
@@ -160,11 +163,8 @@ ScalarFunction ListZipFun::GetFunction() {
 
 	auto fun = ScalarFunction({}, LogicalType::LIST(LogicalTypeId::STRUCT), ListZipFunction, ListZipBind);
 	fun.varargs = LogicalType::ANY;
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING; // Special handling needed?
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	return fun;
 }
 
-void ListZipFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"list_zip", "array_zip"}, GetFunction());
-}
 } // namespace duckdb

package/src/duckdb/src/{core_functions → function}/scalar/map/map_contains.cpp

@@ -1,6 +1,6 @@
-#include "duckdb/core_functions/scalar/map_functions.hpp"
 #include "duckdb/function/scalar/list/contains_or_position.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/function/scalar/map_functions.hpp"
 
 namespace duckdb {
 
@@ -48,9 +48,9 @@ static unique_ptr<FunctionData> MapContainsBind(ClientContext &context, ScalarFu
 }
 
 ScalarFunction MapContainsFun::GetFunction() {
-
 	ScalarFunction fun("map_contains", {LogicalType::MAP(LogicalType::ANY, LogicalType::ANY), LogicalType::ANY},
 	                   LogicalType::BOOLEAN, MapContainsFunction, MapContainsBind);
 	return fun;
 }
+
 } // namespace duckdb

package/src/duckdb/src/function/scalar/nested_functions.cpp

@@ -37,15 +37,4 @@ void MapUtil::ReinterpretMap(Vector &result, Vector &input, idx_t count) {
 	result.SetVectorType(input.GetVectorType());
 }
 
-void BuiltinFunctions::RegisterNestedFunctions() {
-	Register<StructExtractFun>();
-	Register<ListConcatFun>();
-	Register<ListContainsFun>();
-	Register<ListPositionFun>();
-	Register<ListExtractFun>();
-	Register<ListResizeFun>();
-	Register<ListZipFun>();
-	Register<ListSelectFun>();
-}
-
 } // namespace duckdb

package/src/duckdb/src/function/scalar/{operators → operator}/add.cpp

@@ -90,7 +90,8 @@ template <>
 timestamp_t AddOperator::Operation(date_t left, interval_t right) {
 	if (left == date_t::infinity()) {
 		return timestamp_t::infinity();
-	} else if (left == date_t::ninfinity()) {
+	}
+	if (left == date_t::ninfinity()) {
 		return timestamp_t::ninfinity();
 	}
 	return Interval::Add(Timestamp::FromDatetime(left, dtime_t(0)), right);