duckdb 1.3.2 → 1.3.3-dev4.0

package/src/duckdb/src/function/scalar/string/substring.cpp

@@ -34,13 +34,13 @@ static inline void AssertInSupportedRange(idx_t input_size, int64_t offset, int6
 	}
 }
 
-string_t SubstringEmptyString(Vector &result) {
+static string_t SubstringEmptyString(Vector &result) {
 	auto result_string = StringVector::EmptyString(result, 0);
 	result_string.Finalize();
 	return result_string;
 }
 
-string_t SubstringSlice(Vector &result, const char *input_data, int64_t offset, int64_t length) {
+static string_t SubstringSlice(Vector &result, const char *input_data, int64_t offset, int64_t length) {
 	auto result_string = StringVector::EmptyString(result, UnsafeNumericCast<idx_t>(length));
 	auto result_data = result_string.GetDataWriteable();
 	memcpy(result_data, input_data + offset, UnsafeNumericCast<size_t>(length));
@@ -49,7 +49,7 @@ string_t SubstringSlice(Vector &result, const char *input_data, int64_t offset,
 }
 
 // compute start and end characters from the given input size and offset/length
-bool SubstringStartEnd(int64_t input_size, int64_t offset, int64_t length, int64_t &start, int64_t &end) {
+static bool SubstringStartEnd(int64_t input_size, int64_t offset, int64_t length, int64_t &start, int64_t &end) {
 	if (length == 0) {
 		return false;
 	}
@@ -250,6 +250,8 @@ string_t SubstringGrapheme(Vector &result, string_t input, int64_t offset, int64
 	                      UnsafeNumericCast<int64_t>(end_pos - start_pos));
 }
 
+namespace {
+
 struct SubstringUnicodeOp {
 	static string_t Substring(Vector &result, string_t input, int64_t offset, int64_t length) {
 		return SubstringUnicode(result, input, offset, length);
@@ -263,7 +265,7 @@ struct SubstringGraphemeOp {
 };
 
 template <class OP>
-static void SubstringFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void SubstringFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &input_vector = args.data[0];
 	auto &offset_vector = args.data[1];
 	if (args.ColumnCount() == 3) {
@@ -282,7 +284,7 @@ static void SubstringFunction(DataChunk &args, ExpressionState &state, Vector &r
 	}
 }
 
-static void SubstringFunctionASCII(DataChunk &args, ExpressionState &state, Vector &result) {
+void SubstringFunctionASCII(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &input_vector = args.data[0];
 	auto &offset_vector = args.data[1];
 	if (args.ColumnCount() == 3) {
@@ -301,7 +303,7 @@ static void SubstringFunctionASCII(DataChunk &args, ExpressionState &state, Vect
 	}
 }
 
-static unique_ptr<BaseStatistics> SubstringPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
+unique_ptr<BaseStatistics> SubstringPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
 	// can only propagate stats if the children have stats
@@ -312,6 +314,8 @@ static unique_ptr<BaseStatistics> SubstringPropagateStats(ClientContext &context
 	return nullptr;
 }
 
+} // namespace
+
 ScalarFunctionSet SubstringFun::GetFunctions() {
 	ScalarFunctionSet substr("substring");
 	substr.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT, LogicalType::BIGINT},

package/src/duckdb/src/function/scalar/string/suffix.cpp

@@ -5,14 +5,7 @@
 
 namespace duckdb {
 
-static bool SuffixFunction(const string_t &str, const string_t &suffix);
-
-struct SuffixOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return SuffixFunction(left, right);
-	}
-};
+namespace {
 
 static bool SuffixFunction(const string_t &str, const string_t &suffix) {
 	auto suffix_size = suffix.GetSize();
@@ -33,6 +26,15 @@ static bool SuffixFunction(const string_t &str, const string_t &suffix) {
 	return true;
 }
 
+struct SuffixOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		return SuffixFunction(left, right);
+	}
+};
+
+} // namespace
+
 ScalarFunction SuffixFun::GetFunction() {
 	return ScalarFunction("suffix",                                     // name of the function
 	                      {LogicalType::VARCHAR, LogicalType::VARCHAR}, // argument list

package/src/duckdb/src/function/scalar/struct/remap_struct.cpp

@@ -9,6 +9,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct RemapColumnInfo {
 	optional_idx index;
 	optional_idx default_index;
@@ -36,13 +38,12 @@ public:
 	}
 };
 
-static void RemapNested(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
-                        const vector<RemapColumnInfo> &remap_info);
+void RemapNested(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
+                 const vector<RemapColumnInfo> &remap_info);
 
-static void RemapChildVectors(const Vector &result, const vector<reference<Vector>> &input_vectors,
-                              const vector<reference<Vector>> &result_vectors,
-                              const vector<RemapColumnInfo> &remap_info, Vector &default_vector,
-                              const bool has_top_level_null, idx_t count) {
+void RemapChildVectors(const Vector &result, const vector<reference<Vector>> &input_vectors,
+                       const vector<reference<Vector>> &result_vectors, const vector<RemapColumnInfo> &remap_info,
+                       Vector &default_vector, const bool has_top_level_null, idx_t count) {
 	// set up the correct vector references
 	for (idx_t i = 0; i < remap_info.size(); i++) {
 		auto &remap = remap_info[i];
@@ -76,8 +77,8 @@ static void RemapChildVectors(const Vector &result, const vector<reference<Vecto
 	}
 }
 
-static void RemapMap(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
-                     const vector<RemapColumnInfo> &remap_info) {
+void RemapMap(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
+              const vector<RemapColumnInfo> &remap_info) {
 	auto &input_key_vector = MapVector::GetKeys(input);
 	auto &input_value_vector = MapVector::GetValues(input);
 
@@ -132,8 +133,8 @@ static void RemapMap(Vector &input, Vector &default_vector, Vector &result, idx_
 	RemapChildVectors(result, input_vectors, result_vectors, remap_info, default_vector, has_top_level_null, list_size);
 }
 
-static void RemapList(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
-                      const vector<RemapColumnInfo> &remap_info) {
+void RemapList(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
+               const vector<RemapColumnInfo> &remap_info) {
 	auto &input_vector = ListVector::GetEntry(input);
 	auto &result_vector = ListVector::GetEntry(result);
 	auto list_size = ListVector::GetListSize(input);
@@ -181,8 +182,8 @@ static void RemapList(Vector &input, Vector &default_vector, Vector &result, idx
 	RemapChildVectors(result, input_vectors, result_vectors, remap_info, default_vector, has_top_level_null, list_size);
 }
 
-static void RemapStruct(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
-                        const vector<RemapColumnInfo> &remap_info) {
+void RemapStruct(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
+                 const vector<RemapColumnInfo> &remap_info) {
 	auto &input_child_vectors = StructVector::GetEntries(input);
 	auto &result_child_vectors = StructVector::GetEntries(result);
 	if (result_child_vectors.size() != remap_info.size()) {
@@ -226,8 +227,8 @@ static void RemapStruct(Vector &input, Vector &default_vector, Vector &result, i
 	                  result_size);
 }
 
-static void RemapNested(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
-                        const vector<RemapColumnInfo> &remap_info) {
+void RemapNested(Vector &input, Vector &default_vector, Vector &result, idx_t result_size,
+                 const vector<RemapColumnInfo> &remap_info) {
 	auto &source_type = input.GetType();
 	D_ASSERT(source_type.IsNested());
 	switch (source_type.id()) {
@@ -242,7 +243,7 @@ static void RemapNested(Vector &input, Vector &default_vector, Vector &result, i
 	}
 }
 
-static void RemapStructFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void RemapStructFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	auto &info = func_expr.bind_info->Cast<RemapStructBindData>();
 
@@ -539,8 +540,8 @@ struct RemapEntry {
 	}
 };
 
-static unique_ptr<FunctionData> RemapStructBind(ClientContext &context, ScalarFunction &bound_function,
-                                                vector<unique_ptr<Expression>> &arguments) {
+unique_ptr<FunctionData> RemapStructBind(ClientContext &context, ScalarFunction &bound_function,
+                                         vector<unique_ptr<Expression>> &arguments) {
 	D_ASSERT(arguments.size() == 4);
 	for (idx_t arg_idx = 0; arg_idx < 3; arg_idx++) {
 		auto &arg = arguments[arg_idx];
@@ -621,6 +622,8 @@ static unique_ptr<FunctionData> RemapStructBind(ClientContext &context, ScalarFu
 	return make_uniq<RemapStructBindData>(std::move(remap));
 }
 
+} // namespace
+
 ScalarFunction RemapStructFun::GetFunction() {
 	ScalarFunction remap("remap_struct",
 	                     {LogicalTypeId::ANY, LogicalTypeId::ANY, LogicalTypeId::ANY, LogicalTypeId::ANY},

package/src/duckdb/src/function/scalar/struct/struct_concat.cpp

@@ -84,7 +84,7 @@ static unique_ptr<FunctionData> StructConcatBind(ClientContext &context, ScalarF
 	return nullptr;
 }
 
-unique_ptr<BaseStatistics> StructConcatStats(ClientContext &context, FunctionStatisticsInput &input) {
+static unique_ptr<BaseStatistics> StructConcatStats(ClientContext &context, FunctionStatisticsInput &input) {
 	const auto &expr = input.expr;
 
 	auto &arg_stats = input.child_stats;

package/src/duckdb/src/function/scalar/struct/struct_contains.cpp

@@ -0,0 +1,255 @@
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/function/scalar/struct_functions.hpp"
+#include "duckdb/function/scalar/list/contains_or_position.hpp"
+
+namespace duckdb {
+
+template <class T, class RETURN_TYPE, bool FIND_NULLS>
+static void TemplatedStructSearch(Vector &input_vector, vector<unique_ptr<Vector>> &members, Vector &target,
+                                  const idx_t count, Vector &result) {
+	// If the return type is not a bool, return the position
+	const auto return_pos = std::is_same<RETURN_TYPE, int32_t>::value;
+
+	const auto &target_type = target.GetType();
+
+	UnifiedVectorFormat vector_format;
+	input_vector.ToUnifiedFormat(count, vector_format);
+
+	UnifiedVectorFormat target_format;
+	target.ToUnifiedFormat(count, target_format);
+	const auto target_data = UnifiedVectorFormat::GetData<T>(target_format);
+
+	vector<const T *> member_datas;
+	vector<UnifiedVectorFormat> member_vectors;
+	idx_t total_matches = 0;
+	for (const auto &member : members) {
+		if (member->GetType().InternalType() == target_type.InternalType()) {
+			UnifiedVectorFormat member_format;
+			member->ToUnifiedFormat(count, member_format);
+			member_datas.push_back(UnifiedVectorFormat::GetData<T>(member_format));
+			member_vectors.push_back(std::move(member_format));
+			total_matches++;
+		} else {
+			member_datas.push_back(nullptr);
+			member_vectors.push_back(UnifiedVectorFormat());
+		}
+	}
+
+	if (total_matches == 0 && return_pos) {
+		// if there are no members that match the target type, we cannot return a position
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+		ConstantVector::SetNull(result, true);
+		return;
+	}
+
+	result.SetVectorType(VectorType::FLAT_VECTOR);
+	auto result_data = FlatVector::GetData<RETURN_TYPE>(result);
+	auto &result_validity = FlatVector::Validity(result);
+
+	const auto member_count = members.size();
+	for (idx_t row = 0; row < count; row++) {
+		const auto &member_row_idx = vector_format.sel->get_index(row);
+
+		if (!vector_format.validity.RowIsValid(member_row_idx)) {
+			result_validity.SetInvalid(row);
+			continue;
+		}
+
+		const auto &target_row_idx = target_format.sel->get_index(row);
+		const bool target_valid = target_format.validity.RowIsValid(target_row_idx);
+
+		// We are finished if we are not looking for NULL, and the target is NULL.
+		const auto finished = !FIND_NULLS && !target_valid;
+		// We did not find the target (finished, or struct is empty).
+		if (finished) {
+			if (!target_valid || return_pos) {
+				result_validity.SetInvalid(row);
+			} else {
+				result_data[row] = false;
+			}
+			continue;
+		}
+
+		bool found = false;
+
+		for (idx_t member_idx = 0; member_idx < member_count; member_idx++) {
+			auto &member_data = member_datas[member_idx];
+			if (!member_data) {
+				continue; // skip if member data is not compatible with the target type
+			}
+			const auto &member_vector = member_vectors[member_idx];
+			const auto member_data_idx = member_vector.sel->get_index(row);
+			const auto col_valid = member_vector.validity.RowIsValid(member_data_idx);
+
+			auto is_null = FIND_NULLS && !col_valid && !target_valid;
+			auto both_valid_and_match = col_valid && target_valid &&
+			                            Equals::Operation<T>(member_data[member_data_idx], target_data[target_row_idx]);
+
+			if (is_null || both_valid_and_match) {
+				found = true;
+				if (return_pos) {
+					result_data[row] = UnsafeNumericCast<int32_t>(member_idx + 1);
+				} else {
+					result_data[row] = true;
+				}
+			}
+		}
+
+		if (!found) {
+			if (return_pos) {
+				result_validity.SetInvalid(row);
+			} else {
+				result_data[row] = false;
+			}
+		}
+	}
+}
+
+template <class RETURN_TYPE, bool FIND_NULLS>
+static void StructNestedOp(Vector &input_vector, vector<unique_ptr<Vector>> &members, Vector &target, const idx_t count,
+                           Vector &result) {
+	const OrderModifiers order_modifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST);
+
+	// Set up sort keys for nested types.
+	const auto members_size = members.size();
+	vector<unique_ptr<Vector>> member_sort_key_vectors;
+	for (idx_t i = 0; i < members_size; i++) {
+		Vector member_sort_key_vec(LogicalType::BLOB, count);
+		CreateSortKeyHelpers::CreateSortKeyWithValidity(*members[i], member_sort_key_vec, order_modifiers, count);
+
+		auto member_sort_key_ptr = make_uniq<Vector>(member_sort_key_vec);
+		member_sort_key_vectors.push_back(std::move(member_sort_key_ptr));
+	}
+
+	Vector target_sort_key_vec(LogicalType::BLOB, count);
+	CreateSortKeyHelpers::CreateSortKeyWithValidity(target, target_sort_key_vec, order_modifiers, count);
+
+	TemplatedStructSearch<string_t, RETURN_TYPE, FIND_NULLS>(input_vector, member_sort_key_vectors, target_sort_key_vec,
+	                                                         count, result);
+}
+
+template <class RETURN_TYPE, bool FIND_NULLS>
+static void StructSearchOp(Vector &input_vector, vector<unique_ptr<Vector>> &members, Vector &target, const idx_t count,
+                           Vector &result) {
+	const auto &target_type = target.GetType().InternalType();
+	switch (target_type) {
+	case PhysicalType::BOOL:
+	case PhysicalType::INT8:
+		return TemplatedStructSearch<int8_t, RETURN_TYPE, FIND_NULLS>(input_vector, members, target, count, result);
+	case PhysicalType::INT16:
+		return TemplatedStructSearch<int16_t, RETURN_TYPE, FIND_NULLS>(input_vector, members, target, count, result);
+	case PhysicalType::INT32:
+		return TemplatedStructSearch<int32_t, RETURN_TYPE, FIND_NULLS>(input_vector, members, target, count, result);
+	case PhysicalType::INT64:
+		return TemplatedStructSearch<int64_t, RETURN_TYPE, FIND_NULLS>(input_vector, members, target, count, result);
+	case PhysicalType::INT128:
+		return TemplatedStructSearch<hugeint_t, RETURN_TYPE, FIND_NULLS>(input_vector, members, target, count, result);
+	case PhysicalType::UINT8:
+		return TemplatedStructSearch<uint8_t, RETURN_TYPE, FIND_NULLS>(input_vector, members, target, count, result);
+	case PhysicalType::UINT16:
+		return TemplatedStructSearch<uint16_t, RETURN_TYPE, FIND_NULLS>(input_vector, members, target, count, result);
+	case PhysicalType::UINT32:
+		return TemplatedStructSearch<uint32_t, RETURN_TYPE, FIND_NULLS>(input_vector, members, target, count, result);
+	case PhysicalType::UINT64:
+		return TemplatedStructSearch<uint64_t, RETURN_TYPE, FIND_NULLS>(input_vector, members, target, count, result);
+	case PhysicalType::UINT128:
+		return TemplatedStructSearch<uhugeint_t, RETURN_TYPE, FIND_NULLS>(input_vector, members, target, count, result);
+	case PhysicalType::FLOAT:
+		return TemplatedStructSearch<float, RETURN_TYPE, FIND_NULLS>(input_vector, members, target, count, result);
+	case PhysicalType::DOUBLE:
+		return TemplatedStructSearch<double, RETURN_TYPE, FIND_NULLS>(input_vector, members, target, count, result);
+	case PhysicalType::VARCHAR:
+		return TemplatedStructSearch<string_t, RETURN_TYPE, FIND_NULLS>(input_vector, members, target, count, result);
+	case PhysicalType::INTERVAL:
+		return TemplatedStructSearch<interval_t, RETURN_TYPE, FIND_NULLS>(input_vector, members, target, count, result);
+	case PhysicalType::STRUCT:
+	case PhysicalType::LIST:
+	case PhysicalType::ARRAY:
+		return StructNestedOp<RETURN_TYPE, FIND_NULLS>(input_vector, members, target, count, result);
+	default:
+		throw NotImplementedException("This function has not been implemented for logical type %s",
+		                              TypeIdToString(target_type));
+	}
+}
+
+template <class RETURN_TYPE, bool FIND_NULLS = false>
+static void StructSearchFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	if (result.GetType().id() == LogicalTypeId::SQLNULL) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+		ConstantVector::SetNull(result, true);
+		return;
+	}
+
+	const auto count = args.size();
+	auto &input_vector = args.data[0];
+	auto &members = StructVector::GetEntries(input_vector);
+	auto &target = args.data[1];
+
+	StructSearchOp<RETURN_TYPE, FIND_NULLS>(input_vector, members, target, count, result);
+
+	if (args.AllConstant()) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+}
+
+static unique_ptr<FunctionData> StructContainsBind(ClientContext &context, ScalarFunction &bound_function,
+                                                   vector<unique_ptr<Expression>> &arguments) {
+	D_ASSERT(bound_function.arguments.size() == 2);
+	auto &child_type = arguments[0]->return_type;
+	if (child_type.id() == LogicalTypeId::UNKNOWN) {
+		throw ParameterNotResolvedException();
+	}
+
+	if (child_type.id() == LogicalTypeId::SQLNULL) {
+		bound_function.arguments[0] = LogicalTypeId::UNKNOWN;
+		bound_function.arguments[1] = LogicalTypeId::UNKNOWN;
+		bound_function.return_type = LogicalType::SQLNULL;
+		return nullptr;
+	}
+
+	auto &struct_children = StructType::GetChildTypes(arguments[0]->return_type);
+	if (struct_children.empty()) {
+		throw InternalException("Can't check for containment in an empty struct");
+	}
+	if (!StructType::IsUnnamed(child_type)) {
+		throw BinderException("%s can only be used on unnamed structs", bound_function.name);
+	}
+	bound_function.arguments[0] = child_type;
+
+	// the value type must match one of the struct's children
+	LogicalType max_child_type = arguments[1]->return_type;
+	vector<LogicalType> new_child_types;
+	for (auto &child : struct_children) {
+		if (!LogicalType::TryGetMaxLogicalType(context, child.second, max_child_type, max_child_type)) {
+			new_child_types.push_back(child.second);
+			continue;
+		}
+
+		new_child_types.push_back(max_child_type);
+		bound_function.arguments[1] = max_child_type;
+	}
+
+	child_list_t<LogicalType> cast_children;
+	for (idx_t i = 0; i < new_child_types.size(); i++) {
+		cast_children.push_back(make_pair(struct_children[i].first, new_child_types[i]));
+	}
+
+	bound_function.arguments[0] = LogicalType::STRUCT(cast_children);
+
+	return nullptr;
+}
+
+ScalarFunction StructContainsFun::GetFunction() {
+	return ScalarFunction("struct_contains", {LogicalTypeId::STRUCT, LogicalType::ANY}, LogicalType::BOOLEAN,
+	                      StructSearchFunction<bool>, StructContainsBind);
+}
+
+ScalarFunction StructPositionFun::GetFunction() {
+	ScalarFunction fun("struct_contains", {LogicalTypeId::STRUCT, LogicalType::ANY}, LogicalType::INTEGER,
+	                   StructSearchFunction<int32_t, true>, StructContainsBind);
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	return fun;
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/scalar/struct/struct_pack.cpp

@@ -60,7 +60,7 @@ static unique_ptr<FunctionData> StructPackBind(ClientContext &context, ScalarFun
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
-unique_ptr<BaseStatistics> StructPackStats(ClientContext &context, FunctionStatisticsInput &input) {
+static unique_ptr<BaseStatistics> StructPackStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
 	auto struct_stats = StructStats::CreateUnknown(expr.return_type);
@@ -71,7 +71,7 @@ unique_ptr<BaseStatistics> StructPackStats(ClientContext &context, FunctionStati
 }
 
 template <bool IS_STRUCT_PACK>
-ScalarFunction GetStructPackFunction() {
+static ScalarFunction GetStructPackFunction() {
 	ScalarFunction fun(IS_STRUCT_PACK ? "struct_pack" : "row", {}, LogicalTypeId::STRUCT, StructPackFunction,
 	                   StructPackBind<IS_STRUCT_PACK>, nullptr, StructPackStats);
 	fun.varargs = LogicalType::ANY;

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -11,6 +11,8 @@
 
 namespace duckdb {
 
+namespace {
+
 // aggregate state export
 struct ExportAggregateBindData : public FunctionData {
 	AggregateFunction aggr;
@@ -52,8 +54,8 @@ struct CombineState : public FunctionLocalState {
 	}
 };
 
-static unique_ptr<FunctionLocalState> InitCombineState(ExpressionState &state, const BoundFunctionExpression &expr,
-                                                       FunctionData *bind_data_p) {
+unique_ptr<FunctionLocalState> InitCombineState(ExpressionState &state, const BoundFunctionExpression &expr,
+                                                FunctionData *bind_data_p) {
 	auto &bind_data = bind_data_p->Cast<ExportAggregateBindData>();
 	return make_uniq<CombineState>(bind_data.state_size);
 }
@@ -72,13 +74,13 @@ struct FinalizeState : public FunctionLocalState {
 	}
 };
 
-static unique_ptr<FunctionLocalState> InitFinalizeState(ExpressionState &state, const BoundFunctionExpression &expr,
-                                                        FunctionData *bind_data_p) {
+unique_ptr<FunctionLocalState> InitFinalizeState(ExpressionState &state, const BoundFunctionExpression &expr,
+                                                 FunctionData *bind_data_p) {
 	auto &bind_data = bind_data_p->Cast<ExportAggregateBindData>();
 	return make_uniq<FinalizeState>(bind_data.state_size);
 }
 
-static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, Vector &result) {
+void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, Vector &result) {
 	auto &bind_data = ExportAggregateBindData::GetFrom(state_p);
 	auto &local_state = ExecuteFunctionState::GetFunctionState(state_p)->Cast<FinalizeState>();
 	local_state.allocator.Reset();
@@ -119,7 +121,7 @@ static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, V
 	}
 }
 
-static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Vector &result) {
+void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Vector &result) {
 	auto &bind_data = ExportAggregateBindData::GetFrom(state_p);
 	auto &local_state = ExecuteFunctionState::GetFunctionState(state_p)->Cast<CombineState>();
 	local_state.allocator.Reset();
@@ -181,8 +183,8 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 	}
 }
 
-static unique_ptr<FunctionData> BindAggregateState(ClientContext &context, ScalarFunction &bound_function,
-                                                   vector<unique_ptr<Expression>> &arguments) {
+unique_ptr<FunctionData> BindAggregateState(ClientContext &context, ScalarFunction &bound_function,
+                                            vector<unique_ptr<Expression>> &arguments) {
 
 	// grab the aggregate type and bind the aggregate again
 
@@ -253,8 +255,8 @@ static unique_ptr<FunctionData> BindAggregateState(ClientContext &context, Scala
 	return make_uniq<ExportAggregateBindData>(bound_aggr, bound_aggr.state_size(bound_aggr));
 }
 
-static void ExportAggregateFinalize(Vector &state, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-                                    idx_t offset) {
+void ExportAggregateFinalize(Vector &state, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
+                             idx_t offset) {
 	D_ASSERT(offset == 0);
 	auto &bind_data = aggr_input_data.bind_data->Cast<ExportAggregateFunctionBindData>();
 	auto state_size = bind_data.aggregate->function.state_size(bind_data.aggregate->function);
@@ -266,39 +268,26 @@ static void ExportAggregateFinalize(Vector &state, AggregateInputData &aggr_inpu
 	}
 }
 
-ExportAggregateFunctionBindData::ExportAggregateFunctionBindData(unique_ptr<Expression> aggregate_p) {
-	D_ASSERT(aggregate_p->GetExpressionType() == ExpressionType::BOUND_AGGREGATE);
-	aggregate = unique_ptr_cast<Expression, BoundAggregateExpression>(std::move(aggregate_p));
-}
-
-unique_ptr<FunctionData> ExportAggregateFunctionBindData::Copy() const {
-	return make_uniq<ExportAggregateFunctionBindData>(aggregate->Copy());
-}
-
-bool ExportAggregateFunctionBindData::Equals(const FunctionData &other_p) const {
-	auto &other = other_p.Cast<ExportAggregateFunctionBindData>();
-	return aggregate->Equals(*other.aggregate);
-}
-
-static void ExportStateAggregateSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                                          const AggregateFunction &function) {
+void ExportStateAggregateSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+                                   const AggregateFunction &function) {
 	throw NotImplementedException("FIXME: export state serialize");
 }
 
-static unique_ptr<FunctionData> ExportStateAggregateDeserialize(Deserializer &deserializer,
-                                                                AggregateFunction &function) {
+unique_ptr<FunctionData> ExportStateAggregateDeserialize(Deserializer &deserializer, AggregateFunction &function) {
 	throw NotImplementedException("FIXME: export state deserialize");
 }
 
-static void ExportStateScalarSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                                       const ScalarFunction &function) {
+void ExportStateScalarSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+                                const ScalarFunction &function) {
 	throw NotImplementedException("FIXME: export state serialize");
 }
 
-static unique_ptr<FunctionData> ExportStateScalarDeserialize(Deserializer &deserializer, ScalarFunction &function) {
+unique_ptr<FunctionData> ExportStateScalarDeserialize(Deserializer &deserializer, ScalarFunction &function) {
 	throw NotImplementedException("FIXME: export state deserialize");
 }
 
+} // namespace
+
 unique_ptr<BoundAggregateExpression>
 ExportAggregateFunction::Bind(unique_ptr<BoundAggregateExpression> child_aggregate) {
 	auto &bound_function = child_aggregate->function;
@@ -341,6 +330,20 @@ ExportAggregateFunction::Bind(unique_ptr<BoundAggregateExpression> child_aggrega
 	                                           child_aggregate->aggr_type);
 }
 
+ExportAggregateFunctionBindData::ExportAggregateFunctionBindData(unique_ptr<Expression> aggregate_p) {
+	D_ASSERT(aggregate_p->GetExpressionType() == ExpressionType::BOUND_AGGREGATE);
+	aggregate = unique_ptr_cast<Expression, BoundAggregateExpression>(std::move(aggregate_p));
+}
+
+unique_ptr<FunctionData> ExportAggregateFunctionBindData::Copy() const {
+	return make_uniq<ExportAggregateFunctionBindData>(aggregate->Copy());
+}
+
+bool ExportAggregateFunctionBindData::Equals(const FunctionData &other_p) const {
+	auto &other = other_p.Cast<ExportAggregateFunctionBindData>();
+	return aggregate->Equals(*other.aggregate);
+}
+
 ScalarFunction FinalizeFun::GetFunction() {
 	auto result = ScalarFunction("finalize", {LogicalTypeId::AGGREGATE_STATE}, LogicalTypeId::INVALID,
 	                             AggregateStateFinalize, BindAggregateState, nullptr, nullptr, InitFinalizeState);

package/src/duckdb/src/function/scalar/system/current_connection_id.cpp

@@ -7,6 +7,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct CurrentConnectionIdData : FunctionData {
 	explicit CurrentConnectionIdData(Value connection_id_p) : connection_id(std::move(connection_id_p)) {
 	}
@@ -25,12 +27,14 @@ unique_ptr<FunctionData> CurrentConnectionIdBind(ClientContext &context, ScalarF
 	return make_uniq<CurrentConnectionIdData>(Value::UBIGINT(context.GetConnectionId()));
 }
 
-static void CurrentConnectionIdFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void CurrentConnectionIdFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	const auto &info = func_expr.bind_info->Cast<CurrentConnectionIdData>();
 	result.Reference(info.connection_id);
 }
 
+} // namespace
+
 ScalarFunction CurrentConnectionId::GetFunction() {
 	return ScalarFunction({}, LogicalType::UBIGINT, CurrentConnectionIdFunction, CurrentConnectionIdBind, nullptr,
 	                      nullptr, nullptr, LogicalType(LogicalTypeId::INVALID), FunctionStability::VOLATILE);

package/src/duckdb/src/function/scalar/system/current_query_id.cpp

@@ -7,6 +7,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct CurrentQueryIdData : FunctionData {
 	explicit CurrentQueryIdData(Value query_id_p) : query_id(std::move(query_id_p)) {
 	}
@@ -31,12 +33,14 @@ unique_ptr<FunctionData> CurrentQueryIdBind(ClientContext &context, ScalarFuncti
 	return make_uniq<CurrentQueryIdData>(query_id);
 }
 
-static void CurrentQueryIdFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void CurrentQueryIdFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	const auto &info = func_expr.bind_info->Cast<CurrentQueryIdData>();
 	result.Reference(info.query_id);
 }
 
+} // namespace
+
 ScalarFunction CurrentQueryId::GetFunction() {
 	return ScalarFunction({}, LogicalType::UBIGINT, CurrentQueryIdFunction, CurrentQueryIdBind, nullptr, nullptr,
 	                      nullptr, LogicalType(LogicalTypeId::INVALID), FunctionStability::VOLATILE);