duckdb 0.7.2-dev2740.0 → 0.7.2-dev2867.0

package/src/duckdb/src/{function → core_functions}/scalar/list/array_slice.cpp

@@ -1,6 +1,6 @@
+#include "duckdb/core_functions/scalar/list_functions.hpp"
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/chunk_collection.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
@@ -9,16 +9,6 @@
 
 namespace duckdb {
 
-template <typename INPUT_TYPE, typename INDEX_TYPE>
-INDEX_TYPE ValueOffset(const INPUT_TYPE &value) {
-	return 0;
-}
-
-template <>
-int64_t ValueOffset(const list_entry_t &value) {
-	return value.offset;
-}
-
 template <typename INPUT_TYPE, typename INDEX_TYPE>
 INDEX_TYPE ValueLength(const INPUT_TYPE &value) {
 	return 0;
@@ -190,13 +180,13 @@ static unique_ptr<FunctionData> ArraySliceBind(ClientContext &context, ScalarFun
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
-void ArraySliceFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction ListSliceFun::GetFunction() {
 	// the arguments and return types are actually set in the binder function
 	ScalarFunction fun({LogicalType::ANY, LogicalType::BIGINT, LogicalType::BIGINT}, LogicalType::ANY,
 	                   ArraySliceFunction, ArraySliceBind);
 	fun.varargs = LogicalType::ANY;
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction({"array_slice", "list_slice"}, fun);
+	return fun;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/scalar/list/flatten.cpp

@@ -1,7 +1,8 @@
+#include "duckdb/core_functions/scalar/list_functions.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/storage/statistics/list_stats.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
 
 namespace duckdb {
 
@@ -127,10 +128,9 @@ static unique_ptr<BaseStatistics> ListFlattenStats(ClientContext &context, Funct
 	return child_copy.ToUnique();
 }
 
-void ListFlattenFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction fun({LogicalType::LIST(LogicalType::LIST(LogicalType::ANY))}, LogicalType::LIST(LogicalType::ANY),
-	                   ListFlattenFunction, ListFlattenBind, nullptr, ListFlattenStats);
-	set.AddFunction({"flatten"}, fun);
+ScalarFunction ListFlattenFun::GetFunction() {
+	return ScalarFunction({LogicalType::LIST(LogicalType::LIST(LogicalType::ANY))}, LogicalType::LIST(LogicalType::ANY),
+	                      ListFlattenFunction, ListFlattenBind, nullptr, ListFlattenStats);
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/scalar/list/list_aggregates.cpp

@@ -1,7 +1,8 @@
+#include "duckdb/core_functions/scalar/list_functions.hpp"
+#include "duckdb/core_functions/aggregate/nested_functions.hpp"
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
 #include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/aggregate/nested_functions.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
@@ -506,16 +507,4 @@ ScalarFunction ListUniqueFun::GetFunction() {
 	                      ListUniqueBind);
 }
 
-void ListAggregateFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"list_aggregate", "array_aggregate", "list_aggr", "array_aggr", "aggregate"}, GetFunction());
-}
-
-void ListDistinctFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"list_distinct", "array_distinct"}, GetFunction());
-}
-
-void ListUniqueFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"list_unique", "array_unique"}, GetFunction());
-}
-
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/scalar/list/list_lambdas.cpp

@@ -1,3 +1,4 @@
+#include "duckdb/core_functions/scalar/list_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
@@ -377,38 +378,22 @@ static unique_ptr<FunctionData> ListFilterBind(ClientContext &context, ScalarFun
 	return ListLambdaBind<1>(context, bound_function, arguments);
 }
 
-void ListTransformFun::RegisterFunction(BuiltinFunctions &set) {
-
-	ScalarFunction fun("list_transform", {LogicalType::LIST(LogicalType::ANY), LogicalType::LAMBDA},
-	                   LogicalType::LIST(LogicalType::ANY), ListTransformFunction, ListTransformBind, nullptr, nullptr);
+ScalarFunction ListTransformFun::GetFunction() {
+	ScalarFunction fun({LogicalType::LIST(LogicalType::ANY), LogicalType::LAMBDA}, LogicalType::LIST(LogicalType::ANY),
+	                   ListTransformFunction, ListTransformBind, nullptr, nullptr);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.serialize = ListLambdaBindData::Serialize;
 	fun.deserialize = ListLambdaBindData::Deserialize;
-	set.AddFunction(fun);
-
-	fun.name = "array_transform";
-	set.AddFunction(fun);
-	fun.name = "list_apply";
-	set.AddFunction(fun);
-	fun.name = "array_apply";
-	set.AddFunction(fun);
-	fun.name = "apply";
-	set.AddFunction(fun);
+	return fun;
 }
 
-void ListFilterFun::RegisterFunction(BuiltinFunctions &set) {
-
-	ScalarFunction fun("list_filter", {LogicalType::LIST(LogicalType::ANY), LogicalType::LAMBDA},
-	                   LogicalType::LIST(LogicalType::ANY), ListFilterFunction, ListFilterBind, nullptr, nullptr);
+ScalarFunction ListFilterFun::GetFunction() {
+	ScalarFunction fun({LogicalType::LIST(LogicalType::ANY), LogicalType::LAMBDA}, LogicalType::LIST(LogicalType::ANY),
+	                   ListFilterFunction, ListFilterBind, nullptr, nullptr);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.serialize = ListLambdaBindData::Serialize;
 	fun.deserialize = ListLambdaBindData::Deserialize;
-	set.AddFunction(fun);
-
-	fun.name = "array_filter";
-	set.AddFunction(fun);
-	fun.name = "filter";
-	set.AddFunction(fun);
+	return fun;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/scalar/list/list_sort.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/core_functions/scalar/list_functions.hpp"
 #include "duckdb/common/serializer/enum_serializer.hpp"
 #include "duckdb/common/types/chunk_collection.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
@@ -298,10 +298,7 @@ static unique_ptr<FunctionData> ListReverseSortBind(ClientContext &context, Scal
 	return ListSortBind(context, bound_function, arguments, order, null_order);
 }
 
-void ListSortFun::RegisterFunction(BuiltinFunctions &set) {
-
-	// normal sort
-
+ScalarFunctionSet ListSortFun::GetFunctions() {
 	// one parameter: list
 	ScalarFunction sort({LogicalType::LIST(LogicalType::ANY)}, LogicalType::LIST(LogicalType::ANY), ListSortFunction,
 	                    ListNormalSortBind);
@@ -314,20 +311,14 @@ void ListSortFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunction sort_orders({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR, LogicalType::VARCHAR},
 	                           LogicalType::LIST(LogicalType::ANY), ListSortFunction, ListNormalSortBind);
 
-	ScalarFunctionSet list_sort("list_sort");
+	ScalarFunctionSet list_sort;
 	list_sort.AddFunction(sort);
 	list_sort.AddFunction(sort_order);
 	list_sort.AddFunction(sort_orders);
-	set.AddFunction(list_sort);
-
-	ScalarFunctionSet array_sort("array_sort");
-	array_sort.AddFunction(sort);
-	array_sort.AddFunction(sort_order);
-	array_sort.AddFunction(sort_orders);
-	set.AddFunction(array_sort);
-
-	// reverse sort
+	return list_sort;
+}
 
+ScalarFunctionSet ListReverseSortFun::GetFunctions() {
 	// one parameter: list
 	ScalarFunction sort_reverse({LogicalType::LIST(LogicalType::ANY)}, LogicalType::LIST(LogicalType::ANY),
 	                            ListSortFunction, ListReverseSortBind);
@@ -336,15 +327,10 @@ void ListSortFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunction sort_reverse_null_order({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR},
 	                                       LogicalType::LIST(LogicalType::ANY), ListSortFunction, ListReverseSortBind);
 
-	ScalarFunctionSet list_reverse_sort("list_reverse_sort");
+	ScalarFunctionSet list_reverse_sort;
 	list_reverse_sort.AddFunction(sort_reverse);
 	list_reverse_sort.AddFunction(sort_reverse_null_order);
-	set.AddFunction(list_reverse_sort);
-
-	ScalarFunctionSet array_reverse_sort("array_reverse_sort");
-	array_reverse_sort.AddFunction(sort_reverse);
-	array_reverse_sort.AddFunction(sort_reverse_null_order);
-	set.AddFunction(array_reverse_sort);
+	return list_reverse_sort;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/scalar/list/list_value.cpp

@@ -1,11 +1,12 @@
+#include "duckdb/core_functions/scalar/list_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/pair.hpp"
 #include "duckdb/storage/statistics/list_stats.hpp"
 #include "duckdb/planner/expression_binder.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
 
 namespace duckdb {
 
@@ -57,15 +58,13 @@ unique_ptr<BaseStatistics> ListValueStats(ClientContext &context, FunctionStatis
 	return list_stats.ToUnique();
 }
 
-void ListValueFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction ListValueFun::GetFunction() {
 	// the arguments and return types are actually set in the binder function
 	ScalarFunction fun("list_value", {}, LogicalTypeId::LIST, ListValueFunction, ListValueBind, nullptr,
 	                   ListValueStats);
 	fun.varargs = LogicalType::ANY;
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(fun);
-	fun.name = "list_pack";
-	set.AddFunction(fun);
+	return fun;
 }
 
 } // namespace duckdb

package/src/duckdb/src/{function → core_functions}/scalar/list/range.cpp

@@ -1,5 +1,5 @@
+#include "duckdb/core_functions/scalar/list_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/common/types/timestamp.hpp"
@@ -239,9 +239,9 @@ static void ListRangeFunction(DataChunk &args, ExpressionState &state, Vector &r
 	result.Verify(args.size());
 }
 
-void ListRangeFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunctionSet ListRangeFun::GetFunctions() {
 	// the arguments and return types are actually set in the binder function
-	ScalarFunctionSet range_set("range");
+	ScalarFunctionSet range_set;
 	range_set.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::LIST(LogicalType::BIGINT),
 	                                     ListRangeFunction<NumericRangeInfo, false>));
 	range_set.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT},
@@ -253,9 +253,11 @@ void ListRangeFun::RegisterFunction(BuiltinFunctions &set) {
 	range_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL},
 	                                     LogicalType::LIST(LogicalType::TIMESTAMP),
 	                                     ListRangeFunction<TimestampRangeInfo, false>));
-	set.AddFunction(range_set);
+	return range_set;
+}
 
-	ScalarFunctionSet generate_series("generate_series");
+ScalarFunctionSet GenerateSeriesFun::GetFunctions() {
+	ScalarFunctionSet generate_series;
 	generate_series.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::LIST(LogicalType::BIGINT),
 	                                           ListRangeFunction<NumericRangeInfo, true>));
 	generate_series.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT},
@@ -267,7 +269,7 @@ void ListRangeFun::RegisterFunction(BuiltinFunctions &set) {
 	generate_series.AddFunction(ScalarFunction({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL},
 	                                           LogicalType::LIST(LogicalType::TIMESTAMP),
 	                                           ListRangeFunction<TimestampRangeInfo, true>));
-	set.AddFunction(generate_series);
+	return generate_series;
 }
 
 } // namespace duckdb

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

@@ -1,8 +1,9 @@
+#include "duckdb/core_functions/scalar/map_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
 
 namespace duckdb {
 
@@ -39,11 +40,11 @@ static unique_ptr<FunctionData> CardinalityBind(ClientContext &context, ScalarFu
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
-void CardinalityFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction fun("cardinality", {LogicalType::ANY}, LogicalType::UBIGINT, CardinalityFunction, CardinalityBind);
+ScalarFunction CardinalityFun::GetFunction() {
+	ScalarFunction fun({LogicalType::ANY}, LogicalType::UBIGINT, CardinalityFunction, CardinalityBind);
 	fun.varargs = LogicalType::ANY;
 	fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING;
-	set.AddFunction(fun);
+	return fun;
 }
 
 } // namespace duckdb

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

@@ -1,71 +1,14 @@
+#include "duckdb/core_functions/scalar/map_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/types/value_map.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
 
 namespace duckdb {
 
-MapInvalidReason CheckMapValidity(Vector &map, idx_t count, const SelectionVector &sel) {
-	D_ASSERT(map.GetType().id() == LogicalTypeId::MAP);
-	UnifiedVectorFormat map_vdata;
-
-	map.ToUnifiedFormat(count, map_vdata);
-	auto &map_validity = map_vdata.validity;
-
-	auto list_data = ListVector::GetData(map);
-	auto &keys = MapVector::GetKeys(map);
-	UnifiedVectorFormat key_vdata;
-	keys.ToUnifiedFormat(count, key_vdata);
-	auto &key_validity = key_vdata.validity;
-
-	for (idx_t row = 0; row < count; row++) {
-		auto mapped_row = sel.get_index(row);
-		auto row_idx = map_vdata.sel->get_index(mapped_row);
-		// map is allowed to be NULL
-		if (!map_validity.RowIsValid(row_idx)) {
-			continue;
-		}
-		row_idx = key_vdata.sel->get_index(row);
-		value_set_t unique_keys;
-		for (idx_t i = 0; i < list_data[row_idx].length; i++) {
-			auto index = list_data[row_idx].offset + i;
-			index = key_vdata.sel->get_index(index);
-			if (!key_validity.RowIsValid(index)) {
-				return MapInvalidReason::NULL_KEY;
-			}
-			auto value = keys.GetValue(index);
-			auto result = unique_keys.insert(value);
-			if (!result.second) {
-				return MapInvalidReason::DUPLICATE_KEY;
-			}
-		}
-	}
-	return MapInvalidReason::VALID;
-}
-
-void MapConversionVerify(Vector &vector, idx_t count) {
-	auto valid_check = CheckMapValidity(vector, count);
-	switch (valid_check) {
-	case MapInvalidReason::VALID:
-		break;
-	case MapInvalidReason::DUPLICATE_KEY: {
-		throw InvalidInputException("Map keys have to be unique");
-	}
-	case MapInvalidReason::NULL_KEY: {
-		throw InvalidInputException("Map keys can not be NULL");
-	}
-	case MapInvalidReason::NULL_KEY_LIST: {
-		throw InvalidInputException("The list of map keys is not allowed to be NULL");
-	}
-	default: {
-		throw InternalException("MapInvalidReason not implemented");
-	}
-	}
-}
-
 // Example:
 // source: [1,2,3], expansion_factor: 4
 // target (result): [1,2,3,1,2,3,1,2,3,1,2,3]
@@ -200,7 +143,7 @@ static void MapFunction(DataChunk &args, ExpressionState &state, Vector &result)
 		value_vector.Reference(ListVector::GetEntry(args.data[1]));
 	}
 
-	MapConversionVerify(result, args.size());
+	MapVector::MapConversionVerify(result, args.size());
 	result.Verify(args.size());
 }
 
@@ -234,12 +177,12 @@ static unique_ptr<FunctionData> MapBind(ClientContext &context, ScalarFunction &
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
-void MapFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction MapFun::GetFunction() {
 	//! the arguments and return types are actually set in the binder function
-	ScalarFunction fun("map", {}, LogicalTypeId::MAP, MapFunction, MapBind);
+	ScalarFunction fun({}, LogicalTypeId::MAP, MapFunction, MapBind);
 	fun.varargs = LogicalType::ANY;
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(fun);
+	return fun;
 }
 
 } // namespace duckdb

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

@@ -1,9 +1,10 @@
+#include "duckdb/core_functions/scalar/map_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/pair.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
 
 namespace duckdb {
 
@@ -50,12 +51,12 @@ static unique_ptr<FunctionData> MapEntriesBind(ClientContext &context, ScalarFun
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
-void MapEntriesFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction MapEntriesFun::GetFunction() {
 	//! the arguments and return types are actually set in the binder function
-	ScalarFunction fun("map_entries", {}, LogicalTypeId::LIST, MapEntriesFunction, MapEntriesBind);
+	ScalarFunction fun({}, LogicalTypeId::LIST, MapEntriesFunction, MapEntriesBind);
 	fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING;
 	fun.varargs = LogicalType::ANY;
-	set.AddFunction(fun);
+	return fun;
 }
 
 } // namespace duckdb

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

@@ -1,10 +1,28 @@
+#include "duckdb/core_functions/scalar/map_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
 
 namespace duckdb {
+
+struct MapKeyArgFunctor {
+	// MAP is a LIST(STRUCT(K,V))
+	// meaning the MAP itself is a List, but the child vector that we're interested in (the keys)
+	// are a level deeper than the initial child vector
+
+	static Vector &GetList(Vector &map) {
+		return map;
+	}
+	static idx_t GetListSize(Vector &map) {
+		return ListVector::GetListSize(map);
+	}
+	static Vector &GetEntry(Vector &map) {
+		return MapVector::GetKeys(map);
+	}
+};
+
 void FillResult(Vector &map, Vector &offsets, Vector &result, idx_t count) {
 	UnifiedVectorFormat map_data;
 	map.ToUnifiedFormat(count, map_data);
@@ -124,14 +142,11 @@ static unique_ptr<FunctionData> MapExtractBind(ClientContext &context, ScalarFun
 	return make_uniq<VariableReturnBindData>(value_type);
 }
 
-void MapExtractFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction fun("map_extract", {LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, MapExtractFunction,
-	                   MapExtractBind);
+ScalarFunction MapExtractFun::GetFunction() {
+	ScalarFunction fun({LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, MapExtractFunction, MapExtractBind);
 	fun.varargs = LogicalType::ANY;
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(fun);
-	fun.name = "element_at";
-	set.AddFunction(fun);
+	return fun;
 }
 
 } // namespace duckdb

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

@@ -1,8 +1,9 @@
+#include "duckdb/core_functions/scalar/map_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
 
 namespace duckdb {
 
@@ -11,7 +12,7 @@ static void MapFromEntriesFunction(DataChunk &args, ExpressionState &state, Vect
 
 	result.Reinterpret(args.data[0]);
 
-	MapConversionVerify(result, count);
+	MapVector::MapConversionVerify(result, count);
 	result.Verify(count);
 
 	if (args.AllConstant()) {
@@ -48,12 +49,12 @@ static unique_ptr<FunctionData> MapFromEntriesBind(ClientContext &context, Scala
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
-void MapFromEntriesFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction MapFromEntriesFun::GetFunction() {
 	//! the arguments and return types are actually set in the binder function
-	ScalarFunction fun("map_from_entries", {}, LogicalTypeId::MAP, MapFromEntriesFunction, MapFromEntriesBind);
+	ScalarFunction fun({}, LogicalTypeId::MAP, MapFromEntriesFunction, MapFromEntriesBind);
 	fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING;
 	fun.varargs = LogicalType::ANY;
-	set.AddFunction(fun);
+	return fun;
 }
 
 } // namespace duckdb

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

@@ -1,9 +1,10 @@
+#include "duckdb/core_functions/scalar/map_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/pair.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
 
 namespace duckdb {
 
@@ -79,19 +80,19 @@ static unique_ptr<FunctionData> MapValuesBind(ClientContext &context, ScalarFunc
 	return MapKeyValueBind(context, bound_function, arguments, MapType::ValueType);
 }
 
-void MapKeysFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction MapKeysFun::GetFunction() {
 	//! the arguments and return types are actually set in the binder function
-	ScalarFunction fun("map_keys", {}, LogicalTypeId::LIST, MapKeysFunction, MapKeysBind);
+	ScalarFunction fun({}, LogicalTypeId::LIST, MapKeysFunction, MapKeysBind);
 	fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING;
 	fun.varargs = LogicalType::ANY;
-	set.AddFunction(fun);
+	return fun;
 }
 
-void MapValuesFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction fun("map_values", {}, LogicalTypeId::LIST, MapValuesFunction, MapValuesBind);
+ScalarFunction MapValuesFun::GetFunction() {
+	ScalarFunction fun({}, LogicalTypeId::LIST, MapValuesFunction, MapValuesBind);
 	fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING;
 	fun.varargs = LogicalType::ANY;
-	set.AddFunction(fun);
+	return fun;
 }
 
 } // namespace duckdb