duckdb 1.3.3-dev4.0 → 1.3.3

package/src/duckdb/extension/core_functions/scalar/list/array_slice.cpp

@@ -11,13 +11,14 @@
 
 namespace duckdb {
 
-namespace {
-
 struct ListSliceBindData : public FunctionData {
 	ListSliceBindData(const LogicalType &return_type_p, bool begin_is_empty_p, bool end_is_empty_p)
 	    : return_type(return_type_p), begin_is_empty(begin_is_empty_p), end_is_empty(end_is_empty_p) {
 	}
+	~ListSliceBindData() override;
+
 	LogicalType return_type;
+
 	bool begin_is_empty;
 	bool end_is_empty;
 
@@ -26,6 +27,9 @@ public:
 	unique_ptr<FunctionData> Copy() const override;
 };
 
+ListSliceBindData::~ListSliceBindData() {
+}
+
 bool ListSliceBindData::Equals(const FunctionData &other_p) const {
 	auto &other = other_p.Cast<ListSliceBindData>();
 	return return_type == other.return_type && begin_is_empty == other.begin_is_empty &&
@@ -37,7 +41,7 @@ unique_ptr<FunctionData> ListSliceBindData::Copy() const {
 }
 
 template <typename INDEX_TYPE>
-idx_t CalculateSliceLength(idx_t begin, idx_t end, INDEX_TYPE step, bool svalid) {
+static idx_t CalculateSliceLength(idx_t begin, idx_t end, INDEX_TYPE step, bool svalid) {
 	if (step < 0) {
 		step = AbsValue(step);
 	}
@@ -119,7 +123,7 @@ struct ListSliceOperations {
 };
 
 template <typename INPUT_TYPE, typename INDEX_TYPE>
-void ClampIndex(INDEX_TYPE &index, const INPUT_TYPE &value, const INDEX_TYPE length, bool is_min) {
+static void ClampIndex(INDEX_TYPE &index, const INPUT_TYPE &value, const INDEX_TYPE length, bool is_min) {
 	if (index < 0) {
 		index = (!is_min) ? index + 1 : index;
 		index = length + index;
@@ -131,7 +135,7 @@ void ClampIndex(INDEX_TYPE &index, const INPUT_TYPE &value, const INDEX_TYPE len
 }
 
 template <typename INPUT_TYPE, typename INDEX_TYPE, typename OP>
-bool ClampSlice(const INPUT_TYPE &value, INDEX_TYPE &begin, INDEX_TYPE &end) {
+static bool ClampSlice(const INPUT_TYPE &value, INDEX_TYPE &begin, INDEX_TYPE &end) {
 	// Clamp offsets
 	begin = (begin != 0 && begin != (INDEX_TYPE)NumericLimits<int64_t>::Minimum()) ? begin - 1 : begin;
 
@@ -158,9 +162,10 @@ bool ClampSlice(const INPUT_TYPE &value, INDEX_TYPE &begin, INDEX_TYPE &end) {
 }
 
 template <typename INPUT_TYPE, typename INDEX_TYPE, typename OP>
-void ExecuteConstantSlice(Vector &result, Vector &str_vector, Vector &begin_vector, Vector &end_vector,
-                          optional_ptr<Vector> step_vector, const idx_t count, SelectionVector &sel, idx_t &sel_idx,
-                          optional_ptr<Vector> result_child_vector, bool begin_is_empty, bool end_is_empty) {
+static void ExecuteConstantSlice(Vector &result, Vector &str_vector, Vector &begin_vector, Vector &end_vector,
+                                 optional_ptr<Vector> step_vector, const idx_t count, SelectionVector &sel,
+                                 idx_t &sel_idx, optional_ptr<Vector> result_child_vector, bool begin_is_empty,
+                                 bool end_is_empty) {
 
 	// check all this nullness early
 	auto str_valid = !ConstantVector::IsNull(str_vector);
@@ -175,20 +180,13 @@ void ExecuteConstantSlice(Vector &result, Vector &str_vector, Vector &begin_vect
 
 	auto result_data = ConstantVector::GetData<INPUT_TYPE>(result);
 	auto str_data = ConstantVector::GetData<INPUT_TYPE>(str_vector);
+	auto begin_data = ConstantVector::GetData<INDEX_TYPE>(begin_vector);
+	auto end_data = ConstantVector::GetData<INDEX_TYPE>(end_vector);
 	auto step_data = step_vector ? ConstantVector::GetData<INDEX_TYPE>(*step_vector) : nullptr;
 
 	auto str = str_data[0];
-	INDEX_TYPE begin, end;
-	if (begin_is_empty) {
-		begin = 0;
-	} else {
-		begin = *ConstantVector::GetData<INDEX_TYPE>(begin_vector);
-	}
-	if (end_is_empty) {
-		end = OP::ValueLength(str);
-	} else {
-		end = *ConstantVector::GetData<INDEX_TYPE>(end_vector);
-	}
+	auto begin = begin_is_empty ? 0 : begin_data[0];
+	auto end = end_is_empty ? OP::ValueLength(str) : end_data[0];
 	auto step = step_data ? step_data[0] : 1;
 
 	if (step < 0) {
@@ -229,9 +227,9 @@ void ExecuteConstantSlice(Vector &result, Vector &str_vector, Vector &begin_vect
 }
 
 template <typename INPUT_TYPE, typename INDEX_TYPE, typename OP>
-void ExecuteFlatSlice(Vector &result, Vector &list_vector, Vector &begin_vector, Vector &end_vector,
-                      optional_ptr<Vector> step_vector, const idx_t count, SelectionVector &sel, idx_t &sel_idx,
-                      optional_ptr<Vector> result_child_vector, bool begin_is_empty, bool end_is_empty) {
+static void ExecuteFlatSlice(Vector &result, Vector &list_vector, Vector &begin_vector, Vector &end_vector,
+                             optional_ptr<Vector> step_vector, const idx_t count, SelectionVector &sel, idx_t &sel_idx,
+                             optional_ptr<Vector> result_child_vector, bool begin_is_empty, bool end_is_empty) {
 	UnifiedVectorFormat list_data, begin_data, end_data, step_data;
 	idx_t sel_length = 0;
 
@@ -305,8 +303,8 @@ void ExecuteFlatSlice(Vector &result, Vector &list_vector, Vector &begin_vector,
 }
 
 template <typename INPUT_TYPE, typename INDEX_TYPE, typename OP>
-void ExecuteSlice(Vector &result, Vector &list_or_str_vector, Vector &begin_vector, Vector &end_vector,
-                  optional_ptr<Vector> step_vector, const idx_t count, bool begin_is_empty, bool end_is_empty) {
+static void ExecuteSlice(Vector &result, Vector &list_or_str_vector, Vector &begin_vector, Vector &end_vector,
+                         optional_ptr<Vector> step_vector, const idx_t count, bool begin_is_empty, bool end_is_empty) {
 	optional_ptr<Vector> result_child_vector;
 	if (step_vector) {
 		result_child_vector = &ListVector::GetEntry(result);
@@ -327,7 +325,7 @@ void ExecuteSlice(Vector &result, Vector &list_or_str_vector, Vector &begin_vect
 	result.Verify(count);
 }
 
-void ArraySliceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void ArraySliceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 3 || args.ColumnCount() == 4);
 	D_ASSERT(args.data.size() == 3 || args.data.size() == 4);
 	auto count = args.size();
@@ -380,7 +378,7 @@ void ArraySliceFunction(DataChunk &args, ExpressionState &state, Vector &result)
 	}
 }
 
-bool CheckIfParamIsEmpty(duckdb::unique_ptr<duckdb::Expression> &param) {
+static bool CheckIfParamIsEmpty(duckdb::unique_ptr<duckdb::Expression> &param) {
 	bool is_empty = false;
 	if (param->return_type.id() == LogicalTypeId::LIST) {
 		auto empty_list = make_uniq<BoundConstantExpression>(Value::LIST(LogicalType::INTEGER, vector<Value>()));
@@ -393,8 +391,8 @@ bool CheckIfParamIsEmpty(duckdb::unique_ptr<duckdb::Expression> &param) {
 	return is_empty;
 }
 
-unique_ptr<FunctionData> ArraySliceBind(ClientContext &context, ScalarFunction &bound_function,
-                                        vector<unique_ptr<Expression>> &arguments) {
+static unique_ptr<FunctionData> ArraySliceBind(ClientContext &context, ScalarFunction &bound_function,
+                                               vector<unique_ptr<Expression>> &arguments) {
 	D_ASSERT(arguments.size() == 3 || arguments.size() == 4);
 	D_ASSERT(bound_function.arguments.size() == 3 || bound_function.arguments.size() == 4);
 
@@ -452,7 +450,6 @@ unique_ptr<FunctionData> ArraySliceBind(ClientContext &context, ScalarFunction &
 	return make_uniq<ListSliceBindData>(bound_function.return_type, begin_is_empty, end_is_empty);
 }
 
-} // namespace
 ScalarFunctionSet ListSliceFun::GetFunctions() {
 	// the arguments and return types are actually set in the binder function
 	ScalarFunction fun({LogicalType::ANY, LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, ArraySliceFunction,

package/src/duckdb/extension/core_functions/scalar/list/flatten.cpp

@@ -7,9 +7,7 @@
 
 namespace duckdb {
 
-namespace {
-
-void ListFlattenFunction(DataChunk &args, ExpressionState &, Vector &result) {
+static void ListFlattenFunction(DataChunk &args, ExpressionState &, Vector &result) {
 
 	const auto flat_list_data = FlatVector::GetData<list_entry_t>(result);
 	auto &flat_list_mask = FlatVector::Validity(result);
@@ -142,7 +140,52 @@ void ListFlattenFunction(DataChunk &args, ExpressionState &, Vector &result) {
 	}
 }
 
-unique_ptr<BaseStatistics> ListFlattenStats(ClientContext &context, FunctionStatisticsInput &input) {
+static unique_ptr<FunctionData> ListFlattenBind(ClientContext &context, ScalarFunction &bound_function,
+                                                vector<unique_ptr<Expression>> &arguments) {
+	D_ASSERT(bound_function.arguments.size() == 1);
+
+	if (arguments[0]->return_type.id() == LogicalTypeId::ARRAY) {
+		auto child_type = ArrayType::GetChildType(arguments[0]->return_type);
+		if (child_type.id() == LogicalTypeId::ARRAY) {
+			child_type = LogicalType::LIST(ArrayType::GetChildType(child_type));
+		}
+		arguments[0] =
+		    BoundCastExpression::AddCastToType(context, std::move(arguments[0]), LogicalType::LIST(child_type));
+	} else if (arguments[0]->return_type.id() == LogicalTypeId::LIST) {
+		auto child_type = ListType::GetChildType(arguments[0]->return_type);
+		if (child_type.id() == LogicalTypeId::ARRAY) {
+			child_type = LogicalType::LIST(ArrayType::GetChildType(child_type));
+			arguments[0] =
+			    BoundCastExpression::AddCastToType(context, std::move(arguments[0]), LogicalType::LIST(child_type));
+		}
+	}
+
+	auto &input_type = arguments[0]->return_type;
+	bound_function.arguments[0] = input_type;
+	if (input_type.IsUnknown()) {
+		bound_function.arguments[0] = LogicalType::UNKNOWN;
+		bound_function.return_type = LogicalType::UNKNOWN;
+		return nullptr;
+	}
+	D_ASSERT(input_type.id() == LogicalTypeId::LIST);
+
+	auto child_type = ListType::GetChildType(input_type);
+	if (child_type.id() == LogicalType::SQLNULL) {
+		bound_function.return_type = input_type;
+		return make_uniq<VariableReturnBindData>(bound_function.return_type);
+	}
+	if (child_type.IsUnknown()) {
+		bound_function.arguments[0] = LogicalType::UNKNOWN;
+		bound_function.return_type = LogicalType::UNKNOWN;
+		return nullptr;
+	}
+	D_ASSERT(child_type.id() == LogicalTypeId::LIST);
+
+	bound_function.return_type = child_type;
+	return make_uniq<VariableReturnBindData>(bound_function.return_type);
+}
+
+static unique_ptr<BaseStatistics> ListFlattenStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &list_child_stats = ListStats::GetChildStats(child_stats[0]);
 	auto child_copy = list_child_stats.Copy();
@@ -150,12 +193,9 @@ unique_ptr<BaseStatistics> ListFlattenStats(ClientContext &context, FunctionStat
 	return child_copy.ToUnique();
 }
 
-} // namespace
-
 ScalarFunction ListFlattenFun::GetFunction() {
-	return ScalarFunction({LogicalType::LIST(LogicalType::LIST(LogicalType::TEMPLATE("T")))},
-	                      LogicalType::LIST(LogicalType::TEMPLATE("T")), ListFlattenFunction, nullptr, nullptr,
-	                      ListFlattenStats);
+	return ScalarFunction({LogicalType::LIST(LogicalType::LIST(LogicalType::ANY))}, LogicalType::LIST(LogicalType::ANY),
+	                      ListFlattenFunction, ListFlattenBind, nullptr, ListFlattenStats);
 }
 
 } // namespace duckdb

package/src/duckdb/extension/core_functions/scalar/list/list_aggregates.cpp

@@ -15,8 +15,6 @@
 
 namespace duckdb {
 
-namespace {
-
 struct ListAggregatesLocalState : public FunctionLocalState {
 	explicit ListAggregatesLocalState(Allocator &allocator) : arena_allocator(allocator) {
 	}
@@ -30,7 +28,7 @@ unique_ptr<FunctionLocalState> ListAggregatesInitLocalState(ExpressionState &sta
 }
 // FIXME: benchmark the use of simple_update against using update (if applicable)
 
-unique_ptr<FunctionData> ListAggregatesBindFailure(ScalarFunction &bound_function) {
+static unique_ptr<FunctionData> ListAggregatesBindFailure(ScalarFunction &bound_function) {
 	bound_function.arguments[0] = LogicalType::SQLNULL;
 	bound_function.return_type = LogicalType::SQLNULL;
 	return make_uniq<VariableReturnBindData>(LogicalType::SQLNULL);
@@ -201,7 +199,7 @@ struct UniqueFunctor {
 };
 
 template <class FUNCTION_FUNCTOR, bool IS_AGGR = false>
-void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto count = args.size();
 	Vector &lists = args.data[0];
 
@@ -371,23 +369,23 @@ void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vector &res
 	}
 }
 
-void ListAggregateFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void ListAggregateFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() >= 2);
 	ListAggregatesFunction<AggregateFunctor, true>(args, state, result);
 }
 
-void ListDistinctFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void ListDistinctFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 1);
 	ListAggregatesFunction<DistinctFunctor>(args, state, result);
 }
 
-void ListUniqueFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void ListUniqueFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 1);
 	ListAggregatesFunction<UniqueFunctor>(args, state, result);
 }
 
 template <bool IS_AGGR = false>
-unique_ptr<FunctionData>
+static unique_ptr<FunctionData>
 ListAggregatesBindFunction(ClientContext &context, ScalarFunction &bound_function, const LogicalType &list_child_type,
                            AggregateFunction &aggr_function, vector<unique_ptr<Expression>> &arguments) {
 
@@ -421,8 +419,8 @@ ListAggregatesBindFunction(ClientContext &context, ScalarFunction &bound_functio
 }
 
 template <bool IS_AGGR = false>
-unique_ptr<FunctionData> ListAggregatesBind(ClientContext &context, ScalarFunction &bound_function,
-                                            vector<unique_ptr<Expression>> &arguments) {
+static unique_ptr<FunctionData> ListAggregatesBind(ClientContext &context, ScalarFunction &bound_function,
+                                                   vector<unique_ptr<Expression>> &arguments) {
 
 	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
 
@@ -491,8 +489,8 @@ unique_ptr<FunctionData> ListAggregatesBind(ClientContext &context, ScalarFuncti
 	return ListAggregatesBindFunction<IS_AGGR>(context, bound_function, child_type, aggr_function, arguments);
 }
 
-unique_ptr<FunctionData> ListAggregateBind(ClientContext &context, ScalarFunction &bound_function,
-                                           vector<unique_ptr<Expression>> &arguments) {
+static unique_ptr<FunctionData> ListAggregateBind(ClientContext &context, ScalarFunction &bound_function,
+                                                  vector<unique_ptr<Expression>> &arguments) {
 
 	// the list column and the name of the aggregate function
 	D_ASSERT(bound_function.arguments.size() >= 2);
@@ -501,7 +499,27 @@ unique_ptr<FunctionData> ListAggregateBind(ClientContext &context, ScalarFunctio
 	return ListAggregatesBind<true>(context, bound_function, arguments);
 }
 
-} // namespace
+static unique_ptr<FunctionData> ListDistinctBind(ClientContext &context, ScalarFunction &bound_function,
+                                                 vector<unique_ptr<Expression>> &arguments) {
+
+	D_ASSERT(bound_function.arguments.size() == 1);
+	D_ASSERT(arguments.size() == 1);
+
+	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
+	bound_function.return_type = arguments[0]->return_type;
+
+	return ListAggregatesBind<>(context, bound_function, arguments);
+}
+
+static unique_ptr<FunctionData> ListUniqueBind(ClientContext &context, ScalarFunction &bound_function,
+                                               vector<unique_ptr<Expression>> &arguments) {
+
+	D_ASSERT(bound_function.arguments.size() == 1);
+	D_ASSERT(arguments.size() == 1);
+	bound_function.return_type = LogicalType::UBIGINT;
+
+	return ListAggregatesBind<>(context, bound_function, arguments);
+}
 
 ScalarFunction ListAggregateFun::GetFunction() {
 	auto result =
@@ -516,14 +534,13 @@ ScalarFunction ListAggregateFun::GetFunction() {
 }
 
 ScalarFunction ListDistinctFun::GetFunction() {
-	return ScalarFunction({LogicalType::LIST(LogicalType::TEMPLATE("T"))},
-	                      LogicalType::LIST(LogicalType::TEMPLATE("T")), ListDistinctFunction,
-	                      ListAggregatesBind<false>, nullptr, nullptr, ListAggregatesInitLocalState);
+	return ScalarFunction({LogicalType::LIST(LogicalType::ANY)}, LogicalType::LIST(LogicalType::ANY),
+	                      ListDistinctFunction, ListDistinctBind, nullptr, nullptr, ListAggregatesInitLocalState);
 }
 
 ScalarFunction ListUniqueFun::GetFunction() {
 	return ScalarFunction({LogicalType::LIST(LogicalType::ANY)}, LogicalType::UBIGINT, ListUniqueFunction,
-	                      ListAggregatesBind<false>, nullptr, nullptr, ListAggregatesInitLocalState);
+	                      ListUniqueBind, nullptr, nullptr, ListAggregatesInitLocalState);
 }
 
 } // namespace duckdb

package/src/duckdb/extension/core_functions/scalar/list/list_has_any_or_all.cpp

@@ -6,6 +6,52 @@
 
 namespace duckdb {
 
+static unique_ptr<FunctionData> ListHasAnyOrAllBind(ClientContext &context, ScalarFunction &bound_function,
+                                                    vector<unique_ptr<Expression>> &arguments) {
+
+	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
+	arguments[1] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[1]));
+
+	const auto &lhs_type = arguments[0]->return_type;
+	const auto &rhs_type = arguments[1]->return_type;
+
+	if (lhs_type.IsUnknown() && rhs_type.IsUnknown()) {
+		bound_function.arguments[0] = rhs_type;
+		bound_function.arguments[1] = lhs_type;
+		bound_function.return_type = LogicalType::UNKNOWN;
+		return nullptr;
+	}
+
+	// LHS and RHS must have the same input type.
+	// Thus, we can proceed binding, even if we only know the type of one of the arguments.
+
+	if (lhs_type.IsUnknown() || rhs_type.IsUnknown()) {
+		bound_function.arguments[0] = lhs_type.IsUnknown() ? rhs_type : lhs_type;
+		bound_function.arguments[1] = rhs_type.IsUnknown() ? lhs_type : rhs_type;
+		return nullptr;
+	}
+
+	// Ensure the lists have the same child type, else throw.
+
+	bound_function.arguments[0] = lhs_type;
+	bound_function.arguments[1] = rhs_type;
+
+	const auto &lhs_child = ListType::GetChildType(bound_function.arguments[0]);
+	const auto &rhs_child = ListType::GetChildType(bound_function.arguments[1]);
+
+	if (lhs_child != LogicalType::SQLNULL && rhs_child != LogicalType::SQLNULL && lhs_child != rhs_child) {
+		LogicalType common_child;
+		if (!LogicalType::TryGetMaxLogicalType(context, lhs_child, rhs_child, common_child)) {
+			throw BinderException("'%s' cannot compare lists of different types: '%s' and '%s'", bound_function.name,
+			                      lhs_child.ToString(), rhs_child.ToString());
+		}
+		bound_function.arguments[0] = LogicalType::LIST(common_child);
+		bound_function.arguments[1] = LogicalType::LIST(common_child);
+	}
+
+	return nullptr;
+}
+
 static void ListHasAnyFunction(DataChunk &args, ExpressionState &, Vector &result) {
 
 	auto &l_vec = args.data[0];
@@ -167,14 +213,14 @@ static void ListHasAllFunction(DataChunk &args, ExpressionState &state, Vector &
 }
 
 ScalarFunction ListHasAnyFun::GetFunction() {
-	ScalarFunction fun({LogicalType::LIST(LogicalType::TEMPLATE("T")), LogicalType::LIST(LogicalType::TEMPLATE("T"))},
-	                   LogicalType::BOOLEAN, ListHasAnyFunction);
+	ScalarFunction fun({LogicalType::LIST(LogicalType::ANY), LogicalType::LIST(LogicalType::ANY)}, LogicalType::BOOLEAN,
+	                   ListHasAnyFunction, ListHasAnyOrAllBind);
 	return fun;
 }
 
 ScalarFunction ListHasAllFun::GetFunction() {
-	ScalarFunction fun({LogicalType::LIST(LogicalType::TEMPLATE("T")), LogicalType::LIST(LogicalType::TEMPLATE("T"))},
-	                   LogicalType::BOOLEAN, ListHasAllFunction);
+	ScalarFunction fun({LogicalType::LIST(LogicalType::ANY), LogicalType::LIST(LogicalType::ANY)}, LogicalType::BOOLEAN,
+	                   ListHasAllFunction, ListHasAnyOrAllBind);
 	return fun;
 }
 

package/src/duckdb/extension/core_functions/scalar/list/list_reduce.cpp

@@ -4,8 +4,6 @@
 
 namespace duckdb {
 
-namespace {
-
 struct ReduceExecuteInfo {
 	ReduceExecuteInfo(LambdaFunctions::LambdaInfo &info, ClientContext &context)
 	    : left_slice(make_uniq<Vector>(*info.child_vector)) {
@@ -64,8 +62,8 @@ struct ReduceExecuteInfo {
 	SelectionVector active_rows_sel;
 };
 
-bool ExecuteReduce(const idx_t loops, ReduceExecuteInfo &execute_info, LambdaFunctions::LambdaInfo &info,
-                   DataChunk &result_chunk) {
+static bool ExecuteReduce(const idx_t loops, ReduceExecuteInfo &execute_info, LambdaFunctions::LambdaInfo &info,
+                          DataChunk &result_chunk) {
 	idx_t original_row_idx = 0;
 	idx_t reduced_row_idx = 0;
 	idx_t valid_row_idx = 0;
@@ -173,8 +171,44 @@ bool ExecuteReduce(const idx_t loops, ReduceExecuteInfo &execute_info, LambdaFun
 	return false;
 }
 
-unique_ptr<FunctionData> ListReduceBind(ClientContext &context, ScalarFunction &bound_function,
-                                        vector<unique_ptr<Expression>> &arguments) {
+void LambdaFunctions::ListReduceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	// Initializes the left slice from the list entries, active rows, the expression executor and the input types
+	bool completed = false;
+	LambdaInfo info(args, state, result, completed);
+	if (completed) {
+		return;
+	}
+
+	ReduceExecuteInfo execute_info(info, state.GetContext());
+
+	// Since the left slice references the result chunk, we need to create two result chunks.
+	// This means there is always an empty result chunk for the next iteration,
+	// without the referenced chunk having to be reset until the current iteration is complete.
+	DataChunk odd_result_chunk;
+	odd_result_chunk.Initialize(Allocator::DefaultAllocator(), {info.lambda_expr->return_type});
+
+	DataChunk even_result_chunk;
+	even_result_chunk.Initialize(Allocator::DefaultAllocator(), {info.lambda_expr->return_type});
+
+	// Execute reduce until all rows are finished.
+	idx_t loops = 0;
+	bool end = false;
+	while (!end) {
+		auto &result_chunk = loops % 2 ? odd_result_chunk : even_result_chunk;
+		auto &spare_result_chunk = loops % 2 ? even_result_chunk : odd_result_chunk;
+
+		end = ExecuteReduce(loops, execute_info, info, result_chunk);
+		spare_result_chunk.Reset();
+		loops++;
+	}
+
+	if (info.is_all_constant && !info.is_volatile) {
+		info.result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+}
+
+static unique_ptr<FunctionData> ListReduceBind(ClientContext &context, ScalarFunction &bound_function,
+                                               vector<unique_ptr<Expression>> &arguments) {
 
 	// the list column and the bound lambda expression
 	D_ASSERT(arguments.size() == 2 || arguments.size() == 3);
@@ -264,49 +298,11 @@ LogicalType BindReduceChildren(ClientContext &context, const vector<LogicalType>
 	}
 }
 
-LogicalType ListReduceBindLambda(ClientContext &context, const vector<LogicalType> &function_child_types,
-                                 const idx_t parameter_idx) {
+static LogicalType ListReduceBindLambda(ClientContext &context, const vector<LogicalType> &function_child_types,
+                                        const idx_t parameter_idx) {
 	return BindReduceChildren(context, function_child_types, parameter_idx);
 }
 
-} // namespace
-
-void LambdaFunctions::ListReduceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	// Initializes the left slice from the list entries, active rows, the expression executor and the input types
-	bool completed = false;
-	LambdaInfo info(args, state, result, completed);
-	if (completed) {
-		return;
-	}
-
-	ReduceExecuteInfo execute_info(info, state.GetContext());
-
-	// Since the left slice references the result chunk, we need to create two result chunks.
-	// This means there is always an empty result chunk for the next iteration,
-	// without the referenced chunk having to be reset until the current iteration is complete.
-	DataChunk odd_result_chunk;
-	odd_result_chunk.Initialize(Allocator::DefaultAllocator(), {info.lambda_expr->return_type});
-
-	DataChunk even_result_chunk;
-	even_result_chunk.Initialize(Allocator::DefaultAllocator(), {info.lambda_expr->return_type});
-
-	// Execute reduce until all rows are finished.
-	idx_t loops = 0;
-	bool end = false;
-	while (!end) {
-		auto &result_chunk = loops % 2 ? odd_result_chunk : even_result_chunk;
-		auto &spare_result_chunk = loops % 2 ? even_result_chunk : odd_result_chunk;
-
-		end = ExecuteReduce(loops, execute_info, info, result_chunk);
-		spare_result_chunk.Reset();
-		loops++;
-	}
-
-	if (info.is_all_constant && !info.is_volatile) {
-		info.result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
 ScalarFunctionSet ListReduceFun::GetFunctions() {
 	ScalarFunction fun({LogicalType::LIST(LogicalType::ANY), LogicalType::LAMBDA}, LogicalType::ANY,
 	                   LambdaFunctions::ListReduceFunction, ListReduceBind, nullptr, nullptr);