duckdb 0.10.3-dev0.0 → 0.10.3-dev6.0

package/src/duckdb/src/common/types.cpp

@@ -364,6 +364,18 @@ string LogicalType::ToString() const {
 	if (id_ != LogicalTypeId::USER) {
 		auto alias = GetAlias();
 		if (!alias.empty()) {
+			auto mods_ptr = GetModifiers();
+			if (mods_ptr && !mods_ptr->empty()) {
+				auto &mods = *mods_ptr;
+				alias += "(";
+				for (idx_t i = 0; i < mods.size(); i++) {
+					alias += mods[i].ToString();
+					if (i < mods.size() - 1) {
+						alias += ", ";
+					}
+				}
+				alias += ")";
+			}
 			return alias;
 		}
 	}
@@ -457,6 +469,7 @@ string LogicalType::ToString() const {
 		auto &catalog = UserType::GetCatalog(*this);
 		auto &schema = UserType::GetSchema(*this);
 		auto &type = UserType::GetTypeName(*this);
+		auto &mods = UserType::GetTypeModifiers(*this);
 
 		if (!catalog.empty()) {
 			result = KeywordHelper::WriteOptionallyQuoted(catalog);
@@ -471,11 +484,26 @@ string LogicalType::ToString() const {
 			result += ".";
 		}
 		result += KeywordHelper::WriteOptionallyQuoted(type);
+
+		if (!mods.empty()) {
+			result += "(";
+			for (idx_t i = 0; i < mods.size(); i++) {
+				result += mods[i].ToString();
+				if (i < mods.size() - 1) {
+					result += ", ";
+				}
+			}
+			result += ")";
+		}
+
 		return result;
 	}
 	case LogicalTypeId::AGGREGATE_STATE: {
 		return AggregateStateType::GetTypeName(*this);
 	}
+	case LogicalTypeId::SQLNULL: {
+		return "\"NULL\"";
+	}
 	default:
 		return EnumUtil::ToString(id_);
 	}
@@ -501,7 +529,9 @@ LogicalType TransformStringToLogicalType(const string &str) {
 
 LogicalType GetUserTypeRecursive(const LogicalType &type, ClientContext &context) {
 	if (type.id() == LogicalTypeId::USER && type.HasAlias()) {
-		return Catalog::GetType(context, INVALID_CATALOG, INVALID_SCHEMA, type.GetAlias());
+		auto &type_entry =
+		    Catalog::GetEntry<TypeCatalogEntry>(context, INVALID_CATALOG, INVALID_SCHEMA, type.GetAlias());
+		return type_entry.user_type;
 	}
 	// Look for LogicalTypeId::USER in nested types
 	if (type.id() == LogicalTypeId::STRUCT) {
@@ -1110,7 +1140,7 @@ bool ApproxEqual(float ldecimal, float rdecimal) {
 	if (!Value::FloatIsFinite(ldecimal) || !Value::FloatIsFinite(rdecimal)) {
 		return ldecimal == rdecimal;
 	}
-	float epsilon = std::fabs(rdecimal) * 0.01 + 0.00000001;
+	float epsilon = static_cast<float>(std::fabs(rdecimal) * 0.01 + 0.00000001);
 	return std::fabs(ldecimal - rdecimal) <= epsilon;
 }
 
@@ -1128,9 +1158,18 @@ bool ApproxEqual(double ldecimal, double rdecimal) {
 //===--------------------------------------------------------------------===//
 // Extra Type Info
 //===--------------------------------------------------------------------===//
+
+LogicalType LogicalType::DeepCopy() const {
+	LogicalType copy = *this;
+	if (type_info_) {
+		copy.type_info_ = type_info_->Copy();
+	}
+	return copy;
+}
+
 void LogicalType::SetAlias(string alias) {
 	if (!type_info_) {
-		type_info_ = make_shared<ExtraTypeInfo>(ExtraTypeInfoType::GENERIC_TYPE_INFO, std::move(alias));
+		type_info_ = make_shared_ptr<ExtraTypeInfo>(ExtraTypeInfoType::GENERIC_TYPE_INFO, std::move(alias));
 	} else {
 		type_info_->alias = std::move(alias);
 	}
@@ -1156,6 +1195,53 @@ bool LogicalType::HasAlias() const {
 	return false;
 }
 
+void LogicalType::SetModifiers(vector<Value> modifiers) {
+	if (!type_info_ && !modifiers.empty()) {
+		type_info_ = make_shared_ptr<ExtraTypeInfo>(ExtraTypeInfoType::GENERIC_TYPE_INFO);
+	}
+	type_info_->modifiers = std::move(modifiers);
+}
+
+bool LogicalType::HasModifiers() const {
+	if (id() == LogicalTypeId::USER) {
+		return !UserType::GetTypeModifiers(*this).empty();
+	}
+	if (type_info_) {
+		return !type_info_->modifiers.empty();
+	}
+	return false;
+}
+
+vector<Value> LogicalType::GetModifiersCopy() const {
+	if (id() == LogicalTypeId::USER) {
+		return UserType::GetTypeModifiers(*this);
+	}
+	if (type_info_) {
+		return type_info_->modifiers;
+	}
+	return {};
+}
+
+optional_ptr<vector<Value>> LogicalType::GetModifiers() {
+	if (id() == LogicalTypeId::USER) {
+		return UserType::GetTypeModifiers(*this);
+	}
+	if (type_info_) {
+		return type_info_->modifiers;
+	}
+	return nullptr;
+}
+
+optional_ptr<const vector<Value>> LogicalType::GetModifiers() const {
+	if (id() == LogicalTypeId::USER) {
+		return UserType::GetTypeModifiers(*this);
+	}
+	if (type_info_) {
+		return type_info_->modifiers;
+	}
+	return nullptr;
+}
+
 //===--------------------------------------------------------------------===//
 // Decimal Type
 //===--------------------------------------------------------------------===//
@@ -1179,7 +1265,7 @@ uint8_t DecimalType::MaxWidth() {
 
 LogicalType LogicalType::DECIMAL(uint8_t width, uint8_t scale) {
 	D_ASSERT(width >= scale);
-	auto type_info = make_shared<DecimalTypeInfo>(width, scale);
+	auto type_info = make_shared_ptr<DecimalTypeInfo>(width, scale);
 	return LogicalType(LogicalTypeId::DECIMAL, std::move(type_info));
 }
 
@@ -1201,7 +1287,7 @@ string StringType::GetCollation(const LogicalType &type) {
 }
 
 LogicalType LogicalType::VARCHAR_COLLATION(string collation) { // NOLINT
-	auto string_info = make_shared<StringTypeInfo>(std::move(collation));
+	auto string_info = make_shared_ptr<StringTypeInfo>(std::move(collation));
 	return LogicalType(LogicalTypeId::VARCHAR, std::move(string_info));
 }
 
@@ -1216,7 +1302,7 @@ const LogicalType &ListType::GetChildType(const LogicalType &type) {
 }
 
 LogicalType LogicalType::LIST(const LogicalType &child) {
-	auto info = make_shared<ListTypeInfo>(child);
+	auto info = make_shared_ptr<ListTypeInfo>(child);
 	return LogicalType(LogicalTypeId::LIST, std::move(info));
 }
 
@@ -1288,12 +1374,12 @@ bool StructType::IsUnnamed(const LogicalType &type) {
 }
 
 LogicalType LogicalType::STRUCT(child_list_t<LogicalType> children) {
-	auto info = make_shared<StructTypeInfo>(std::move(children));
+	auto info = make_shared_ptr<StructTypeInfo>(std::move(children));
 	return LogicalType(LogicalTypeId::STRUCT, std::move(info));
 }
 
 LogicalType LogicalType::AGGREGATE_STATE(aggregate_state_t state_type) { // NOLINT
-	auto info = make_shared<AggregateStateTypeInfo>(std::move(state_type));
+	auto info = make_shared_ptr<AggregateStateTypeInfo>(std::move(state_type));
 	return LogicalType(LogicalTypeId::AGGREGATE_STATE, std::move(info));
 }
 
@@ -1318,7 +1404,7 @@ LogicalType LogicalType::MAP(const LogicalType &child_p) {
 	new_children[1].first = "value";
 
 	auto child = LogicalType::STRUCT(std::move(new_children));
-	auto info = make_shared<ListTypeInfo>(child);
+	auto info = make_shared_ptr<ListTypeInfo>(child);
 	return LogicalType(LogicalTypeId::MAP, std::move(info));
 }
 
@@ -1347,7 +1433,7 @@ LogicalType LogicalType::UNION(child_list_t<LogicalType> members) {
 	D_ASSERT(members.size() <= UnionType::MAX_UNION_MEMBERS);
 	// union types always have a hidden "tag" field in front
 	members.insert(members.begin(), {"", LogicalType::UTINYINT});
-	auto info = make_shared<StructTypeInfo>(std::move(members));
+	auto info = make_shared_ptr<StructTypeInfo>(std::move(members));
 	return LogicalType(LogicalTypeId::UNION, std::move(info));
 }
 
@@ -1399,13 +1485,33 @@ const string &UserType::GetTypeName(const LogicalType &type) {
 	return info->Cast<UserTypeInfo>().user_type_name;
 }
 
+const vector<Value> &UserType::GetTypeModifiers(const LogicalType &type) {
+	D_ASSERT(type.id() == LogicalTypeId::USER);
+	auto info = type.AuxInfo();
+	D_ASSERT(info);
+	return info->Cast<UserTypeInfo>().user_type_modifiers;
+}
+
+vector<Value> &UserType::GetTypeModifiers(LogicalType &type) {
+	D_ASSERT(type.id() == LogicalTypeId::USER);
+	auto info = type.GetAuxInfoShrPtr();
+	D_ASSERT(info);
+	return info->Cast<UserTypeInfo>().user_type_modifiers;
+}
+
 LogicalType LogicalType::USER(const string &user_type_name) {
-	auto info = make_shared<UserTypeInfo>(user_type_name);
+	auto info = make_shared_ptr<UserTypeInfo>(user_type_name);
+	return LogicalType(LogicalTypeId::USER, std::move(info));
+}
+
+LogicalType LogicalType::USER(const string &user_type_name, const vector<Value> &user_type_mods) {
+	auto info = make_shared_ptr<UserTypeInfo>(user_type_name, user_type_mods);
 	return LogicalType(LogicalTypeId::USER, std::move(info));
 }
 
-LogicalType LogicalType::USER(string catalog, string schema, string name) {
-	auto info = make_shared<UserTypeInfo>(std::move(catalog), std::move(schema), std::move(name));
+LogicalType LogicalType::USER(string catalog, string schema, string name, vector<Value> user_type_mods) {
+	auto info = make_shared_ptr<UserTypeInfo>(std::move(catalog), std::move(schema), std::move(name),
+	                                          std::move(user_type_mods));
 	return LogicalType(LogicalTypeId::USER, std::move(info));
 }
 
@@ -1520,13 +1626,13 @@ LogicalType ArrayType::ConvertToList(const LogicalType &type) {
 
 LogicalType LogicalType::ARRAY(const LogicalType &child, idx_t size) {
 	D_ASSERT(size > 0);
-	D_ASSERT(size < ArrayType::MAX_ARRAY_SIZE);
-	auto info = make_shared<ArrayTypeInfo>(child, size);
+	D_ASSERT(size <= ArrayType::MAX_ARRAY_SIZE);
+	auto info = make_shared_ptr<ArrayTypeInfo>(child, size);
 	return LogicalType(LogicalTypeId::ARRAY, std::move(info));
 }
 
 LogicalType LogicalType::ARRAY(const LogicalType &child) {
-	auto info = make_shared<ArrayTypeInfo>(child, 0);
+	auto info = make_shared_ptr<ArrayTypeInfo>(child, 0);
 	return LogicalType(LogicalTypeId::ARRAY, std::move(info));
 }
 
@@ -1534,7 +1640,7 @@ LogicalType LogicalType::ARRAY(const LogicalType &child) {
 // Any Type
 //===--------------------------------------------------------------------===//
 LogicalType LogicalType::ANY_PARAMS(LogicalType target, idx_t cast_score) { // NOLINT
-	auto type_info = make_shared<AnyTypeInfo>(std::move(target), cast_score);
+	auto type_info = make_shared_ptr<AnyTypeInfo>(std::move(target), cast_score);
 	return LogicalType(LogicalTypeId::ANY, std::move(type_info));
 }
 
@@ -1587,7 +1693,7 @@ LogicalType LogicalType::INTEGER_LITERAL(const Value &constant) { // NOLINT
 	if (!constant.type().IsIntegral()) {
 		throw InternalException("INTEGER_LITERAL can only be made from literals of integer types");
 	}
-	auto type_info = make_shared<IntegerLiteralTypeInfo>(constant);
+	auto type_info = make_shared_ptr<IntegerLiteralTypeInfo>(constant);
 	return LogicalType(LogicalTypeId::INTEGER_LITERAL, std::move(type_info));
 }
 

package/src/duckdb/src/common/vector_operations/generators.cpp

@@ -18,7 +18,7 @@ void TemplatedGenerateSequence(Vector &result, idx_t count, int64_t start, int64
 	}
 	result.SetVectorType(VectorType::FLAT_VECTOR);
 	auto result_data = FlatVector::GetData<T>(result);
-	auto value = (T)start;
+	auto value = T(start);
 	for (idx_t i = 0; i < count; i++) {
 		if (i > 0) {
 			value += increment;
@@ -44,12 +44,6 @@ void VectorOperations::GenerateSequence(Vector &result, idx_t count, int64_t sta
 	case PhysicalType::INT64:
 		TemplatedGenerateSequence<int64_t>(result, count, start, increment);
 		break;
-	case PhysicalType::FLOAT:
-		TemplatedGenerateSequence<float>(result, count, start, increment);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedGenerateSequence<double>(result, count, start, increment);
-		break;
 	default:
 		throw NotImplementedException("Unimplemented type for generate sequence");
 	}
@@ -64,10 +58,10 @@ void TemplatedGenerateSequence(Vector &result, idx_t count, const SelectionVecto
 	}
 	result.SetVectorType(VectorType::FLAT_VECTOR);
 	auto result_data = FlatVector::GetData<T>(result);
-	auto value = (T)start;
+	auto value = static_cast<uint64_t>(start);
 	for (idx_t i = 0; i < count; i++) {
-		auto idx = UnsafeNumericCast<int64_t>(sel.get_index(i));
-		result_data[idx] = UnsafeNumericCast<T>(value + increment * idx);
+		auto idx = sel.get_index(i);
+		result_data[idx] = static_cast<T>(value + static_cast<uint64_t>(increment) * idx);
 	}
 }
 
@@ -89,12 +83,6 @@ void VectorOperations::GenerateSequence(Vector &result, idx_t count, const Selec
 	case PhysicalType::INT64:
 		TemplatedGenerateSequence<int64_t>(result, count, sel, start, increment);
 		break;
-	case PhysicalType::FLOAT:
-		TemplatedGenerateSequence<float>(result, count, sel, start, increment);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedGenerateSequence<double>(result, count, sel, start, increment);
-		break;
 	default:
 		throw NotImplementedException("Unimplemented type for generate sequence");
 	}

package/src/duckdb/src/common/vector_operations/is_distinct_from.cpp

@@ -476,6 +476,16 @@ idx_t PositionComparator::Final<duckdb::DistinctLessThan>(Vector &left, Vector &
 	return VectorOperations::DistinctGreaterThan(right, left, &sel, count, true_sel, false_sel, null_mask);
 }
 
+template <>
+idx_t PositionComparator::Final<duckdb::DistinctLessThanNullsFirst>(Vector &left, Vector &right,
+                                                                    const SelectionVector &sel, idx_t count,
+                                                                    optional_ptr<SelectionVector> true_sel,
+                                                                    optional_ptr<SelectionVector> false_sel,
+                                                                    optional_ptr<ValidityMask> null_mask) {
+	// DistinctGreaterThan has NULLs last
+	return VectorOperations::DistinctGreaterThan(right, left, &sel, count, true_sel, false_sel, null_mask);
+}
+
 template <>
 idx_t PositionComparator::Final<duckdb::DistinctGreaterThan>(Vector &left, Vector &right, const SelectionVector &sel,
                                                              idx_t count, optional_ptr<SelectionVector> true_sel,
@@ -484,6 +494,16 @@ idx_t PositionComparator::Final<duckdb::DistinctGreaterThan>(Vector &left, Vecto
 	return VectorOperations::DistinctGreaterThan(left, right, &sel, count, true_sel, false_sel, null_mask);
 }
 
+template <>
+idx_t PositionComparator::Final<duckdb::DistinctGreaterThanNullsFirst>(Vector &left, Vector &right,
+                                                                       const SelectionVector &sel, idx_t count,
+                                                                       optional_ptr<SelectionVector> true_sel,
+                                                                       optional_ptr<SelectionVector> false_sel,
+                                                                       optional_ptr<ValidityMask> null_mask) {
+	// DistinctLessThan has NULLs last
+	return VectorOperations::DistinctLessThan(right, left, &sel, count, true_sel, false_sel, null_mask);
+}
+
 using StructEntries = vector<unique_ptr<Vector>>;
 
 static void ExtractNestedSelection(const SelectionVector &slice_sel, const idx_t count, const SelectionVector &sel,

package/src/duckdb/src/common/vector_operations/null_operations.cpp

@@ -102,7 +102,7 @@ idx_t VectorOperations::CountNotNull(Vector &input, const idx_t count) {
 	default:
 		for (idx_t i = 0; i < count; ++i) {
 			const auto row_idx = vdata.sel->get_index(i);
-			valid += int(vdata.validity.RowIsValid(row_idx));
+			valid += idx_t(vdata.validity.RowIsValid(row_idx));
 		}
 		break;
 	}

package/src/duckdb/src/common/vector_operations/numeric_inplace_operators.cpp

@@ -23,14 +23,14 @@ void VectorOperations::AddInPlace(Vector &input, int64_t right, idx_t count) {
 	case VectorType::CONSTANT_VECTOR: {
 		D_ASSERT(!ConstantVector::IsNull(input));
 		auto data = ConstantVector::GetData<uintptr_t>(input);
-		*data += right;
+		*data += UnsafeNumericCast<uintptr_t>(right);
 		break;
 	}
 	default: {
 		D_ASSERT(input.GetVectorType() == VectorType::FLAT_VECTOR);
 		auto data = FlatVector::GetData<uintptr_t>(input);
 		for (idx_t i = 0; i < count; i++) {
-			data[i] += right;
+			data[i] = UnsafeNumericCast<uintptr_t>(UnsafeNumericCast<int64_t>(data[i]) + right);
 		}
 		break;
 	}

package/src/duckdb/src/core_functions/aggregate/distributive/approx_count.cpp

@@ -43,7 +43,7 @@ struct ApproxCountDistinctFunction {
 	template <class T, class STATE>
 	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
 		if (state.log) {
-			target = state.log->Count();
+			target = UnsafeNumericCast<T>(state.log->Count());
 		} else {
 			target = 0;
 		}

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

@@ -1,12 +1,12 @@
-#include "duckdb/core_functions/aggregate/distributive_functions.hpp"
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/operator/comparison_operators.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
+#include "duckdb/core_functions/aggregate/distributive_functions.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
 
 namespace duckdb {
 
@@ -174,7 +174,9 @@ struct ArgMinMaxBase {
 
 	static unique_ptr<FunctionData> Bind(ClientContext &context, AggregateFunction &function,
 	                                     vector<unique_ptr<Expression>> &arguments) {
-		ExpressionBinder::PushCollation(context, arguments[1], arguments[1]->return_type, false);
+		if (arguments[1]->return_type.InternalType() == PhysicalType::VARCHAR) {
+			ExpressionBinder::PushCollation(context, arguments[1], arguments[1]->return_type, false);
+		}
 		function.arguments[0] = arguments[0]->return_type;
 		function.return_type = arguments[0]->return_type;
 		return nullptr;
@@ -318,9 +320,7 @@ AggregateFunction GetArgMinMaxFunctionInternal(const LogicalType &by_type, const
 	if (type.InternalType() == PhysicalType::VARCHAR || by_type.InternalType() == PhysicalType::VARCHAR) {
 		function.destructor = AggregateFunction::StateDestroy<STATE, OP>;
 	}
-	if (by_type.InternalType() == PhysicalType::VARCHAR) {
-		function.bind = OP::Bind;
-	}
+	function.bind = OP::Bind;
 	return function;
 }
 
@@ -376,6 +376,13 @@ static unique_ptr<FunctionData> BindDecimalArgMinMax(ClientContext &context, Agg
 	idx_t best_target = DConstants::INVALID_INDEX;
 	int64_t lowest_cost = NumericLimits<int64_t>::Maximum();
 	for (idx_t i = 0; i < by_types.size(); ++i) {
+		// Before falling back to casting, check for a physical type match for the by_type
+		if (by_types[i].InternalType() == by_type.InternalType()) {
+			lowest_cost = 0;
+			best_target = DConstants::INVALID_INDEX;
+			break;
+		}
+
 		auto cast_cost = CastFunctionSet::Get(context).ImplicitCastCost(by_type, by_types[i]);
 		if (cast_cost < 0) {
 			continue;

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

@@ -10,6 +10,7 @@ namespace duckdb {
 
 template <class T>
 struct BitState {
+	using TYPE = T;
 	bool is_set;
 	T value;
 };
@@ -67,7 +68,7 @@ struct BitwiseOperation {
 
 	template <class INPUT_TYPE, class STATE>
 	static void Assign(STATE &state, INPUT_TYPE input) {
-		state.value = input;
+		state.value = typename STATE::TYPE(input);
 	}
 
 	template <class STATE, class OP>
@@ -90,7 +91,7 @@ struct BitwiseOperation {
 		if (!state.is_set) {
 			finalize_data.ReturnNull();
 		} else {
-			target = state.value;
+			target = T(state.value);
 		}
 	}
 
@@ -102,21 +103,23 @@ struct BitwiseOperation {
 struct BitAndOperation : public BitwiseOperation {
 	template <class INPUT_TYPE, class STATE>
 	static void Execute(STATE &state, INPUT_TYPE input) {
-		state.value &= input;
+		state.value &= typename STATE::TYPE(input);
+		;
 	}
 };
 
 struct BitOrOperation : public BitwiseOperation {
 	template <class INPUT_TYPE, class STATE>
 	static void Execute(STATE &state, INPUT_TYPE input) {
-		state.value |= input;
+		state.value |= typename STATE::TYPE(input);
+		;
 	}
 };
 
 struct BitXorOperation : public BitwiseOperation {
 	template <class INPUT_TYPE, class STATE>
 	static void Execute(STATE &state, INPUT_TYPE input) {
-		state.value ^= input;
+		state.value ^= typename STATE::TYPE(input);
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>

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

@@ -107,7 +107,7 @@ struct BitStringAggOperation {
 		if (!TrySubtractOperator::Operation(max, min, result)) {
 			return NumericLimits<idx_t>::Maximum();
 		}
-		idx_t val(result);
+		auto val = NumericCast<idx_t>(result);
 		if (val == NumericLimits<idx_t>::Maximum()) {
 			return val;
 		}
@@ -116,7 +116,7 @@ struct BitStringAggOperation {
 
 	template <class INPUT_TYPE, class STATE>
 	static void Execute(STATE &state, INPUT_TYPE input, INPUT_TYPE min) {
-		Bit::SetBit(state.value, input - min, 1);
+		Bit::SetBit(state.value, UnsafeNumericCast<idx_t>(input - min), 1);
 	}
 
 	template <class STATE, class OP>

package/src/duckdb/src/core_functions/aggregate/distributive/sum.cpp

@@ -140,8 +140,8 @@ unique_ptr<BaseStatistics> SumPropagateStats(ClientContext &context, BoundAggreg
 		default:
 			throw InternalException("Unsupported type for propagate sum stats");
 		}
-		auto max_sum_negative = max_negative * hugeint_t(input.node_stats->max_cardinality);
-		auto max_sum_positive = max_positive * hugeint_t(input.node_stats->max_cardinality);
+		auto max_sum_negative = max_negative * Hugeint::Convert(input.node_stats->max_cardinality);
+		auto max_sum_positive = max_positive * Hugeint::Convert(input.node_stats->max_cardinality);
 		if (max_sum_positive >= NumericLimits<int64_t>::Maximum() ||
 		    max_sum_negative <= NumericLimits<int64_t>::Minimum()) {
 			// sum can potentially exceed int64_t bounds: use hugeint sum

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

@@ -185,6 +185,8 @@ unique_ptr<FunctionData> BindApproxQuantile(ClientContext &context, AggregateFun
 	vector<float> quantiles;
 	if (quantile_val.type().id() != LogicalTypeId::LIST) {
 		quantiles.push_back(CheckApproxQuantile(quantile_val));
+	} else if (quantile_val.IsNull()) {
+		throw BinderException("APPROXIMATE QUANTILE parameter list cannot be NULL");
 	} else {
 		for (const auto &element_val : ListValue::GetChildren(quantile_val)) {
 			quantiles.push_back(CheckApproxQuantile(element_val));

package/src/duckdb/src/core_functions/aggregate/holistic/mode.cpp

@@ -27,7 +27,7 @@ struct hash<duckdb::interval_t> {
 template <>
 struct hash<duckdb::hugeint_t> {
 	inline size_t operator()(const duckdb::hugeint_t &val) const {
-		return hash<int64_t> {}(val.upper) ^ hash<int64_t> {}(val.lower);
+		return hash<int64_t> {}(val.upper) ^ hash<uint64_t> {}(val.lower);
 	}
 };
 
@@ -102,7 +102,7 @@ struct ModeState {
 	void ModeRm(const KEY_TYPE &key, idx_t frame) {
 		auto &attr = (*frequency_map)[key];
 		auto old_count = attr.count;
-		nonzero -= int(old_count == 1);
+		nonzero -= size_t(old_count == 1);
 
 		attr.count -= 1;
 		if (count == old_count && key == *mode) {

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

@@ -157,7 +157,7 @@ struct CastInterpolation {
 	template <typename TARGET_TYPE>
 	static inline TARGET_TYPE Interpolate(const TARGET_TYPE &lo, const double d, const TARGET_TYPE &hi) {
 		const auto delta = hi - lo;
-		return lo + delta * d;
+		return UnsafeNumericCast<TARGET_TYPE>(lo + delta * d);
 	}
 };
 
@@ -295,7 +295,8 @@ bool operator==(const QuantileValue &x, const QuantileValue &y) {
 template <bool DISCRETE>
 struct Interpolator {
 	Interpolator(const QuantileValue &q, const idx_t n_p, const bool desc_p)
-	    : desc(desc_p), RN((double)(n_p - 1) * q.dbl), FRN(floor(RN)), CRN(ceil(RN)), begin(0), end(n_p) {
+	    : desc(desc_p), RN((double)(n_p - 1) * q.dbl), FRN(UnsafeNumericCast<idx_t>(floor(RN))),
+	      CRN(UnsafeNumericCast<idx_t>(ceil(RN))), begin(0), end(n_p) {
 	}
 
 	template <class INPUT_TYPE, class TARGET_TYPE, typename ACCESSOR = QuantileDirect<INPUT_TYPE>>
@@ -356,14 +357,16 @@ struct Interpolator<true> {
 			//	Integer arithmetic for accuracy
 			const auto integral = q.integral;
 			const auto scaling = q.scaling;
-			const auto scaled_q = DecimalMultiplyOverflowCheck::Operation<hugeint_t, hugeint_t, hugeint_t>(n, integral);
-			const auto scaled_n = DecimalMultiplyOverflowCheck::Operation<hugeint_t, hugeint_t, hugeint_t>(n, scaling);
+			const auto scaled_q =
+			    DecimalMultiplyOverflowCheck::Operation<hugeint_t, hugeint_t, hugeint_t>(Hugeint::Convert(n), integral);
+			const auto scaled_n =
+			    DecimalMultiplyOverflowCheck::Operation<hugeint_t, hugeint_t, hugeint_t>(Hugeint::Convert(n), scaling);
 			floored = Cast::Operation<hugeint_t, idx_t>((scaled_n - scaled_q) / scaling);
 			break;
 		}
 		default:
 			const auto scaled_q = (double)(n * q.dbl);
-			floored = floor(n - scaled_q);
+			floored = UnsafeNumericCast<idx_t>(floor(n - scaled_q));
 			break;
 		}
 

package/src/duckdb/src/core_functions/aggregate/holistic/reservoir_quantile.cpp

@@ -52,11 +52,11 @@ struct ReservoirQuantileState {
 struct ReservoirQuantileBindData : public FunctionData {
 	ReservoirQuantileBindData() {
 	}
-	ReservoirQuantileBindData(double quantile_p, int32_t sample_size_p)
+	ReservoirQuantileBindData(double quantile_p, idx_t sample_size_p)
 	    : quantiles(1, quantile_p), sample_size(sample_size_p) {
 	}
 
-	ReservoirQuantileBindData(vector<double> quantiles_p, int32_t sample_size_p)
+	ReservoirQuantileBindData(vector<double> quantiles_p, idx_t sample_size_p)
 	    : quantiles(std::move(quantiles_p)), sample_size(sample_size_p) {
 	}
 
@@ -84,7 +84,7 @@ struct ReservoirQuantileBindData : public FunctionData {
 	}
 
 	vector<double> quantiles;
-	int32_t sample_size;
+	idx_t sample_size;
 };
 
 struct ReservoirQuantileOperation {
@@ -325,12 +325,13 @@ unique_ptr<FunctionData> BindReservoirQuantile(ClientContext &context, Aggregate
 	}
 
 	if (arguments.size() == 2) {
+		// remove the quantile argument so we can use the unary aggregate
 		if (function.arguments.size() == 2) {
 			Function::EraseArgument(function, arguments, arguments.size() - 1);
 		} else {
 			arguments.pop_back();
 		}
-		return make_uniq<ReservoirQuantileBindData>(quantiles, 8192);
+		return make_uniq<ReservoirQuantileBindData>(quantiles, 8192ULL);
 	}
 	if (!arguments[2]->IsFoldable()) {
 		throw BinderException("RESERVOIR_QUANTILE can only take constant sample size parameters");
@@ -345,10 +346,15 @@ unique_ptr<FunctionData> BindReservoirQuantile(ClientContext &context, Aggregate
 		throw BinderException("Size of the RESERVOIR_QUANTILE sample must be bigger than 0");
 	}
 
-	// remove the quantile argument so we can use the unary aggregate
-	Function::EraseArgument(function, arguments, arguments.size() - 1);
-	Function::EraseArgument(function, arguments, arguments.size() - 1);
-	return make_uniq<ReservoirQuantileBindData>(quantiles, sample_size);
+	// remove the quantile arguments so we can use the unary aggregate
+	if (function.arguments.size() == arguments.size()) {
+		Function::EraseArgument(function, arguments, arguments.size() - 1);
+		Function::EraseArgument(function, arguments, arguments.size() - 1);
+	} else {
+		arguments.pop_back();
+		arguments.pop_back();
+	}
+	return make_uniq<ReservoirQuantileBindData>(quantiles, NumericCast<idx_t>(sample_size));
 }
 
 unique_ptr<FunctionData> BindReservoirQuantileDecimal(ClientContext &context, AggregateFunction &function,