duckdb 0.3.5-dev1226.0 → 0.3.5-dev1237.0

package/src/duckdb.cpp

@@ -84231,6 +84231,7 @@ void ModeFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+
 namespace duckdb {
 
 struct AbsOperator {
@@ -84241,21 +84242,60 @@ struct AbsOperator {
 };
 
 template <>
-inline hugeint_t AbsOperator::Operation(const hugeint_t &input) {
+inline hugeint_t AbsOperator::Operation(hugeint_t input) {
 	const hugeint_t zero(0);
-	return (input < zero) ? (zero - input) : input;
+	return (input < zero) ? -input : input;
+}
+
+struct TryAbsOperator {
+	template <class TA, class TR>
+	static inline TR Operation(TA input) {
+		return AbsOperator::Operation<TA, TR>(input);
+	}
+};
+
+template <>
+inline int8_t TryAbsOperator::Operation(int8_t input) {
+	if (input == NumericLimits<int8_t>::Minimum()) {
+		throw OutOfRangeException("Overflow on abs(%d)", input);
+	}
+	return input < 0 ? -input : input;
+}
+
+template <>
+inline int16_t TryAbsOperator::Operation(int16_t input) {
+	if (input == NumericLimits<int16_t>::Minimum()) {
+		throw OutOfRangeException("Overflow on abs(%d)", input);
+	}
+	return input < 0 ? -input : input;
+}
+
+template <>
+inline int32_t TryAbsOperator::Operation(int32_t input) {
+	if (input == NumericLimits<int32_t>::Minimum()) {
+		throw OutOfRangeException("Overflow on abs(%d)", input);
+	}
+	return input < 0 ? -input : input;
+}
+
+template <>
+inline int64_t TryAbsOperator::Operation(int64_t input) {
+	if (input == NumericLimits<int64_t>::Minimum()) {
+		throw OutOfRangeException("Overflow on abs(%d)", input);
+	}
+	return input < 0 ? -input : input;
 }
 
 template <>
-inline dtime_t AbsOperator::Operation(const dtime_t &input) {
-	return dtime_t(AbsOperator::Operation<int64_t, int64_t>(input.micros));
+inline dtime_t TryAbsOperator::Operation(dtime_t input) {
+	return dtime_t(TryAbsOperator::Operation<int64_t, int64_t>(input.micros));
 }
 
 template <>
-inline interval_t AbsOperator::Operation(const interval_t &input) {
-	return {AbsOperator::Operation<int32_t, int32_t>(input.months),
-	        AbsOperator::Operation<int32_t, int32_t>(input.days),
-	        AbsOperator::Operation<int64_t, int64_t>(input.micros)};
+inline interval_t TryAbsOperator::Operation(interval_t input) {
+	return {TryAbsOperator::Operation<int32_t, int32_t>(input.months),
+	        TryAbsOperator::Operation<int32_t, int32_t>(input.days),
+	        TryAbsOperator::Operation<int64_t, int64_t>(input.micros)};
 }
 
 } // namespace duckdb
@@ -85153,7 +85193,7 @@ struct MadAccessor {
 
 	inline RESULT_TYPE operator()(const INPUT_TYPE &input) const {
 		const auto delta = input - median;
-		return AbsOperator::Operation<RESULT_TYPE, RESULT_TYPE>(delta);
+		return TryAbsOperator::Operation<RESULT_TYPE, RESULT_TYPE>(delta);
 	}
 };
 
@@ -85168,7 +85208,7 @@ struct MadAccessor<hugeint_t, double, double> {
 	}
 	inline RESULT_TYPE operator()(const INPUT_TYPE &input) const {
 		const auto delta = Hugeint::Cast<double>(input) - median;
-		return AbsOperator::Operation<double, double>(delta);
+		return TryAbsOperator::Operation<double, double>(delta);
 	}
 };
 
@@ -85184,7 +85224,7 @@ struct MadAccessor<date_t, interval_t, timestamp_t> {
 	inline RESULT_TYPE operator()(const INPUT_TYPE &input) const {
 		const auto dt = Cast::Operation<date_t, timestamp_t>(input);
 		const auto delta = dt - median;
-		return Interval::FromMicro(AbsOperator::Operation<int64_t, int64_t>(delta));
+		return Interval::FromMicro(TryAbsOperator::Operation<int64_t, int64_t>(delta));
 	}
 };
 
@@ -85199,7 +85239,7 @@ struct MadAccessor<timestamp_t, interval_t, timestamp_t> {
 	}
 	inline RESULT_TYPE operator()(const INPUT_TYPE &input) const {
 		const auto delta = input - median;
-		return Interval::FromMicro(AbsOperator::Operation<int64_t, int64_t>(delta));
+		return Interval::FromMicro(TryAbsOperator::Operation<int64_t, int64_t>(delta));
 	}
 };
 
@@ -85214,7 +85254,7 @@ struct MadAccessor<dtime_t, interval_t, dtime_t> {
 	}
 	inline RESULT_TYPE operator()(const INPUT_TYPE &input) const {
 		const auto delta = input - median;
-		return Interval::FromMicro(AbsOperator::Operation<int64_t, int64_t>(delta));
+		return Interval::FromMicro(TryAbsOperator::Operation<int64_t, int64_t>(delta));
 	}
 };
 
@@ -89690,10 +89730,8 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
-			return PropagateDatePartStatistics<T, YearOperator>(child_stats);
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateDatePartStatistics<T, YearOperator>(input.child_stats);
 		}
 	};
 
@@ -89704,11 +89742,9 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
 			// min/max of month operator is [1, 12]
-			return PropagateSimpleDatePartStatistics<1, 12>(child_stats);
+			return PropagateSimpleDatePartStatistics<1, 12>(input.child_stats);
 		}
 	};
 
@@ -89719,11 +89755,9 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
 			// min/max of day operator is [1, 31]
-			return PropagateSimpleDatePartStatistics<1, 31>(child_stats);
+			return PropagateSimpleDatePartStatistics<1, 31>(input.child_stats);
 		}
 	};
 
@@ -89740,10 +89774,8 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
-			return PropagateDatePartStatistics<T, DecadeOperator>(child_stats);
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateDatePartStatistics<T, DecadeOperator>(input.child_stats);
 		}
 	};
 
@@ -89770,10 +89802,8 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
-			return PropagateDatePartStatistics<T, CenturyOperator>(child_stats);
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateDatePartStatistics<T, CenturyOperator>(input.child_stats);
 		}
 	};
 
@@ -89794,10 +89824,8 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
-			return PropagateDatePartStatistics<T, MillenniumOperator>(child_stats);
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateDatePartStatistics<T, MillenniumOperator>(input.child_stats);
 		}
 	};
 
@@ -89813,11 +89841,9 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
 			// min/max of quarter operator is [1, 4]
-			return PropagateSimpleDatePartStatistics<1, 4>(child_stats);
+			return PropagateSimpleDatePartStatistics<1, 4>(input.child_stats);
 		}
 	};
 
@@ -89835,10 +89861,8 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
-			return PropagateSimpleDatePartStatistics<0, 6>(child_stats);
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateSimpleDatePartStatistics<0, 6>(input.child_stats);
 		}
 	};
 
@@ -89850,10 +89874,8 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
-			return PropagateSimpleDatePartStatistics<1, 7>(child_stats);
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateSimpleDatePartStatistics<1, 7>(input.child_stats);
 		}
 	};
 
@@ -89864,10 +89886,8 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
-			return PropagateSimpleDatePartStatistics<1, 366>(child_stats);
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateSimpleDatePartStatistics<1, 366>(input.child_stats);
 		}
 	};
 
@@ -89878,10 +89898,8 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
-			return PropagateSimpleDatePartStatistics<1, 54>(child_stats);
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateSimpleDatePartStatistics<1, 54>(input.child_stats);
 		}
 	};
 
@@ -89892,10 +89910,8 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
-			return PropagateDatePartStatistics<T, ISOYearOperator>(child_stats);
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateDatePartStatistics<T, ISOYearOperator>(input.child_stats);
 		}
 	};
 
@@ -89913,10 +89929,8 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
-			return PropagateDatePartStatistics<T, YearWeekOperator>(child_stats);
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateDatePartStatistics<T, YearWeekOperator>(input.child_stats);
 		}
 	};
 
@@ -89927,10 +89941,8 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
-			return PropagateSimpleDatePartStatistics<0, 60000000>(child_stats);
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateSimpleDatePartStatistics<0, 60000000>(input.child_stats);
 		}
 	};
 
@@ -89941,10 +89953,8 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
-			return PropagateSimpleDatePartStatistics<0, 60000>(child_stats);
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateSimpleDatePartStatistics<0, 60000>(input.child_stats);
 		}
 	};
 
@@ -89955,10 +89965,8 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
-			return PropagateSimpleDatePartStatistics<0, 60>(child_stats);
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateSimpleDatePartStatistics<0, 60>(input.child_stats);
 		}
 	};
 
@@ -89969,10 +89977,8 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
-			return PropagateSimpleDatePartStatistics<0, 60>(child_stats);
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateSimpleDatePartStatistics<0, 60>(input.child_stats);
 		}
 	};
 
@@ -89983,10 +89989,8 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
-			return PropagateSimpleDatePartStatistics<0, 24>(child_stats);
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateSimpleDatePartStatistics<0, 24>(input.child_stats);
 		}
 	};
 
@@ -89997,10 +90001,8 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
-			return PropagateDatePartStatistics<T, EpochOperator>(child_stats);
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateDatePartStatistics<T, EpochOperator>(input.child_stats);
 		}
 	};
 
@@ -90016,10 +90018,8 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
-			return PropagateSimpleDatePartStatistics<0, 1>(child_stats);
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateSimpleDatePartStatistics<0, 1>(input.child_stats);
 		}
 	};
 
@@ -90031,10 +90031,8 @@ struct DatePart {
 		}
 
 		template <class T>
-		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
-		                                                      FunctionData *bind_data,
-		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
-			return PropagateSimpleDatePartStatistics<0, 0>(child_stats);
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateSimpleDatePartStatistics<0, 0>(input.child_stats);
 		}
 	};
 
@@ -90488,12 +90486,10 @@ int64_t DatePart::EpochOperator::Operation(dtime_t input) {
 }
 
 template <>
-unique_ptr<BaseStatistics>
-DatePart::EpochOperator::PropagateStatistics<dtime_t>(ClientContext &context, BoundFunctionExpression &expr,
-                                                      FunctionData *bind_data,
-                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
+unique_ptr<BaseStatistics> DatePart::EpochOperator::PropagateStatistics<dtime_t>(ClientContext &context,
+                                                                                 FunctionStatisticsInput &input) {
 	// time seconds range over a single day
-	return PropagateSimpleDatePartStatistics<0, 86400>(child_stats);
+	return PropagateSimpleDatePartStatistics<0, 86400>(input.child_stats);
 }
 
 template <>
@@ -94247,9 +94243,9 @@ unique_ptr<FunctionData> StatsBind(ClientContext &context, ScalarFunction &bound
 	return make_unique<StatsBindData>();
 }
 
-static unique_ptr<BaseStatistics> StatsPropagateStats(ClientContext &context, BoundFunctionExpression &expr,
-                                                      FunctionData *bind_data,
-                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
+static unique_ptr<BaseStatistics> StatsPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
+	auto &child_stats = input.child_stats;
+	auto &bind_data = input.bind_data;
 	if (child_stats[0]) {
 		auto &info = (StatsBindData &)*bind_data;
 		info.stats = child_stats[0]->ToString();
@@ -94889,9 +94885,8 @@ static unique_ptr<FunctionData> ListFlattenBind(ClientContext &context, ScalarFu
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
 
-static unique_ptr<BaseStatistics> ListFlattenStats(ClientContext &context, BoundFunctionExpression &expr,
-                                                   FunctionData *bind_data,
-                                                   vector<unique_ptr<BaseStatistics>> &child_stats) {
+static unique_ptr<BaseStatistics> ListFlattenStats(ClientContext &context, FunctionStatisticsInput &input) {
+	auto &child_stats = input.child_stats;
 	if (!child_stats[0]) {
 		return nullptr;
 	}
@@ -95495,9 +95490,8 @@ static unique_ptr<FunctionData> ListConcatBind(ClientContext &context, ScalarFun
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
 
-static unique_ptr<BaseStatistics> ListConcatStats(ClientContext &context, BoundFunctionExpression &expr,
-                                                  FunctionData *bind_data,
-                                                  vector<unique_ptr<BaseStatistics>> &child_stats) {
+static unique_ptr<BaseStatistics> ListConcatStats(ClientContext &context, FunctionStatisticsInput &input) {
+	auto &child_stats = input.child_stats;
 	D_ASSERT(child_stats.size() == 2);
 	if (!child_stats[0] || !child_stats[1]) {
 		return nullptr;
@@ -95735,9 +95729,8 @@ static unique_ptr<FunctionData> ListExtractBind(ClientContext &context, ScalarFu
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
 
-static unique_ptr<BaseStatistics> ListExtractStats(ClientContext &context, BoundFunctionExpression &expr,
-                                                   FunctionData *bind_data,
-                                                   vector<unique_ptr<BaseStatistics>> &child_stats) {
+static unique_ptr<BaseStatistics> ListExtractStats(ClientContext &context, FunctionStatisticsInput &input) {
+	auto &child_stats = input.child_stats;
 	if (!child_stats[0]) {
 		return nullptr;
 	}
@@ -96198,8 +96191,9 @@ static unique_ptr<FunctionData> ListValueBind(ClientContext &context, ScalarFunc
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
 
-unique_ptr<BaseStatistics> ListValueStats(ClientContext &context, BoundFunctionExpression &expr,
-                                          FunctionData *bind_data, vector<unique_ptr<BaseStatistics>> &child_stats) {
+unique_ptr<BaseStatistics> ListValueStats(ClientContext &context, FunctionStatisticsInput &input) {
+	auto &child_stats = input.child_stats;
+	auto &expr = input.expr;
 	auto list_stats = make_unique<ListStatistics>(expr.return_type);
 	for (idx_t i = 0; i < child_stats.size(); i++) {
 		if (child_stats[i]) {
@@ -96252,17 +96246,20 @@ struct NumericRangeInfo {
 		if (start_value < end_value && increment_value < 0) {
 			return 0;
 		}
-		int64_t total_diff = AbsValue(end_value - start_value);
-		int64_t increment = AbsValue(increment_value);
-		int64_t total_values = total_diff / increment;
+		hugeint_t total_diff = AbsValue(hugeint_t(end_value) - hugeint_t(start_value));
+		hugeint_t increment = AbsValue(hugeint_t(increment_value));
+		hugeint_t total_values = total_diff / increment;
 		if (total_diff % increment == 0) {
 			if (inclusive_bound) {
-				total_values++;
+				total_values += 1;
 			}
 		} else {
-			total_values++;
+			total_values += 1;
 		}
-		return total_values;
+		if (total_values > NumericLimits<uint32_t>::Maximum()) {
+			throw InvalidInputException("Lists larger than 2^32 elements are not supported");
+		}
+		return Hugeint::Cast<uint64_t>(total_values);
 	}
 
 	static void Increment(int64_t &input, int64_t increment) {
@@ -96308,12 +96305,18 @@ struct TimestampRangeInfo {
 			while (inclusive_bound ? start_value >= end_value : start_value > end_value) {
 				start_value = Interval::Add(start_value, increment_value);
 				total_values++;
+				if (total_values > NumericLimits<uint32_t>::Maximum()) {
+					throw InvalidInputException("Lists larger than 2^32 elements are not supported");
+				}
 			}
 		} else {
 			// positive interval, start_value is going up
 			while (inclusive_bound ? start_value <= end_value : start_value < end_value) {
 				start_value = Interval::Add(start_value, increment_value);
 				total_values++;
+				if (total_values > NumericLimits<uint32_t>::Maximum()) {
+					throw InvalidInputException("Lists larger than 2^32 elements are not supported");
+				}
 			}
 		}
 		return total_values;
@@ -96442,8 +96445,10 @@ static void ListRangeFunction(DataChunk &args, ExpressionState &state, Vector &r
 
 		typename OP::TYPE range_value = start_value;
 		for (idx_t range_idx = 0; range_idx < list_data[i].length; range_idx++) {
+			if (range_idx > 0) {
+				OP::Increment(range_value, increment);
+			}
 			range_data[total_idx++] = range_value;
-			OP::Increment(range_value, increment);
 		}
 	}
 
@@ -96903,6 +96908,7 @@ struct Atan2Fun {
 
 
 
+
 #include <cmath>
 #include <errno.h>
 
@@ -96936,7 +96942,6 @@ static scalar_function_t GetScalarIntegerUnaryFunctionFixedReturn(const LogicalT
 //===--------------------------------------------------------------------===//
 // nextafter
 //===--------------------------------------------------------------------===//
-
 struct NextAfterOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA base, TB exponent) {
@@ -96967,6 +96972,71 @@ void NextAfterFun::RegisterFunction(BuiltinFunctions &set) {
 //===--------------------------------------------------------------------===//
 // abs
 //===--------------------------------------------------------------------===//
+static unique_ptr<BaseStatistics> PropagateAbsStats(ClientContext &context, FunctionStatisticsInput &input) {
+	auto &child_stats = input.child_stats;
+	auto &expr = input.expr;
+	D_ASSERT(child_stats.size() == 1);
+	// can only propagate stats if the children have stats
+	if (!child_stats[0]) {
+		return nullptr;
+	}
+	auto &lstats = (NumericStatistics &)*child_stats[0];
+	Value new_min, new_max;
+	bool potential_overflow = true;
+	if (!lstats.min.IsNull() && !lstats.max.IsNull()) {
+		switch (expr.return_type.InternalType()) {
+		case PhysicalType::INT8:
+			potential_overflow = lstats.min.GetValue<int8_t>() == NumericLimits<int8_t>::Minimum();
+			break;
+		case PhysicalType::INT16:
+			potential_overflow = lstats.min.GetValue<int16_t>() == NumericLimits<int16_t>::Minimum();
+			break;
+		case PhysicalType::INT32:
+			potential_overflow = lstats.min.GetValue<int32_t>() == NumericLimits<int32_t>::Minimum();
+			break;
+		case PhysicalType::INT64:
+			potential_overflow = lstats.min.GetValue<int64_t>() == NumericLimits<int64_t>::Minimum();
+			break;
+		default:
+			return nullptr;
+		}
+	}
+	if (potential_overflow) {
+		new_min = Value(expr.return_type);
+		new_max = Value(expr.return_type);
+	} else {
+		// no potential overflow
+
+		// compute stats
+		auto current_min = lstats.min.GetValue<int64_t>();
+		auto current_max = lstats.max.GetValue<int64_t>();
+
+		int64_t min_val, max_val;
+
+		if (current_min < 0 && current_max < 0) {
+			// if both min and max are below zero, then min=abs(cur_max) and max=abs(cur_min)
+			min_val = AbsValue(current_max);
+			max_val = AbsValue(current_min);
+		} else if (current_min < 0) {
+			D_ASSERT(current_max >= 0);
+			// if min is below zero and max is above 0, then min=0 and max=max(cur_max, abs(cur_min))
+			min_val = 0;
+			max_val = MaxValue(AbsValue(current_min), current_max);
+		} else {
+			// if both current_min and current_max are > 0, then the abs is a no-op and can be removed entirely
+			*input.expr_ptr = move(input.expr.children[0]);
+			return move(child_stats[0]);
+		}
+		new_min = Value::Numeric(expr.return_type, min_val);
+		new_max = Value::Numeric(expr.return_type, max_val);
+		expr.function.function = ScalarFunction::GetScalarUnaryFunction<AbsOperator>(expr.return_type);
+	}
+	auto stats =
+	    make_unique<NumericStatistics>(expr.return_type, move(new_min), move(new_max), StatisticsType::LOCAL_STATS);
+	stats->validity_stats = lstats.validity_stats->Copy();
+	return move(stats);
+}
+
 template <class OP>
 unique_ptr<FunctionData> DecimalUnaryOpBind(ClientContext &context, ScalarFunction &bound_function,
                                             vector<unique_ptr<Expression>> &arguments) {
@@ -96993,10 +97063,28 @@ unique_ptr<FunctionData> DecimalUnaryOpBind(ClientContext &context, ScalarFuncti
 void AbsFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet abs("abs");
 	for (auto &type : LogicalType::Numeric()) {
-		if (type.id() == LogicalTypeId::DECIMAL) {
+		switch (type.id()) {
+		case LogicalTypeId::DECIMAL:
 			abs.AddFunction(ScalarFunction({type}, type, nullptr, false, false, DecimalUnaryOpBind<AbsOperator>));
-		} else {
+			break;
+		case LogicalTypeId::TINYINT:
+		case LogicalTypeId::SMALLINT:
+		case LogicalTypeId::INTEGER:
+		case LogicalTypeId::BIGINT: {
+			ScalarFunction func({type}, type, ScalarFunction::GetScalarUnaryFunction<TryAbsOperator>(type));
+			func.statistics = PropagateAbsStats;
+			abs.AddFunction(func);
+			break;
+		}
+		case LogicalTypeId::UTINYINT:
+		case LogicalTypeId::USMALLINT:
+		case LogicalTypeId::UINTEGER:
+		case LogicalTypeId::UBIGINT:
+			abs.AddFunction(ScalarFunction({type}, type, ScalarFunction::NopFunction));
+			break;
+		default:
 			abs.AddFunction(ScalarFunction({type}, type, ScalarFunction::GetScalarUnaryFunction<AbsOperator>(type)));
+			break;
 		}
 	}
 	set.AddFunction(abs);
@@ -98601,9 +98689,9 @@ struct SubtractPropagateStatistics {
 };
 
 template <class OP, class PROPAGATE, class BASEOP>
-static unique_ptr<BaseStatistics> PropagateNumericStats(ClientContext &context, BoundFunctionExpression &expr,
-                                                        FunctionData *bind_data,
-                                                        vector<unique_ptr<BaseStatistics>> &child_stats) {
+static unique_ptr<BaseStatistics> PropagateNumericStats(ClientContext &context, FunctionStatisticsInput &input) {
+	auto &child_stats = input.child_stats;
+	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() == 2);
 	// can only propagate stats if the children have stats
 	if (!child_stats[0] || !child_stats[1]) {
@@ -98914,9 +99002,9 @@ struct NegatePropagateStatistics {
 	}
 };
 
-static unique_ptr<BaseStatistics> NegateBindStatistics(ClientContext &context, BoundFunctionExpression &expr,
-                                                       FunctionData *bind_data,
-                                                       vector<unique_ptr<BaseStatistics>> &child_stats) {
+static unique_ptr<BaseStatistics> NegateBindStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+	auto &child_stats = input.child_stats;
+	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() == 1);
 	// can only propagate stats if the children have stats
 	if (!child_stats[0]) {
@@ -100445,9 +100533,9 @@ static void CaseConvertFunctionASCII(DataChunk &args, ExpressionState &state, Ve
 }
 
 template <bool IS_UPPER>
-static unique_ptr<BaseStatistics> CaseConvertPropagateStats(ClientContext &context, BoundFunctionExpression &expr,
-                                                            FunctionData *bind_data,
-                                                            vector<unique_ptr<BaseStatistics>> &child_stats) {
+static unique_ptr<BaseStatistics> CaseConvertPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
+	auto &child_stats = input.child_stats;
+	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() == 1);
 	// can only propagate stats if the children have stats
 	if (!child_stats[0]) {
@@ -100969,9 +101057,9 @@ struct InstrAsciiOperator {
 	}
 };
 
-static unique_ptr<BaseStatistics> InStrPropagateStats(ClientContext &context, BoundFunctionExpression &expr,
-                                                      FunctionData *bind_data,
-                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
+static unique_ptr<BaseStatistics> InStrPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
+	auto &child_stats = input.child_stats;
+	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() == 2);
 	// can only propagate stats if the children have stats
 	if (!child_stats[0]) {
@@ -101177,9 +101265,9 @@ struct BitLenOperator {
 	}
 };
 
-static unique_ptr<BaseStatistics> LengthPropagateStats(ClientContext &context, BoundFunctionExpression &expr,
-                                                       FunctionData *bind_data,
-                                                       vector<unique_ptr<BaseStatistics>> &child_stats) {
+static unique_ptr<BaseStatistics> LengthPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
+	auto &child_stats = input.child_stats;
+	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() == 1);
 	// can only propagate stats if the children have stats
 	if (!child_stats[0]) {
@@ -101806,9 +101894,9 @@ static void LikeEscapeFunction(DataChunk &args, ExpressionState &state, Vector &
 }
 
 template <class ASCII_OP>
-static unique_ptr<BaseStatistics> ILikePropagateStats(ClientContext &context, BoundFunctionExpression &expr,
-                                                      FunctionData *bind_data,
-                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
+static unique_ptr<BaseStatistics> ILikePropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
+	auto &child_stats = input.child_stats;
+	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() >= 1);
 	// can only propagate stats if the children have stats
 	if (!child_stats[0]) {
@@ -103518,9 +103606,9 @@ static void SubstringFunctionASCII(DataChunk &args, ExpressionState &state, Vect
 	}
 }
 
-static unique_ptr<BaseStatistics> SubstringPropagateStats(ClientContext &context, BoundFunctionExpression &expr,
-                                                          FunctionData *bind_data,
-                                                          vector<unique_ptr<BaseStatistics>> &child_stats) {
+static unique_ptr<BaseStatistics> SubstringPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
+	auto &child_stats = input.child_stats;
+	auto &expr = input.expr;
 	// can only propagate stats if the children have stats
 	if (!child_stats[0]) {
 		return nullptr;
@@ -103936,9 +104024,9 @@ static unique_ptr<FunctionData> StructExtractBind(ClientContext &context, Scalar
 	return make_unique<StructExtractBindData>(key, key_index, return_type);
 }
 
-static unique_ptr<BaseStatistics> PropagateStructExtractStats(ClientContext &context, BoundFunctionExpression &expr,
-                                                              FunctionData *bind_data,
-                                                              vector<unique_ptr<BaseStatistics>> &child_stats) {
+static unique_ptr<BaseStatistics> PropagateStructExtractStats(ClientContext &context, FunctionStatisticsInput &input) {
+	auto &child_stats = input.child_stats;
+	auto &bind_data = input.bind_data;
 	if (!child_stats[0]) {
 		return nullptr;
 	}
@@ -104022,8 +104110,9 @@ static unique_ptr<FunctionData> StructPackBind(ClientContext &context, ScalarFun
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
 
-unique_ptr<BaseStatistics> StructPackStats(ClientContext &context, BoundFunctionExpression &expr,
-                                           FunctionData *bind_data, vector<unique_ptr<BaseStatistics>> &child_stats) {
+unique_ptr<BaseStatistics> StructPackStats(ClientContext &context, FunctionStatisticsInput &input) {
+	auto &child_stats = input.child_stats;
+	auto &expr = input.expr;
 	auto struct_stats = make_unique<StructStatistics>(expr.return_type);
 	D_ASSERT(child_stats.size() == struct_stats->child_stats.size());
 	for (idx_t i = 0; i < struct_stats->child_stats.size(); i++) {
@@ -139183,7 +139272,8 @@ unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundFuncti
 	if (!func.function.statistics) {
 		return nullptr;
 	}
-	return func.function.statistics(context, func, func.bind_info.get(), stats);
+	FunctionStatisticsInput input(func, func.bind_info.get(), stats, expr_ptr);
+	return func.function.statistics(context, input);
 }
 
 } // namespace duckdb