Update vendored DuckDB sources to 620e685c6d

CMakeLists.txt

@@ -163,6 +163,7 @@ set(DUCKDB_SRC_FILES
   src/duckdb/ub_src_function_scalar.cpp
   src/duckdb/ub_src_function_scalar_date.cpp
   src/duckdb/ub_src_function_scalar_generic.cpp
+  src/duckdb/ub_src_function_scalar_geometry.cpp
   src/duckdb/ub_src_function_scalar_list.cpp
   src/duckdb/ub_src_function_scalar_map.cpp
   src/duckdb/ub_src_function_scalar_operator.cpp
@@ -377,9 +378,9 @@ set(DUCKDB_SRC_FILES
   src/duckdb/extension/parquet/parquet_float16.cpp
   src/duckdb/extension/parquet/parquet_statistics.cpp
   src/duckdb/extension/parquet/parquet_shredding.cpp
+  src/duckdb/extension/parquet/parquet_geometry.cpp
   src/duckdb/extension/parquet/parquet_multi_file_info.cpp
   src/duckdb/extension/parquet/column_reader.cpp
-  src/duckdb/extension/parquet/geo_parquet.cpp
   src/duckdb/extension/parquet/parquet_field_id.cpp
   src/duckdb/extension/parquet/parquet_extension.cpp
   src/duckdb/extension/parquet/column_writer.cpp

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

@@ -149,7 +149,8 @@ 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) && COMPARATOR::Operation(y_data, state.value)) {
+		if (binary.right_mask.RowIsValid(binary.ridx) &&
+		    (state.val_null || 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/bitagg.cpp

@@ -166,15 +166,13 @@ 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/bitstring_agg.cpp

@@ -235,7 +235,6 @@ 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/string_agg.cpp

@@ -120,6 +120,12 @@ unique_ptr<FunctionData> StringAggBind(ClientContext &context, AggregateFunction
 		return make_uniq<StringAggBindData>(",");
 	}
 	D_ASSERT(arguments.size() == 2);
+	// Check if any argument is of UNKNOWN type (parameter not yet bound)
+	for (auto &arg : arguments) {
+		if (arg->return_type.id() == LogicalTypeId::UNKNOWN) {
+			throw ParameterNotResolvedException();
+		}
+	}
 	if (arguments[1]->HasParameter()) {
 		throw ParameterNotResolvedException();
 	}

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

@@ -294,7 +294,6 @@ 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/mad.cpp

@@ -57,7 +57,6 @@ 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/nested/histogram.cpp

@@ -61,7 +61,6 @@ 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];
@@ -209,7 +208,6 @@ 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/list.cpp

@@ -47,7 +47,6 @@ 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;
@@ -75,7 +74,6 @@ 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
@@ -98,7 +96,6 @@ 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);
@@ -132,7 +129,6 @@ 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) {
@@ -147,7 +143,6 @@ 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);
@@ -182,7 +177,6 @@ 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/include/core_functions/aggregate/algebraic/stddev.hpp

@@ -9,7 +9,8 @@
 #pragma once
 
 #include "duckdb/function/aggregate_function.hpp"
-#include <ctgmath>
+#include <complex>
+#include <cmath>
 
 namespace duckdb {
 

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

@@ -300,7 +300,6 @@ 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/array_kernels.hpp

@@ -13,7 +13,6 @@ 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;
@@ -43,7 +42,6 @@ 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;
@@ -78,7 +76,6 @@ 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;

src/duckdb/extension/core_functions/lambda_functions.cpp

@@ -18,7 +18,6 @@ struct LambdaExecuteInfo {
 	LambdaExecuteInfo(ClientContext &context, const Expression &lambda_expr, const DataChunk &args,
 	                  const bool has_index, const Vector &child_vector)
 	    : has_index(has_index) {
-
 		expr_executor = make_uniq<ExpressionExecutor>(context, lambda_expr);
 
 		// get the input types for the input chunk
@@ -103,7 +102,6 @@ struct ListFilterFunctor {
 	//! Uses the lambda vector to filter the incoming list and to append the filtered list to the result vector
 	static void AppendResult(Vector &result, Vector &lambda_vector, const idx_t elem_cnt, list_entry_t *result_entries,
 	                         ListFilterInfo &info, LambdaExecuteInfo &execute_info) {
-
 		idx_t count = 0;
 		SelectionVector sel(elem_cnt);
 		UnifiedVectorFormat lambda_data;
@@ -184,7 +182,6 @@ LambdaFunctions::GetMutableColumnInfo(vector<LambdaFunctions::ColumnInfo> &data)
 static void ExecuteExpression(const idx_t elem_cnt, const LambdaFunctions::ColumnInfo &column_info,
                               const vector<LambdaFunctions::ColumnInfo> &column_infos, const Vector &index_vector,
                               LambdaExecuteInfo &info) {
-
 	info.input_chunk.SetCardinality(elem_cnt);
 	info.lambda_chunk.SetCardinality(elem_cnt);
 
@@ -203,7 +200,6 @@ static void ExecuteExpression(const idx_t elem_cnt, const LambdaFunctions::Colum
 	// (slice and) reference the other columns
 	vector<Vector> slices;
 	for (idx_t i = 0; i < column_infos.size(); i++) {
-
 		if (column_infos[i].vector.get().GetVectorType() == VectorType::CONSTANT_VECTOR) {
 			// only reference constant vectorsl
 			info.input_chunk.data[i + slice_offset].Reference(column_infos[i].vector);
@@ -273,7 +269,6 @@ LogicalType LambdaFunctions::BindBinaryChildren(const vector<LogicalType> &funct
 
 template <class FUNCTION_FUNCTOR>
 static void ExecuteLambda(DataChunk &args, ExpressionState &state, Vector &result) {
-
 	bool result_is_null = false;
 	LambdaFunctions::LambdaInfo info(args, state, result, result_is_null);
 	if (result_is_null) {
@@ -302,7 +297,6 @@ static void ExecuteLambda(DataChunk &args, ExpressionState &state, Vector &resul
 	idx_t elem_cnt = 0;
 	idx_t offset = 0;
 	for (idx_t row_idx = 0; row_idx < info.row_count; row_idx++) {
-
 		auto list_idx = info.list_column_format.sel->get_index(row_idx);
 		const auto &list_entry = info.list_entries[list_idx];
 
@@ -322,10 +316,8 @@ static void ExecuteLambda(DataChunk &args, ExpressionState &state, Vector &resul
 
 		// iterate the elements of the current list and create the corresponding selection vectors
 		for (idx_t child_idx = 0; child_idx < list_entry.length; child_idx++) {
-
 			// reached STANDARD_VECTOR_SIZE elements
 			if (elem_cnt == STANDARD_VECTOR_SIZE) {
-
 				execute_info.lambda_chunk.Reset();
 				ExecuteExpression(elem_cnt, child_info, info.column_infos, index_vector, execute_info);
 				auto &lambda_vector = execute_info.lambda_chunk.data[0];

src/duckdb/extension/core_functions/scalar/array/array_functions.cpp

@@ -6,7 +6,6 @@ namespace duckdb {
 
 static unique_ptr<FunctionData> ArrayGenericBinaryBind(ClientContext &context, ScalarFunction &bound_function,
                                                        vector<unique_ptr<Expression>> &arguments) {
-
 	const auto &lhs_type = arguments[0]->return_type;
 	const auto &rhs_type = arguments[1]->return_type;
 

src/duckdb/extension/core_functions/scalar/date/date_sub.cpp

@@ -37,7 +37,6 @@ struct DateSub {
 	struct MonthOperator {
 		template <class TA, class TB, class TR>
 		static inline TR Operation(TA start_ts, TB end_ts) {
-
 			if (start_ts > end_ts) {
 				return -MonthOperator::Operation<TA, TB, TR>(end_ts, start_ts);
 			}

src/duckdb/extension/core_functions/scalar/date/make_date.cpp

@@ -65,7 +65,6 @@ void ExecuteStructMakeDate(DataChunk &input, ExpressionState &state, Vector &res
 struct MakeTimeOperator {
 	template <typename HH, typename MM, typename SS, typename RESULT_TYPE>
 	static RESULT_TYPE Operation(HH hh, MM mm, SS ss) {
-
 		auto hh_32 = Cast::Operation<HH, int32_t>(hh);
 		auto mm_32 = Cast::Operation<MM, int32_t>(mm);
 		// Have to check this separately because safe casting of DOUBLE => INT32 can round.

src/duckdb/extension/core_functions/scalar/date/time_bucket.cpp

@@ -16,7 +16,6 @@ namespace duckdb {
 namespace {
 
 struct TimeBucket {
-
 	// Use 2000-01-03 00:00:00 (Monday) as origin when bucket_width is days, hours, ... for TimescaleDB compatibility
 	// There are 10959 days between 1970-01-01 and 2000-01-03
 	constexpr static const int64_t DEFAULT_ORIGIN_MICROS = 10959 * Interval::MICROS_PER_DAY;

src/duckdb/extension/core_functions/scalar/generic/current_setting.cpp

@@ -33,7 +33,6 @@ void CurrentSettingFunction(DataChunk &args, ExpressionState &state, Vector &res
 
 unique_ptr<FunctionData> CurrentSettingBind(ClientContext &context, ScalarFunction &bound_function,
                                             vector<unique_ptr<Expression>> &arguments) {
-
 	auto &key_child = arguments[0];
 	if (key_child->return_type.id() == LogicalTypeId::UNKNOWN) {
 		throw ParameterNotResolvedException();

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

@@ -161,7 +161,6 @@ 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) {
-
 	// check all this nullness early
 	auto str_valid = !ConstantVector::IsNull(str_vector);
 	auto begin_valid = !ConstantVector::IsNull(begin_vector);

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

@@ -10,7 +10,6 @@ namespace duckdb {
 namespace {
 
 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);
 

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

@@ -187,7 +187,6 @@ struct UniqueFunctor {
 
 		auto result_data = FlatVector::GetData<uint64_t>(result);
 		for (idx_t i = 0; i < count; i++) {
-
 			auto state = states[sdata.sel->get_index(i)];
 
 			if (!state->hist) {
@@ -253,7 +252,6 @@ void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vector &res
 	idx_t states_idx = 0;
 
 	for (idx_t i = 0; i < count; i++) {
-
 		// initialize the state for this list
 		auto state_ptr = state_buffer.get() + size * i;
 		states[i] = state_ptr;
@@ -390,7 +388,6 @@ template <bool IS_AGGR = false>
 unique_ptr<FunctionData>
 ListAggregatesBindFunction(ClientContext &context, ScalarFunction &bound_function, const LogicalType &list_child_type,
                            AggregateFunction &aggr_function, vector<unique_ptr<Expression>> &arguments) {
-
 	// create the child expression and its type
 	vector<unique_ptr<Expression>> children;
 	auto expr = make_uniq<BoundConstantExpression>(Value(list_child_type));
@@ -423,7 +420,6 @@ 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) {
-
 	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
 
 	if (arguments[0]->return_type.id() == LogicalTypeId::SQLNULL) {
@@ -493,7 +489,6 @@ unique_ptr<FunctionData> ListAggregatesBind(ClientContext &context, ScalarFuncti
 
 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);
 	D_ASSERT(arguments.size() >= 2);

src/duckdb/extension/core_functions/scalar/list/list_filter.cpp

@@ -7,7 +7,6 @@ namespace duckdb {
 
 static unique_ptr<FunctionData> ListFilterBind(ClientContext &context, ScalarFunction &bound_function,
                                                vector<unique_ptr<Expression>> &arguments) {
-
 	// the list column and the bound lambda expression
 	D_ASSERT(arguments.size() == 2);
 	if (arguments[1]->GetExpressionClass() != ExpressionClass::BOUND_LAMBDA) {

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

@@ -7,7 +7,6 @@
 namespace duckdb {
 
 static void ListHasAnyFunction(DataChunk &args, ExpressionState &, Vector &result) {
-
 	auto &l_vec = args.data[0];
 	auto &r_vec = args.data[1];
 
@@ -63,7 +62,6 @@ static void ListHasAnyFunction(DataChunk &args, ExpressionState &, Vector &resul
 
 		    // Use the smaller list to build the set
 		    if (r_list.length < l_list.length) {
-
 			    build_list = r_list;
 			    probe_list = l_list;
 
@@ -96,7 +94,6 @@ static void ListHasAnyFunction(DataChunk &args, ExpressionState &, Vector &resul
 }
 
 static void ListHasAllFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-
 	const auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	const auto swap = func_expr.function.name == "<@";
 

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

@@ -175,7 +175,6 @@ bool ExecuteReduce(const idx_t loops, ReduceExecuteInfo &execute_info, LambdaFun
 
 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);
 	if (arguments[1]->GetExpressionClass() != ExpressionClass::BOUND_LAMBDA) {