Merge branch 'duckdb:main' into build-linux-amd64-only-musl

duckdb · Jan 18, 2025 · 9326a43 · 9326a43
2 parents 00f6526 + e7008ef
commit 9326a43
Show file tree

Hide file tree

Showing 545 changed files with 22,986 additions and 15,998 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
diff --git a/LICENSE b/LICENSE
@@ -1,4 +1,4 @@
-Copyright 2018-2024 Stichting DuckDB Foundation
+Copyright 2018-2025 Stichting DuckDB Foundation
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

diff --git a/src/duckdb/extension/core_functions/aggregate/holistic/mad.cpp b/src/duckdb/extension/core_functions/aggregate/holistic/mad.cpp
@@ -276,7 +276,7 @@ AggregateFunction GetTypedMedianAbsoluteDeviationAggregateFunction(const Logical
 	return fun;
 }
 
-AggregateFunction GetMedianAbsoluteDeviationAggregateFunction(const LogicalType &type) {
+AggregateFunction GetMedianAbsoluteDeviationAggregateFunctionInternal(const LogicalType &type) {
 	switch (type.id()) {
 	case LogicalTypeId::FLOAT:
 		return GetTypedMedianAbsoluteDeviationAggregateFunction<float, float, float>(type, type);
@@ -314,6 +314,12 @@ AggregateFunction GetMedianAbsoluteDeviationAggregateFunction(const LogicalType
 	}
 }
 
+AggregateFunction GetMedianAbsoluteDeviationAggregateFunction(const LogicalType &type) {
+	auto result = GetMedianAbsoluteDeviationAggregateFunctionInternal(type);
+	result.errors = FunctionErrors::CAN_THROW_RUNTIME_ERROR;
+	return result;
+}
+
 unique_ptr<FunctionData> BindMedianAbsoluteDeviationDecimal(ClientContext &context, AggregateFunction &function,
                                                             vector<unique_ptr<Expression>> &arguments) {
 	function = GetMedianAbsoluteDeviationAggregateFunction(arguments[0]->return_type);

diff --git a/src/duckdb/extension/core_functions/scalar/array/array_functions.cpp b/src/duckdb/extension/core_functions/scalar/array/array_functions.cpp
@@ -210,9 +210,13 @@ template <class OP>
 static void AddArrayFoldFunction(ScalarFunctionSet &set, const LogicalType &type) {
 	const auto array = LogicalType::ARRAY(type, optional_idx());
 	if (type.id() == LogicalTypeId::FLOAT) {
-		set.AddFunction(ScalarFunction({array, array}, type, ArrayGenericFold<float, OP>, ArrayGenericBinaryBind));
+		ScalarFunction function({array, array}, type, ArrayGenericFold<float, OP>, ArrayGenericBinaryBind);
+		BaseScalarFunction::SetReturnsError(function);
+		set.AddFunction(function);
 	} else if (type.id() == LogicalTypeId::DOUBLE) {
-		set.AddFunction(ScalarFunction({array, array}, type, ArrayGenericFold<double, OP>, ArrayGenericBinaryBind));
+		ScalarFunction function({array, array}, type, ArrayGenericFold<double, OP>, ArrayGenericBinaryBind);
+		BaseScalarFunction::SetReturnsError(function);
+		set.AddFunction(function);
 	} else {
 		throw NotImplementedException("Array function not implemented for type %s", type.ToString());
 	}
@@ -267,6 +271,9 @@ ScalarFunctionSet ArrayCrossProductFun::GetFunctions() {
 	    ScalarFunction({float_array, float_array}, float_array, ArrayFixedCombine<float, CrossProductOp, 3>));
 	set.AddFunction(
 	    ScalarFunction({double_array, double_array}, double_array, ArrayFixedCombine<double, CrossProductOp, 3>));
+	for (auto &func : set.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
 	return set;
 }
 

diff --git a/src/duckdb/extension/core_functions/scalar/bit/bitstring.cpp b/src/duckdb/extension/core_functions/scalar/bit/bitstring.cpp
@@ -46,6 +46,9 @@ ScalarFunctionSet BitStringFun::GetFunctions() {
 	    ScalarFunction({LogicalType::VARCHAR, LogicalType::INTEGER}, LogicalType::BIT, BitStringFunction<true>));
 	bitstring.AddFunction(
 	    ScalarFunction({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::BIT, BitStringFunction<false>));
+	for (auto &func : bitstring.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
 	return bitstring;
 }
 
@@ -64,8 +67,10 @@ struct GetBitOperator {
 };
 
 ScalarFunction GetBitFun::GetFunction() {
-	return ScalarFunction({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::INTEGER,
-	                      ScalarFunction::BinaryFunction<string_t, int32_t, int32_t, GetBitOperator>);
+	ScalarFunction func({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::INTEGER,
+	                    ScalarFunction::BinaryFunction<string_t, int32_t, int32_t, GetBitOperator>);
+	BaseScalarFunction::SetReturnsError(func);
+	return func;
 }
 
 //===--------------------------------------------------------------------===//
@@ -90,8 +95,10 @@ static void SetBitOperation(DataChunk &args, ExpressionState &state, Vector &res
 }
 
 ScalarFunction SetBitFun::GetFunction() {
-	return ScalarFunction({LogicalType::BIT, LogicalType::INTEGER, LogicalType::INTEGER}, LogicalType::BIT,
-	                      SetBitOperation);
+	ScalarFunction function({LogicalType::BIT, LogicalType::INTEGER, LogicalType::INTEGER}, LogicalType::BIT,
+	                        SetBitOperation);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 //===--------------------------------------------------------------------===//

diff --git a/src/duckdb/extension/core_functions/scalar/blob/base64.cpp b/src/duckdb/extension/core_functions/scalar/blob/base64.cpp
@@ -39,7 +39,9 @@ ScalarFunction ToBase64Fun::GetFunction() {
 }
 
 ScalarFunction FromBase64Fun::GetFunction() {
-	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::BLOB, Base64DecodeFunction);
+	ScalarFunction function({LogicalType::VARCHAR}, LogicalType::BLOB, Base64DecodeFunction);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 } // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/blob/encode.cpp b/src/duckdb/extension/core_functions/scalar/blob/encode.cpp
@@ -34,7 +34,9 @@ ScalarFunction EncodeFun::GetFunction() {
 }
 
 ScalarFunction DecodeFun::GetFunction() {
-	return ScalarFunction({LogicalType::BLOB}, LogicalType::VARCHAR, DecodeFunction);
+	ScalarFunction function({LogicalType::BLOB}, LogicalType::VARCHAR, DecodeFunction);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 } // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/date/date_part.cpp b/src/duckdb/extension/core_functions/scalar/date/date_part.cpp
@@ -1705,6 +1705,9 @@ ScalarFunctionSet GetGenericDatePartFunction(scalar_function_t date_func, scalar
 	operator_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, std::move(ts_func), nullptr,
 	                                        nullptr, ts_stats, DATE_CACHE));
 	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, LogicalType::BIGINT, std::move(interval_func)));
+	for (auto &func : operator_set.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
 	return operator_set;
 }
 
@@ -2019,7 +2022,11 @@ ScalarFunctionSet QuarterFun::GetFunctions() {
 }
 
 ScalarFunctionSet DayOfWeekFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::DayOfWeekOperator>();
+	auto set = GetDatePartFunction<DatePart::DayOfWeekOperator>();
+	for (auto &func : set.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
+	return set;
 }
 
 ScalarFunctionSet ISODayOfWeekFun::GetFunctions() {
@@ -2046,9 +2053,14 @@ ScalarFunctionSet TimezoneFun::GetFunctions() {
 	auto operator_set = GetDatePartFunction<DatePart::TimezoneOperator>();
 
 	//	PG also defines timezone(INTERVAL, TIME_TZ) => TIME_TZ
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::INTERVAL, LogicalType::TIME_TZ}, LogicalType::TIME_TZ,
-	                   DatePart::TimezoneOperator::BinaryFunction<interval_t, dtime_tz_t, dtime_tz_t>));
+	ScalarFunction function({LogicalType::INTERVAL, LogicalType::TIME_TZ}, LogicalType::TIME_TZ,
+	                        DatePart::TimezoneOperator::BinaryFunction<interval_t, dtime_tz_t, dtime_tz_t>);
+
+	operator_set.AddFunction(function);
+
+	for (auto &func : operator_set.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
 
 	return operator_set;
 }
@@ -2241,6 +2253,10 @@ ScalarFunctionSet DatePartFun::GetFunctions() {
 	date_part.AddFunction(StructDatePart::GetFunction<interval_t>(LogicalType::INTERVAL));
 	date_part.AddFunction(StructDatePart::GetFunction<dtime_tz_t>(LogicalType::TIME_TZ));
 
+	for (auto &func : date_part.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
+
 	return date_part;
 }
 

diff --git a/src/duckdb/extension/core_functions/scalar/date/date_trunc.cpp b/src/duckdb/extension/core_functions/scalar/date/date_trunc.cpp
@@ -728,6 +728,9 @@ ScalarFunctionSet DateTruncFun::GetFunctions() {
 	                                      DateTruncFunction<date_t, timestamp_t>, DateTruncBind));
 	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::INTERVAL}, LogicalType::INTERVAL,
 	                                      DateTruncFunction<interval_t, interval_t>));
+	for (auto &func : date_trunc.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
 	return date_trunc;
 }
 

diff --git a/src/duckdb/extension/core_functions/scalar/date/epoch.cpp b/src/duckdb/extension/core_functions/scalar/date/epoch.cpp
@@ -11,7 +11,7 @@ struct EpochSecOperator {
 	static RESULT_TYPE Operation(INPUT_TYPE sec) {
 		int64_t result;
 		if (!TryCast::Operation(sec * Interval::MICROS_PER_SEC, result)) {
-			throw ConversionException("Could not convert epoch seconds to TIMESTAMP WITH TIME ZONE");
+			throw ConversionException("Epoch seconds out of range for TIMESTAMP WITH TIME ZONE");
 		}
 		return timestamp_t(result);
 	}

diff --git a/src/duckdb/extension/core_functions/scalar/date/make_date.cpp b/src/duckdb/extension/core_functions/scalar/date/make_date.cpp
@@ -103,6 +103,10 @@ struct MakeTimestampOperator {
 
 	template <typename T, typename RESULT_TYPE>
 	static RESULT_TYPE Operation(T value) {
+		const auto result = RESULT_TYPE(value);
+		if (!Timestamp::IsFinite(result)) {
+			throw ConversionException("Timestamp microseconds out of range: %ld", value);
+		}
 		return RESULT_TYPE(value);
 	}
 };
@@ -140,12 +144,17 @@ ScalarFunctionSet MakeDateFun::GetFunctions() {
 	    {"year", LogicalType::BIGINT}, {"month", LogicalType::BIGINT}, {"day", LogicalType::BIGINT}};
 	make_date.AddFunction(
 	    ScalarFunction({LogicalType::STRUCT(make_date_children)}, LogicalType::DATE, ExecuteStructMakeDate<int64_t>));
+	for (auto &func : make_date.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
 	return make_date;
 }
 
 ScalarFunction MakeTimeFun::GetFunction() {
-	return ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE}, LogicalType::TIME,
-	                      ExecuteMakeTime<int64_t>);
+	ScalarFunction function({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE}, LogicalType::TIME,
+	                        ExecuteMakeTime<int64_t>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunctionSet MakeTimestampFun::GetFunctions() {
@@ -155,6 +164,10 @@ ScalarFunctionSet MakeTimestampFun::GetFunctions() {
 	                                        LogicalType::TIMESTAMP, ExecuteMakeTimestamp<int64_t>));
 	operator_set.AddFunction(
 	    ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, ExecuteMakeTimestamp<int64_t>));
+
+	for (auto &func : operator_set.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
 	return operator_set;
 }
 

diff --git a/src/duckdb/extension/core_functions/scalar/date/time_bucket.cpp b/src/duckdb/extension/core_functions/scalar/date/time_bucket.cpp
@@ -364,6 +364,9 @@ ScalarFunctionSet TimeBucketFun::GetFunctions() {
 	                                       LogicalType::DATE, TimeBucketOriginFunction<date_t>));
 	time_bucket.AddFunction(ScalarFunction({LogicalType::INTERVAL, LogicalType::TIMESTAMP, LogicalType::TIMESTAMP},
 	                                       LogicalType::TIMESTAMP, TimeBucketOriginFunction<timestamp_t>));
+	for (auto &func : time_bucket.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
 	return time_bucket;
 }
 

diff --git a/src/duckdb/extension/core_functions/scalar/date/to_interval.cpp b/src/duckdb/extension/core_functions/scalar/date/to_interval.cpp
@@ -165,68 +165,94 @@ struct ToMicroSecondsOperator {
 };
 
 ScalarFunction ToMillenniaFun::GetFunction() {
-	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToMillenniaOperator>);
+	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToMillenniaOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToCenturiesFun::GetFunction() {
-	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToCenturiesOperator>);
+	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToCenturiesOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToDecadesFun::GetFunction() {
-	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToDecadesOperator>);
+	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToDecadesOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToYearsFun::GetFunction() {
-	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToYearsOperator>);
+	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToYearsOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToQuartersFun::GetFunction() {
-	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToQuartersOperator>);
+	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToQuartersOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToMonthsFun::GetFunction() {
-	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToMonthsOperator>);
+	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToMonthsOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToWeeksFun::GetFunction() {
-	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToWeeksOperator>);
+	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToWeeksOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToDaysFun::GetFunction() {
-	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToDaysOperator>);
+	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToDaysOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToHoursFun::GetFunction() {
-	return ScalarFunction({LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int64_t, interval_t, ToHoursOperator>);
+	ScalarFunction function({LogicalType::BIGINT}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int64_t, interval_t, ToHoursOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToMinutesFun::GetFunction() {
-	return ScalarFunction({LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int64_t, interval_t, ToMinutesOperator>);
+	ScalarFunction function({LogicalType::BIGINT}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int64_t, interval_t, ToMinutesOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToSecondsFun::GetFunction() {
-	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<double, interval_t, ToSecondsOperator>);
+	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<double, interval_t, ToSecondsOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToMillisecondsFun::GetFunction() {
-	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<double, interval_t, ToMilliSecondsOperator>);
+	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<double, interval_t, ToMilliSecondsOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToMicrosecondsFun::GetFunction() {
-	return ScalarFunction({LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int64_t, interval_t, ToMicroSecondsOperator>);
+	ScalarFunction function({LogicalType::BIGINT}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int64_t, interval_t, ToMicroSecondsOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 } // namespace duckdb
diff --git a/src/duckdb/extension/core_functions/scalar/generic/binning.cpp b/src/duckdb/extension/core_functions/scalar/generic/binning.cpp
@@ -500,6 +500,7 @@ ScalarFunctionSet EquiWidthBinsFun::GetFunctions() {
 	for (auto &function : functions.functions) {
 		function.serialize = EquiWidthBinSerialize;
 		function.deserialize = EquiWidthBinDeserialize;
+		BaseScalarFunction::SetReturnsError(function);
 	}
 	return functions;
 }

diff --git a/src/duckdb/extension/core_functions/scalar/list/array_slice.cpp b/src/duckdb/extension/core_functions/scalar/list/array_slice.cpp
@@ -449,7 +449,7 @@ ScalarFunctionSet ListSliceFun::GetFunctions() {
 	ScalarFunction fun({LogicalType::ANY, LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, ArraySliceFunction,
 	                   ArraySliceBind);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-
+	BaseScalarFunction::SetReturnsError(fun);
 	ScalarFunctionSet set;
 	set.AddFunction(fun);
 	fun.arguments.push_back(LogicalType::BIGINT);

diff --git a/src/duckdb/extension/core_functions/scalar/list/list_aggregates.cpp b/src/duckdb/extension/core_functions/scalar/list/list_aggregates.cpp
@@ -468,6 +468,7 @@ static unique_ptr<FunctionData> ListAggregatesBind(ClientContext &context, Scala
 	// found a matching function, bind it as an aggregate
 	auto best_function = func.functions.GetFunctionByOffset(best_function_idx.GetIndex());
 	if (IS_AGGR) {
+		bound_function.errors = best_function.errors;
 		return ListAggregatesBindFunction<IS_AGGR>(context, bound_function, child_type, best_function, arguments);
 	}
 
@@ -512,6 +513,7 @@ static unique_ptr<FunctionData> ListUniqueBind(ClientContext &context, ScalarFun
 ScalarFunction ListAggregateFun::GetFunction() {
 	auto result = ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR}, LogicalType::ANY,
 	                             ListAggregateFunction, ListAggregateBind);
+	BaseScalarFunction::SetReturnsError(result);
 	result.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	result.varargs = LogicalType::ANY;
 	result.serialize = ListAggregatesBindData::SerializeFunction;