duckdb 1.3.1-dev6.0 → 1.3.2-dev0.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "1.3.1-dev6.0",
+  "version": "1.3.2-dev0.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

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

@@ -21,11 +21,7 @@ struct ArgMinMaxStateBase {
 	}
 
 	template <class T>
-	static inline void DestroyValue(T &value) {
-	}
-
-	template <class T>
-	static inline void AssignValue(T &target, T new_value) {
+	static inline void AssignValue(T &target, T new_value, AggregateInputData &aggregate_input_data) {
 		target = new_value;
 	}
 
@@ -45,23 +41,21 @@ void ArgMinMaxStateBase::CreateValue(string_t &value) {
 }
 
 template <>
-void ArgMinMaxStateBase::DestroyValue(string_t &value) {
-	if (!value.IsInlined()) {
-		delete[] value.GetData();
-	}
-}
-
-template <>
-void ArgMinMaxStateBase::AssignValue(string_t &target, string_t new_value) {
-	DestroyValue(target);
+void ArgMinMaxStateBase::AssignValue(string_t &target, string_t new_value, AggregateInputData &aggregate_input_data) {
 	if (new_value.IsInlined()) {
 		target = new_value;
 	} else {
 		// non-inlined string, need to allocate space for it
 		auto len = new_value.GetSize();
-		auto ptr = new char[len];
+		char *ptr;
+		if (!target.IsInlined() && target.GetSize() >= len) {
+			// Target has enough space, reuse ptr
+			ptr = target.GetPointer();
+		} else {
+			// Target might be too small, allocate
+			ptr = reinterpret_cast<char *>(aggregate_input_data.allocator.Allocate(len));
+		}
 		memcpy(ptr, new_value.GetData(), len);
-
 		target = string_t(ptr, UnsafeNumericCast<uint32_t>(len));
 	}
 }
@@ -83,14 +77,6 @@ struct ArgMinMaxState : public ArgMinMaxStateBase {
 		CreateValue(arg);
 		CreateValue(value);
 	}
-
-	~ArgMinMaxState() {
-		if (is_initialized) {
-			DestroyValue(arg);
-			DestroyValue(value);
-			is_initialized = false;
-		}
-	}
 };
 
 template <class COMPARATOR, bool IGNORE_NULL>
@@ -106,16 +92,17 @@ struct ArgMinMaxBase {
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE>
-	static void Assign(STATE &state, const A_TYPE &x, const B_TYPE &y, const bool x_null) {
+	static void Assign(STATE &state, const A_TYPE &x, const B_TYPE &y, const bool x_null,
+	                   AggregateInputData &aggregate_input_data) {
 		if (IGNORE_NULL) {
-			STATE::template AssignValue<A_TYPE>(state.arg, x);
-			STATE::template AssignValue<B_TYPE>(state.value, y);
+			STATE::template AssignValue<A_TYPE>(state.arg, x, aggregate_input_data);
+			STATE::template AssignValue<B_TYPE>(state.value, y, aggregate_input_data);
 		} else {
 			state.arg_null = x_null;
 			if (!state.arg_null) {
-				STATE::template AssignValue<A_TYPE>(state.arg, x);
+				STATE::template AssignValue<A_TYPE>(state.arg, x, aggregate_input_data);
 			}
-			STATE::template AssignValue<B_TYPE>(state.value, y);
+			STATE::template AssignValue<B_TYPE>(state.value, y, aggregate_input_data);
 		}
 	}
 
@@ -123,7 +110,7 @@ struct ArgMinMaxBase {
 	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &binary) {
 		if (!state.is_initialized) {
 			if (IGNORE_NULL || binary.right_mask.RowIsValid(binary.ridx)) {
-				Assign(state, x, y, !binary.left_mask.RowIsValid(binary.lidx));
+				Assign(state, x, y, !binary.left_mask.RowIsValid(binary.lidx), binary.input);
 				state.is_initialized = true;
 			}
 		} else {
@@ -134,17 +121,17 @@ struct ArgMinMaxBase {
 	template <class A_TYPE, class B_TYPE, class STATE>
 	static void Execute(STATE &state, A_TYPE x_data, B_TYPE y_data, AggregateBinaryInput &binary) {
 		if ((IGNORE_NULL || binary.right_mask.RowIsValid(binary.ridx)) && COMPARATOR::Operation(y_data, state.value)) {
-			Assign(state, x_data, y_data, !binary.left_mask.RowIsValid(binary.lidx));
+			Assign(state, x_data, y_data, !binary.left_mask.RowIsValid(binary.lidx), binary.input);
 		}
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggregate_input_data) {
 		if (!source.is_initialized) {
 			return;
 		}
 		if (!target.is_initialized || COMPARATOR::Operation(source.value, target.value)) {
-			Assign(target, source.arg, source.value, source.arg_null);
+			Assign(target, source.arg, source.value, source.arg_null, aggregate_input_data);
 			target.is_initialized = true;
 		}
 	}
@@ -201,7 +188,8 @@ template <typename COMPARATOR, bool IGNORE_NULL, OrderType ORDER_TYPE,
           class UPDATE_TYPE = SpecializedGenericArgMinMaxState>
 struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR, IGNORE_NULL> {
 	template <class STATE>
-	static void Update(Vector inputs[], AggregateInputData &, idx_t input_count, Vector &state_vector, idx_t count) {
+	static void Update(Vector inputs[], AggregateInputData &aggregate_input_data, idx_t input_count,
+	                   Vector &state_vector, idx_t count) {
 		auto &arg = inputs[0];
 		UnifiedVectorFormat adata;
 		arg.ToUnifiedFormat(count, adata);
@@ -238,7 +226,7 @@ struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR, IGNORE_NULL> {
 			const auto sidx = sdata.sel->get_index(i);
 			auto &state = *states[sidx];
 			if (!state.is_initialized || COMPARATOR::template Operation<BY_TYPE>(bval, state.value)) {
-				STATE::template AssignValue<BY_TYPE>(state.value, bval);
+				STATE::template AssignValue<BY_TYPE>(state.value, bval, aggregate_input_data);
 				state.arg_null = arg_null;
 				// micro-adaptivity: it is common we overwrite the same state repeatedly
 				// e.g. when running arg_max(val, ts) and ts is sorted in ascending order
@@ -271,20 +259,20 @@ struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR, IGNORE_NULL> {
 		for (idx_t i = 0; i < assign_count; i++) {
 			const auto sidx = sdata.sel->get_index(sel.get_index(i));
 			auto &state = *states[sidx];
-			STATE::template AssignValue<ARG_TYPE>(state.arg, sort_key_data[i]);
+			STATE::template AssignValue<ARG_TYPE>(state.arg, sort_key_data[i], aggregate_input_data);
 		}
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggregate_input_data) {
 		if (!source.is_initialized) {
 			return;
 		}
 		if (!target.is_initialized || COMPARATOR::Operation(source.value, target.value)) {
-			STATE::template AssignValue<typename STATE::BY_TYPE>(target.value, source.value);
+			STATE::template AssignValue<typename STATE::BY_TYPE>(target.value, source.value, aggregate_input_data);
 			target.arg_null = source.arg_null;
 			if (!target.arg_null) {
-				STATE::template AssignValue<typename STATE::ARG_TYPE>(target.arg, source.arg);
+				STATE::template AssignValue<typename STATE::ARG_TYPE>(target.arg, source.arg, aggregate_input_data);
 			}
 			target.is_initialized = true;
 		}

package/src/duckdb/extension/core_functions/aggregate/holistic/quantile.cpp

@@ -6,7 +6,6 @@
 #include "duckdb/common/operator/abs.hpp"
 #include "core_functions/aggregate/quantile_state.hpp"
 #include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/queue.hpp"
 #include "duckdb/common/serializer/serializer.hpp"
 #include "duckdb/common/serializer/deserializer.hpp"
 #include "duckdb/function/aggregate/sort_key_helpers.hpp"
@@ -588,7 +587,7 @@ AggregateFunction GetContinuousQuantileList(const LogicalType &type) {
 //===--------------------------------------------------------------------===//
 // Quantile binding
 //===--------------------------------------------------------------------===//
-static const Value &CheckQuantile(const Value &quantile_val) {
+static Value CheckQuantile(const Value &quantile_val) {
 	if (quantile_val.IsNull()) {
 		throw BinderException("QUANTILE parameter cannot be NULL");
 	}
@@ -820,7 +819,7 @@ struct ContinuousQuantileListFunction {
 };
 
 template <class OP>
-AggregateFunction EmptyQuantileFunction(LogicalType input, LogicalType result, const LogicalType &extra_arg) {
+AggregateFunction EmptyQuantileFunction(LogicalType input, const LogicalType &result, const LogicalType &extra_arg) {
 	AggregateFunction fun({std::move(input)}, std::move(result), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
 	                      OP::Bind);
 	if (extra_arg.id() != LogicalTypeId::INVALID) {

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

@@ -144,7 +144,7 @@ struct QuantileCompare {
 		const auto lval = accessor_l(lhs);
 		const auto rval = accessor_r(rhs);
 
-		return desc ? (rval < lval) : (lval < rval);
+		return desc ? LessThan::Operation(rval, lval) : LessThan::Operation(lval, rval);
 	}
 };
 

package/src/duckdb/extension/core_functions/lambda_functions.cpp

@@ -244,28 +244,30 @@ unique_ptr<FunctionData> ListLambdaBindData::Deserialize(Deserializer &deseriali
 //===--------------------------------------------------------------------===//
 // LambdaFunctions
 //===--------------------------------------------------------------------===//
-
-LogicalType LambdaFunctions::BindBinaryLambda(const idx_t parameter_idx, const LogicalType &list_child_type) {
-	switch (parameter_idx) {
-	case 0:
-		return list_child_type;
-	case 1:
-		return LogicalType::BIGINT;
-	default:
-		throw BinderException("This lambda function only supports up to two lambda parameters!");
+LogicalType LambdaFunctions::DetermineListChildType(const LogicalType &child_type) {
+	if (child_type.id() != LogicalTypeId::SQLNULL && child_type.id() != LogicalTypeId::UNKNOWN) {
+		if (child_type.id() == LogicalTypeId::ARRAY) {
+			return ArrayType::GetChildType(child_type);
+		} else if (child_type.id() == LogicalTypeId::LIST) {
+			return ListType::GetChildType(child_type);
+		}
+		throw InternalException("The first argument must be a list or array type");
 	}
+
+	return child_type;
 }
 
-LogicalType LambdaFunctions::BindTernaryLambda(const idx_t parameter_idx, const LogicalType &list_child_type) {
+LogicalType LambdaFunctions::BindBinaryChildren(const vector<LogicalType> &function_child_types,
+                                                const idx_t parameter_idx) {
+	auto list_type = DetermineListChildType(function_child_types[0]);
+
 	switch (parameter_idx) {
 	case 0:
-		return list_child_type;
+		return list_type;
 	case 1:
-		return list_child_type;
-	case 2:
 		return LogicalType::BIGINT;
 	default:
-		throw BinderException("This lambda function only supports up to three lambda parameters!");
+		throw BinderException("This lambda function only supports up to two lambda parameters!");
 	}
 }
 

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

@@ -30,8 +30,9 @@ static unique_ptr<FunctionData> ListFilterBind(ClientContext &context, ScalarFun
 	return LambdaFunctions::ListLambdaBind(context, bound_function, arguments, has_index);
 }
 
-static LogicalType ListFilterBindLambda(const idx_t parameter_idx, const LogicalType &list_child_type) {
-	return LambdaFunctions::BindBinaryLambda(parameter_idx, list_child_type);
+static LogicalType ListFilterBindLambda(ClientContext &context, const vector<LogicalType> &function_child_types,
+                                        const idx_t parameter_idx) {
+	return LambdaFunctions::BindBinaryChildren(function_child_types, parameter_idx);
 }
 
 ScalarFunction ListFilterFun::GetFunction() {

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

@@ -1,7 +1,6 @@
 #include "core_functions/scalar/list_functions.hpp"
 #include "duckdb/function/lambda_functions.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
 
 namespace duckdb {
 
@@ -219,12 +218,6 @@ static unique_ptr<FunctionData> ListReduceBind(ClientContext &context, ScalarFun
 
 	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
 
-	auto &bound_lambda_expr = arguments[1]->Cast<BoundLambdaExpression>();
-	if (bound_lambda_expr.parameter_count < 2 || bound_lambda_expr.parameter_count > 3) {
-		throw BinderException("list_reduce expects a function with 2 or 3 arguments");
-	}
-	auto has_index = bound_lambda_expr.parameter_count == 3;
-
 	unique_ptr<FunctionData> bind_data = LambdaFunctions::ListLambdaPrepareBind(arguments, context, bound_function);
 	if (bind_data) {
 		return bind_data;
@@ -236,7 +229,7 @@ static unique_ptr<FunctionData> ListReduceBind(ClientContext &context, ScalarFun
 	bool has_initial = arguments.size() == 3;
 	if (has_initial) {
 		const auto initial_value_type = arguments[2]->return_type;
-		// Check if the initial value type is the same as the list child type and if not find the max logical type
+		// Check if the initial value type is the same as the return type of the lambda expression
 		if (list_child_type != initial_value_type) {
 			LogicalType max_logical_type;
 			const auto has_max_logical_type =
@@ -253,6 +246,12 @@ static unique_ptr<FunctionData> ListReduceBind(ClientContext &context, ScalarFun
 		}
 	}
 
+	auto &bound_lambda_expr = arguments[1]->Cast<BoundLambdaExpression>();
+	if (bound_lambda_expr.parameter_count < 2 || bound_lambda_expr.parameter_count > 3) {
+		throw BinderException("list_reduce expects a function with 2 or 3 arguments");
+	}
+	auto has_index = bound_lambda_expr.parameter_count == 3;
+
 	auto cast_lambda_expr =
 	    BoundCastExpression::AddCastToType(context, std::move(bound_lambda_expr.lambda_expr), list_child_type);
 	if (!cast_lambda_expr) {
@@ -263,8 +262,45 @@ static unique_ptr<FunctionData> ListReduceBind(ClientContext &context, ScalarFun
 	                                     has_initial);
 }
 
-static LogicalType ListReduceBindLambda(const idx_t parameter_idx, const LogicalType &list_child_type) {
-	return LambdaFunctions::BindTernaryLambda(parameter_idx, list_child_type);
+LogicalType BindReduceChildren(ClientContext &context, const vector<LogicalType> &function_child_types,
+                               const idx_t parameter_idx) {
+	auto list_child_type = LambdaFunctions::DetermineListChildType(function_child_types[0]);
+
+	// if there is an initial value, find the max logical type
+	if (function_child_types.size() == 3) {
+		// the initial value is the third child
+		constexpr idx_t initial_idx = 2;
+
+		const LogicalType initial_value_type = function_child_types[initial_idx];
+		if (initial_value_type != list_child_type) {
+			// we need to check if the initial value type is the same as the return type of the lambda expression
+			LogicalType max_logical_type;
+			const auto has_max_logical_type =
+			    LogicalType::TryGetMaxLogicalType(context, list_child_type, initial_value_type, max_logical_type);
+			if (!has_max_logical_type) {
+				throw BinderException(
+				    "The initial value type must be the same as the list child type or a common super type");
+			}
+
+			list_child_type = max_logical_type;
+		}
+	}
+
+	switch (parameter_idx) {
+	case 0:
+		return list_child_type;
+	case 1:
+		return list_child_type;
+	case 2:
+		return LogicalType::BIGINT;
+	default:
+		throw BinderException("This lambda function only supports up to three lambda parameters!");
+	}
+}
+
+static LogicalType ListReduceBindLambda(ClientContext &context, const vector<LogicalType> &function_child_types,
+                                        const idx_t parameter_idx) {
+	return BindReduceChildren(context, function_child_types, parameter_idx);
 }
 
 ScalarFunctionSet ListReduceFun::GetFunctions() {

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

@@ -22,8 +22,9 @@ static unique_ptr<FunctionData> ListTransformBind(ClientContext &context, Scalar
 	return LambdaFunctions::ListLambdaBind(context, bound_function, arguments, has_index);
 }
 
-static LogicalType ListTransformBindLambda(const idx_t parameter_idx, const LogicalType &list_child_type) {
-	return LambdaFunctions::BindBinaryLambda(parameter_idx, list_child_type);
+static LogicalType ListTransformBindLambda(ClientContext &context, const vector<LogicalType> &function_child_types,
+                                           const idx_t parameter_idx) {
+	return LambdaFunctions::BindBinaryChildren(function_child_types, parameter_idx);
 }
 
 ScalarFunction ListTransformFun::GetFunction() {

package/src/duckdb/extension/core_functions/scalar/random/random.cpp

@@ -29,7 +29,9 @@ struct ExtractTimestampUuidOperator {
 		}
 
 		// UUID v7 begins with a 48 bit big-endian Unix Epoch timestamp with millisecond granularity.
-		const int64_t upper = input.upper;
+		int64_t upper = input.upper;
+		// flip the top byte
+		upper ^= NumericLimits<int64_t>::Minimum();
 		int64_t unix_ts_milli = upper;
 		unix_ts_milli = unix_ts_milli >> 16;
 

package/src/duckdb/extension/icu/icu-datefunc.cpp

@@ -82,10 +82,12 @@ bool ICUDateFunc::TrySetTimeZone(icu::Calendar *calendar, const string_t &tz_id)
 	return true;
 }
 
-void ICUDateFunc::SetTimeZone(icu::Calendar *calendar, const string_t &tz_id) {
+void ICUDateFunc::SetTimeZone(icu::Calendar *calendar, const string_t &tz_id, string *error_message) {
 	string tz_str = tz_id.GetString();
-	auto tz = ICUHelpers::GetTimeZone(tz_str);
-	calendar->adoptTimeZone(tz.release());
+	auto tz = ICUHelpers::GetTimeZone(tz_str, error_message);
+	if (tz) {
+		calendar->adoptTimeZone(tz.release());
+	}
 }
 
 timestamp_t ICUDateFunc::GetTimeUnsafe(icu::Calendar *calendar, uint64_t micros) {

package/src/duckdb/extension/icu/icu-strptime.cpp

@@ -293,7 +293,12 @@ struct ICUStrptime : public ICUDateFunc {
 
 				    // Change TZ if one was provided.
 				    if (tz.GetSize()) {
-					    SetTimeZone(calendar, tz);
+					    string error_msg;
+					    SetTimeZone(calendar, tz, &error_msg);
+					    if (!error_msg.empty()) {
+						    HandleCastError::AssignError(error_msg, parameters);
+						    mask.SetInvalid(idx);
+					    }
 				    }
 
 				    // Now get the parts in the given time zone

package/src/duckdb/extension/icu/icu-timezone.cpp

@@ -247,6 +247,10 @@ struct ICUToNaiveTimestamp : public ICUDateFunc {
 		if (!input.context) {
 			throw InternalException("Missing context for TIMESTAMPTZ to TIMESTAMP cast.");
 		}
+		if (input.context->config.disable_timestamptz_casts) {
+			throw BinderException("Casting from TIMESTAMP WITH TIME ZONE to TIMESTAMP without an explicit time zone "
+			                      "has been disabled  - use \"AT TIME ZONE ...\"");
+		}
 
 		auto cast_data = make_uniq<CastData>(make_uniq<BindData>(*input.context));
 

package/src/duckdb/extension/icu/icu_extension.cpp

@@ -252,7 +252,7 @@ unique_ptr<icu::TimeZone> ICUHelpers::TryGetTimeZone(string &tz_str) {
 	return GetTimeZoneInternal(tz_str, candidates);
 }
 
-unique_ptr<icu::TimeZone> ICUHelpers::GetTimeZone(string &tz_str) {
+unique_ptr<icu::TimeZone> ICUHelpers::GetTimeZone(string &tz_str, string *error_message) {
 	vector<string> candidates;
 	auto tz = GetTimeZoneInternal(tz_str, candidates);
 	if (tz) {
@@ -260,7 +260,12 @@ unique_ptr<icu::TimeZone> ICUHelpers::GetTimeZone(string &tz_str) {
 	}
 	string candidate_str =
 	    StringUtil::CandidatesMessage(StringUtil::TopNJaroWinkler(candidates, tz_str), "Candidate time zones");
-
+	if (error_message) {
+		duckdb::stringstream ss;
+		ss << "Unknown TimeZone '" << tz_str << "'!\n" << candidate_str;
+		*error_message = ss.str();
+		return nullptr;
+	}
 	throw NotImplementedException("Unknown TimeZone '%s'!\n%s", tz_str, candidate_str);
 }
 

package/src/duckdb/extension/icu/include/icu-datefunc.hpp

@@ -50,7 +50,7 @@ struct ICUDateFunc {
 	//! Tries to set the time zone for the calendar and returns false if it is not valid.
 	static bool TrySetTimeZone(icu::Calendar *calendar, const string_t &tz_id);
 	//! Sets the time zone for the calendar. Throws if it is not valid
-	static void SetTimeZone(icu::Calendar *calendar, const string_t &tz_id);
+	static void SetTimeZone(icu::Calendar *calendar, const string_t &tz_id, string *error_message = nullptr);
 	//! Gets the timestamp from the calendar, throwing if it is not in range.
 	static bool TryGetTime(icu::Calendar *calendar, uint64_t micros, timestamp_t &result);
 	//! Gets the timestamp from the calendar, throwing if it is not in range.

package/src/duckdb/extension/icu/include/icu-helpers.hpp

@@ -18,7 +18,7 @@ struct ICUHelpers {
 	//! Tries to get a time zone - returns nullptr if the timezone is not found
 	static unique_ptr<icu::TimeZone> TryGetTimeZone(string &tz_str);
 	//! Gets a time zone - throws an error if the timezone is not found
-	static unique_ptr<icu::TimeZone> GetTimeZone(string &tz_str);
+	static unique_ptr<icu::TimeZone> GetTimeZone(string &tz_str, string *error_message = nullptr);
 
 	static TimestampComponents GetComponents(timestamp_tz_t ts, icu::Calendar *calendar);
 

package/src/duckdb/extension/icu/third_party/icu/common/uloc.cpp

@@ -45,8 +45,8 @@
 #include "uenumimp.h"
 #include "uassert.h"
 #include "charstr.h"
-
 #include <stdio.h> /* for sprintf */
+#include "duckdb/common/string_util.hpp"
 
 U_NAMESPACE_USE
 
@@ -2229,7 +2229,7 @@ uloc_acceptLanguageFromHTTP(char *result, int32_t resultAvailable, UAcceptResult
     }
 
     for(s=httpAcceptLanguage;s&&*s;) {
-        while(isspace(*s)) /* eat space at the beginning */
+        while(duckdb::StringUtil::CharacterIsSpace(*s)) /* eat space at the beginning */
             s++;
         itemEnd=uprv_strchr(s,',');
         paramEnd=uprv_strchr(s,';');
@@ -2242,13 +2242,13 @@ uloc_acceptLanguageFromHTTP(char *result, int32_t resultAvailable, UAcceptResult
             if(*t=='q') {
                 t++;
             }
-            while(isspace(*t)) {
+            while(duckdb::StringUtil::CharacterIsSpace(*t)) {
                 t++;
             }
             if(*t=='=') {
                 t++;
             }
-            while(isspace(*t)) {
+            while(duckdb::StringUtil::CharacterIsSpace(*t)) {
                 t++;
             }
             items[n].q = (float)_uloc_strtod(t,NULL);
@@ -2259,7 +2259,7 @@ uloc_acceptLanguageFromHTTP(char *result, int32_t resultAvailable, UAcceptResult
         }
         items[n].dummy=0;
         /* eat spaces prior to semi */
-        for(t=(paramEnd-1);(paramEnd>s)&&isspace(*t);t--)
+        for(t=(paramEnd-1);(paramEnd>s)&&duckdb::StringUtil::CharacterIsSpace(*t);t--)
             ;
         int32_t slen = static_cast<int32_t>(((t+1)-s));
         if(slen > ULOC_FULLNAME_CAPACITY) {

package/src/duckdb/extension/json/include/json_common.hpp

@@ -360,4 +360,23 @@ inline char *JSONCommon::WriteVal(yyjson_mut_val *val, yyjson_alc *alc, idx_t &l
 	return yyjson_mut_val_write_opts(val, JSONCommon::WRITE_FLAG, alc, reinterpret_cast<size_t *>(&len), nullptr);
 }
 
+struct yyjson_doc_deleter {
+	void operator()(yyjson_doc *doc) {
+		if (doc) {
+			yyjson_doc_free(doc);
+		}
+	}
+};
+
+struct yyjson_mut_doc_deleter {
+	void operator()(yyjson_mut_doc *doc) {
+		if (doc) {
+			yyjson_mut_doc_free(doc);
+		}
+	}
+};
+
+using yyjson_doc_ptr = unique_ptr<yyjson_doc, yyjson_doc_deleter>;
+using yyjson_mut_doc_ptr = unique_ptr<yyjson_mut_doc, yyjson_mut_doc_deleter>;
+
 } // namespace duckdb

package/src/duckdb/extension/json/include/json_deserializer.hpp

@@ -6,13 +6,10 @@ namespace duckdb {
 
 class JsonDeserializer : public Deserializer {
 public:
-	JsonDeserializer(yyjson_val *val, yyjson_doc *doc) : doc(doc) {
+	JsonDeserializer(yyjson_val *val, const yyjson_doc_ptr &doc) : doc(doc.get()) {
 		deserialize_enum_from_string = true;
 		stack.emplace_back(val);
 	}
-	~JsonDeserializer() {
-		yyjson_doc_free(doc);
-	}
 
 private:
 	struct StackFrame {

package/src/duckdb/extension/json/include/json_functions.hpp

@@ -27,7 +27,7 @@ public:
 	JSONReadFunctionData(bool constant, string path_p, idx_t len, JSONCommon::JSONPathType path_type);
 	unique_ptr<FunctionData> Copy() const override;
 	bool Equals(const FunctionData &other_p) const override;
-	static JSONCommon::JSONPathType CheckPath(const Value &path_val, string &path, size_t &len);
+	static JSONCommon::JSONPathType CheckPath(const Value &path_val, string &path, idx_t &len);
 	static unique_ptr<FunctionData> Bind(ClientContext &context, ScalarFunction &bound_function,
 	                                     vector<unique_ptr<Expression>> &arguments);
 
@@ -36,12 +36,12 @@ public:
 	const string path;
 	const JSONCommon::JSONPathType path_type;
 	const char *ptr;
-	const size_t len;
+	const idx_t len;
 };
 
 struct JSONReadManyFunctionData : public FunctionData {
 public:
-	JSONReadManyFunctionData(vector<string> paths_p, vector<size_t> lens_p);
+	JSONReadManyFunctionData(vector<string> paths_p, vector<idx_t> lens_p);
 	unique_ptr<FunctionData> Copy() const override;
 	bool Equals(const FunctionData &other_p) const override;
 	static unique_ptr<FunctionData> Bind(ClientContext &context, ScalarFunction &bound_function,
@@ -50,7 +50,7 @@ public:
 public:
 	const vector<string> paths;
 	vector<const char *> ptrs;
-	const vector<size_t> lens;
+	const vector<idx_t> lens;
 };
 
 struct JSONFunctionLocalState : public FunctionLocalState {