duckdb 0.7.2-dev2706.0 → 0.7.2-dev2820.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/persistent/physical_insert.cpp

@@ -102,6 +102,7 @@ public:
 	optional_ptr<OptimisticDataWriter> writer;
 	// Rows that have been updated by a DO UPDATE conflict
 	unordered_set<row_t> updated_rows;
+	idx_t update_count = 0;
 };
 
 unique_ptr<GlobalSinkState> PhysicalInsert::GetGlobalSinkState(ClientContext &context) const {
@@ -217,10 +218,10 @@ void PhysicalInsert::CombineExistingAndInsertTuples(DataChunk &result, DataChunk
 	result.SetCardinality(input_chunk.size());
 }
 
-void PhysicalInsert::PerformOnConflictAction(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table,
-                                             Vector &row_ids) const {
+idx_t PhysicalInsert::PerformOnConflictAction(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table,
+                                              Vector &row_ids) const {
 	if (action_type == OnConflictAction::NOTHING) {
-		return;
+		return 0;
 	}
 
 	DataChunk update_chunk; // contains only the to-update columns
@@ -259,6 +260,7 @@ void PhysicalInsert::PerformOnConflictAction(ExecutionContext &context, DataChun
 	auto &data_table = table.GetStorage();
 	// Perform the update, using the results of the SET expressions
 	data_table.Update(table, context.client, row_ids, set_columns, update_chunk);
+	return update_chunk.size();
 }
 
 // TODO: should we use a hash table to keep track of this instead?
@@ -275,12 +277,12 @@ void PhysicalInsert::RegisterUpdatedRows(InsertLocalState &lstate, const Vector
 	}
 }
 
-void PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context,
-                                        InsertLocalState &lstate) const {
+idx_t PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context,
+                                         InsertLocalState &lstate) const {
 	auto &data_table = table.GetStorage();
 	if (action_type == OnConflictAction::THROW) {
 		data_table.VerifyAppendConstraints(table, context.client, lstate.insert_chunk, nullptr);
-		return;
+		return 0;
 	}
 	// Check whether any conflicts arise, and if they all meet the conflict_target + condition
 	// If that's not the case - We throw the first error
@@ -291,8 +293,8 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionConte
 	data_table.VerifyAppendConstraints(table, context.client, lstate.insert_chunk, &conflict_manager);
 	conflict_manager.Finalize();
 	if (conflict_manager.ConflictCount() == 0) {
-		// No conflicts found
-		return;
+		// No conflicts found, 0 updates performed
+		return 0;
 	}
 	auto &conflicts = conflict_manager.Conflicts();
 	auto &row_ids = conflict_manager.RowIds();
@@ -343,7 +345,7 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionConte
 
 	RegisterUpdatedRows(lstate, row_ids, combined_chunk.size());
 
-	PerformOnConflictAction(context, combined_chunk, table, row_ids);
+	idx_t updated_tuples = PerformOnConflictAction(context, combined_chunk, table, row_ids);
 
 	// Remove the conflicting tuples from the insert chunk
 	SelectionVector sel_vec(lstate.insert_chunk.size());
@@ -351,6 +353,7 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionConte
 	    SelectionVector::Inverted(conflicts.Selection(), sel_vec, conflicts.Count(), lstate.insert_chunk.size());
 	lstate.insert_chunk.Slice(sel_vec, new_size);
 	lstate.insert_chunk.SetCardinality(new_size);
+	return updated_tuples;
 }
 
 SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p,
@@ -368,13 +371,14 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 			gstate.initialized = true;
 		}
 
-		OnConflictHandling(table, context, lstate);
+		idx_t updated_tuples = OnConflictHandling(table, context, lstate);
 		storage.LocalAppend(gstate.append_state, table, context.client, lstate.insert_chunk, true);
 
 		if (return_chunk) {
 			gstate.return_collection.Append(lstate.insert_chunk);
 		}
-		gstate.insert_count += chunk.size();
+		gstate.insert_count += lstate.insert_chunk.size();
+		gstate.insert_count += updated_tuples;
 	} else {
 		D_ASSERT(!return_chunk);
 		// parallel append
@@ -388,7 +392,8 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 			lstate.local_collection->InitializeAppend(lstate.local_append_state);
 			lstate.writer = &gstate.table.GetStorage().CreateOptimisticWriter(context.client);
 		}
-		OnConflictHandling(table, context, lstate);
+		lstate.update_count += OnConflictHandling(table, context, lstate);
+
 		auto new_row_group = lstate.local_collection->Append(lstate.insert_chunk, lstate.local_append_state);
 		if (new_row_group) {
 			lstate.writer->CheckFlushToDisk(*lstate.local_collection);
@@ -421,6 +426,7 @@ void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 		// we have few rows - append to the local storage directly
 		lock_guard<mutex> lock(gstate.lock);
 		gstate.insert_count += append_count;
+		gstate.insert_count += lstate.update_count;
 		auto &table = gstate.table;
 		auto &storage = table.GetStorage();
 		storage.InitializeLocalAppend(gstate.append_state, context.client);
@@ -438,6 +444,7 @@ void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 
 		lock_guard<mutex> lock(gstate.lock);
 		gstate.insert_count += append_count;
+		gstate.insert_count += lstate.update_count;
 		gstate.table.GetStorage().LocalMerge(context.client, *lstate.local_collection);
 	}
 }

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;
 }