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

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/common/limits.hpp"
 #include "fmt/format.h"
@@ -152,20 +152,20 @@ static void PrintfFunction(DataChunk &args, ExpressionState &state, Vector &resu
 	}
 }
 
-void PrintfFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction PrintfFun::GetFunction() {
 	// duckdb_fmt::printf_context, duckdb_fmt::vsprintf
-	ScalarFunction printf_fun =
-	    ScalarFunction("printf", {LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                   PrintfFunction<FMTPrintf, duckdb_fmt::printf_context>, BindPrintfFunction);
+	ScalarFunction printf_fun({LogicalType::VARCHAR}, LogicalType::VARCHAR,
+	                          PrintfFunction<FMTPrintf, duckdb_fmt::printf_context>, BindPrintfFunction);
 	printf_fun.varargs = LogicalType::ANY;
-	set.AddFunction(printf_fun);
+	return printf_fun;
+}
 
+ScalarFunction FormatFun::GetFunction() {
 	// duckdb_fmt::format_context, duckdb_fmt::vformat
-	ScalarFunction format_fun =
-	    ScalarFunction("format", {LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                   PrintfFunction<FMTFormat, duckdb_fmt::format_context>, BindPrintfFunction);
+	ScalarFunction format_fun({LogicalType::VARCHAR}, LogicalType::VARCHAR,
+	                          PrintfFunction<FMTFormat, duckdb_fmt::format_context>, BindPrintfFunction);
 	format_fun.varargs = LogicalType::ANY;
-	set.AddFunction(format_fun);
+	return format_fun;
 }
 
 } // namespace duckdb

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/binary_executor.hpp"
@@ -33,11 +33,8 @@ static void RepeatFunction(DataChunk &args, ExpressionState &state, Vector &resu
 	    });
 }
 
-void RepeatFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("repeat",                                    // name of the function
-	                               {LogicalType::VARCHAR, LogicalType::BIGINT}, // argument list
-	                               LogicalType::VARCHAR,                        // return type
-	                               RepeatFunction));                            // pointer to function implementation
+ScalarFunction RepeatFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR, RepeatFunction);
 }
 
 } // namespace duckdb

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
@@ -76,12 +76,9 @@ static void ReplaceFunction(DataChunk &args, ExpressionState &state, Vector &res
 	    });
 }
 
-void ReplaceFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("replace",             // name of the function
-	                               {LogicalType::VARCHAR, // argument list
-	                                LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                               LogicalType::VARCHAR, // return type
-	                               ReplaceFunction));    // pointer to function implementation
+ScalarFunction ReplaceFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
+	                      ReplaceFunction);
 }
 
 } // namespace duckdb

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
@@ -49,8 +49,8 @@ static void ReverseFunction(DataChunk &args, ExpressionState &state, Vector &res
 	UnaryExecutor::ExecuteString<string_t, string_t, ReverseOperator>(args.data[0], result, args.size());
 }
 
-void ReverseFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("reverse", {LogicalType::VARCHAR}, LogicalType::VARCHAR, ReverseFunction));
+ScalarFunction ReverseFun::GetFunction() {
+	return ScalarFunction("reverse", {LogicalType::VARCHAR}, LogicalType::VARCHAR, ReverseFunction);
 }
 
 } // namespace duckdb

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
@@ -35,13 +35,9 @@ struct StartsWithOperator {
 	}
 };
 
-void StartsWithFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction starts_with =
-	    ScalarFunction("starts_with", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                   ScalarFunction::BinaryFunction<string_t, string_t, bool, StartsWithOperator>);
-	set.AddFunction(starts_with);
-	starts_with.name = "^@";
-	set.AddFunction(starts_with);
+ScalarFunction StartsWithOperatorFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
+	                      ScalarFunction::BinaryFunction<string_t, string_t, bool, StartsWithOperator>);
 }
 
 } // namespace duckdb

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

@@ -3,8 +3,9 @@
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/common/vector_size.hpp"
 #include "duckdb/function/scalar/regexp.hpp"
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/function/scalar/string_functions.hpp"
 
 namespace duckdb {
 
@@ -171,15 +172,17 @@ static void StringSplitRegexFunction(DataChunk &args, ExpressionState &state, Ve
 	}
 }
 
-void StringSplitFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction StringSplitFun::GetFunction() {
 	auto varchar_list_type = LogicalType::LIST(LogicalType::VARCHAR);
 
-	auto regular_fun =
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, varchar_list_type, StringSplitFunction);
-	regular_fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction({"string_split", "str_split", "string_to_array", "split"}, regular_fun);
+	ScalarFunction string_split({LogicalType::VARCHAR, LogicalType::VARCHAR}, varchar_list_type, StringSplitFunction);
+	string_split.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	return string_split;
+}
 
-	ScalarFunctionSet regexp_split("string_split_regex");
+ScalarFunctionSet StringSplitRegexFun::GetFunctions() {
+	auto varchar_list_type = LogicalType::LIST(LogicalType::VARCHAR);
+	ScalarFunctionSet regexp_split;
 	ScalarFunction regex_fun({LogicalType::VARCHAR, LogicalType::VARCHAR}, varchar_list_type, StringSplitRegexFunction,
 	                         RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
 	                         FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING);
@@ -187,10 +190,7 @@ void StringSplitFun::RegisterFunction(BuiltinFunctions &set) {
 	// regexp options
 	regex_fun.arguments.emplace_back(LogicalType::VARCHAR);
 	regexp_split.AddFunction(regex_fun);
-	for (auto &name : {"string_split_regex", "str_split_regex", "regexp_split_to_array"}) {
-		regexp_split.name = name;
-		set.AddFunction(regexp_split);
-	}
+	return regexp_split;
 }
 
 } // namespace duckdb

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
@@ -88,12 +88,9 @@ static void TranslateFunction(DataChunk &args, ExpressionState &state, Vector &r
 	    });
 }
 
-void TranslateFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("translate",           // name of the function
-	                               {LogicalType::VARCHAR, // argument list
-	                                LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                               LogicalType::VARCHAR, // return type
-	                               TranslateFunction));  // pointer to function implementation
+ScalarFunction TranslateFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
+	                      TranslateFunction);
 }
 
 } // namespace duckdb

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

@@ -1,4 +1,4 @@
-#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/core_functions/scalar/string_functions.hpp"
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
@@ -125,25 +125,30 @@ static void BinaryTrimFunction(DataChunk &input, ExpressionState &state, Vector
 	    });
 }
 
-void TrimFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet ltrim("ltrim");
-	ScalarFunctionSet rtrim("rtrim");
-	ScalarFunctionSet trim("trim");
-
-	ltrim.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, UnaryTrimFunction<true, false>));
-	rtrim.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, UnaryTrimFunction<false, true>));
+ScalarFunctionSet TrimFun::GetFunctions() {
+	ScalarFunctionSet trim;
 	trim.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, UnaryTrimFunction<true, true>));
 
+	trim.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
+	                                BinaryTrimFunction<true, true>));
+	return trim;
+}
+
+ScalarFunctionSet LtrimFun::GetFunctions() {
+	ScalarFunctionSet ltrim;
+	ltrim.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, UnaryTrimFunction<true, false>));
 	ltrim.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	                                 BinaryTrimFunction<true, false>));
+	return ltrim;
+}
+
+ScalarFunctionSet RtrimFun::GetFunctions() {
+	ScalarFunctionSet rtrim;
+	rtrim.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, UnaryTrimFunction<false, true>));
+
 	rtrim.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	                                 BinaryTrimFunction<false, true>));
-	trim.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                BinaryTrimFunction<true, true>));
-
-	set.AddFunction(ltrim);
-	set.AddFunction(rtrim);
-	set.AddFunction(trim);
+	return rtrim;
 }
 
 } // namespace duckdb

package/src/duckdb/src/core_functions/scalar/string/unicode.cpp

@@ -0,0 +1,28 @@
+#include "duckdb/core_functions/scalar/string_functions.hpp"
+
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
+#include "duckdb/common/vector_operations/unary_executor.hpp"
+#include "utf8proc.hpp"
+
+#include <string.h>
+
+namespace duckdb {
+
+struct UnicodeOperator {
+	template <class TA, class TR>
+	static inline TR Operation(const TA &input) {
+		auto str = reinterpret_cast<const utf8proc_uint8_t *>(input.GetData());
+		auto len = input.GetSize();
+		utf8proc_int32_t codepoint;
+		(void)utf8proc_iterate(str, len, &codepoint);
+		return codepoint;
+	}
+};
+
+ScalarFunction UnicodeFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::INTEGER,
+	                      ScalarFunction::UnaryFunction<string_t, int32_t, UnicodeOperator>);
+}
+
+} // namespace duckdb

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

@@ -1,3 +1,4 @@
+#include "duckdb/core_functions/scalar/struct_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
@@ -96,14 +97,13 @@ unique_ptr<BaseStatistics> StructInsertStats(ClientContext &context, FunctionSta
 	return new_struct_stats.ToUnique();
 }
 
-void StructInsertFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction StructInsertFun::GetFunction() {
 	// the arguments and return types are actually set in the binder function
-	ScalarFunction fun("struct_insert", {}, LogicalTypeId::STRUCT, StructInsertFunction, StructInsertBind, nullptr,
-	                   StructInsertStats);
+	ScalarFunction fun({}, LogicalTypeId::STRUCT, StructInsertFunction, StructInsertBind, nullptr, StructInsertStats);
 	fun.varargs = LogicalType::ANY;
 	fun.serialize = VariableReturnBindData::Serialize;
 	fun.deserialize = VariableReturnBindData::Deserialize;
-	set.AddFunction(fun);
+	return fun;
 }
 
 } // namespace duckdb

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

@@ -1,3 +1,4 @@
+#include "duckdb/core_functions/scalar/struct_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
@@ -68,7 +69,7 @@ unique_ptr<BaseStatistics> StructPackStats(ClientContext &context, FunctionStati
 	return struct_stats.ToUnique();
 }
 
-void StructPackFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction StructPackFun::GetFunction() {
 	// the arguments and return types are actually set in the binder function
 	ScalarFunction fun("struct_pack", {}, LogicalTypeId::STRUCT, StructPackFunction, StructPackBind, nullptr,
 	                   StructPackStats);
@@ -76,9 +77,7 @@ void StructPackFun::RegisterFunction(BuiltinFunctions &set) {
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.serialize = VariableReturnBindData::Serialize;
 	fun.deserialize = VariableReturnBindData::Deserialize;
-	set.AddFunction(fun);
-	fun.name = "row";
-	set.AddFunction(fun);
+	return fun;
 }
 
 } // namespace duckdb

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

@@ -1,6 +1,6 @@
+#include "duckdb/core_functions/scalar/union_functions.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 
@@ -97,14 +97,10 @@ static unique_ptr<FunctionData> UnionExtractBind(ClientContext &context, ScalarF
 	return make_uniq<UnionExtractBindData>(key, key_index, return_type);
 }
 
-void UnionExtractFun::RegisterFunction(BuiltinFunctions &set) {
+ScalarFunction UnionExtractFun::GetFunction() {
 	// the arguments and return types are actually set in the binder function
-	auto fun = ScalarFunction("union_extract", {LogicalTypeId::UNION, LogicalType::VARCHAR}, LogicalType::ANY,
-	                          UnionExtractFunction, UnionExtractBind, nullptr, nullptr);
-
-	ScalarFunctionSet extract("union_extract");
-	extract.AddFunction(fun);
-	set.AddFunction(extract);
+	return ScalarFunction({LogicalTypeId::UNION, LogicalType::VARCHAR}, LogicalType::ANY, UnionExtractFunction,
+	                      UnionExtractBind, nullptr, nullptr);
 }
 
 } // namespace duckdb

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

@@ -1,6 +1,6 @@
+#include "duckdb/core_functions/scalar/union_functions.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 
@@ -50,13 +50,9 @@ static void UnionTagFunction(DataChunk &args, ExpressionState &state, Vector &re
 	result.Reinterpret(UnionVector::GetTags(args.data[0]));
 }
 
-void UnionTagFun::RegisterFunction(BuiltinFunctions &set) {
-	auto fun = ScalarFunction("union_tag", {LogicalTypeId::UNION}, LogicalTypeId::ANY, UnionTagFunction, UnionTagBind,
-	                          nullptr, nullptr); // TODO: Statistics?
-
-	ScalarFunctionSet union_tag("union_tag");
-	union_tag.AddFunction(fun);
-	set.AddFunction(union_tag);
+ScalarFunction UnionTagFun::GetFunction() {
+	return ScalarFunction({LogicalTypeId::UNION}, LogicalTypeId::ANY, UnionTagFunction, UnionTagBind, nullptr,
+	                      nullptr); // TODO: Statistics?
 }
 
 } // namespace duckdb

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

@@ -1,3 +1,4 @@
+#include "duckdb/core_functions/scalar/union_functions.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
@@ -6,57 +7,6 @@
 
 namespace duckdb {
 
-UnionInvalidReason CheckUnionValidity(Vector &vector, idx_t count, const SelectionVector &sel) {
-	D_ASSERT(vector.GetType().id() == LogicalTypeId::UNION);
-	auto member_count = UnionType::GetMemberCount(vector.GetType());
-	if (member_count == 0) {
-		return UnionInvalidReason::NO_MEMBERS;
-	}
-
-	UnifiedVectorFormat union_vdata;
-	vector.ToUnifiedFormat(count, union_vdata);
-
-	UnifiedVectorFormat tags_vdata;
-	auto &tag_vector = UnionVector::GetTags(vector);
-	tag_vector.ToUnifiedFormat(count, tags_vdata);
-
-	// check that only one member is valid at a time
-	for (idx_t row_idx = 0; row_idx < count; row_idx++) {
-		auto union_mapped_row_idx = sel.get_index(row_idx);
-		if (!union_vdata.validity.RowIsValid(union_mapped_row_idx)) {
-			continue;
-		}
-
-		auto tag_mapped_row_idx = tags_vdata.sel->get_index(row_idx);
-		if (!tags_vdata.validity.RowIsValid(tag_mapped_row_idx)) {
-			continue;
-		}
-
-		auto tag = ((union_tag_t *)tags_vdata.data)[tag_mapped_row_idx];
-		if (tag >= member_count) {
-			return UnionInvalidReason::TAG_OUT_OF_RANGE;
-		}
-
-		bool found_valid = false;
-		for (idx_t member_idx = 0; member_idx < member_count; member_idx++) {
-
-			UnifiedVectorFormat member_vdata;
-			auto &member = UnionVector::GetMember(vector, member_idx);
-			member.ToUnifiedFormat(count, member_vdata);
-
-			auto mapped_row_idx = member_vdata.sel->get_index(row_idx);
-			if (member_vdata.validity.RowIsValid(mapped_row_idx)) {
-				if (found_valid) {
-					return UnionInvalidReason::VALIDITY_OVERLAP;
-				}
-				found_valid = true;
-			}
-		}
-	}
-
-	return UnionInvalidReason::VALID;
-}
-
 struct UnionValueBindData : public FunctionData {
 	UnionValueBindData() {
 	}
@@ -106,18 +56,13 @@ static unique_ptr<FunctionData> UnionValueBind(ClientContext &context, ScalarFun
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
-void UnionValueFun::RegisterFunction(BuiltinFunctions &set) {
-
-	auto fun =
-	    ScalarFunction("union_value", {}, LogicalTypeId::UNION, UnionValueFunction, UnionValueBind, nullptr, nullptr);
+ScalarFunction UnionValueFun::GetFunction() {
+	ScalarFunction fun("union_value", {}, LogicalTypeId::UNION, UnionValueFunction, UnionValueBind, nullptr, nullptr);
 	fun.varargs = LogicalType::ANY;
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.serialize = VariableReturnBindData::Serialize;
 	fun.deserialize = VariableReturnBindData::Deserialize;
-
-	ScalarFunctionSet union_value("union_value");
-	union_value.AddFunction(fun);
-	set.AddFunction(union_value);
+	return fun;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/persistent/base_csv_reader.cpp

@@ -9,7 +9,7 @@
 #include "duckdb/common/operator/decimal_cast_operators.hpp"
 #include "duckdb/common/vector_operations/unary_executor.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/scalar/strftime.hpp"
+#include "duckdb/function/scalar/strftime_format.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/parser/column_definition.hpp"
 #include "duckdb/storage/data_table.hpp"

package/src/duckdb/src/execution/operator/persistent/buffered_csv_reader.cpp

@@ -7,7 +7,7 @@
 #include "duckdb/common/types/cast_helpers.hpp"
 #include "duckdb/common/vector_operations/unary_executor.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/scalar/strftime.hpp"
+#include "duckdb/function/scalar/strftime_format.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/parser/column_definition.hpp"
 #include "duckdb/storage/data_table.hpp"

package/src/duckdb/src/execution/operator/persistent/parallel_csv_reader.cpp

@@ -7,7 +7,7 @@
 #include "duckdb/common/types/cast_helpers.hpp"
 #include "duckdb/common/vector_operations/unary_executor.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/scalar/strftime.hpp"
+#include "duckdb/function/scalar/strftime_format.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/parser/column_definition.hpp"
 #include "duckdb/storage/data_table.hpp"

package/src/duckdb/src/execution/operator/schema/physical_create_type.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
+#include "duckdb/common/string_map_set.hpp"
 
 namespace duckdb {
 
@@ -21,6 +22,7 @@ public:
 	Vector result;
 	idx_t size = 0;
 	idx_t capacity = STANDARD_VECTOR_SIZE;
+	string_set_t found_strings;
 };
 
 unique_ptr<GlobalSinkState> PhysicalCreateType::GetGlobalSinkState(ClientContext &context) const {
@@ -52,8 +54,15 @@ SinkResultType PhysicalCreateType::Sink(ExecutionContext &context, GlobalSinkSta
 		if (!sdata.validity.RowIsValid(idx)) {
 			throw InvalidInputException("Attempted to create ENUM type with NULL value!");
 		}
-		result_ptr[gstate.size++] =
-		    StringVector::AddStringOrBlob(gstate.result, src_ptr[idx].GetData(), src_ptr[idx].GetSize());
+		auto str = src_ptr[idx];
+		auto entry = gstate.found_strings.find(src_ptr[idx]);
+		if (entry != gstate.found_strings.end()) {
+			// entry was already found - skip
+			continue;
+		}
+		auto owned_string = StringVector::AddStringOrBlob(gstate.result, str.GetData(), str.GetSize());
+		gstate.found_strings.insert(owned_string);
+		result_ptr[gstate.size++] = owned_string;
 	}
 	return SinkResultType::NEED_MORE_INPUT;
 }

package/src/duckdb/src/function/aggregate/distributive_functions.cpp

@@ -7,26 +7,9 @@
 namespace duckdb {
 
 void BuiltinFunctions::RegisterDistributiveAggregates() {
-	Register<BitAndFun>();
-	Register<BitOrFun>();
-	Register<BitXorFun>();
-	Register<BitStringAggFun>();
 	Register<CountStarFun>();
 	Register<CountFun>();
 	Register<FirstFun>();
-	Register<MaxFun>();
-	Register<MinFun>();
-	Register<SumFun>();
-	Register<StringAggFun>();
-	Register<ApproxCountDistinctFun>();
-	Register<ProductFun>();
-	Register<BoolOrFun>();
-	Register<BoolAndFun>();
-	Register<ArgMinFun>();
-	Register<ArgMaxFun>();
-	Register<SkewFun>();
-	Register<KurtosisFun>();
-	Register<EntropyFun>();
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/cast/string_cast.cpp

@@ -330,7 +330,7 @@ bool VectorStringToMap::StringToNestedTypeCastLoop(string_t *source_data, Validi
 			}
 		}
 	}
-	MapConversionVerify(result, count);
+	MapVector::MapConversionVerify(result, count);
 	return all_converted;
 }
 

package/src/duckdb/src/function/function.cpp

@@ -92,21 +92,13 @@ void BuiltinFunctions::Initialize() {
 	RegisterTableFunctions();
 	RegisterArrowFunctions();
 
-	RegisterAlgebraicAggregates();
 	RegisterDistributiveAggregates();
-	RegisterNestedAggregates();
-	RegisterHolisticAggregates();
-	RegisterRegressiveAggregates();
 
-	RegisterDateFunctions();
-	RegisterEnumFunctions();
 	RegisterGenericFunctions();
-	RegisterMathFunctions();
 	RegisterOperators();
 	RegisterSequenceFunctions();
 	RegisterStringFunctions();
 	RegisterNestedFunctions();
-	RegisterTrigonometricsFunctions();
 
 	RegisterPragmaFunctions();
 

package/src/duckdb/src/function/function_set.cpp

@@ -3,9 +3,16 @@
 
 namespace duckdb {
 
+ScalarFunctionSet::ScalarFunctionSet() : FunctionSet("") {
+}
+
 ScalarFunctionSet::ScalarFunctionSet(string name) : FunctionSet(std::move(name)) {
 }
 
+ScalarFunctionSet::ScalarFunctionSet(ScalarFunction fun) : FunctionSet(std::move(fun.name)) {
+	functions.push_back(std::move(fun));
+}
+
 ScalarFunction ScalarFunctionSet::GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments) {
 	string error;
 	FunctionBinder binder(context);
@@ -17,9 +24,16 @@ ScalarFunction ScalarFunctionSet::GetFunctionByArguments(ClientContext &context,
 	return GetFunctionByOffset(index);
 }
 
+AggregateFunctionSet::AggregateFunctionSet() : FunctionSet("") {
+}
+
 AggregateFunctionSet::AggregateFunctionSet(string name) : FunctionSet(std::move(name)) {
 }
 
+AggregateFunctionSet::AggregateFunctionSet(AggregateFunction fun) : FunctionSet(std::move(fun.name)) {
+	functions.push_back(std::move(fun));
+}
+
 AggregateFunction AggregateFunctionSet::GetFunctionByArguments(ClientContext &context,
                                                                const vector<LogicalType> &arguments) {
 	string error;
@@ -53,6 +67,10 @@ AggregateFunction AggregateFunctionSet::GetFunctionByArguments(ClientContext &co
 TableFunctionSet::TableFunctionSet(string name) : FunctionSet(std::move(name)) {
 }
 
+TableFunctionSet::TableFunctionSet(TableFunction fun) : FunctionSet(std::move(fun.name)) {
+	functions.push_back(std::move(fun));
+}
+
 TableFunction TableFunctionSet::GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments) {
 	string error;
 	FunctionBinder binder(context);
@@ -64,4 +82,11 @@ TableFunction TableFunctionSet::GetFunctionByArguments(ClientContext &context, c
 	return GetFunctionByOffset(index);
 }
 
+PragmaFunctionSet::PragmaFunctionSet(string name) : FunctionSet(std::move(name)) {
+}
+
+PragmaFunctionSet::PragmaFunctionSet(PragmaFunction fun) : FunctionSet(std::move(fun.name)) {
+	functions.push_back(std::move(fun));
+}
+
 } // namespace duckdb