Update vendored DuckDB sources to c8906e701e

Author: duckdblabs-bot

CMakeLists.txt

@@ -149,8 +149,7 @@ struct ArgMinMaxBase {
 		D_ASSERT(binary.input.bind_data);
 		const auto &bind_data = binary.input.bind_data->Cast<ArgMinMaxFunctionData>();
 
-		if (binary.right_mask.RowIsValid(binary.ridx) &&
-		    (state.val_null || COMPARATOR::Operation(y_data, state.value))) {
+		if (binary.right_mask.RowIsValid(binary.ridx) && COMPARATOR::Operation(y_data, state.value)) {
 			if (bind_data.null_handling != ArgMinMaxNullHandling::IGNORE_ANY_NULL ||
 			    binary.left_mask.RowIsValid(binary.lidx)) {
 				Assign(state, x_data, y_data, !binary.left_mask.RowIsValid(binary.lidx), false, binary.input);

src/duckdb/extension/core_functions/aggregate/distributive/arg_min_max.cpp

@@ -166,13 +166,15 @@ struct BitStringBitwiseOperation : public BitwiseOperation {
 };
 
 struct BitStringAndOperation : public BitStringBitwiseOperation {
+
 	template <class INPUT_TYPE, class STATE>
 	static void Execute(STATE &state, INPUT_TYPE input) {
 		Bit::BitwiseAnd(input, state.value, state.value);
 	}
 };
 
 struct BitStringOrOperation : public BitStringBitwiseOperation {
+
 	template <class INPUT_TYPE, class STATE>
 	static void Execute(STATE &state, INPUT_TYPE input) {
 		Bit::BitwiseOr(input, state.value, state.value);

src/duckdb/extension/core_functions/aggregate/distributive/bitagg.cpp

@@ -235,6 +235,7 @@ idx_t BitStringAggOperation::GetRange(uhugeint_t min, uhugeint_t max) {
 
 unique_ptr<BaseStatistics> BitstringPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
                                                    AggregateStatisticsInput &input) {
+
 	if (NumericStats::HasMinMax(input.child_stats[0])) {
 		auto &bind_agg_data = input.bind_data->Cast<BitstringAggBindData>();
 		bind_agg_data.min = NumericStats::Min(input.child_stats[0]);

src/duckdb/extension/core_functions/aggregate/distributive/bitstring_agg.cpp

@@ -294,6 +294,7 @@ AggregateFunction GetApproximateQuantileAggregate(const LogicalType &type) {
 
 template <class CHILD_TYPE>
 struct ApproxQuantileListOperation : public ApproxQuantileOperation {
+
 	template <class RESULT_TYPE, class STATE>
 	static void Finalize(STATE &state, RESULT_TYPE &target, AggregateFinalizeData &finalize_data) {
 		if (state.pos == 0) {

src/duckdb/extension/core_functions/aggregate/holistic/approximate_quantile.cpp

@@ -57,6 +57,7 @@ struct QuantileReuseUpdater {
 };
 
 void ReuseIndexes(idx_t *index, const SubFrames &currs, const SubFrames &prevs) {
+
 	//  Copy overlapping indices by scanning the previous set and copying down into holes.
 	//	We copy instead of leaving gaps in case there are fewer values in the current frame.
 	FrameSet prev_set(prevs);

src/duckdb/extension/core_functions/aggregate/holistic/mad.cpp

@@ -61,6 +61,7 @@ struct StringMapType {
 template <class OP, class T, class MAP_TYPE>
 void HistogramUpdateFunction(Vector inputs[], AggregateInputData &aggr_input, idx_t input_count, Vector &state_vector,
                              idx_t count) {
+
 	D_ASSERT(input_count == 1);
 
 	auto &input = inputs[0];
@@ -208,6 +209,7 @@ AggregateFunction GetHistogramFunction(const LogicalType &type) {
 template <bool IS_ORDERED = true>
 unique_ptr<FunctionData> HistogramBindFunction(ClientContext &context, AggregateFunction &function,
                                                vector<unique_ptr<Expression>> &arguments) {
+
 	D_ASSERT(arguments.size() == 1);
 
 	if (arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) {

src/duckdb/extension/core_functions/aggregate/nested/histogram.cpp

@@ -47,6 +47,7 @@ struct ListFunction {
 
 void ListUpdateFunction(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, Vector &state_vector,
                         idx_t count) {
+
 	D_ASSERT(input_count == 1);
 	auto &input = inputs[0];
 	RecursiveUnifiedVectorFormat input_data;
@@ -74,6 +75,7 @@ void ListAbsorbFunction(Vector &states_vector, Vector &combined, AggregateInputD
 
 	auto combined_ptr = FlatVector::GetData<ListAggState *>(combined);
 	for (idx_t i = 0; i < count; i++) {
+
 		auto &state = *states_ptr[states_data.sel->get_index(i)];
 		if (state.linked_list.total_capacity == 0) {
 			// NULL, no need to append
@@ -96,6 +98,7 @@ void ListAbsorbFunction(Vector &states_vector, Vector &combined, AggregateInputD
 
 void ListFinalize(Vector &states_vector, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
                   idx_t offset) {
+
 	UnifiedVectorFormat states_data;
 	states_vector.ToUnifiedFormat(count, states_data);
 	auto states = UnifiedVectorFormat::GetData<ListAggState *>(states_data);
@@ -129,6 +132,7 @@ void ListFinalize(Vector &states_vector, AggregateInputData &aggr_input_data, Ve
 	ListVector::Reserve(result, total_len);
 	auto &result_child = ListVector::GetEntry(result);
 	for (idx_t i = 0; i < count; i++) {
+
 		auto &state = *states[states_data.sel->get_index(i)];
 		const auto rid = i + offset;
 		if (state.linked_list.total_capacity == 0) {
@@ -143,6 +147,7 @@ void ListFinalize(Vector &states_vector, AggregateInputData &aggr_input_data, Ve
 }
 
 void ListCombineFunction(Vector &states_vector, Vector &combined, AggregateInputData &aggr_input_data, idx_t count) {
+
 	//	Can we use destructive combining?
 	if (aggr_input_data.combine_type == AggregateCombineType::ALLOW_DESTRUCTIVE) {
 		ListAbsorbFunction(states_vector, combined, aggr_input_data, count);
@@ -177,6 +182,7 @@ void ListCombineFunction(Vector &states_vector, Vector &combined, AggregateInput
 
 unique_ptr<FunctionData> ListBindFunction(ClientContext &context, AggregateFunction &function,
                                           vector<unique_ptr<Expression>> &arguments) {
+
 	function.return_type = LogicalType::LIST(arguments[0]->return_type);
 	return make_uniq<ListBindData>(function.return_type);
 }

src/duckdb/extension/core_functions/aggregate/nested/list.cpp

@@ -300,6 +300,7 @@ struct QuantileIncluded {
 };
 
 struct QuantileSortTree {
+
 	unique_ptr<WindowIndexTree> index_tree;
 
 	QuantileSortTree(AggregateInputData &aggr_input_data, const WindowPartitionInput &partition) {

src/duckdb/extension/core_functions/include/core_functions/aggregate/quantile_sort_tree.hpp

@@ -13,6 +13,7 @@ struct InnerProductOp {
 
 	template <class TYPE>
 	static TYPE Operation(const TYPE *lhs_data, const TYPE *rhs_data, const idx_t count) {
+
 		TYPE result = 0;
 
 		auto lhs_ptr = lhs_data;
@@ -42,6 +43,7 @@ struct CosineSimilarityOp {
 
 	template <class TYPE>
 	static TYPE Operation(const TYPE *lhs_data, const TYPE *rhs_data, const idx_t count) {
+
 		TYPE distance = 0;
 		TYPE norm_l = 0;
 		TYPE norm_r = 0;
@@ -76,6 +78,7 @@ struct DistanceSquaredOp {
 
 	template <class TYPE>
 	static TYPE Operation(const TYPE *lhs_data, const TYPE *rhs_data, const idx_t count) {
+
 		TYPE distance = 0;
 
 		auto l_ptr = lhs_data;