duckdb 1.3.4 → 1.4.0

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

@@ -0,0 +1,157 @@
+#include "duckdb/common/file_system.hpp"
+#include "duckdb/common/vector_operations/unary_executor.hpp"
+#include "duckdb/function/built_in_functions.hpp"
+#include "duckdb/function/copy_function.hpp"
+
+namespace duckdb {
+
+//----------------------------------------------------------------------------------------------------------------------
+// Bind
+//----------------------------------------------------------------------------------------------------------------------
+namespace {
+
+struct WriteBlobBindData final : public TableFunctionData {
+	FileCompressionType compression_type = FileCompressionType::AUTO_DETECT;
+};
+
+string ParseStringOption(const Value &value, const string &loption) {
+	if (value.IsNull()) {
+		return string();
+	}
+	if (value.type().id() == LogicalTypeId::LIST) {
+		auto &children = ListValue::GetChildren(value);
+		if (children.size() != 1) {
+			throw BinderException("\"%s\" expects a single argument as a string value", loption);
+		}
+		return ParseStringOption(children[0], loption);
+	}
+	if (value.type().id() != LogicalTypeId::VARCHAR) {
+		throw BinderException("\"%s\" expects a string argument!", loption);
+	}
+	return value.GetValue<string>();
+}
+
+unique_ptr<FunctionData> WriteBlobBind(ClientContext &context, CopyFunctionBindInput &input,
+                                       const vector<string> &names, const vector<LogicalType> &sql_types) {
+	if (sql_types.size() != 1 || sql_types.back().id() != LogicalTypeId::BLOB) {
+		throw BinderException("\"COPY (FORMAT BLOB)\" only supports a single BLOB column");
+	}
+
+	auto result = make_uniq<WriteBlobBindData>();
+
+	for (auto &lopt : input.info.options) {
+		if (StringUtil::CIEquals(lopt.first, "compression")) {
+			auto compression_str = ParseStringOption(lopt.second[0], lopt.first);
+			result->compression_type = FileCompressionTypeFromString(compression_str);
+		} else {
+			throw BinderException("Unrecognized option for COPY (FORMAT BLOB): \"%s\"", lopt.first);
+		}
+	}
+
+	return std::move(result);
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+// Global State
+//----------------------------------------------------------------------------------------------------------------------
+struct WriteBlobGlobalState final : public GlobalFunctionData {
+	unique_ptr<FileHandle> handle;
+	mutex lock;
+};
+
+unique_ptr<GlobalFunctionData> WriteBlobInitializeGlobal(ClientContext &context, FunctionData &bind_data,
+                                                         const string &file_path) {
+
+	auto &bdata = bind_data.Cast<WriteBlobBindData>();
+	auto &fs = FileSystem::GetFileSystem(context);
+
+	auto flags = FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE_NEW | bdata.compression_type;
+	auto handle = fs.OpenFile(file_path, flags);
+
+	auto result = make_uniq<WriteBlobGlobalState>();
+	result->handle = std::move(handle);
+
+	return std::move(result);
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+// Local State
+//----------------------------------------------------------------------------------------------------------------------
+struct WriteBlobLocalState final : public LocalFunctionData {};
+
+unique_ptr<LocalFunctionData> WriteBlobInitializeLocal(ExecutionContext &context, FunctionData &bind_data) {
+	return make_uniq_base<LocalFunctionData, WriteBlobLocalState>();
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+// Sink
+//----------------------------------------------------------------------------------------------------------------------
+void WriteBlobSink(ExecutionContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
+                   LocalFunctionData &lstate, DataChunk &input) {
+	D_ASSERT(input.ColumnCount() == 1);
+
+	auto &state = gstate.Cast<WriteBlobGlobalState>();
+	lock_guard<mutex> glock(state.lock);
+
+	auto &handle = state.handle;
+
+	UnifiedVectorFormat vdata;
+	input.data[0].ToUnifiedFormat(input.size(), vdata);
+	const auto blobs = UnifiedVectorFormat::GetData<string_t>(vdata);
+
+	for (idx_t row_idx = 0; row_idx < input.size(); row_idx++) {
+		const auto out_idx = vdata.sel->get_index(row_idx);
+		if (vdata.validity.RowIsValid(out_idx)) {
+
+			auto &blob = blobs[out_idx];
+			auto blob_len = blob.GetSize();
+			auto blob_ptr = blob.GetDataWriteable();
+			auto blob_end = blob_ptr + blob_len;
+
+			while (blob_ptr < blob_end) {
+				auto written = handle->Write(blob_ptr, blob_len);
+				if (written <= 0) {
+					throw IOException("Failed to write to file!");
+				}
+				blob_ptr += written;
+			}
+		}
+	}
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+// Combine
+//----------------------------------------------------------------------------------------------------------------------
+void WriteBlobCombine(ExecutionContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
+                      LocalFunctionData &lstate) {
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+// Finalize
+//----------------------------------------------------------------------------------------------------------------------
+void WriteBlobFinalize(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate) {
+	auto &state = gstate.Cast<WriteBlobGlobalState>();
+	lock_guard<mutex> glock(state.lock);
+
+	state.handle->Close();
+}
+
+} // namespace
+
+//----------------------------------------------------------------------------------------------------------------------
+// Register
+//----------------------------------------------------------------------------------------------------------------------
+void BuiltinFunctions::RegisterCopyFunctions() {
+	CopyFunction info("blob");
+	info.copy_to_bind = WriteBlobBind;
+	info.copy_to_initialize_local = WriteBlobInitializeLocal;
+	info.copy_to_initialize_global = WriteBlobInitializeGlobal;
+	info.copy_to_sink = WriteBlobSink;
+	info.copy_to_combine = WriteBlobCombine;
+	info.copy_to_finalize = WriteBlobFinalize;
+	info.extension = "blob";
+
+	AddFunction(info);
+}
+
+} // namespace duckdb

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

@@ -2,6 +2,21 @@
 
 namespace duckdb {
 
+CopyFunction::CopyFunction(const string &name)
+    : Function(name), plan(nullptr), copy_to_select(nullptr), copy_to_bind(nullptr), copy_options(nullptr),
+      copy_to_initialize_local(nullptr), copy_to_initialize_global(nullptr), copy_to_get_written_statistics(nullptr),
+      copy_to_sink(nullptr), copy_to_combine(nullptr), copy_to_finalize(nullptr), execution_mode(nullptr),
+      initialize_operator(nullptr), prepare_batch(nullptr), flush_batch(nullptr), desired_batch_size(nullptr),
+      rotate_files(nullptr), rotate_next_file(nullptr), serialize(nullptr), deserialize(nullptr),
+      copy_from_bind(nullptr) {
+}
+
+CopyOption::CopyOption() : type(LogicalType::ANY), mode(CopyOptionMode::READ_WRITE) {
+}
+
+CopyOption::CopyOption(LogicalType type_p, CopyOptionMode mode_p) : type(std::move(type_p)), mode(mode_p) {
+}
+
 vector<string> GetCopyFunctionReturnNames(CopyFunctionReturnType return_type) {
 	switch (return_type) {
 	case CopyFunctionReturnType::CHANGED_ROWS:

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

@@ -101,6 +101,8 @@ void BuiltinFunctions::Initialize() {
 
 	RegisterPragmaFunctions();
 
+	RegisterCopyFunctions();
+
 	// initialize collations
 	AddCollation("nocase", LowerFun::GetFunction(), true);
 	AddCollation("noaccent", StripAccentsFun::GetFunction(), true);

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

@@ -3,6 +3,7 @@
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
 #include "duckdb/common/limits.hpp"
+#include "duckdb/common/type_visitor.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/aggregate_function.hpp"
 #include "duckdb/function/cast_rules.hpp"
@@ -33,7 +34,7 @@ optional_idx FunctionBinder::BindVarArgsFunctionCost(const SimpleFunction &func,
 			// arguments match: do nothing
 			continue;
 		}
-		int64_t cast_cost = CastFunctionSet::Get(context).ImplicitCastCost(arguments[i], arg_type);
+		int64_t cast_cost = CastFunctionSet::ImplicitCastCost(context, arguments[i], arg_type);
 		if (cast_cost >= 0) {
 			// we can implicitly cast, add the cost to the total cost
 			cost += idx_t(cast_cost);
@@ -61,7 +62,7 @@ optional_idx FunctionBinder::BindFunctionCost(const SimpleFunction &func, const
 			has_parameter = true;
 			continue;
 		}
-		int64_t cast_cost = CastFunctionSet::Get(context).ImplicitCastCost(arguments[i], func.arguments[i]);
+		int64_t cast_cost = CastFunctionSet::ImplicitCastCost(context, arguments[i], func.arguments[i]);
 		if (cast_cost >= 0) {
 			// we can implicitly cast, add the cost to the total cost
 			cost += idx_t(cast_cost);
@@ -234,7 +235,7 @@ optional_idx FunctionBinder::BindFunction(const string &name, TableFunctionSet &
 
 enum class LogicalTypeComparisonResult : uint8_t { IDENTICAL_TYPE, TARGET_IS_ANY, DIFFERENT_TYPES };
 
-LogicalTypeComparisonResult RequiresCast(const LogicalType &source_type, const LogicalType &target_type) {
+static LogicalTypeComparisonResult RequiresCast(const LogicalType &source_type, const LogicalType &target_type) {
 	if (target_type.id() == LogicalTypeId::ANY) {
 		return LogicalTypeComparisonResult::TARGET_IS_ANY;
 	}
@@ -250,7 +251,7 @@ LogicalTypeComparisonResult RequiresCast(const LogicalType &source_type, const L
 	return LogicalTypeComparisonResult::DIFFERENT_TYPES;
 }
 
-bool TypeRequiresPrepare(const LogicalType &type) {
+static bool TypeRequiresPrepare(const LogicalType &type) {
 	if (type.id() == LogicalTypeId::ANY) {
 		return true;
 	}
@@ -260,7 +261,7 @@ bool TypeRequiresPrepare(const LogicalType &type) {
 	return false;
 }
 
-LogicalType PrepareTypeForCastRecursive(const LogicalType &type) {
+static LogicalType PrepareTypeForCastRecursive(const LogicalType &type) {
 	if (type.id() == LogicalTypeId::ANY) {
 		return AnyType::GetTargetType(type);
 	}
@@ -270,7 +271,7 @@ LogicalType PrepareTypeForCastRecursive(const LogicalType &type) {
 	return type;
 }
 
-void PrepareTypeForCast(LogicalType &type) {
+static void PrepareTypeForCast(LogicalType &type) {
 	if (!TypeRequiresPrepare(type)) {
 		return;
 	}
@@ -354,11 +355,11 @@ unique_ptr<Expression> FunctionBinder::BindScalarFunction(ScalarFunctionCatalogE
 	return BindScalarFunction(bound_function, std::move(children), is_operator, binder);
 }
 
-bool RequiresCollationPropagation(const LogicalType &type) {
+static bool RequiresCollationPropagation(const LogicalType &type) {
 	return type.id() == LogicalTypeId::VARCHAR && !type.HasAlias();
 }
 
-string ExtractCollation(const vector<unique_ptr<Expression>> &children) {
+static string ExtractCollation(const vector<unique_ptr<Expression>> &children) {
 	string collation;
 	for (auto &arg : children) {
 		if (!RequiresCollationPropagation(arg->return_type)) {
@@ -375,7 +376,8 @@ string ExtractCollation(const vector<unique_ptr<Expression>> &children) {
 	return collation;
 }
 
-void PropagateCollations(ClientContext &, ScalarFunction &bound_function, vector<unique_ptr<Expression>> &children) {
+static void PropagateCollations(ClientContext &, ScalarFunction &bound_function,
+                                vector<unique_ptr<Expression>> &children) {
 	if (!RequiresCollationPropagation(bound_function.return_type)) {
 		// we only need to propagate if the function returns a varchar
 		return;
@@ -390,8 +392,8 @@ void PropagateCollations(ClientContext &, ScalarFunction &bound_function, vector
 	bound_function.return_type = std::move(collation_type);
 }
 
-void PushCollations(ClientContext &context, ScalarFunction &bound_function, vector<unique_ptr<Expression>> &children,
-                    CollationType type) {
+static void PushCollations(ClientContext &context, ScalarFunction &bound_function,
+                           vector<unique_ptr<Expression>> &children, CollationType type) {
 	auto collation = ExtractCollation(children);
 	if (collation.empty()) {
 		// no collation to push
@@ -413,8 +415,8 @@ void PushCollations(ClientContext &context, ScalarFunction &bound_function, vect
 	}
 }
 
-void HandleCollations(ClientContext &context, ScalarFunction &bound_function,
-                      vector<unique_ptr<Expression>> &children) {
+static void HandleCollations(ClientContext &context, ScalarFunction &bound_function,
+                             vector<unique_ptr<Expression>> &children) {
 	switch (bound_function.collation_handling) {
 	case FunctionCollationHandling::IGNORE_COLLATIONS:
 		// explicitly ignoring collation handling
@@ -431,9 +433,224 @@ void HandleCollations(ClientContext &context, ScalarFunction &bound_function,
 	}
 }
 
+static void InferTemplateType(ClientContext &context, const LogicalType &source, const LogicalType &target,
+                              case_insensitive_map_t<vector<LogicalType>> &bindings, const Expression &current_expr,
+                              const BaseScalarFunction &function) {
+
+	if (target.id() == LogicalTypeId::UNKNOWN || target.id() == LogicalTypeId::SQLNULL) {
+		// If the actual type is unknown, we cannot infer anything more.
+		// Therefore, we map all remaining templates in the source to UNKNOWN or SQLNULL, if not already inferred to
+		// something else
+
+		// This might seem a bit strange, why not just not set the binding and error out later when we try to substitute
+		// all templates? Well, this is how bindings for most nested functions already work, they simply propagate the
+		// UNKNOWN/SQLNULL. The binder will later check for UNKNOWN/SQLNULL in return types and if it finds one, insert
+		// a dummy cast to INT32 so that the function can be executed without errors (and just return NULLs).
+
+		TypeVisitor::Contains(source, [&](const LogicalType &child) {
+			if (child.id() == LogicalTypeId::TEMPLATE) {
+				const auto index = TemplateType::GetName(child);
+				if (bindings.find(index) == bindings.end()) {
+					// not found, add the binding
+					bindings[index] = {target.id()};
+				}
+			}
+			return false; // continue visiting
+		});
+		return;
+	}
+
+	// If the source is a template type, we bind it, or try to unify its existing binding with the target type.
+	if (source.id() == LogicalTypeId::TEMPLATE) {
+		const auto &index = TemplateType::GetName(source);
+		auto it = bindings.find(index);
+		if (it == bindings.end()) {
+			// not found, add the binding
+			bindings[index] = {target};
+			return;
+		}
+		if (it->second.back() == target) {
+			// already bound to the same type
+			return;
+		}
+
+		// Try to unify (promote) the type candidates
+		LogicalType result;
+		if (LogicalType::TryGetMaxLogicalType(context, it->second.back(), target, result)) {
+			// Type unification was successful
+			if (it->second.back() != result) {
+				// update the binding
+				it->second.push_back(target);
+				it->second.push_back(std::move(result)); // Push the new promoted type
+			}
+			return;
+		}
+
+		// If we reach here, it means the types are incompatible
+		string msg =
+		    StringUtil::Format("Cannot deduce template type '%s' in function: '%s'\nType '%s' was inferred to be:\n",
+		                       TemplateType::GetName(source), function.ToString(), TemplateType::GetName(source));
+		const auto &steps = it->second;
+
+		for (idx_t i = 0; i < steps.size(); i += 2) {
+			if (i == 0) {
+				// Normalize the first step to ensure it is a valid type
+				msg += StringUtil::Format(" - '%s', from first occurrence\n", steps[i].ToString());
+			} else {
+				msg += StringUtil::Format(" - '%s', by promoting '%s' + '%s'\n", steps[i].ToString(),
+				                          steps[i - 2].ToString(), steps[i - 1]);
+			}
+		}
+		msg += StringUtil::Format(" - '%s', which is incompatible with previously inferred type!", target.ToString());
+		throw BinderException(current_expr.GetQueryLocation(), msg);
+	}
+
+	// Otherwise, recurse downwards into nested types, and try to infer nested type members
+	// This only works if the source and target types are completely defined (excluding templates),
+	// i.e. they have aux info.
+	if (!(source.IsNested() && target.IsNested() && source.AuxInfo() && target.AuxInfo())) {
+		return;
+	}
+
+	switch (source.id()) {
+	case LogicalTypeId::LIST:
+	case LogicalTypeId::ARRAY: {
+		if ((source.id() == LogicalTypeId::ARRAY || source.id() == LogicalTypeId::LIST) &&
+		    (target.id() == LogicalTypeId::LIST || target.id() == LogicalTypeId::ARRAY)) {
+
+			const auto &source_child =
+			    source.id() == LogicalTypeId::LIST ? ListType::GetChildType(source) : ArrayType::GetChildType(source);
+			const auto &target_child =
+			    target.id() == LogicalTypeId::LIST ? ListType::GetChildType(target) : ArrayType::GetChildType(target);
+			InferTemplateType(context, source_child, target_child, bindings, current_expr, function);
+		}
+	} break;
+	case LogicalTypeId::MAP: {
+		// Map is only implicitly castable to map, so we only need to handle this case here/
+		if (target.id() == LogicalTypeId::MAP) {
+			const auto &source_key = MapType::KeyType(source);
+			const auto &source_val = MapType::ValueType(source);
+			const auto &target_key = MapType::KeyType(target);
+			const auto &target_val = MapType::ValueType(target);
+
+			InferTemplateType(context, source_key, target_key, bindings, current_expr, function);
+			InferTemplateType(context, source_val, target_val, bindings, current_expr, function);
+		}
+	} break;
+	case LogicalTypeId::UNION: {
+		// TODO: Support union types with template member types.
+		throw NotImplementedException("Union types cannot infer templated member types yet!");
+	} break;
+	case LogicalTypeId::STRUCT: {
+		// Structs are only implicitly castable to structs, so we only need to handle this case here.
+		if (target.id() == LogicalTypeId::STRUCT && StructType::IsUnnamed(source)) {
+			const auto &source_children = StructType::GetChildTypes(source);
+			const auto &target_children = StructType::GetChildTypes(target);
+
+			const auto common_children = MinValue(source_children.size(), target_children.size());
+			for (idx_t i = 0; i < common_children; i++) {
+				const auto &source_child_type = source_children[i].second;
+				const auto &target_child_type = target_children[i].second;
+				InferTemplateType(context, source_child_type, target_child_type, bindings, current_expr, function);
+			}
+		} else {
+			// TODO: Support named structs with template child types.
+			throw NotImplementedException("Named structs cannot infer templated child types yet!");
+		}
+	} break;
+	default:
+		break; // no template type to infer
+	}
+}
+
+static void SubstituteTemplateType(LogicalType &type, case_insensitive_map_t<vector<LogicalType>> &bindings,
+                                   const string &function_name) {
+
+	// Replace all template types in with their bound concrete types.
+	type = TypeVisitor::VisitReplace(type, [&](const LogicalType &t) -> LogicalType {
+		if (t.id() == LogicalTypeId::TEMPLATE) {
+			const auto index = TemplateType::GetName(t);
+			auto it = bindings.find(index);
+			if (it != bindings.end()) {
+				// found a binding, return the concrete type
+				return LogicalType::NormalizeType(it->second.back());
+			}
+
+			// If we reach here, the template type was not bound to any concrete type.
+			// We dont throw an error here, but give users a chance to handle unresolved template type later in the
+			// "bind_scalar_function_t" callback. We then throw an error if the template type is still not bound
+			// in the "CheckTemplateTypesResolved" method afterwards.
+		}
+		return t;
+	});
+}
+
+void FunctionBinder::ResolveTemplateTypes(BaseScalarFunction &bound_function,
+                                          const vector<unique_ptr<Expression>> &children) {
+	case_insensitive_map_t<vector<LogicalType>> bindings;
+	vector<reference<LogicalType>> to_substitute;
+
+	// First, we need to infer the template types from the children.
+	for (idx_t i = 0; i < bound_function.arguments.size(); i++) {
+		auto &param = bound_function.arguments[i];
+
+		// If the parameter is not templated, we can skip it.
+		if (param.IsTemplated()) {
+			auto actual = ExpressionBinder::GetExpressionReturnType(*children[i]);
+			InferTemplateType(context, param, actual, bindings, *children[i], bound_function);
+
+			to_substitute.emplace_back(param);
+		}
+	}
+
+	// If the function has a templated varargs, we need to infer its type too
+	if (bound_function.varargs.IsTemplated()) {
+		// All remaining children are considered varargs.
+		for (idx_t i = bound_function.arguments.size(); i < children.size(); i++) {
+			auto actual = ExpressionBinder::GetExpressionReturnType(*children[i]);
+			InferTemplateType(context, bound_function.varargs, actual, bindings, *children[i], bound_function);
+		}
+		to_substitute.emplace_back(bound_function.varargs);
+	}
+
+	// If the return type is templated, we need to subsitute it as well
+	if (bound_function.return_type.IsTemplated()) {
+		to_substitute.emplace_back(bound_function.return_type);
+	}
+
+	// Finally, substitute all template types in the bound function with their concrete types.
+	for (auto &templated_type : to_substitute) {
+		SubstituteTemplateType(templated_type, bindings, bound_function.name);
+	}
+}
+
+static void VerifyTemplateType(const LogicalType &type, const string &function_name) {
+	TypeVisitor::Contains(type, [&](const LogicalType &type) {
+		if (type.id() == LogicalTypeId::TEMPLATE) {
+			const auto msg =
+			    "Function '%s' has a template parameter type '%s' that could not be resolved to a concrete type";
+			throw BinderException(msg, function_name, TemplateType::GetName(type));
+		}
+		return false; // continue visiting
+	});
+}
+
+// Verify that all template types are bound to concrete types.
+void FunctionBinder::CheckTemplateTypesResolved(const BaseScalarFunction &bound_function) {
+	for (const auto &arg : bound_function.arguments) {
+		VerifyTemplateType(arg, bound_function.name);
+	}
+	VerifyTemplateType(bound_function.varargs, bound_function.name);
+	VerifyTemplateType(bound_function.return_type, bound_function.name);
+}
+
 unique_ptr<Expression> FunctionBinder::BindScalarFunction(ScalarFunction bound_function,
                                                           vector<unique_ptr<Expression>> children, bool is_operator,
                                                           optional_ptr<Binder> binder) {
+
+	// Attempt to resolve template types, before we call the "Bind" callback.
+	ResolveTemplateTypes(bound_function, children);
+
 	unique_ptr<FunctionData> bind_info;
 
 	if (bound_function.bind) {
@@ -448,11 +665,15 @@ unique_ptr<Expression> FunctionBinder::BindScalarFunction(ScalarFunction bound_f
 		bind_info = bound_function.bind_extended(bind_input, bound_function, children);
 	}
 
+	// After the "bind" callback, we verify that all template types are bound to concrete types.
+	CheckTemplateTypesResolved(bound_function);
+
 	if (bound_function.get_modified_databases && binder) {
 		auto &properties = binder->GetStatementProperties();
 		FunctionModifiedDatabasesInput input(bind_info, properties);
 		bound_function.get_modified_databases(context, input);
 	}
+
 	HandleCollations(context, bound_function, children);
 
 	// check if we need to add casts to the children
@@ -477,6 +698,9 @@ unique_ptr<BoundAggregateExpression> FunctionBinder::BindAggregateFunction(Aggre
                                                                            vector<unique_ptr<Expression>> children,
                                                                            unique_ptr<Expression> filter,
                                                                            AggregateType aggr_type) {
+
+	ResolveTemplateTypes(bound_function, children);
+
 	unique_ptr<FunctionData> bind_info;
 	if (bound_function.bind) {
 		bind_info = bound_function.bind(context, bound_function, children);
@@ -484,6 +708,8 @@ unique_ptr<BoundAggregateExpression> FunctionBinder::BindAggregateFunction(Aggre
 		children.resize(MinValue(bound_function.arguments.size(), children.size()));
 	}
 
+	CheckTemplateTypesResolved(bound_function);
+
 	// check if we need to add casts to the children
 	CastToFunctionArguments(bound_function, children);
 

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

@@ -6,6 +6,7 @@
 #include "duckdb/function/scalar/generic_functions.hpp"
 #include "duckdb/function/scalar/list_functions.hpp"
 #include "duckdb/function/scalar/map_functions.hpp"
+#include "duckdb/function/scalar/variant_functions.hpp"
 #include "duckdb/function/scalar/operator_functions.hpp"
 #include "duckdb/function/scalar/sequence_functions.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
@@ -53,6 +54,7 @@ static const StaticFunctionDefinition function[] = {
 	DUCKDB_SCALAR_FUNCTION_SET(InternalCompressIntegralUintegerFun),
 	DUCKDB_SCALAR_FUNCTION_SET(InternalCompressIntegralUsmallintFun),
 	DUCKDB_SCALAR_FUNCTION_SET(InternalCompressIntegralUtinyintFun),
+	DUCKDB_SCALAR_FUNCTION(InternalCompressStringHugeintFun),
 	DUCKDB_SCALAR_FUNCTION(InternalCompressStringUbigintFun),
 	DUCKDB_SCALAR_FUNCTION(InternalCompressStringUhugeintFun),
 	DUCKDB_SCALAR_FUNCTION(InternalCompressStringUintegerFun),
@@ -159,9 +161,13 @@ static const StaticFunctionDefinition function[] = {
 	DUCKDB_SCALAR_FUNCTION(StrlenFun),
 	DUCKDB_SCALAR_FUNCTION_SET(StrpTimeFun),
 	DUCKDB_SCALAR_FUNCTION(StructConcatFun),
+	DUCKDB_SCALAR_FUNCTION(StructContainsFun),
 	DUCKDB_SCALAR_FUNCTION_SET(StructExtractFun),
 	DUCKDB_SCALAR_FUNCTION(StructExtractAtFun),
+	DUCKDB_SCALAR_FUNCTION_ALIAS(StructHasFun),
+	DUCKDB_SCALAR_FUNCTION_ALIAS(StructIndexofFun),
 	DUCKDB_SCALAR_FUNCTION(StructPackFun),
+	DUCKDB_SCALAR_FUNCTION(StructPositionFun),
 	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(SubstrFun),
 	DUCKDB_SCALAR_FUNCTION_SET(SubstringFun),
 	DUCKDB_SCALAR_FUNCTION_SET(SubstringGraphemeFun),
@@ -170,6 +176,8 @@ static const StaticFunctionDefinition function[] = {
 	DUCKDB_SCALAR_FUNCTION_SET(TryStrpTimeFun),
 	DUCKDB_SCALAR_FUNCTION_ALIAS(UcaseFun),
 	DUCKDB_SCALAR_FUNCTION(UpperFun),
+	DUCKDB_SCALAR_FUNCTION_SET(VariantExtractFun),
+	DUCKDB_SCALAR_FUNCTION(VariantTypeofFun),
 	DUCKDB_SCALAR_FUNCTION_SET(WriteLogFun),
 	DUCKDB_SCALAR_FUNCTION(ConcatOperatorFun),
 	DUCKDB_SCALAR_FUNCTION(LikeFun),