duckdb 1.3.3-dev0.0 → 1.3.3-dev4.0

package/src/duckdb/extension/core_functions/scalar/operators/bitwise.cpp

@@ -4,7 +4,6 @@
 #include "duckdb/common/types/bit.hpp"
 
 namespace duckdb {
-
 template <class OP>
 static scalar_function_t GetScalarIntegerUnaryFunction(const LogicalType &type) {
 	scalar_function_t function;
@@ -88,6 +87,8 @@ static scalar_function_t GetScalarIntegerBinaryFunction(const LogicalType &type)
 //===--------------------------------------------------------------------===//
 // & [bitwise_and]
 //===--------------------------------------------------------------------===//
+namespace {
+
 struct BitwiseANDOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA left, TB right) {
@@ -95,7 +96,7 @@ struct BitwiseANDOperator {
 	}
 };
 
-static void BitwiseANDOperation(DataChunk &args, ExpressionState &state, Vector &result) {
+void BitwiseANDOperation(DataChunk &args, ExpressionState &state, Vector &result) {
 	BinaryExecutor::Execute<string_t, string_t, string_t>(
 	    args.data[0], args.data[1], result, args.size(), [&](string_t rhs, string_t lhs) {
 		    string_t target = StringVector::EmptyString(result, rhs.GetSize());
@@ -105,6 +106,8 @@ static void BitwiseANDOperation(DataChunk &args, ExpressionState &state, Vector
 	    });
 }
 
+} // namespace
+
 ScalarFunctionSet BitwiseAndFun::GetFunctions() {
 	ScalarFunctionSet functions;
 	for (auto &type : LogicalType::Integral()) {
@@ -121,6 +124,8 @@ ScalarFunctionSet BitwiseAndFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // | [bitwise_or]
 //===--------------------------------------------------------------------===//
+namespace {
+
 struct BitwiseOROperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA left, TB right) {
@@ -128,7 +133,7 @@ struct BitwiseOROperator {
 	}
 };
 
-static void BitwiseOROperation(DataChunk &args, ExpressionState &state, Vector &result) {
+void BitwiseOROperation(DataChunk &args, ExpressionState &state, Vector &result) {
 	BinaryExecutor::Execute<string_t, string_t, string_t>(
 	    args.data[0], args.data[1], result, args.size(), [&](string_t rhs, string_t lhs) {
 		    string_t target = StringVector::EmptyString(result, rhs.GetSize());
@@ -138,6 +143,8 @@ static void BitwiseOROperation(DataChunk &args, ExpressionState &state, Vector &
 	    });
 }
 
+} // namespace
+
 ScalarFunctionSet BitwiseOrFun::GetFunctions() {
 	ScalarFunctionSet functions;
 	for (auto &type : LogicalType::Integral()) {
@@ -154,6 +161,8 @@ ScalarFunctionSet BitwiseOrFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // # [bitwise_xor]
 //===--------------------------------------------------------------------===//
+namespace {
+
 struct BitwiseXOROperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA left, TB right) {
@@ -161,7 +170,7 @@ struct BitwiseXOROperator {
 	}
 };
 
-static void BitwiseXOROperation(DataChunk &args, ExpressionState &state, Vector &result) {
+void BitwiseXOROperation(DataChunk &args, ExpressionState &state, Vector &result) {
 	BinaryExecutor::Execute<string_t, string_t, string_t>(
 	    args.data[0], args.data[1], result, args.size(), [&](string_t rhs, string_t lhs) {
 		    string_t target = StringVector::EmptyString(result, rhs.GetSize());
@@ -171,6 +180,8 @@ static void BitwiseXOROperation(DataChunk &args, ExpressionState &state, Vector
 	    });
 }
 
+} // namespace
+
 ScalarFunctionSet BitwiseXorFun::GetFunctions() {
 	ScalarFunctionSet functions;
 	for (auto &type : LogicalType::Integral()) {
@@ -187,6 +198,8 @@ ScalarFunctionSet BitwiseXorFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // ~ [bitwise_not]
 //===--------------------------------------------------------------------===//
+namespace {
+
 struct BitwiseNotOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -194,7 +207,7 @@ struct BitwiseNotOperator {
 	}
 };
 
-static void BitwiseNOTOperation(DataChunk &args, ExpressionState &state, Vector &result) {
+void BitwiseNOTOperation(DataChunk &args, ExpressionState &state, Vector &result) {
 	UnaryExecutor::Execute<string_t, string_t>(args.data[0], result, args.size(), [&](string_t input) {
 		string_t target = StringVector::EmptyString(result, input.GetSize());
 
@@ -203,6 +216,8 @@ static void BitwiseNOTOperation(DataChunk &args, ExpressionState &state, Vector
 	});
 }
 
+} // namespace
+
 ScalarFunctionSet BitwiseNotFun::GetFunctions() {
 	ScalarFunctionSet functions;
 	for (auto &type : LogicalType::Integral()) {
@@ -218,6 +233,8 @@ ScalarFunctionSet BitwiseNotFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // << [bitwise_left_shift]
 //===--------------------------------------------------------------------===//
+namespace {
+
 struct BitwiseShiftLeftOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA input, TB shift) {
@@ -246,7 +263,7 @@ struct BitwiseShiftLeftOperator {
 	}
 };
 
-static void BitwiseShiftLeftOperation(DataChunk &args, ExpressionState &state, Vector &result) {
+void BitwiseShiftLeftOperation(DataChunk &args, ExpressionState &state, Vector &result) {
 	BinaryExecutor::Execute<string_t, int32_t, string_t>(
 	    args.data[0], args.data[1], result, args.size(), [&](string_t input, int32_t shift) {
 		    auto max_shift = UnsafeNumericCast<int32_t>(Bit::BitLength(input));
@@ -266,6 +283,7 @@ static void BitwiseShiftLeftOperation(DataChunk &args, ExpressionState &state, V
 		    return target;
 	    });
 }
+} // namespace
 
 ScalarFunctionSet LeftShiftFun::GetFunctions() {
 	ScalarFunctionSet functions;
@@ -284,6 +302,8 @@ ScalarFunctionSet LeftShiftFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // >> [bitwise_right_shift]
 //===--------------------------------------------------------------------===//
+namespace {
+
 template <class T>
 bool RightShiftInRange(T shift) {
 	return shift >= 0 && shift < T(sizeof(T) * 8);
@@ -296,7 +316,7 @@ struct BitwiseShiftRightOperator {
 	}
 };
 
-static void BitwiseShiftRightOperation(DataChunk &args, ExpressionState &state, Vector &result) {
+void BitwiseShiftRightOperation(DataChunk &args, ExpressionState &state, Vector &result) {
 	BinaryExecutor::Execute<string_t, int32_t, string_t>(
 	    args.data[0], args.data[1], result, args.size(), [&](string_t input, int32_t shift) {
 		    auto max_shift = UnsafeNumericCast<int32_t>(Bit::BitLength(input));
@@ -313,6 +333,8 @@ static void BitwiseShiftRightOperation(DataChunk &args, ExpressionState &state,
 	    });
 }
 
+} // namespace
+
 ScalarFunctionSet RightShiftFun::GetFunctions() {
 	ScalarFunctionSet functions;
 	for (auto &type : LogicalType::Integral()) {

package/src/duckdb/extension/core_functions/scalar/random/random.cpp

@@ -9,6 +9,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct ExtractVersionUuidOperator {
 	template <typename INPUT_TYPE, typename RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
@@ -42,7 +44,7 @@ struct ExtractTimestampUuidOperator {
 };
 
 template <typename INPUT, typename OP>
-static void ExtractVersionFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void ExtractVersionFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 1);
 	auto &input = args.data[0];
 	idx_t count = args.size();
@@ -50,7 +52,7 @@ static void ExtractVersionFunction(DataChunk &args, ExpressionState &state, Vect
 }
 
 template <typename INPUT, typename OP>
-static void ExtractTimestampFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void ExtractTimestampFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 1);
 	auto &input = args.data[0];
 	idx_t count = args.size();
@@ -65,7 +67,7 @@ struct RandomLocalState : public FunctionLocalState {
 	RandomEngine random_engine;
 };
 
-static void RandomFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void RandomFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 0);
 	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RandomLocalState>();
 
@@ -76,21 +78,14 @@ static void RandomFunction(DataChunk &args, ExpressionState &state, Vector &resu
 	}
 }
 
-static unique_ptr<FunctionLocalState> RandomInitLocalState(ExpressionState &state, const BoundFunctionExpression &expr,
-                                                           FunctionData *bind_data) {
+unique_ptr<FunctionLocalState> RandomInitLocalState(ExpressionState &state, const BoundFunctionExpression &expr,
+                                                    FunctionData *bind_data) {
 	auto &random_engine = RandomEngine::Get(state.GetContext());
 	lock_guard<mutex> guard(random_engine.lock);
 	return make_uniq<RandomLocalState>(random_engine.NextRandomInteger64());
 }
 
-ScalarFunction RandomFun::GetFunction() {
-	ScalarFunction random("random", {}, LogicalType::DOUBLE, RandomFunction, nullptr, nullptr, nullptr,
-	                      RandomInitLocalState);
-	random.stability = FunctionStability::VOLATILE;
-	return random;
-}
-
-static void GenerateUUIDv4Function(DataChunk &args, ExpressionState &state, Vector &result) {
+void GenerateUUIDv4Function(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 0);
 	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RandomLocalState>();
 
@@ -102,7 +97,7 @@ static void GenerateUUIDv4Function(DataChunk &args, ExpressionState &state, Vect
 	}
 }
 
-static void GenerateUUIDv7Function(DataChunk &args, ExpressionState &state, Vector &result) {
+void GenerateUUIDv7Function(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 0);
 	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RandomLocalState>();
 
@@ -114,6 +109,15 @@ static void GenerateUUIDv7Function(DataChunk &args, ExpressionState &state, Vect
 	}
 }
 
+} // namespace
+
+ScalarFunction RandomFun::GetFunction() {
+	ScalarFunction random("random", {}, LogicalType::DOUBLE, RandomFunction, nullptr, nullptr, nullptr,
+	                      RandomInitLocalState);
+	random.stability = FunctionStability::VOLATILE;
+	return random;
+}
+
 ScalarFunction UUIDFun::GetFunction() {
 	return UUIDv4Fun::GetFunction();
 }

package/src/duckdb/extension/core_functions/scalar/random/setseed.cpp

@@ -9,6 +9,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct SetseedBindData : public FunctionData {
 	//! The client context for the function call
 	ClientContext &context;
@@ -25,7 +27,7 @@ struct SetseedBindData : public FunctionData {
 	}
 };
 
-static void SetSeedFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void SetSeedFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	auto &info = func_expr.bind_info->Cast<SetseedBindData>();
 	auto &input = args.data[0];
@@ -52,6 +54,8 @@ unique_ptr<FunctionData> SetSeedBind(ClientContext &context, ScalarFunction &bou
 	return make_uniq<SetseedBindData>(context);
 }
 
+} // namespace
+
 ScalarFunction SetseedFun::GetFunction() {
 	ScalarFunction setseed("setseed", {LogicalType::DOUBLE}, LogicalType::SQLNULL, SetSeedFunction, SetSeedBind);
 	setseed.stability = FunctionStability::VOLATILE;

package/src/duckdb/extension/core_functions/scalar/string/hex.cpp

@@ -393,7 +393,7 @@ ScalarFunctionSet HexFun::GetFunctions() {
 	to_hex.AddFunction(
 	    ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, ToHexFunction<string_t, HexStrOperator>));
 	to_hex.AddFunction(
-	    ScalarFunction({LogicalType::VARINT}, LogicalType::VARCHAR, ToHexFunction<string_t, HexStrOperator>));
+	    ScalarFunction({LogicalType::BIGNUM}, LogicalType::VARCHAR, ToHexFunction<string_t, HexStrOperator>));
 	to_hex.AddFunction(
 	    ScalarFunction({LogicalType::BLOB}, LogicalType::VARCHAR, ToHexFunction<string_t, HexStrOperator>));
 	to_hex.AddFunction(
@@ -419,7 +419,7 @@ ScalarFunctionSet BinFun::GetFunctions() {
 	to_binary.AddFunction(
 	    ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, ToBinaryFunction<string_t, BinaryStrOperator>));
 	to_binary.AddFunction(
-	    ScalarFunction({LogicalType::VARINT}, LogicalType::VARCHAR, ToBinaryFunction<string_t, BinaryStrOperator>));
+	    ScalarFunction({LogicalType::BIGNUM}, LogicalType::VARCHAR, ToBinaryFunction<string_t, BinaryStrOperator>));
 	to_binary.AddFunction(ScalarFunction({LogicalType::UBIGINT}, LogicalType::VARCHAR,
 	                                     ToBinaryFunction<uint64_t, BinaryIntegralOperator>));
 	to_binary.AddFunction(

package/src/duckdb/extension/core_functions/scalar/string/instr.cpp

@@ -50,9 +50,11 @@ static unique_ptr<BaseStatistics> InStrPropagateStats(ClientContext &context, Fu
 }
 
 ScalarFunction InstrFun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BIGINT,
-	                      ScalarFunction::BinaryFunction<string_t, string_t, int64_t, InstrOperator>, nullptr, nullptr,
-	                      InStrPropagateStats);
+	auto function = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BIGINT,
+	                               ScalarFunction::BinaryFunction<string_t, string_t, int64_t, InstrOperator>, nullptr,
+	                               nullptr, InStrPropagateStats);
+	function.collation_handling = FunctionCollationHandling::PUSH_COMBINABLE_COLLATIONS;
+	return function;
 }
 
 } // namespace duckdb

package/src/duckdb/extension/core_functions/scalar/string/printf.cpp

@@ -41,6 +41,12 @@ unique_ptr<FunctionData> BindPrintfFunction(ClientContext &context, ScalarFuncti
 		case LogicalTypeId::UBIGINT:
 			bound_function.arguments.emplace_back(LogicalType::UBIGINT);
 			break;
+		case LogicalTypeId::HUGEINT:
+			bound_function.arguments.emplace_back(LogicalType::HUGEINT);
+			break;
+		case LogicalTypeId::UHUGEINT:
+			bound_function.arguments.emplace_back(LogicalType::UHUGEINT);
+			break;
 		case LogicalTypeId::FLOAT:
 		case LogicalTypeId::DOUBLE:
 			bound_function.arguments.emplace_back(LogicalType::DOUBLE);
@@ -146,6 +152,16 @@ static void PrintfFunction(DataChunk &args, ExpressionState &state, Vector &resu
 				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
 				break;
 			}
+			case LogicalTypeId::HUGEINT: {
+				auto arg_data = FlatVector::GetData<hugeint_t>(col);
+				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
+				break;
+			}
+			case LogicalTypeId::UHUGEINT: {
+				auto arg_data = FlatVector::GetData<uhugeint_t>(col);
+				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));
+				break;
+			}
 			case LogicalTypeId::DOUBLE: {
 				auto arg_data = FlatVector::GetData<double>(col);
 				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(arg_data[arg_idx]));

package/src/duckdb/extension/core_functions/scalar/string/repeat.cpp

@@ -31,21 +31,6 @@ static void RepeatFunction(DataChunk &args, ExpressionState &, Vector &result) {
 	    });
 }
 
-unique_ptr<FunctionData> RepeatBindFunction(ClientContext &, ScalarFunction &bound_function,
-                                            vector<unique_ptr<Expression>> &arguments) {
-	switch (arguments[0]->return_type.id()) {
-	case LogicalTypeId::UNKNOWN:
-		throw ParameterNotResolvedException();
-	case LogicalTypeId::LIST:
-		break;
-	default:
-		throw NotImplementedException("repeat(list, count) requires a list as parameter");
-	}
-	bound_function.arguments[0] = arguments[0]->return_type;
-	bound_function.return_type = arguments[0]->return_type;
-	return nullptr;
-}
-
 static void RepeatListFunction(DataChunk &args, ExpressionState &, Vector &result) {
 	auto &list_vector = args.data[0];
 	auto &cnt_vector = args.data[1];
@@ -79,8 +64,8 @@ ScalarFunctionSet RepeatFun::GetFunctions() {
 	for (const auto &type : {LogicalType::VARCHAR, LogicalType::BLOB}) {
 		repeat.AddFunction(ScalarFunction({type, LogicalType::BIGINT}, type, RepeatFunction));
 	}
-	repeat.AddFunction(ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::BIGINT},
-	                                  LogicalType::LIST(LogicalType::ANY), RepeatListFunction, RepeatBindFunction));
+	repeat.AddFunction(ScalarFunction({LogicalType::LIST(LogicalType::TEMPLATE("T")), LogicalType::BIGINT},
+	                                  LogicalType::LIST(LogicalType::TEMPLATE("T")), RepeatListFunction));
 	for (auto &func : repeat.functions) {
 		BaseScalarFunction::SetReturnsError(func);
 	}

package/src/duckdb/extension/core_functions/scalar/struct/struct_insert.cpp

@@ -72,7 +72,7 @@ static unique_ptr<FunctionData> StructInsertBind(ClientContext &context, ScalarF
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
-unique_ptr<BaseStatistics> StructInsertStats(ClientContext &context, FunctionStatisticsInput &input) {
+static unique_ptr<BaseStatistics> StructInsertStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
 	auto new_stats = StructStats::CreateUnknown(expr.return_type);

package/src/duckdb/extension/core_functions/scalar/struct/struct_update.cpp

@@ -0,0 +1,161 @@
+#include "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"
+#include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
+#include "duckdb/storage/statistics/struct_stats.hpp"
+#include "duckdb/planner/expression_binder.hpp"
+
+namespace duckdb {
+
+static void StructUpdateFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &starting_vec = args.data[0];
+	starting_vec.Verify(args.size());
+
+	auto &starting_child_entries = StructVector::GetEntries(starting_vec);
+	auto &result_child_entries = StructVector::GetEntries(result);
+
+	auto &starting_types = StructType::GetChildTypes(starting_vec.GetType());
+
+	auto &func_args = state.expr.Cast<BoundFunctionExpression>().children;
+	auto new_entries = case_insensitive_tree_t<idx_t>();
+	auto is_new_field = vector<bool>(args.ColumnCount(), true);
+
+	for (idx_t arg_idx = 1; arg_idx < func_args.size(); arg_idx++) {
+		auto &new_child = func_args[arg_idx];
+		new_entries.emplace(new_child->alias, arg_idx);
+	}
+
+	// Assign the original child entries to the STRUCT.
+	for (idx_t field_idx = 0; field_idx < starting_child_entries.size(); field_idx++) {
+		auto &starting_child = starting_child_entries[field_idx];
+		auto update = new_entries.find(starting_types[field_idx].first.c_str());
+
+		if (update == new_entries.end()) {
+			// No update present, copy from source
+			result_child_entries[field_idx]->Reference(*starting_child);
+		} else {
+			// We found a replacement of the same name to update
+			auto arg_idx = update->second;
+			result_child_entries[field_idx]->Reference(args.data[arg_idx]);
+			is_new_field[arg_idx] = false;
+		}
+	}
+
+	// Assign the new (not updated) children to the end of the result vector.
+	for (idx_t arg_idx = 1, field_idx = starting_child_entries.size(); arg_idx < args.ColumnCount(); arg_idx++) {
+		if (is_new_field[arg_idx]) {
+			result_child_entries[field_idx++]->Reference(args.data[arg_idx]);
+		}
+	}
+
+	result.Verify(args.size());
+	if (args.AllConstant()) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+}
+
+static unique_ptr<FunctionData> StructUpdateBind(ClientContext &context, ScalarFunction &bound_function,
+                                                 vector<unique_ptr<Expression>> &arguments) {
+	if (arguments.empty()) {
+		throw InvalidInputException("Missing required arguments for struct_update function.");
+	}
+	if (LogicalTypeId::STRUCT != arguments[0]->return_type.id()) {
+		throw InvalidInputException("The first argument to struct_update must be a STRUCT");
+	}
+	if (arguments.size() < 2) {
+		throw InvalidInputException("Can't update nothing into a STRUCT");
+	}
+
+	child_list_t<LogicalType> new_children;
+	auto &existing_children = StructType::GetChildTypes(arguments[0]->return_type);
+
+	auto incomming_children = case_insensitive_tree_t<idx_t>();
+	auto is_new_field = vector<bool>(arguments.size(), true);
+
+	// Validate incomming arguments and record names
+	for (idx_t arg_idx = 1; arg_idx < arguments.size(); arg_idx++) {
+		auto &child = arguments[arg_idx];
+		if (child->alias.empty()) {
+			throw BinderException("Need named argument for struct update, e.g., a := b");
+		} else if (incomming_children.find(child->alias) != incomming_children.end()) {
+			throw InvalidInputException("Duplicate named argument provided for %s", child->alias.c_str());
+		}
+		incomming_children.emplace(child->alias, arg_idx);
+	}
+
+	for (idx_t field_idx = 0; field_idx < existing_children.size(); field_idx++) {
+		auto &existing_child = existing_children[field_idx];
+		auto update = incomming_children.find(existing_child.first);
+		if (update == incomming_children.end()) {
+			// No update provided for the named value
+			new_children.push_back(make_pair(existing_child.first, existing_child.second));
+		} else {
+			// Update the struct with the new data of the same name
+			auto arg_idx = update->second;
+			auto &new_child = arguments[arg_idx];
+			new_children.push_back(make_pair(new_child->alias, new_child->return_type));
+			is_new_field[arg_idx] = false;
+		}
+	}
+
+	// Loop through the additional arguments (name/value pairs)
+	for (idx_t arg_idx = 1; arg_idx < arguments.size(); arg_idx++) {
+		if (is_new_field[arg_idx]) {
+			auto &child = arguments[arg_idx];
+			new_children.push_back(make_pair(child->alias, child->return_type));
+		}
+	}
+
+	bound_function.return_type = LogicalType::STRUCT(new_children);
+	return make_uniq<VariableReturnBindData>(bound_function.return_type);
+}
+
+unique_ptr<BaseStatistics> StructUpdateStats(ClientContext &context, FunctionStatisticsInput &input) {
+	auto &child_stats = input.child_stats;
+	auto &expr = input.expr;
+
+	auto incomming_children = case_insensitive_tree_t<idx_t>();
+	auto is_new_field = vector<bool>(expr.children.size(), true);
+	auto new_stats = StructStats::CreateUnknown(expr.return_type);
+
+	for (idx_t arg_idx = 1; arg_idx < expr.children.size(); arg_idx++) {
+		auto &new_child = expr.children[arg_idx];
+		incomming_children.emplace(new_child->alias, arg_idx);
+	}
+
+	auto existing_type = child_stats[0].GetType();
+	auto existing_count = StructType::GetChildCount(existing_type);
+	auto existing_stats = StructStats::GetChildStats(child_stats[0]);
+	for (idx_t field_idx = 0; field_idx < existing_count; field_idx++) {
+		auto &existing_child = existing_stats[field_idx];
+		auto update = incomming_children.find(StructType::GetChildName(existing_type, field_idx));
+		if (update == incomming_children.end()) {
+			StructStats::SetChildStats(new_stats, field_idx, existing_child);
+		} else {
+			auto arg_idx = update->second;
+			StructStats::SetChildStats(new_stats, field_idx, child_stats[arg_idx]);
+			is_new_field[arg_idx] = false;
+		}
+	}
+
+	for (idx_t arg_idx = 1, field_idx = existing_count; arg_idx < expr.children.size(); arg_idx++) {
+		if (is_new_field[arg_idx]) {
+			StructStats::SetChildStats(new_stats, field_idx++, child_stats[arg_idx]);
+		}
+	}
+
+	return new_stats.ToUnique();
+}
+
+ScalarFunction StructUpdateFun::GetFunction() {
+	ScalarFunction fun({}, LogicalTypeId::STRUCT, StructUpdateFunction, StructUpdateBind, nullptr, StructUpdateStats);
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	fun.varargs = LogicalType::ANY;
+	fun.serialize = VariableReturnBindData::Serialize;
+	fun.deserialize = VariableReturnBindData::Deserialize;
+	return fun;
+}
+
+} // namespace duckdb

package/src/duckdb/extension/core_functions/scalar/union/union_extract.cpp

@@ -6,6 +6,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct UnionExtractBindData : public FunctionData {
 	UnionExtractBindData(string key, idx_t index, LogicalType type)
 	    : key(std::move(key)), index(index), type(std::move(type)) {
@@ -25,7 +27,7 @@ public:
 	}
 };
 
-static void UnionExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void UnionExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	auto &info = func_expr.bind_info->Cast<UnionExtractBindData>();
 
@@ -39,8 +41,8 @@ static void UnionExtractFunction(DataChunk &args, ExpressionState &state, Vector
 	result.Verify(args.size());
 }
 
-static unique_ptr<FunctionData> UnionExtractBind(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
+unique_ptr<FunctionData> UnionExtractBind(ClientContext &context, ScalarFunction &bound_function,
+                                          vector<unique_ptr<Expression>> &arguments) {
 	D_ASSERT(bound_function.arguments.size() == 2);
 	if (arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) {
 		throw ParameterNotResolvedException();
@@ -99,6 +101,8 @@ static unique_ptr<FunctionData> UnionExtractBind(ClientContext &context, ScalarF
 	return make_uniq<UnionExtractBindData>(key, key_index, return_type);
 }
 
+} // namespace
+
 ScalarFunction UnionExtractFun::GetFunction() {
 	// the arguments and return types are actually set in the binder function
 	return ScalarFunction({LogicalTypeId::UNION, LogicalType::VARCHAR}, LogicalType::ANY, UnionExtractFunction,

package/src/duckdb/extension/core_functions/scalar/union/union_tag.cpp

@@ -6,8 +6,10 @@
 
 namespace duckdb {
 
-static unique_ptr<FunctionData> UnionTagBind(ClientContext &context, ScalarFunction &bound_function,
-                                             vector<unique_ptr<Expression>> &arguments) {
+namespace {
+
+unique_ptr<FunctionData> UnionTagBind(ClientContext &context, ScalarFunction &bound_function,
+                                      vector<unique_ptr<Expression>> &arguments) {
 
 	if (arguments.empty()) {
 		throw BinderException("Missing required arguments for union_tag function.");
@@ -45,11 +47,13 @@ static unique_ptr<FunctionData> UnionTagBind(ClientContext &context, ScalarFunct
 	return nullptr;
 }
 
-static void UnionTagFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void UnionTagFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(result.GetType().id() == LogicalTypeId::ENUM);
 	result.Reinterpret(UnionVector::GetTags(args.data[0]));
 }
 
+} // namespace
+
 ScalarFunction UnionTagFun::GetFunction() {
 	return ScalarFunction({LogicalTypeId::UNION}, LogicalTypeId::ANY, UnionTagFunction, UnionTagBind, nullptr,
 	                      nullptr); // TODO: Statistics?

package/src/duckdb/extension/core_functions/scalar/union/union_value.cpp

@@ -7,6 +7,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct UnionValueBindData : public FunctionData {
 	UnionValueBindData() {
 	}
@@ -20,7 +22,7 @@ public:
 	}
 };
 
-static void UnionValueFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void UnionValueFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	// Assign the new entries to the result vector
 	UnionVector::GetMember(result, 0).Reference(args.data[0]);
 
@@ -36,8 +38,8 @@ static void UnionValueFunction(DataChunk &args, ExpressionState &state, Vector &
 	result.Verify(args.size());
 }
 
-static unique_ptr<FunctionData> UnionValueBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
+unique_ptr<FunctionData> UnionValueBind(ClientContext &context, ScalarFunction &bound_function,
+                                        vector<unique_ptr<Expression>> &arguments) {
 
 	if (arguments.size() != 1) {
 		throw BinderException("union_value takes exactly one argument");
@@ -56,6 +58,8 @@ static unique_ptr<FunctionData> UnionValueBind(ClientContext &context, ScalarFun
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
+} // namespace
+
 ScalarFunction UnionValueFun::GetFunction() {
 	ScalarFunction fun("union_value", {}, LogicalTypeId::UNION, UnionValueFunction, UnionValueBind, nullptr, nullptr);
 	fun.varargs = LogicalType::ANY;