duckdb 0.3.5-dev464.0 → 0.3.5-dev503.0

package/src/duckdb.cpp

@@ -23360,6 +23360,13 @@ bool TryCast::Operation(date_t input, date_t &result, bool strict) {
 
 template <>
 bool TryCast::Operation(date_t input, timestamp_t &result, bool strict) {
+	if (input == date_t::infinity()) {
+		result = timestamp_t::infinity();
+		return true;
+	} else if (input == date_t::ninfinity()) {
+		result = timestamp_t::ninfinity();
+		return true;
+	}
 	return Timestamp::TryFromDatetime(input, Time::FromTime(0, 0, 0), result);
 }
 
@@ -39321,6 +39328,18 @@ bool Date::ParseDoubleDigit(const char *buf, idx_t len, idx_t &pos, int32_t &res
 	return false;
 }
 
+static bool TryConvertDateSpecial(const char *buf, idx_t len, idx_t &pos, const char *special) {
+	auto p = pos;
+	for (; p < len && *special; ++p) {
+		const auto s = *special++;
+		if (!s || StringUtil::CharacterToLower(buf[p]) != s) {
+			return false;
+		}
+	}
+	pos = p;
+	return true;
+}
+
 bool Date::TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result, bool strict) {
 	pos = 0;
 	if (len == 0) {
@@ -39349,7 +39368,19 @@ bool Date::TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result
 		}
 	}
 	if (!StringUtil::CharacterIsDigit(buf[pos])) {
-		return false;
+		// Check for special values
+		if (TryConvertDateSpecial(buf, len, pos, "infinity")) {
+			result = yearneg ? date_t::ninfinity() : date_t::infinity();
+		} else if (TryConvertDateSpecial(buf, len, pos, "epoch")) {
+			result = date_t::epoch();
+		} else {
+			return false;
+		}
+		// skip trailing spaces - parsing must be strict here
+		while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
+			pos++;
+		}
+		return pos == len;
 	}
 	// first parse the year
 	for (; pos < len && StringUtil::CharacterIsDigit(buf[pos]); pos++) {
@@ -39450,6 +39481,13 @@ date_t Date::FromString(const string &str, bool strict) {
 }
 
 string Date::ToString(date_t date) {
+	// PG displays temporal infinities in lowercase,
+	// but numerics in Titlecase.
+	if (date == date_t::infinity()) {
+		return "infinity";
+	} else if (date == date_t::ninfinity()) {
+		return "-infinity";
+	}
 	int32_t date_units[3];
 	idx_t year_length;
 	bool add_bc;
@@ -41678,6 +41716,9 @@ bool Interval::GreaterThanEquals(interval_t left, interval_t right) {
 }
 
 date_t Interval::Add(date_t left, interval_t right) {
+	if (!Date::IsFinite(left)) {
+		return left;
+	}
 	date_t result;
 	if (right.months != 0) {
 		int32_t year, month, day;
@@ -41707,6 +41748,9 @@ date_t Interval::Add(date_t left, interval_t right) {
 			throw OutOfRangeException("Date out of range");
 		}
 	}
+	if (!Date::IsFinite(result)) {
+		throw OutOfRangeException("Date out of range");
+	}
 	return result;
 }
 
@@ -41724,6 +41768,9 @@ dtime_t Interval::Add(dtime_t left, interval_t right, date_t &date) {
 }
 
 timestamp_t Interval::Add(timestamp_t left, interval_t right) {
+	if (!Timestamp::IsFinite(left)) {
+		return left;
+	}
 	date_t date;
 	dtime_t time;
 	Timestamp::Convert(left, date, time);
@@ -42354,7 +42401,14 @@ bool Timestamp::TryConvertTimestamp(const char *str, idx_t len, timestamp_t &res
 		return false;
 	}
 	if (pos == len) {
-		// no time: only a date
+		// no time: only a date or special
+		if (date == date_t::infinity()) {
+			result = timestamp_t::infinity();
+			return true;
+		} else if (date == date_t::ninfinity()) {
+			result = timestamp_t::ninfinity();
+			return true;
+		}
 		return Timestamp::TryFromDatetime(date, dtime_t(0), result);
 	}
 	// try to parse a time field
@@ -42461,6 +42515,11 @@ timestamp_t Timestamp::FromString(const string &str) {
 }
 
 string Timestamp::ToString(timestamp_t timestamp) {
+	if (timestamp == timestamp_t::infinity()) {
+		return "infinity";
+	} else if (timestamp == timestamp_t::ninfinity()) {
+		return "-infinity";
+	}
 	date_t date;
 	dtime_t time;
 	Timestamp::Convert(timestamp, date, time);
@@ -42468,6 +42527,11 @@ string Timestamp::ToString(timestamp_t timestamp) {
 }
 
 date_t Timestamp::GetDate(timestamp_t timestamp) {
+	if (timestamp == timestamp_t::infinity()) {
+		return date_t::infinity();
+	} else if (timestamp == timestamp_t::ninfinity()) {
+		return date_t::ninfinity();
+	}
 	return date_t((timestamp.value + (timestamp.value < 0)) / Interval::MICROS_PER_DAY - (timestamp.value < 0));
 }
 
@@ -42483,7 +42547,7 @@ bool Timestamp::TryFromDatetime(date_t date, dtime_t time, timestamp_t &result)
 	if (!TryAddOperator::Operation<int64_t, int64_t, int64_t>(result.value, time.micros, result.value)) {
 		return false;
 	}
-	return true;
+	return Timestamp::IsFinite(result);
 }
 
 timestamp_t Timestamp::FromDatetime(date_t date, dtime_t time) {
@@ -43049,17 +43113,17 @@ Value Value::MaximumValue(const LogicalType &type) {
 	case LogicalTypeId::TIME:
 		return Value::TIME(dtime_t(Interval::SECS_PER_DAY * Interval::MICROS_PER_SEC - 1));
 	case LogicalTypeId::TIMESTAMP:
-		return Value::TIMESTAMP(timestamp_t(NumericLimits<int64_t>::Maximum()));
+		return Value::TIMESTAMP(timestamp_t(NumericLimits<int64_t>::Maximum() - 1));
 	case LogicalTypeId::TIMESTAMP_MS:
 		return MaximumValue(LogicalType::TIMESTAMP).CastAs(LogicalType::TIMESTAMP_MS);
 	case LogicalTypeId::TIMESTAMP_NS:
-		return Value::TIMESTAMPNS(timestamp_t(NumericLimits<int64_t>::Maximum()));
+		return Value::TIMESTAMPNS(timestamp_t(NumericLimits<int64_t>::Maximum() - 1));
 	case LogicalTypeId::TIMESTAMP_SEC:
 		return MaximumValue(LogicalType::TIMESTAMP).CastAs(LogicalType::TIMESTAMP_S);
 	case LogicalTypeId::TIME_TZ:
 		return Value::TIMETZ(dtime_t(Interval::SECS_PER_DAY * Interval::MICROS_PER_SEC - 1));
 	case LogicalTypeId::TIMESTAMP_TZ:
-		return Value::TIMESTAMPTZ(timestamp_t(NumericLimits<int64_t>::Maximum()));
+		return MaximumValue(LogicalType::TIMESTAMP);
 	case LogicalTypeId::FLOAT:
 		return Value::FLOAT(NumericLimits<float>::Maximum());
 	case LogicalTypeId::DOUBLE:
@@ -43199,6 +43263,16 @@ bool Value::IsFinite(double input) {
 	return Value::DoubleIsFinite(input);
 }
 
+template <>
+bool Value::IsFinite(date_t input) {
+	return Date::IsFinite(input);
+}
+
+template <>
+bool Value::IsFinite(timestamp_t input) {
+	return Timestamp::IsFinite(input);
+}
+
 bool Value::StringIsValid(const char *str, idx_t length) {
 	auto utf_type = Utf8Proc::Analyze(str, length);
 	return utf_type != UnicodeType::INVALID;
@@ -44149,8 +44223,14 @@ string Value::ToString() const {
 		return Timestamp::ToString(value_.timestamp);
 	case LogicalTypeId::TIME_TZ:
 		return Time::ToString(value_.time) + Time::ToUTCOffset(0, 0);
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return Timestamp::ToString(value_.timestamp) + Time::ToUTCOffset(0, 0);
+	case LogicalTypeId::TIMESTAMP_TZ: {
+		// Infinite TSTZ values do not display offsets in PG.
+		auto ret = Timestamp::ToString(value_.timestamp);
+		if (Timestamp::IsFinite(value_.timestamp)) {
+			ret += Time::ToUTCOffset(0, 0);
+		}
+		return ret;
+	}
 	case LogicalTypeId::TIMESTAMP_SEC:
 		return Timestamp::ToString(Timestamp::FromEpochSeconds(value_.timestamp.value));
 	case LogicalTypeId::TIMESTAMP_MS:
@@ -87010,17 +87090,30 @@ static void AgeFunctionStandard(DataChunk &input, ExpressionState &state, Vector
 	D_ASSERT(input.ColumnCount() == 1);
 	auto current_timestamp = Timestamp::GetCurrentTimestamp();
 
-	UnaryExecutor::Execute<timestamp_t, interval_t>(input.data[0], result, input.size(), [&](timestamp_t input) {
-		return Interval::GetAge(current_timestamp, input);
-	});
+	UnaryExecutor::ExecuteWithNulls<timestamp_t, interval_t>(input.data[0], result, input.size(),
+	                                                         [&](timestamp_t input, ValidityMask &mask, idx_t idx) {
+		                                                         if (Timestamp::IsFinite(input)) {
+			                                                         return Interval::GetAge(current_timestamp, input);
+		                                                         } else {
+			                                                         mask.SetInvalid(idx);
+			                                                         return interval_t();
+		                                                         }
+	                                                         });
 }
 
 static void AgeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	D_ASSERT(input.ColumnCount() == 2);
 
-	BinaryExecutor::Execute<timestamp_t, timestamp_t, interval_t>(
+	BinaryExecutor::ExecuteWithNulls<timestamp_t, timestamp_t, interval_t>(
 	    input.data[0], input.data[1], result, input.size(),
-	    [&](timestamp_t input1, timestamp_t input2) { return Interval::GetAge(input1, input2); });
+	    [&](timestamp_t input1, timestamp_t input2, ValidityMask &mask, idx_t idx) {
+		    if (Timestamp::IsFinite(input1) && Timestamp::IsFinite(input2)) {
+			    return Interval::GetAge(input1, input2);
+		    } else {
+			    mask.SetInvalid(idx);
+			    return interval_t();
+		    }
+	    });
 }
 
 void AgeFun::RegisterFunction(BuiltinFunctions &set) {
@@ -87121,6 +87214,19 @@ namespace duckdb {
 // This function is an implementation of the "period-crossing" date difference function from T-SQL
 // https://docs.microsoft.com/en-us/sql/t-sql/functions/datediff-transact-sql?view=sql-server-ver15
 struct DateDiff {
+	template <class TA, class TB, class TR, class OP>
+	static inline void BinaryExecute(Vector &left, Vector &right, Vector &result, idx_t count) {
+		BinaryExecutor::ExecuteWithNulls<TA, TB, TR>(
+		    left, right, result, count, [&](TA startdate, TB enddate, ValidityMask &mask, idx_t idx) {
+			    if (Value::IsFinite(startdate) && Value::IsFinite(enddate)) {
+				    return OP::template Operation<TA, TB, TR>(startdate, enddate);
+			    } else {
+				    mask.SetInvalid(idx);
+				    return TR();
+			    }
+		    });
+	}
+
 	struct YearOperator {
 		template <class TA, class TB, class TR>
 		static inline TR Operation(TA startdate, TB enddate) {
@@ -87427,8 +87533,13 @@ static int64_t DifferenceDates(DatePartSpecifier type, TA startdate, TB enddate)
 
 struct DateDiffTernaryOperator {
 	template <typename TS, typename TA, typename TB, typename TR>
-	static inline TR Operation(TS part, TA startdate, TB enddate) {
-		return DifferenceDates<TA, TB, TR>(GetDatePartSpecifier(part.GetString()), startdate, enddate);
+	static inline TR Operation(TS part, TA startdate, TB enddate, ValidityMask &mask, idx_t idx) {
+		if (Value::IsFinite(startdate) && Value::IsFinite(enddate)) {
+			return DifferenceDates<TA, TB, TR>(GetDatePartSpecifier(part.GetString()), startdate, enddate);
+		} else {
+			mask.SetInvalid(idx);
+			return TR();
+		}
 	}
 };
 
@@ -87436,51 +87547,51 @@ template <typename TA, typename TB, typename TR>
 static void DateDiffBinaryExecutor(DatePartSpecifier type, Vector &left, Vector &right, Vector &result, idx_t count) {
 	switch (type) {
 	case DatePartSpecifier::YEAR:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateDiff::YearOperator>(left, right, result, count);
+		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::YearOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::MONTH:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateDiff::MonthOperator>(left, right, result, count);
+		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::MonthOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::DAY:
 	case DatePartSpecifier::DOW:
 	case DatePartSpecifier::ISODOW:
 	case DatePartSpecifier::DOY:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateDiff::DayOperator>(left, right, result, count);
+		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::DayOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::DECADE:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateDiff::DecadeOperator>(left, right, result, count);
+		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::DecadeOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::CENTURY:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateDiff::CenturyOperator>(left, right, result, count);
+		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::CenturyOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::MILLENNIUM:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateDiff::MilleniumOperator>(left, right, result, count);
+		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::MilleniumOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::QUARTER:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateDiff::QuarterOperator>(left, right, result, count);
+		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::QuarterOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::WEEK:
 	case DatePartSpecifier::YEARWEEK:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateDiff::WeekOperator>(left, right, result, count);
+		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::WeekOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::ISOYEAR:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateDiff::ISOYearOperator>(left, right, result, count);
+		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::ISOYearOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::MICROSECONDS:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateDiff::MicrosecondsOperator>(left, right, result, count);
+		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::MicrosecondsOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::MILLISECONDS:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateDiff::MillisecondsOperator>(left, right, result, count);
+		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::MillisecondsOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::SECOND:
 	case DatePartSpecifier::EPOCH:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateDiff::SecondsOperator>(left, right, result, count);
+		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::SecondsOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::MINUTE:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateDiff::MinutesOperator>(left, right, result, count);
+		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::MinutesOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::HOUR:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateDiff::HoursOperator>(left, right, result, count);
+		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::HoursOperator>(left, right, result, count);
 		break;
 	default:
 		throw NotImplementedException("Specifier type not implemented for DATEDIFF");
@@ -87491,8 +87602,8 @@ template <typename T>
 static void DateDiffFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 3);
 	auto &part_arg = args.data[0];
-	auto &startdate_arg = args.data[1];
-	auto &enddate_arg = args.data[2];
+	auto &start_arg = args.data[1];
+	auto &end_arg = args.data[2];
 
 	if (part_arg.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 		// Common case of constant part.
@@ -87501,11 +87612,12 @@ static void DateDiffFunction(DataChunk &args, ExpressionState &state, Vector &re
 			ConstantVector::SetNull(result, true);
 		} else {
 			const auto type = GetDatePartSpecifier(ConstantVector::GetData<string_t>(part_arg)->GetString());
-			DateDiffBinaryExecutor<T, T, int64_t>(type, startdate_arg, enddate_arg, result, args.size());
+			DateDiffBinaryExecutor<T, T, int64_t>(type, start_arg, end_arg, result, args.size());
 		}
 	} else {
-		TernaryExecutor::Execute<string_t, T, T, int64_t>(part_arg, startdate_arg, enddate_arg, result, args.size(),
-		                                                  DateDiffTernaryOperator::Operation<string_t, T, T, int64_t>);
+		TernaryExecutor::ExecuteWithNulls<string_t, T, T, int64_t>(
+		    part_arg, start_arg, end_arg, result, args.size(),
+		    DateDiffTernaryOperator::Operation<string_t, T, T, int64_t>);
 	}
 }
 
@@ -87680,39 +87792,6 @@ DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType
 	throw NotImplementedException("\"%s\" units \"%s\" not recognized", LogicalTypeIdToString(type.id()), specifier);
 }
 
-template <class T>
-static void LastYearFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	int32_t last_year = 0;
-	UnaryExecutor::Execute<T, int64_t>(args.data[0], result, args.size(),
-	                                   [&](T input) { return Date::ExtractYear(input, &last_year); });
-}
-
-template <class T, class OP>
-static unique_ptr<BaseStatistics> PropagateDatePartStatistics(vector<unique_ptr<BaseStatistics>> &child_stats) {
-	// we can only propagate complex date part stats if the child has stats
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &nstats = (NumericStatistics &)*child_stats[0];
-	if (nstats.min.IsNull() || nstats.max.IsNull()) {
-		return nullptr;
-	}
-	// run the operator on both the min and the max, this gives us the [min, max] bound
-	auto min = nstats.min.GetValueUnsafe<T>();
-	auto max = nstats.max.GetValueUnsafe<T>();
-	if (min > max) {
-		return nullptr;
-	}
-	auto min_part = OP::template Operation<T, int64_t>(min);
-	auto max_part = OP::template Operation<T, int64_t>(max);
-	auto result = make_unique<NumericStatistics>(LogicalType::BIGINT, Value::BIGINT(min_part), Value::BIGINT(max_part),
-	                                             StatisticsType::LOCAL_STATS);
-	if (child_stats[0]->validity_stats) {
-		result->validity_stats = child_stats[0]->validity_stats->Copy();
-	}
-	return move(result);
-}
-
 template <int64_t MIN, int64_t MAX>
 static unique_ptr<BaseStatistics> PropagateSimpleDatePartStatistics(vector<unique_ptr<BaseStatistics>> &child_stats) {
 	// we can always propagate simple date part statistics
@@ -87729,6 +87808,56 @@ static unique_ptr<BaseStatistics> PropagateSimpleDatePartStatistics(vector<uniqu
 }
 
 struct DatePart {
+	template <class T, class OP>
+	static unique_ptr<BaseStatistics> PropagateDatePartStatistics(vector<unique_ptr<BaseStatistics>> &child_stats) {
+		// we can only propagate complex date part stats if the child has stats
+		if (!child_stats[0]) {
+			return nullptr;
+		}
+		auto &nstats = (NumericStatistics &)*child_stats[0];
+		if (nstats.min.IsNull() || nstats.max.IsNull()) {
+			return nullptr;
+		}
+		// run the operator on both the min and the max, this gives us the [min, max] bound
+		auto min = nstats.min.GetValueUnsafe<T>();
+		auto max = nstats.max.GetValueUnsafe<T>();
+		if (min > max) {
+			return nullptr;
+		}
+		// Infinities prevent us from computing generic ranges
+		if (!Value::IsFinite(min) || !Value::IsFinite(max)) {
+			return nullptr;
+		}
+		auto min_part = OP::template Operation<T, int64_t>(min);
+		auto max_part = OP::template Operation<T, int64_t>(max);
+		auto result = make_unique<NumericStatistics>(LogicalType::BIGINT, Value::BIGINT(min_part),
+		                                             Value::BIGINT(max_part), StatisticsType::LOCAL_STATS);
+		if (child_stats[0]->validity_stats) {
+			result->validity_stats = child_stats[0]->validity_stats->Copy();
+		}
+		return move(result);
+	}
+
+	template <typename OP>
+	struct PartOperator {
+		template <class TA, class TR>
+		static inline TR Operation(TA input, ValidityMask &mask, idx_t idx, void *dataptr) {
+			if (Value::IsFinite(input)) {
+				return OP::template Operation<TA, TR>(input);
+			} else {
+				mask.SetInvalid(idx);
+				return TR();
+			}
+		}
+	};
+
+	template <class TA, class TR, class OP>
+	static void UnaryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+		D_ASSERT(input.ColumnCount() >= 1);
+		using IOP = PartOperator<OP>;
+		UnaryExecutor::GenericExecute<TA, TR, IOP>(input.data[0], result, input.size(), nullptr, true);
+	}
+
 	struct YearOperator {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
@@ -88229,6 +88358,20 @@ struct DatePart {
 	};
 };
 
+template <class T>
+static void LastYearFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	int32_t last_year = 0;
+	UnaryExecutor::ExecuteWithNulls<T, int64_t>(args.data[0], result, args.size(),
+	                                            [&](T input, ValidityMask &mask, idx_t idx) {
+		                                            if (Value::IsFinite(input)) {
+			                                            return Date::ExtractYear(input, &last_year);
+		                                            } else {
+			                                            mask.SetInvalid(idx);
+			                                            return 0;
+		                                            }
+	                                            });
+}
+
 template <>
 int64_t DatePart::YearOperator::Operation(timestamp_t input) {
 	return YearOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
@@ -88728,21 +88871,21 @@ static int64_t ExtractElement(DatePartSpecifier type, T element) {
 	}
 }
 
-struct DatePartBinaryOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA specifier, TB date) {
-		return ExtractElement<TB>(GetDatePartSpecifier(specifier.GetString()), date);
-	}
-};
-
 template <typename T>
 static void DatePartFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 2);
-	auto &part_arg = args.data[0];
+	auto &spec_arg = args.data[0];
 	auto &date_arg = args.data[1];
 
-	BinaryExecutor::ExecuteStandard<string_t, T, int64_t, DatePartBinaryOperator>(part_arg, date_arg, result,
-	                                                                              args.size());
+	BinaryExecutor::ExecuteWithNulls<string_t, T, int64_t>(
+	    spec_arg, date_arg, result, args.size(), [&](string_t specifier, T date, ValidityMask &mask, idx_t idx) {
+		    if (Value::IsFinite(date)) {
+			    return ExtractElement<T>(GetDatePartSpecifier(specifier.GetString()), date);
+		    } else {
+			    mask.SetInvalid(idx);
+			    return int64_t(0);
+		    }
+	    });
 }
 
 void AddGenericDatePartOperator(BuiltinFunctions &set, const string &name, scalar_function_t date_func,
@@ -88759,8 +88902,8 @@ void AddGenericDatePartOperator(BuiltinFunctions &set, const string &name, scala
 
 template <class OP>
 static void AddDatePartOperator(BuiltinFunctions &set, string name) {
-	AddGenericDatePartOperator(set, name, ScalarFunction::UnaryFunction<date_t, int64_t, OP>,
-	                           ScalarFunction::UnaryFunction<timestamp_t, int64_t, OP>,
+	AddGenericDatePartOperator(set, name, DatePart::UnaryFunction<date_t, int64_t, OP>,
+	                           DatePart::UnaryFunction<timestamp_t, int64_t, OP>,
 	                           ScalarFunction::UnaryFunction<interval_t, int64_t, OP>,
 	                           OP::template PropagateStatistics<date_t>, OP::template PropagateStatistics<timestamp_t>);
 }
@@ -88783,10 +88926,10 @@ void AddGenericTimePartOperator(BuiltinFunctions &set, const string &name, scala
 template <class OP>
 static void AddTimePartOperator(BuiltinFunctions &set, string name) {
 	AddGenericTimePartOperator(
-	    set, name, ScalarFunction::UnaryFunction<date_t, int64_t, OP>,
-	    ScalarFunction::UnaryFunction<timestamp_t, int64_t, OP>, ScalarFunction::UnaryFunction<interval_t, int64_t, OP>,
-	    ScalarFunction::UnaryFunction<dtime_t, int64_t, OP>, OP::template PropagateStatistics<date_t>,
-	    OP::template PropagateStatistics<timestamp_t>, OP::template PropagateStatistics<dtime_t>);
+	    set, name, DatePart::UnaryFunction<date_t, int64_t, OP>, DatePart::UnaryFunction<timestamp_t, int64_t, OP>,
+	    ScalarFunction::UnaryFunction<interval_t, int64_t, OP>, ScalarFunction::UnaryFunction<dtime_t, int64_t, OP>,
+	    OP::template PropagateStatistics<date_t>, OP::template PropagateStatistics<timestamp_t>,
+	    OP::template PropagateStatistics<dtime_t>);
 }
 
 struct LastDayOperator {
@@ -88914,7 +89057,13 @@ struct StructDatePart {
 					}
 				}
 				auto tdata = ConstantVector::GetData<INPUT_TYPE>(input);
-				DatePart::StructOperator::Operation(part_values.data(), tdata[0], 0, part_mask);
+				if (Value::IsFinite(tdata[0])) {
+					DatePart::StructOperator::Operation(part_values.data(), tdata[0], 0, part_mask);
+				} else {
+					for (auto &child_entry : child_entries) {
+						ConstantVector::SetNull(*child_entry, true);
+					}
+				}
 			}
 		} else {
 			VectorData rdata;
@@ -88949,7 +89098,13 @@ struct StructDatePart {
 			for (idx_t i = 0; i < count; ++i) {
 				const auto idx = rdata.sel->get_index(i);
 				if (arg_valid.RowIsValid(idx)) {
-					DatePart::StructOperator::Operation(part_values.data(), tdata[idx], idx, part_mask);
+					if (Value::IsFinite(tdata[idx])) {
+						DatePart::StructOperator::Operation(part_values.data(), tdata[idx], idx, part_mask);
+					} else {
+						for (auto &child_entry : child_entries) {
+							FlatVector::Validity(*child_entry).SetInvalid(idx);
+						}
+					}
 				} else {
 					res_valid.SetInvalid(idx);
 					for (auto &child_entry : child_entries) {
@@ -89018,25 +89173,25 @@ void DatePartFun::RegisterFunction(BuiltinFunctions &set) {
 	//  register the last_day function
 	ScalarFunctionSet last_day("last_day");
 	last_day.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::DATE,
-	                                    ScalarFunction::UnaryFunction<date_t, date_t, LastDayOperator>));
+	                                    DatePart::UnaryFunction<date_t, date_t, LastDayOperator>));
 	last_day.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::DATE,
-	                                    ScalarFunction::UnaryFunction<timestamp_t, date_t, LastDayOperator>));
+	                                    DatePart::UnaryFunction<timestamp_t, date_t, LastDayOperator>));
 	set.AddFunction(last_day);
 
 	//  register the monthname function
 	ScalarFunctionSet monthname("monthname");
 	monthname.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::VARCHAR,
-	                                     ScalarFunction::UnaryFunction<date_t, string_t, MonthNameOperator>));
+	                                     DatePart::UnaryFunction<date_t, string_t, MonthNameOperator>));
 	monthname.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::VARCHAR,
-	                                     ScalarFunction::UnaryFunction<timestamp_t, string_t, MonthNameOperator>));
+	                                     DatePart::UnaryFunction<timestamp_t, string_t, MonthNameOperator>));
 	set.AddFunction(monthname);
 
 	//  register the dayname function
 	ScalarFunctionSet dayname("dayname");
 	dayname.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::VARCHAR,
-	                                   ScalarFunction::UnaryFunction<date_t, string_t, DayNameOperator>));
+	                                   DatePart::UnaryFunction<date_t, string_t, DayNameOperator>));
 	dayname.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::VARCHAR,
-	                                   ScalarFunction::UnaryFunction<timestamp_t, string_t, DayNameOperator>));
+	                                   DatePart::UnaryFunction<timestamp_t, string_t, DayNameOperator>));
 	set.AddFunction(dayname);
 
 	// finally the actual date_part function
@@ -89077,6 +89232,19 @@ void DatePartFun::RegisterFunction(BuiltinFunctions &set) {
 namespace duckdb {
 
 struct DateSub {
+	template <class TA, class TB, class TR, class OP>
+	static inline void BinaryExecute(Vector &left, Vector &right, Vector &result, idx_t count) {
+		BinaryExecutor::ExecuteWithNulls<TA, TB, TR>(
+		    left, right, result, count, [&](TA startdate, TB enddate, ValidityMask &mask, idx_t idx) {
+			    if (Value::IsFinite(startdate) && Value::IsFinite(enddate)) {
+				    return OP::template Operation<TA, TB, TR>(startdate, enddate);
+			    } else {
+				    mask.SetInvalid(idx);
+				    return TR();
+			    }
+		    });
+	}
+
 	struct MonthOperator {
 		template <class TA, class TB, class TR>
 		static inline TR Operation(TA start_ts, TB end_ts) {
@@ -89403,8 +89571,13 @@ static int64_t SubtractDateParts(DatePartSpecifier type, TA startdate, TB enddat
 
 struct DateSubTernaryOperator {
 	template <typename TS, typename TA, typename TB, typename TR>
-	static inline TR Operation(TS part, TA startdate, TB enddate) {
-		return SubtractDateParts<TA, TB, TR>(GetDatePartSpecifier(part.GetString()), startdate, enddate);
+	static inline TR Operation(TS part, TA startdate, TB enddate, ValidityMask &mask, idx_t idx) {
+		if (Value::IsFinite(startdate) && Value::IsFinite(enddate)) {
+			return SubtractDateParts<TA, TB, TR>(GetDatePartSpecifier(part.GetString()), startdate, enddate);
+		} else {
+			mask.SetInvalid(idx);
+			return TR();
+		}
 	}
 };
 
@@ -89413,48 +89586,48 @@ static void DateSubBinaryExecutor(DatePartSpecifier type, Vector &left, Vector &
 	switch (type) {
 	case DatePartSpecifier::YEAR:
 	case DatePartSpecifier::ISOYEAR:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateSub::YearOperator>(left, right, result, count);
+		DateSub::BinaryExecute<TA, TB, TR, DateSub::YearOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::MONTH:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateSub::MonthOperator>(left, right, result, count);
+		DateSub::BinaryExecute<TA, TB, TR, DateSub::MonthOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::DAY:
 	case DatePartSpecifier::DOW:
 	case DatePartSpecifier::ISODOW:
 	case DatePartSpecifier::DOY:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateSub::DayOperator>(left, right, result, count);
+		DateSub::BinaryExecute<TA, TB, TR, DateSub::DayOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::DECADE:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateSub::DecadeOperator>(left, right, result, count);
+		DateSub::BinaryExecute<TA, TB, TR, DateSub::DecadeOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::CENTURY:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateSub::CenturyOperator>(left, right, result, count);
+		DateSub::BinaryExecute<TA, TB, TR, DateSub::CenturyOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::MILLENNIUM:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateSub::MilleniumOperator>(left, right, result, count);
+		DateSub::BinaryExecute<TA, TB, TR, DateSub::MilleniumOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::QUARTER:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateSub::QuarterOperator>(left, right, result, count);
+		DateSub::BinaryExecute<TA, TB, TR, DateSub::QuarterOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::WEEK:
 	case DatePartSpecifier::YEARWEEK:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateSub::WeekOperator>(left, right, result, count);
+		DateSub::BinaryExecute<TA, TB, TR, DateSub::WeekOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::MICROSECONDS:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateSub::MicrosecondsOperator>(left, right, result, count);
+		DateSub::BinaryExecute<TA, TB, TR, DateSub::MicrosecondsOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::MILLISECONDS:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateSub::MillisecondsOperator>(left, right, result, count);
+		DateSub::BinaryExecute<TA, TB, TR, DateSub::MillisecondsOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::SECOND:
 	case DatePartSpecifier::EPOCH:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateSub::SecondsOperator>(left, right, result, count);
+		DateSub::BinaryExecute<TA, TB, TR, DateSub::SecondsOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::MINUTE:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateSub::MinutesOperator>(left, right, result, count);
+		DateSub::BinaryExecute<TA, TB, TR, DateSub::MinutesOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::HOUR:
-		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateSub::HoursOperator>(left, right, result, count);
+		DateSub::BinaryExecute<TA, TB, TR, DateSub::HoursOperator>(left, right, result, count);
 		break;
 	default:
 		throw NotImplementedException("Specifier type not implemented for DATESUB");
@@ -89465,8 +89638,8 @@ template <typename T>
 static void DateSubFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 3);
 	auto &part_arg = args.data[0];
-	auto &startdate_arg = args.data[1];
-	auto &enddate_arg = args.data[2];
+	auto &start_arg = args.data[1];
+	auto &end_arg = args.data[2];
 
 	if (part_arg.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 		// Common case of constant part.
@@ -89475,11 +89648,12 @@ static void DateSubFunction(DataChunk &args, ExpressionState &state, Vector &res
 			ConstantVector::SetNull(result, true);
 		} else {
 			const auto type = GetDatePartSpecifier(ConstantVector::GetData<string_t>(part_arg)->GetString());
-			DateSubBinaryExecutor<T, T, int64_t>(type, startdate_arg, enddate_arg, result, args.size());
+			DateSubBinaryExecutor<T, T, int64_t>(type, start_arg, end_arg, result, args.size());
 		}
 	} else {
-		TernaryExecutor::Execute<string_t, T, T, int64_t>(part_arg, startdate_arg, enddate_arg, result, args.size(),
-		                                                  DateSubTernaryOperator::Operation<string_t, T, T, int64_t>);
+		TernaryExecutor::ExecuteWithNulls<string_t, T, T, int64_t>(
+		    part_arg, start_arg, end_arg, result, args.size(),
+		    DateSubTernaryOperator::Operation<string_t, T, T, int64_t>);
 	}
 }
 
@@ -89506,9 +89680,21 @@ void DateSubFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+
+
 namespace duckdb {
 
 struct DateTrunc {
+	template <class TA, class TR, class OP>
+	static inline void UnaryExecute(Vector &left, Vector &result, idx_t count) {
+		UnaryExecutor::Execute<TA, TR>(left, result, count, [&](TA input) {
+			if (Value::IsFinite(input)) {
+				return OP::template Operation<TA, TR>(input);
+			} else {
+				return Cast::template Operation<TA, TR>(input);
+			}
+		});
+	}
 
 	struct MillenniumOperator {
 		template <class TA, class TR>
@@ -89813,6 +89999,10 @@ interval_t DateTrunc::MicrosecondOperator::Operation(interval_t input) {
 
 template <class TA, class TR>
 static TR TruncateElement(DatePartSpecifier type, TA element) {
+	if (!Value::IsFinite(element)) {
+		return Cast::template Operation<TA, TR>(element);
+	}
+
 	switch (type) {
 	case DatePartSpecifier::MILLENNIUM:
 		return DateTrunc::MillenniumOperator::Operation<TA, TR>(element);
@@ -89863,51 +90053,51 @@ template <typename TA, typename TR>
 static void DateTruncUnaryExecutor(DatePartSpecifier type, Vector &left, Vector &result, idx_t count) {
 	switch (type) {
 	case DatePartSpecifier::MILLENNIUM:
-		UnaryExecutor::Execute<TA, TR, DateTrunc::MillenniumOperator>(left, result, count);
+		DateTrunc::UnaryExecute<TA, TR, DateTrunc::MillenniumOperator>(left, result, count);
 		break;
 	case DatePartSpecifier::CENTURY:
-		UnaryExecutor::Execute<TA, TR, DateTrunc::CenturyOperator>(left, result, count);
+		DateTrunc::UnaryExecute<TA, TR, DateTrunc::CenturyOperator>(left, result, count);
 		break;
 	case DatePartSpecifier::DECADE:
-		UnaryExecutor::Execute<TA, TR, DateTrunc::DecadeOperator>(left, result, count);
+		DateTrunc::UnaryExecute<TA, TR, DateTrunc::DecadeOperator>(left, result, count);
 		break;
 	case DatePartSpecifier::YEAR:
-		UnaryExecutor::Execute<TA, TR, DateTrunc::YearOperator>(left, result, count);
+		DateTrunc::UnaryExecute<TA, TR, DateTrunc::YearOperator>(left, result, count);
 		break;
 	case DatePartSpecifier::QUARTER:
-		UnaryExecutor::Execute<TA, TR, DateTrunc::QuarterOperator>(left, result, count);
+		DateTrunc::UnaryExecute<TA, TR, DateTrunc::QuarterOperator>(left, result, count);
 		break;
 	case DatePartSpecifier::MONTH:
-		UnaryExecutor::Execute<TA, TR, DateTrunc::MonthOperator>(left, result, count);
+		DateTrunc::UnaryExecute<TA, TR, DateTrunc::MonthOperator>(left, result, count);
 		break;
 	case DatePartSpecifier::WEEK:
 	case DatePartSpecifier::YEARWEEK:
-		UnaryExecutor::Execute<TA, TR, DateTrunc::WeekOperator>(left, result, count);
+		DateTrunc::UnaryExecute<TA, TR, DateTrunc::WeekOperator>(left, result, count);
 		break;
 	case DatePartSpecifier::ISOYEAR:
-		UnaryExecutor::Execute<TA, TR, DateTrunc::ISOYearOperator>(left, result, count);
+		DateTrunc::UnaryExecute<TA, TR, DateTrunc::ISOYearOperator>(left, result, count);
 		break;
 	case DatePartSpecifier::DAY:
 	case DatePartSpecifier::DOW:
 	case DatePartSpecifier::ISODOW:
 	case DatePartSpecifier::DOY:
-		UnaryExecutor::Execute<TA, TR, DateTrunc::DayOperator>(left, result, count);
+		DateTrunc::UnaryExecute<TA, TR, DateTrunc::DayOperator>(left, result, count);
 		break;
 	case DatePartSpecifier::HOUR:
-		UnaryExecutor::Execute<TA, TR, DateTrunc::HourOperator>(left, result, count);
+		DateTrunc::UnaryExecute<TA, TR, DateTrunc::HourOperator>(left, result, count);
 		break;
 	case DatePartSpecifier::MINUTE:
-		UnaryExecutor::Execute<TA, TR, DateTrunc::MinuteOperator>(left, result, count);
+		DateTrunc::UnaryExecute<TA, TR, DateTrunc::MinuteOperator>(left, result, count);
 		break;
 	case DatePartSpecifier::SECOND:
 	case DatePartSpecifier::EPOCH:
-		UnaryExecutor::Execute<TA, TR, DateTrunc::SecondOperator>(left, result, count);
+		DateTrunc::UnaryExecute<TA, TR, DateTrunc::SecondOperator>(left, result, count);
 		break;
 	case DatePartSpecifier::MILLISECONDS:
-		UnaryExecutor::Execute<TA, TR, DateTrunc::MillisecondOperator>(left, result, count);
+		DateTrunc::UnaryExecute<TA, TR, DateTrunc::MillisecondOperator>(left, result, count);
 		break;
 	case DatePartSpecifier::MICROSECONDS:
-		UnaryExecutor::Execute<TA, TR, DateTrunc::MicrosecondOperator>(left, result, count);
+		DateTrunc::UnaryExecute<TA, TR, DateTrunc::MicrosecondOperator>(left, result, count);
 		break;
 	default:
 		throw NotImplementedException("Specifier type not implemented for DATETRUNC");
@@ -90838,14 +91028,20 @@ static void StrfTimeFunctionDate(DataChunk &args, ExpressionState &state, Vector
 		ConstantVector::SetNull(result, true);
 		return;
 	}
-	UnaryExecutor::Execute<date_t, string_t>(args.data[REVERSED ? 1 : 0], result, args.size(), [&](date_t input) {
-		dtime_t time(0);
-		idx_t len = info.format.GetLength(input, time, 0, nullptr);
-		string_t target = StringVector::EmptyString(result, len);
-		info.format.FormatString(input, time, target.GetDataWriteable());
-		target.Finalize();
-		return target;
-	});
+	UnaryExecutor::ExecuteWithNulls<date_t, string_t>(
+	    args.data[REVERSED ? 1 : 0], result, args.size(), [&](date_t input, ValidityMask &mask, idx_t idx) {
+		    if (Date::IsFinite(input)) {
+			    dtime_t time(0);
+			    idx_t len = info.format.GetLength(input, time, 0, nullptr);
+			    string_t target = StringVector::EmptyString(result, len);
+			    info.format.FormatString(input, time, target.GetDataWriteable());
+			    target.Finalize();
+			    return target;
+		    } else {
+			    mask.SetInvalid(idx);
+			    return string_t();
+		    }
+	    });
 }
 
 template <bool REVERSED>
@@ -90859,17 +91055,22 @@ static void StrfTimeFunctionTimestamp(DataChunk &args, ExpressionState &state, V
 		return;
 	}
 
-	UnaryExecutor::Execute<timestamp_t, string_t>(args.data[REVERSED ? 1 : 0], result, args.size(),
-	                                              [&](timestamp_t input) {
-		                                              date_t date;
-		                                              dtime_t time;
-		                                              Timestamp::Convert(input, date, time);
-		                                              idx_t len = info.format.GetLength(date, time, 0, nullptr);
-		                                              string_t target = StringVector::EmptyString(result, len);
-		                                              info.format.FormatString(date, time, target.GetDataWriteable());
-		                                              target.Finalize();
-		                                              return target;
-	                                              });
+	UnaryExecutor::ExecuteWithNulls<timestamp_t, string_t>(
+	    args.data[REVERSED ? 1 : 0], result, args.size(), [&](timestamp_t input, ValidityMask &mask, idx_t idx) {
+		    if (Timestamp::IsFinite(input)) {
+			    date_t date;
+			    dtime_t time;
+			    Timestamp::Convert(input, date, time);
+			    idx_t len = info.format.GetLength(date, time, 0, nullptr);
+			    string_t target = StringVector::EmptyString(result, len);
+			    info.format.FormatString(date, time, target.GetDataWriteable());
+			    target.Finalize();
+			    return target;
+		    } else {
+			    mask.SetInvalid(idx);
+			    return string_t();
+		    }
+	    });
 }
 
 void StrfTimeFun::RegisterFunction(BuiltinFunctions &set) {
@@ -94202,6 +94403,7 @@ void ListValueFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+
 namespace duckdb {
 
 struct NumericRangeInfo {
@@ -94260,6 +94462,11 @@ struct TimestampRangeInfo {
 			// interval is 0: no result
 			return 0;
 		}
+		// We don't allow infinite bounds because they generate errors or infinite loops
+		if (!Timestamp::IsFinite(start_value) || !Timestamp::IsFinite(end_value)) {
+			throw InvalidInputException("Interval infinite bounds not supported");
+		}
+
 		if (is_negative && is_positive) {
 			// we don't allow a mix of
 			throw InvalidInputException("Interval with mix of negative/positive entries not supported");
@@ -96178,11 +96385,18 @@ interval_t AddOperator::Operation(interval_t left, interval_t right) {
 
 template <>
 date_t AddOperator::Operation(date_t left, int32_t right) {
-	int32_t result;
-	if (!TryAddOperator::Operation(left.days, right, result)) {
+	if (!Value::IsFinite(left)) {
+		return left;
+	}
+	int32_t days;
+	if (!TryAddOperator::Operation(left.days, right, days)) {
+		throw OutOfRangeException("Date out of range");
+	}
+	date_t result(days);
+	if (!Value::IsFinite(result)) {
 		throw OutOfRangeException("Date out of range");
 	}
-	return date_t(result);
+	return result;
 }
 
 template <>
@@ -96192,6 +96406,11 @@ date_t AddOperator::Operation(int32_t left, date_t right) {
 
 template <>
 timestamp_t AddOperator::Operation(date_t left, dtime_t right) {
+	if (left == date_t::infinity()) {
+		return timestamp_t::infinity();
+	} else if (left == date_t::ninfinity()) {
+		return timestamp_t::ninfinity();
+	}
 	timestamp_t result;
 	if (!Timestamp::TryFromDatetime(left, right, result)) {
 		throw OutOfRangeException("Timestamp out of range");
@@ -97750,6 +97969,7 @@ hugeint_t DecimalMultiplyOverflowCheck::Operation(hugeint_t left, hugeint_t righ
 
 
 
+
 #include <limits>
 
 namespace duckdb {
@@ -97782,11 +98002,19 @@ int64_t SubtractOperator::Operation(date_t left, date_t right) {
 
 template <>
 date_t SubtractOperator::Operation(date_t left, int32_t right) {
-	int32_t result;
-	if (!TrySubtractOperator::Operation(left.days, right, result)) {
+	if (!Date::IsFinite(left)) {
+		return left;
+	}
+	int32_t days;
+	if (!TrySubtractOperator::Operation(left.days, right, days)) {
 		throw OutOfRangeException("Date out of range");
 	}
-	return date_t(result);
+
+	date_t result(days);
+	if (!Date::IsFinite(result)) {
+		throw OutOfRangeException("Date out of range");
+	}
+	return result;
 }
 
 template <>
@@ -104810,6 +105038,7 @@ struct SummaryTableFunction {
 
 
 
+
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
@@ -104954,6 +105183,11 @@ static unique_ptr<FunctionData> RangeDateTimeBind(ClientContext &context, TableF
 	result->end = inputs[1].GetValue<timestamp_t>();
 	result->increment = inputs[2].GetValue<interval_t>();
 
+	// Infinities either cause errors or infinite loops, so just ban them
+	if (!Timestamp::IsFinite(result->start) || !Timestamp::IsFinite(result->end)) {
+		throw BinderException("RANGE with infinite bounds is not supported");
+	}
+
 	if (result->increment.months == 0 && result->increment.days == 0 && result->increment.micros == 0) {
 		throw BinderException("interval cannot be 0!");
 	}
@@ -108125,6 +108359,8 @@ void PragmaTableInfo::RegisterFunction(BuiltinFunctions &set) {
 } // namespace duckdb
 
 
+
+
 #include <cmath>
 #include <limits>
 
@@ -108236,6 +108472,27 @@ static vector<TestType> GetTestTypes() {
 	     Value::DOUBLE(-std::numeric_limits<double>::infinity()), Value(LogicalType::DOUBLE), Value::DOUBLE(-42)});
 	result.emplace_back(double_list_type, "double_array", empty_double_list, double_list);
 
+	auto date_list_type = LogicalType::LIST(LogicalType::DATE);
+	auto empty_date_list = Value::EMPTYLIST(LogicalType::DATE);
+	auto date_list =
+	    Value::LIST({Value::DATE(date_t()), Value::DATE(date_t::infinity()), Value::DATE(date_t::ninfinity()),
+	                 Value(LogicalType::DATE), Value::DATE(Date::FromString("2022-05-12"))});
+	result.emplace_back(date_list_type, "date_array", empty_date_list, date_list);
+
+	auto timestamp_list_type = LogicalType::LIST(LogicalType::TIMESTAMP);
+	auto empty_timestamp_list = Value::EMPTYLIST(LogicalType::TIMESTAMP);
+	auto timestamp_list = Value::LIST({Value::TIMESTAMP(timestamp_t()), Value::TIMESTAMP(timestamp_t::infinity()),
+	                                   Value::TIMESTAMP(timestamp_t::ninfinity()), Value(LogicalType::TIMESTAMP),
+	                                   Value::TIMESTAMP(Timestamp::FromString("2022-05-12 16:23:45"))});
+	result.emplace_back(timestamp_list_type, "timestamp_array", empty_timestamp_list, timestamp_list);
+
+	auto timestamptz_list_type = LogicalType::LIST(LogicalType::TIMESTAMP_TZ);
+	auto empty_timestamptz_list = Value::EMPTYLIST(LogicalType::TIMESTAMP_TZ);
+	auto timestamptz_list = Value::LIST({Value::TIMESTAMPTZ(timestamp_t()), Value::TIMESTAMPTZ(timestamp_t::infinity()),
+	                                     Value::TIMESTAMPTZ(timestamp_t::ninfinity()), Value(LogicalType::TIMESTAMP_TZ),
+	                                     Value::TIMESTAMPTZ(Timestamp::FromString("2022-05-12 16:23:45-07"))});
+	result.emplace_back(timestamptz_list_type, "timestamptz_array", empty_timestamptz_list, timestamptz_list);
+
 	auto varchar_list_type = LogicalType::LIST(LogicalType::VARCHAR);
 	auto empty_varchar_list = Value::EMPTYLIST(LogicalType::VARCHAR);
 	auto varchar_list =