duckdb 0.3.3-dev1251.0 → 0.3.3-dev1275.0

package/src/duckdb.cpp

@@ -18236,10 +18236,14 @@ duckdb::string_t StringCastTZ::Operation(timestamp_t input, Vector &result);
 
 
 
+
 namespace duckdb {
 
 template <class SRC, class DST>
 static bool TryCastWithOverflowCheck(SRC value, DST &result) {
+	if (!Value::IsFinite<SRC>(value)) {
+		return false;
+	}
 	if (NumericLimits<SRC>::IsSigned() != NumericLimits<DST>::IsSigned()) {
 		if (NumericLimits<SRC>::IsSigned()) {
 			// signed to unsigned conversion
@@ -18282,40 +18286,58 @@ static bool TryCastWithOverflowCheck(SRC value, DST &result) {
 	}
 }
 
-template <>
-bool TryCastWithOverflowCheck(float value, int32_t &result) {
-	if (!(value >= -2147483648.0f && value < 2147483648.0f)) {
+template <class SRC, class T>
+bool TryCastWithOverflowCheckFloat(SRC value, T &result, SRC min, SRC max) {
+	if (!Value::IsFinite<SRC>(value)) {
 		return false;
 	}
-	result = int32_t(value);
+	if (!(value >= min && value < max)) {
+		return false;
+	}
+	result = T(value);
 	return true;
 }
 
+template <>
+bool TryCastWithOverflowCheck(float value, int32_t &result) {
+	return TryCastWithOverflowCheckFloat<float, int32_t>(value, result, -2147483648.0f, 2147483648.0f);
+}
+
 template <>
 bool TryCastWithOverflowCheck(float value, int64_t &result) {
-	if (!(value >= -9223372036854775808.0f && value < 9223372036854775808.0f)) {
-		return false;
-	}
-	result = int64_t(value);
-	return true;
+	return TryCastWithOverflowCheckFloat<float, int64_t>(value, result, -9223372036854775808.0f,
+	                                                     9223372036854775808.0f);
 }
 
 template <>
 bool TryCastWithOverflowCheck(double value, int64_t &result) {
-	if (!(value >= -9223372036854775808.0 && value < 9223372036854775808.0)) {
-		return false;
-	}
-	result = int64_t(value);
+	return TryCastWithOverflowCheckFloat<double, int64_t>(value, result, -9223372036854775808.0, 9223372036854775808.0);
+}
+
+template <>
+bool TryCastWithOverflowCheck(float input, float &result) {
+	result = input;
+	return true;
+}
+template <>
+bool TryCastWithOverflowCheck(float input, double &result) {
+	result = double(input);
+	return true;
+}
+template <>
+bool TryCastWithOverflowCheck(double input, double &result) {
+	result = input;
 	return true;
 }
 
 template <>
 bool TryCastWithOverflowCheck(double input, float &result) {
-	if (input < (double)NumericLimits<float>::Minimum() || input > (double)NumericLimits<float>::Maximum()) {
-		return false;
+	if (!Value::IsFinite(input)) {
+		result = float(input);
+		return true;
 	}
-	auto res = (float)input;
-	if (std::isnan(res) || std::isinf(res)) {
+	auto res = float(input);
+	if (!Value::FloatIsFinite(input)) {
 		return false;
 	}
 	result = res;
@@ -22956,19 +22978,6 @@ bool TryCast::Operation(string_t input, uint64_t &result, bool strict) {
 	return TryIntegerCast<uint64_t, false>(input.GetDataUnsafe(), input.GetSize(), result, strict);
 }
 
-template <class T>
-bool CheckDoubleValidity(T value);
-
-template <>
-bool CheckDoubleValidity(float value) {
-	return Value::FloatIsValid(value);
-}
-
-template <>
-bool CheckDoubleValidity(double value) {
-	return Value::DoubleIsValid(value);
-}
-
 template <class T>
 static bool TryDoubleCast(const char *buf, idx_t len, T &result, bool strict) {
 	// skip any spaces at the start
@@ -22985,9 +22994,6 @@ static bool TryDoubleCast(const char *buf, idx_t len, T &result, bool strict) {
 	}
 	auto endptr = buf + len;
 	auto parse_result = duckdb_fast_float::from_chars(buf, buf + len, result);
-	if (!CheckDoubleValidity<T>(result)) {
-		return false;
-	}
 	if (parse_result.ec != std::errc()) {
 		return false;
 	}
@@ -24679,6 +24685,8 @@ void ProgressBar::Update(bool final) {
 } // namespace duckdb
 
 
+
+
 #include <cfloat>
 #include <cstring> // strlen() on Solaris
 #include <limits.h>
@@ -24707,15 +24715,17 @@ uint32_t EncodeFloat(float x) {
 		buff |= (1u << 31);
 		return buff;
 	}
+	// nan
+	if (Value::IsNan(x)) {
+		return UINT_MAX;
+	}
 	//! infinity
 	if (x > FLT_MAX) {
-		throw InternalException("+INFINITY detected in floating point number");
-		// return UINT_MAX;
+		return UINT_MAX - 1;
 	}
 	//! -infinity
 	if (x < -FLT_MAX) {
-		throw InternalException("-INFINITY detected in floating point number");
-		// return 0;
+		return 0;
 	}
 	buff = Load<uint32_t>((const_data_ptr_t)&x);
 	if ((buff & (1u << 31)) == 0) { //! +0 and positive numbers
@@ -24735,15 +24745,17 @@ uint64_t EncodeDouble(double x) {
 		buff += (1ull << 63);
 		return buff;
 	}
+	// nan
+	if (Value::IsNan(x)) {
+		return ULLONG_MAX;
+	}
 	//! infinity
 	if (x > DBL_MAX) {
-		throw InternalException("+INFINITY detected in floating point number");
-		// return ULLONG_MAX;
+		return ULLONG_MAX - 1;
 	}
 	//! -infinity
 	if (x < -DBL_MAX) {
-		throw InternalException("-INFINITY detected in floating point number");
-		// return 0;
+		return 0;
 	}
 	buff = Load<uint64_t>((const_data_ptr_t)&x);
 	if (buff < (1ull << 63)) { //! +0 and positive numbers
@@ -34687,6 +34699,7 @@ hash_t Hash(uint8_t *val, size_t size) {
 
 
 
+
 #include <cmath>
 #include <limits>
 
@@ -35226,6 +35239,9 @@ bool Hugeint::TryConvert(float value, hugeint_t &result) {
 
 template <class REAL_T>
 bool ConvertFloatingToBigint(REAL_T value, hugeint_t &result) {
+	if (!Value::IsFinite<REAL_T>(value)) {
+		return false;
+	}
 	if (value <= -170141183460469231731687303715884105728.0 || value >= 170141183460469231731687303715884105727.0) {
 		return false;
 	}
@@ -37382,8 +37398,6 @@ void ValidityMask::Slice(const ValidityMask &other, idx_t offset) {
 }
 
 } // namespace duckdb
-#include <utility>
-
 
 
 
@@ -37493,6 +37507,9 @@ hugeint_t ModuloOperator::Operation(hugeint_t left, hugeint_t right);
 
 
 
+#include <utility>
+#include <cmath>
+
 namespace duckdb {
 
 Value::Value(LogicalType type) : type_(move(type)), is_null(true) {
@@ -37507,16 +37524,10 @@ Value::Value(int64_t val) : type_(LogicalType::BIGINT), is_null(false) {
 }
 
 Value::Value(float val) : type_(LogicalType::FLOAT), is_null(false) {
-	if (!Value::FloatIsValid(val)) {
-		throw OutOfRangeException("Invalid float value %f", val);
-	}
 	value_.float_ = val;
 }
 
 Value::Value(double val) : type_(LogicalType::DOUBLE), is_null(false) {
-	if (!Value::DoubleIsValid(val)) {
-		throw OutOfRangeException("Invalid double value %f", val);
-	}
 	value_.double_ = val;
 }
 
@@ -37790,14 +37801,34 @@ Value Value::UBIGINT(uint64_t value) {
 	return result;
 }
 
-bool Value::FloatIsValid(float value) {
+bool Value::FloatIsFinite(float value) {
 	return !(std::isnan(value) || std::isinf(value));
 }
 
-bool Value::DoubleIsValid(double value) {
+bool Value::DoubleIsFinite(double value) {
 	return !(std::isnan(value) || std::isinf(value));
 }
 
+template <>
+bool Value::IsNan(float input) {
+	return std::isnan(input);
+}
+
+template <>
+bool Value::IsNan(double input) {
+	return std::isnan(input);
+}
+
+template <>
+bool Value::IsFinite(float input) {
+	return Value::FloatIsFinite(input);
+}
+
+template <>
+bool Value::IsFinite(double input) {
+	return Value::DoubleIsFinite(input);
+}
+
 bool Value::StringIsValid(const char *str, idx_t length) {
 	auto utf_type = Utf8Proc::Analyze(str, length);
 	return utf_type != UnicodeType::INVALID;
@@ -37850,9 +37881,6 @@ Value Value::DECIMAL(hugeint_t value, uint8_t width, uint8_t scale) {
 }
 
 Value Value::FLOAT(float value) {
-	if (!Value::FloatIsValid(value)) {
-		throw OutOfRangeException("Invalid float value %f", value);
-	}
 	Value result(LogicalType::FLOAT);
 	result.value_.float_ = value;
 	result.is_null = false;
@@ -37860,9 +37888,6 @@ Value Value::FLOAT(float value) {
 }
 
 Value Value::DOUBLE(double value) {
-	if (!Value::DoubleIsValid(value)) {
-		throw OutOfRangeException("Invalid double value %f", value);
-	}
 	Value result(LogicalType::DOUBLE);
 	result.value_.double_ = value;
 	result.is_null = false;
@@ -38863,6 +38888,22 @@ string Value::ToSQLString() const {
 		ret += "}";
 		return ret;
 	}
+	case LogicalTypeId::FLOAT:
+		if (!FloatIsFinite(FloatValue::Get(*this))) {
+			return "'" + ToString() + "'::" + type_.ToString();
+		}
+		return ToString();
+	case LogicalTypeId::DOUBLE: {
+		double val = DoubleValue::Get(*this);
+		if (!DoubleIsFinite(val)) {
+			if (!Value::IsNan(val)) {
+				// to infinity and beyond
+				return val < 0 ? "-1e1000" : "1e1000";
+			}
+			return "'" + ToString() + "'::" + type_.ToString();
+		}
+		return ToString();
+	}
 	case LogicalTypeId::LIST: {
 		string ret = "[";
 		for (size_t i = 0; i < list_value.size(); i++) {
@@ -39242,16 +39283,6 @@ bool Value::ValuesAreEqual(const Value &result_value, const Value &value) {
 	}
 }
 
-template <>
-bool Value::IsValid(float value) {
-	return Value::FloatIsValid(value);
-}
-
-template <>
-bool Value::IsValid(double value) {
-	return Value::DoubleIsValid(value);
-}
-
 } // namespace duckdb
 
 
@@ -40239,30 +40270,6 @@ void Vector::Verify(const SelectionVector &sel, idx_t count) {
 	    (GetVectorType() == VectorType::CONSTANT_VECTOR || GetVectorType() == VectorType::FLAT_VECTOR)) {
 		D_ASSERT(!auxiliary);
 	}
-	if (GetType().InternalType() == PhysicalType::DOUBLE) {
-		// verify that there are no INF or NAN values
-		switch (GetVectorType()) {
-		case VectorType::CONSTANT_VECTOR: {
-			auto dbl = ConstantVector::GetData<double>(*this);
-			if (!ConstantVector::IsNull(*this)) {
-				D_ASSERT(Value::DoubleIsValid(*dbl));
-			}
-			break;
-		}
-		case VectorType::FLAT_VECTOR: {
-			auto doubles = FlatVector::GetData<double>(*this);
-			for (idx_t i = 0; i < count; i++) {
-				auto oidx = sel.get_index(i);
-				if (validity.RowIsValid(oidx)) {
-					D_ASSERT(Value::DoubleIsValid(doubles[oidx]));
-				}
-			}
-			break;
-		}
-		default:
-			break;
-		}
-	}
 	if (GetType().id() == LogicalTypeId::VARCHAR || GetType().id() == LogicalTypeId::JSON) {
 		// verify that there are no '\0' bytes in string values
 		switch (GetVectorType()) {
@@ -41763,11 +41770,23 @@ void LogicalType::Verify() const {
 }
 
 bool ApproxEqual(float ldecimal, float rdecimal) {
+	if (Value::IsNan(ldecimal) && Value::IsNan(rdecimal)) {
+		return true;
+	}
+	if (!Value::FloatIsFinite(ldecimal) || !Value::FloatIsFinite(rdecimal)) {
+		return ldecimal == rdecimal;
+	}
 	float epsilon = std::fabs(rdecimal) * 0.01;
 	return std::fabs(ldecimal - rdecimal) <= epsilon;
 }
 
 bool ApproxEqual(double ldecimal, double rdecimal) {
+	if (Value::IsNan(ldecimal) && Value::IsNan(rdecimal)) {
+		return true;
+	}
+	if (!Value::DoubleIsFinite(ldecimal) || !Value::DoubleIsFinite(rdecimal)) {
+		return ldecimal == rdecimal;
+	}
 	double epsilon = std::fabs(rdecimal) * 0.01;
 	return std::fabs(ldecimal - rdecimal) <= epsilon;
 }
@@ -42847,8 +42866,101 @@ void VectorOperations::Not(Vector &input, Vector &result, idx_t count) {
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/likely.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+#if __GNUC__
+#define DUCKDB_BUILTIN_EXPECT(cond, expected_value) (__builtin_expect(cond, expected_value))
+#else
+#define DUCKDB_BUILTIN_EXPECT(cond, expected_value) (cond)
+#endif
+
+#define DUCKDB_LIKELY(...)   DUCKDB_BUILTIN_EXPECT((__VA_ARGS__), 1)
+#define DUCKDB_UNLIKELY(...) DUCKDB_BUILTIN_EXPECT((__VA_ARGS__), 0)
+
+
 namespace duckdb {
 
+template <class T>
+bool EqualsFloat(T left, T right) {
+	if (DUCKDB_UNLIKELY(Value::IsNan(left) && Value::IsNan(right))) {
+		return true;
+	}
+	return left == right;
+}
+
+template <>
+bool Equals::Operation(float left, float right) {
+	return EqualsFloat<float>(left, right);
+}
+
+template <>
+bool Equals::Operation(double left, double right) {
+	return EqualsFloat<double>(left, right);
+}
+
+template <class T>
+bool GreaterThanFloat(T left, T right) {
+	// handle nans
+	// nan is always bigger than everything else
+	bool left_is_nan = Value::IsNan(left);
+	bool right_is_nan = Value::IsNan(right);
+	// if right is nan, there is no number that is bigger than right
+	if (DUCKDB_UNLIKELY(right_is_nan)) {
+		return false;
+	}
+	// if left is nan, but right is not, left is always bigger
+	if (DUCKDB_UNLIKELY(left_is_nan)) {
+		return true;
+	}
+	return left > right;
+}
+
+template <>
+bool GreaterThan::Operation(float left, float right) {
+	return GreaterThanFloat<float>(left, right);
+}
+
+template <>
+bool GreaterThan::Operation(double left, double right) {
+	return GreaterThanFloat<double>(left, right);
+}
+
+template <class T>
+bool GreaterThanEqualsFloat(T left, T right) {
+	// handle nans
+	// nan is always bigger than everything else
+	bool left_is_nan = Value::IsNan(left);
+	bool right_is_nan = Value::IsNan(right);
+	// if right is nan, there is no bigger number
+	// we only return true if left is also nan (in which case the numbers are equal)
+	if (DUCKDB_UNLIKELY(right_is_nan)) {
+		return left_is_nan;
+	}
+	// if left is nan, but right is not, left is always bigger
+	if (DUCKDB_UNLIKELY(left_is_nan)) {
+		return true;
+	}
+	return left >= right;
+}
+
+template <>
+bool GreaterThanEquals::Operation(float left, float right) {
+	return GreaterThanEqualsFloat<float>(left, right);
+}
+
+template <>
+bool GreaterThanEquals::Operation(double left, double right) {
+	return GreaterThanEqualsFloat<double>(left, right);
+}
+
 struct ComparisonSelector {
 	template <typename OP>
 	static idx_t Select(Vector &left, Vector &right, const SelectionVector *sel, idx_t count, SelectionVector *true_sel,
@@ -44696,24 +44808,6 @@ static bool DecimalCastSwitch(Vector &source, Vector &result, idx_t count, strin
 } // namespace duckdb
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/likely.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#if __GNUC__
-#define DUCKDB_BUILTIN_EXPECT(cond, expected_value) (__builtin_expect(cond, expected_value))
-#else
-#define DUCKDB_BUILTIN_EXPECT(cond, expected_value) (cond)
-#endif
-
-#define DUCKDB_LIKELY(...)   DUCKDB_BUILTIN_EXPECT((__VA_ARGS__), 1)
-#define DUCKDB_UNLIKELY(...) DUCKDB_BUILTIN_EXPECT((__VA_ARGS__), 0)
 
 
 namespace duckdb {
@@ -72380,7 +72474,7 @@ struct NumericAverageOperation : public BaseSumOperation<AverageSetOperation, Re
 		if (state->count == 0) {
 			mask.SetInvalid(idx);
 		} else {
-			if (!Value::DoubleIsValid(state->value)) {
+			if (!Value::DoubleIsFinite(state->value)) {
 				throw OutOfRangeException("AVG is out of range!");
 			}
 			target[idx] = (state->value / state->count);
@@ -72394,7 +72488,7 @@ struct KahanAverageOperation : public BaseSumOperation<AverageSetOperation, Kaha
 		if (state->count == 0) {
 			mask.SetInvalid(idx);
 		} else {
-			if (!Value::DoubleIsValid(state->value)) {
+			if (!Value::DoubleIsFinite(state->value)) {
 				throw OutOfRangeException("AVG is out of range!");
 			}
 			target[idx] = (state->value / state->count) + (state->err / state->count);
@@ -72638,7 +72732,7 @@ struct VarSampOperation : public STDDevBaseOperation {
 			mask.SetInvalid(idx);
 		} else {
 			target[idx] = state->dsquared / (state->count - 1);
-			if (!Value::DoubleIsValid(target[idx])) {
+			if (!Value::DoubleIsFinite(target[idx])) {
 				throw OutOfRangeException("VARSAMP is out of range!");
 			}
 		}
@@ -72652,7 +72746,7 @@ struct VarPopOperation : public STDDevBaseOperation {
 			mask.SetInvalid(idx);
 		} else {
 			target[idx] = state->count > 1 ? (state->dsquared / state->count) : 0;
-			if (!Value::DoubleIsValid(target[idx])) {
+			if (!Value::DoubleIsFinite(target[idx])) {
 				throw OutOfRangeException("VARPOP is out of range!");
 			}
 		}
@@ -72666,7 +72760,7 @@ struct STDDevSampOperation : public STDDevBaseOperation {
 			mask.SetInvalid(idx);
 		} else {
 			target[idx] = sqrt(state->dsquared / (state->count - 1));
-			if (!Value::DoubleIsValid(target[idx])) {
+			if (!Value::DoubleIsFinite(target[idx])) {
 				throw OutOfRangeException("STDDEV_SAMP is out of range!");
 			}
 		}
@@ -72680,7 +72774,7 @@ struct STDDevPopOperation : public STDDevBaseOperation {
 			mask.SetInvalid(idx);
 		} else {
 			target[idx] = state->count > 1 ? sqrt(state->dsquared / state->count) : 0;
-			if (!Value::DoubleIsValid(target[idx])) {
+			if (!Value::DoubleIsFinite(target[idx])) {
 				throw OutOfRangeException("STDDEV_POP is out of range!");
 			}
 		}
@@ -72694,7 +72788,7 @@ struct StandardErrorOfTheMeanOperation : public STDDevBaseOperation {
 			mask.SetInvalid(idx);
 		} else {
 			target[idx] = sqrt(state->dsquared / state->count) / sqrt((state->count));
-			if (!Value::DoubleIsValid(target[idx])) {
+			if (!Value::DoubleIsFinite(target[idx])) {
 				throw OutOfRangeException("SEM is out of range!");
 			}
 		}
@@ -72758,12 +72852,12 @@ struct CorrOperation {
 		} else {
 			auto cov = state->cov_pop.co_moment / state->cov_pop.count;
 			auto std_x = state->dev_pop_x.count > 1 ? sqrt(state->dev_pop_x.dsquared / state->dev_pop_x.count) : 0;
-			if (!Value::DoubleIsValid(std_x)) {
-				throw OutOfRangeException("STDDEV_POP for X is invalid!");
+			if (!Value::DoubleIsFinite(std_x)) {
+				throw OutOfRangeException("STDDEV_POP for X is out of range!");
 			}
 			auto std_y = state->dev_pop_y.count > 1 ? sqrt(state->dev_pop_y.dsquared / state->dev_pop_y.count) : 0;
-			if (!Value::DoubleIsValid(std_y)) {
-				throw OutOfRangeException("STDDEV_POP for Y is invalid!");
+			if (!Value::DoubleIsFinite(std_y)) {
+				throw OutOfRangeException("STDDEV_POP for Y is out of range!");
 			}
 			if (std_x * std_y == 0) {
 				mask.SetInvalid(idx);
@@ -74327,8 +74421,8 @@ struct KurtosisOperation {
 			mask.SetInvalid(idx);
 		} // LCOV_EXCL_STOP
 		target[idx] = (n - 1) * ((n + 1) * m4 / (m2 * m2) - 3 * (n - 1)) / ((n - 2) * (n - 3));
-		if (!Value::DoubleIsValid(target[idx])) {
-			mask.SetInvalid(idx);
+		if (!Value::DoubleIsFinite(target[idx])) {
+			throw OutOfRangeException("Kurtosis is out of range!");
 		}
 	}
 
@@ -75041,8 +75135,8 @@ struct SkewnessOperation {
 		target[idx] = temp1 * temp *
 		              (state->sum_cub - 3 * state->sum_sqr * state->sum * temp + 2 * pow(state->sum, 3) * temp * temp) /
 		              div;
-		if (!Value::DoubleIsValid(target[idx])) {
-			mask.SetInvalid(idx);
+		if (!Value::DoubleIsFinite(target[idx])) {
+			throw OutOfRangeException("SKEW is out of range!");
 		}
 	}
 
@@ -75251,7 +75345,7 @@ struct DoubleSumOperation : public BaseSumOperation<SumSetOperation, ADD_OPERATO
 		if (!state->isset) {
 			mask.SetInvalid(idx);
 		} else {
-			if (!Value::DoubleIsValid(state->value)) {
+			if (!Value::DoubleIsFinite(state->value)) {
 				throw OutOfRangeException("SUM is out of range!");
 			}
 			target[idx] = state->value;
@@ -78931,7 +79025,7 @@ struct RegrSlopeOperation {
 		} else {
 			auto cov = state->cov_pop.co_moment / state->cov_pop.count;
 			auto var_pop = state->var_pop.count > 1 ? (state->var_pop.dsquared / state->var_pop.count) : 0;
-			if (!Value::DoubleIsValid(var_pop)) {
+			if (!Value::DoubleIsFinite(var_pop)) {
 				throw OutOfRangeException("VARPOP is out of range!");
 			}
 			if (var_pop == 0) {
@@ -79056,7 +79150,7 @@ struct RegrR2Operation {
 	template <class T, class STATE>
 	static void Finalize(Vector &result, FunctionData *fd, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		auto var_pop_x = state->var_pop_x.count > 1 ? (state->var_pop_x.dsquared / state->var_pop_x.count) : 0;
-		if (!Value::DoubleIsValid(var_pop_x)) {
+		if (!Value::DoubleIsFinite(var_pop_x)) {
 			throw OutOfRangeException("VARPOP(X) is out of range!");
 		}
 		if (var_pop_x == 0) {
@@ -79064,7 +79158,7 @@ struct RegrR2Operation {
 			return;
 		}
 		auto var_pop_y = state->var_pop_y.count > 1 ? (state->var_pop_y.dsquared / state->var_pop_y.count) : 0;
-		if (!Value::DoubleIsValid(var_pop_y)) {
+		if (!Value::DoubleIsFinite(var_pop_y)) {
 			throw OutOfRangeException("VARPOP(Y) is out of range!");
 		}
 		if (var_pop_y == 0) {
@@ -79145,7 +79239,7 @@ struct RegrBaseOperation {
 			return;
 		}
 		auto var_pop = state->var_pop.count > 1 ? (state->var_pop.dsquared / state->var_pop.count) : 0;
-		if (!Value::DoubleIsValid(var_pop)) {
+		if (!Value::DoubleIsFinite(var_pop)) {
 			throw OutOfRangeException("VARPOP is out of range!");
 		}
 		RegrCountFunction::Finalize<T, size_t>(result, fd, &state->count, target, mask, idx);
@@ -84693,12 +84787,13 @@ struct StrfTimeBindData : public FunctionData {
 	}
 };
 
+template <bool REVERSED>
 static unique_ptr<FunctionData> StrfTimeBindFunction(ClientContext &context, ScalarFunction &bound_function,
                                                      vector<unique_ptr<Expression>> &arguments) {
 	if (!arguments[1]->IsFoldable()) {
 		throw InvalidInputException("strftime format must be a constant");
 	}
-	Value options_str = ExpressionExecutor::EvaluateScalar(*arguments[1]);
+	Value options_str = ExpressionExecutor::EvaluateScalar(*arguments[REVERSED ? 0 : 1]);
 	StrfTimeFormat format;
 	if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
 		auto format_string = options_str.GetValue<string>();
@@ -84710,16 +84805,17 @@ static unique_ptr<FunctionData> StrfTimeBindFunction(ClientContext &context, Sca
 	return make_unique<StrfTimeBindData>(format);
 }
 
+template <bool REVERSED>
 static void StrfTimeFunctionDate(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = (BoundFunctionExpression &)state.expr;
 	auto &info = (StrfTimeBindData &)*func_expr.bind_info;
 
-	if (ConstantVector::IsNull(args.data[1])) {
+	if (ConstantVector::IsNull(args.data[REVERSED ? 0 : 1])) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 		ConstantVector::SetNull(result, true);
 		return;
 	}
-	UnaryExecutor::Execute<date_t, string_t>(args.data[0], result, args.size(), [&](date_t input) {
+	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);
 		string_t target = StringVector::EmptyString(result, len);
@@ -84729,36 +84825,44 @@ static void StrfTimeFunctionDate(DataChunk &args, ExpressionState &state, Vector
 	});
 }
 
+template <bool REVERSED>
 static void StrfTimeFunctionTimestamp(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = (BoundFunctionExpression &)state.expr;
 	auto &info = (StrfTimeBindData &)*func_expr.bind_info;
 
-	if (ConstantVector::IsNull(args.data[1])) {
+	if (ConstantVector::IsNull(args.data[REVERSED ? 0 : 1])) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 		ConstantVector::SetNull(result, true);
 		return;
 	}
 
-	UnaryExecutor::Execute<timestamp_t, string_t>(args.data[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);
-		string_t target = StringVector::EmptyString(result, len);
-		info.format.FormatString(date, time, target.GetDataWriteable());
-		target.Finalize();
-		return target;
-	});
+	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);
+		                                              string_t target = StringVector::EmptyString(result, len);
+		                                              info.format.FormatString(date, time, target.GetDataWriteable());
+		                                              target.Finalize();
+		                                              return target;
+	                                              });
 }
 
 void StrfTimeFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet strftime("strftime");
 
 	strftime.AddFunction(ScalarFunction({LogicalType::DATE, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionDate, false, StrfTimeBindFunction));
+	                                    StrfTimeFunctionDate<false>, false, StrfTimeBindFunction<false>));
 
 	strftime.AddFunction(ScalarFunction({LogicalType::TIMESTAMP, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionTimestamp, false, StrfTimeBindFunction));
+	                                    StrfTimeFunctionTimestamp<false>, false, StrfTimeBindFunction<false>));
+
+	strftime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::VARCHAR,
+	                                    StrfTimeFunctionDate<true>, false, StrfTimeBindFunction<true>));
+
+	strftime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::VARCHAR,
+	                                    StrfTimeFunctionTimestamp<true>, false, StrfTimeBindFunction<true>));
 
 	set.AddFunction(strftime);
 }
@@ -87750,6 +87854,18 @@ struct EvenFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct IsNanFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct IsInfiniteFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct IsFiniteFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 } // namespace duckdb
 
 
@@ -87808,6 +87924,7 @@ struct Atan2Fun {
 
 
 
+
 #include <cmath>
 #include <errno.h>
 
@@ -87838,51 +87955,6 @@ static scalar_function_t GetScalarIntegerUnaryFunctionFixedReturn(const LogicalT
 	return function;
 }
 
-template <class OP>
-struct UnaryDoubleWrapper {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		RESULT_TYPE result = OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input);
-		if (std::isnan(result) || std::isinf(result) || errno != 0) {
-			errno = 0;
-			mask.SetInvalid(idx);
-			return 0;
-		}
-		return result;
-	}
-};
-
-template <class T, class OP>
-static void UnaryDoubleFunctionWrapper(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() >= 1);
-	errno = 0;
-	UnaryExecutor::GenericExecute<T, T, UnaryDoubleWrapper<OP>>(input.data[0], result, input.size(), nullptr, true);
-}
-
-struct BinaryDoubleWrapper {
-	template <class FUNC, class OP, class TA, class TB, class TR>
-	static inline TR Operation(FUNC fun, TA left, TB right, ValidityMask &mask, idx_t idx) {
-		TR result = OP::template Operation<TA, TB, TR>(left, right);
-		if (std::isnan(result) || std::isinf(result) || errno != 0) {
-			errno = 0;
-			mask.SetInvalid(idx);
-			return 0;
-		}
-		return result;
-	}
-
-	static bool AddsNulls() {
-		return true;
-	}
-};
-
-template <class T, class OP>
-static void BinaryDoubleFunctionWrapper(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() >= 2);
-	errno = 0;
-	BinaryExecutor::Execute<T, T, T, OP, BinaryDoubleWrapper>(input.data[0], input.data[1], result, input.size());
-}
-
 //===--------------------------------------------------------------------===//
 // nextafter
 //===--------------------------------------------------------------------===//
@@ -87903,23 +87975,14 @@ struct NextAfterOperator {
 	}
 };
 
-unique_ptr<FunctionData> BindNextAfter(ClientContext &context, ScalarFunction &function,
-                                       vector<unique_ptr<Expression>> &arguments) {
-	if ((arguments[0]->return_type != arguments[1]->return_type) ||
-	    (arguments[0]->return_type != LogicalType::FLOAT && arguments[0]->return_type != LogicalType::DOUBLE)) {
-		throw NotImplementedException("Unimplemented type for NextAfter Function");
-	}
-	return nullptr;
-}
-
 void NextAfterFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet next_after_fun("nextafter");
 	next_after_fun.AddFunction(
 	    ScalarFunction("nextafter", {LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                   BinaryDoubleFunctionWrapper<double, NextAfterOperator>, false, BindNextAfter));
+	                   ScalarFunction::BinaryFunction<double, double, double, NextAfterOperator>, false));
 	next_after_fun.AddFunction(ScalarFunction("nextafter", {LogicalType::FLOAT, LogicalType::FLOAT}, LogicalType::FLOAT,
-	                                          BinaryDoubleFunctionWrapper<float, NextAfterOperator>, false,
-	                                          BindNextAfter));
+	                                          ScalarFunction::BinaryFunction<float, float, float, NextAfterOperator>,
+	                                          false));
 	set.AddFunction(next_after_fun);
 }
 
@@ -87996,10 +88059,10 @@ void BitCountFun::RegisterFunction(BuiltinFunctions &set) {
 //===--------------------------------------------------------------------===//
 struct SignOperator {
 	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		if (left == TA(0)) {
+	static TR Operation(TA input) {
+		if (input == TA(0)) {
 			return 0;
-		} else if (left > TA(0)) {
+		} else if (input > TA(0)) {
 			return 1;
 		} else {
 			return -1;
@@ -88007,6 +88070,28 @@ struct SignOperator {
 	}
 };
 
+template <>
+int8_t SignOperator::Operation(float input) {
+	if (input == 0 || Value::IsNan(input)) {
+		return 0;
+	} else if (input > 0) {
+		return 1;
+	} else {
+		return -1;
+	}
+}
+
+template <>
+int8_t SignOperator::Operation(double input) {
+	if (input == 0 || Value::IsNan(input)) {
+		return 0;
+	} else if (input > 0) {
+		return 1;
+	} else {
+		return -1;
+	}
+}
+
 void SignFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet sign("sign");
 	for (auto &type : LogicalType::Numeric()) {
@@ -88386,7 +88471,7 @@ struct ExpOperator {
 
 void ExpFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(ScalarFunction("exp", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               UnaryDoubleFunctionWrapper<double, ExpOperator>));
+	                               ScalarFunction::UnaryFunction<double, double, ExpOperator>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88401,7 +88486,7 @@ struct PowOperator {
 
 void PowFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunction power_function("pow", {LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                              BinaryDoubleFunctionWrapper<double, PowOperator>);
+	                              ScalarFunction::BinaryFunction<double, double, double, PowOperator>);
 	set.AddFunction(power_function);
 	power_function.name = "power";
 	set.AddFunction(power_function);
@@ -88416,14 +88501,17 @@ void PowFun::RegisterFunction(BuiltinFunctions &set) {
 //===--------------------------------------------------------------------===//
 struct SqrtOperator {
 	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return std::sqrt(left);
+	static inline TR Operation(TA input) {
+		if (input < 0) {
+			throw OutOfRangeException("cannot take square root of a negative number");
+		}
+		return std::sqrt(input);
 	}
 };
 
 void SqrtFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(ScalarFunction("sqrt", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               UnaryDoubleFunctionWrapper<double, SqrtOperator>));
+	                               ScalarFunction::UnaryFunction<double, double, SqrtOperator>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88438,7 +88526,7 @@ struct CbRtOperator {
 
 void CbrtFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(ScalarFunction("cbrt", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               UnaryDoubleFunctionWrapper<double, CbRtOperator>));
+	                               ScalarFunction::UnaryFunction<double, double, CbRtOperator>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88447,14 +88535,20 @@ void CbrtFun::RegisterFunction(BuiltinFunctions &set) {
 
 struct LnOperator {
 	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return std::log(left);
+	static inline TR Operation(TA input) {
+		if (input < 0) {
+			throw OutOfRangeException("cannot take logarithm of a negative number");
+		}
+		if (input == 0) {
+			throw OutOfRangeException("cannot take logarithm of zero");
+		}
+		return std::log(input);
 	}
 };
 
 void LnFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(ScalarFunction("ln", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               UnaryDoubleFunctionWrapper<double, LnOperator>));
+	                               ScalarFunction::UnaryFunction<double, double, LnOperator>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88462,14 +88556,20 @@ void LnFun::RegisterFunction(BuiltinFunctions &set) {
 //===--------------------------------------------------------------------===//
 struct Log10Operator {
 	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return std::log10(left);
+	static inline TR Operation(TA input) {
+		if (input < 0) {
+			throw OutOfRangeException("cannot take logarithm of a negative number");
+		}
+		if (input == 0) {
+			throw OutOfRangeException("cannot take logarithm of zero");
+		}
+		return std::log10(input);
 	}
 };
 
 void Log10Fun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction({"log10", "log"}, ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                                                 UnaryDoubleFunctionWrapper<double, Log10Operator>));
+	                                                 ScalarFunction::UnaryFunction<double, double, Log10Operator>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88477,14 +88577,20 @@ void Log10Fun::RegisterFunction(BuiltinFunctions &set) {
 //===--------------------------------------------------------------------===//
 struct Log2Operator {
 	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return std::log2(left);
+	static inline TR Operation(TA input) {
+		if (input < 0) {
+			throw OutOfRangeException("cannot take logarithm of a negative number");
+		}
+		if (input == 0) {
+			throw OutOfRangeException("cannot take logarithm of zero");
+		}
+		return std::log2(input);
 	}
 };
 
 void Log2Fun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(ScalarFunction("log2", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               UnaryDoubleFunctionWrapper<double, Log2Operator>));
+	                               ScalarFunction::UnaryFunction<double, double, Log2Operator>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88512,7 +88618,7 @@ struct DegreesOperator {
 
 void DegreesFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(ScalarFunction("degrees", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               UnaryDoubleFunctionWrapper<double, DegreesOperator>));
+	                               ScalarFunction::UnaryFunction<double, double, DegreesOperator>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88527,12 +88633,83 @@ struct RadiansOperator {
 
 void RadiansFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(ScalarFunction("radians", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               UnaryDoubleFunctionWrapper<double, RadiansOperator>));
+	                               ScalarFunction::UnaryFunction<double, double, RadiansOperator>));
+}
+
+//===--------------------------------------------------------------------===//
+// isnan
+//===--------------------------------------------------------------------===//
+struct IsNanOperator {
+	template <class TA, class TR>
+	static inline TR Operation(TA input) {
+		return Value::IsNan(input);
+	}
+};
+
+void IsNanFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet funcs("isnan");
+	funcs.AddFunction(ScalarFunction({LogicalType::FLOAT}, LogicalType::BOOLEAN,
+	                                 ScalarFunction::UnaryFunction<float, bool, IsNanOperator>));
+	funcs.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::BOOLEAN,
+	                                 ScalarFunction::UnaryFunction<double, bool, IsNanOperator>));
+	set.AddFunction(funcs);
+}
+
+//===--------------------------------------------------------------------===//
+// isinf
+//===--------------------------------------------------------------------===//
+struct IsInfiniteOperator {
+	template <class TA, class TR>
+	static inline TR Operation(TA input) {
+		return !Value::IsNan(input) && !Value::IsFinite(input);
+	}
+};
+
+void IsInfiniteFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet funcs("isinf");
+	funcs.AddFunction(ScalarFunction({LogicalType::FLOAT}, LogicalType::BOOLEAN,
+	                                 ScalarFunction::UnaryFunction<float, bool, IsInfiniteOperator>));
+	funcs.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::BOOLEAN,
+	                                 ScalarFunction::UnaryFunction<double, bool, IsInfiniteOperator>));
+	set.AddFunction(funcs);
+}
+
+//===--------------------------------------------------------------------===//
+// isfinite
+//===--------------------------------------------------------------------===//
+struct IsFiniteOperator {
+	template <class TA, class TR>
+	static inline TR Operation(TA input) {
+		return Value::IsFinite(input);
+	}
+};
+
+void IsFiniteFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet funcs("isfinite");
+	funcs.AddFunction(ScalarFunction({LogicalType::FLOAT}, LogicalType::BOOLEAN,
+	                                 ScalarFunction::UnaryFunction<float, bool, IsFiniteOperator>));
+	funcs.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::BOOLEAN,
+	                                 ScalarFunction::UnaryFunction<double, bool, IsFiniteOperator>));
+	set.AddFunction(funcs);
 }
 
 //===--------------------------------------------------------------------===//
 // sin
 //===--------------------------------------------------------------------===//
+template <class OP>
+struct NoInfiniteDoubleWrapper {
+	template <class INPUT_TYPE, class RESULT_TYPE>
+	static RESULT_TYPE Operation(INPUT_TYPE input) {
+		if (DUCKDB_UNLIKELY(!Value::IsFinite(input))) {
+			if (Value::IsNan(input)) {
+				return input;
+			}
+			throw OutOfRangeException("input value %lf is out of range for numeric function", input);
+		}
+		return OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input);
+	}
+};
+
 struct SinOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -88541,8 +88718,9 @@ struct SinOperator {
 };
 
 void SinFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("sin", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               UnaryDoubleFunctionWrapper<double, SinOperator>));
+	set.AddFunction(
+	    ScalarFunction("sin", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
+	                   ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<SinOperator>>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88556,8 +88734,9 @@ struct CosOperator {
 };
 
 void CosFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("cos", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               UnaryDoubleFunctionWrapper<double, CosOperator>));
+	set.AddFunction(
+	    ScalarFunction("cos", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
+	                   ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<CosOperator>>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88571,8 +88750,9 @@ struct TanOperator {
 };
 
 void TanFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("tan", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               UnaryDoubleFunctionWrapper<double, TanOperator>));
+	set.AddFunction(
+	    ScalarFunction("tan", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
+	                   ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<TanOperator>>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88589,8 +88769,9 @@ struct ASinOperator {
 };
 
 void AsinFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("asin", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               UnaryDoubleFunctionWrapper<double, ASinOperator>));
+	set.AddFunction(
+	    ScalarFunction("asin", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
+	                   ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<ASinOperator>>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88605,7 +88786,7 @@ struct ATanOperator {
 
 void AtanFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(ScalarFunction("atan", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               UnaryDoubleFunctionWrapper<double, ATanOperator>));
+	                               ScalarFunction::UnaryFunction<double, double, ATanOperator>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88620,7 +88801,7 @@ struct ATan2 {
 
 void Atan2Fun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(ScalarFunction("atan2", {LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               BinaryDoubleFunctionWrapper<double, ATan2>));
+	                               ScalarFunction::BinaryFunction<double, double, double, ATan2>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88634,8 +88815,8 @@ struct ACos {
 };
 
 void AcosFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    ScalarFunction("acos", {LogicalType::DOUBLE}, LogicalType::DOUBLE, UnaryDoubleFunctionWrapper<double, ACos>));
+	set.AddFunction(ScalarFunction("acos", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
+	                               ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<ACos>>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88649,8 +88830,9 @@ struct CotOperator {
 };
 
 void CotFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("cot", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               UnaryDoubleFunctionWrapper<double, CotOperator>));
+	set.AddFunction(
+	    ScalarFunction("cot", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
+	                   ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<CotOperator>>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88658,14 +88840,17 @@ void CotFun::RegisterFunction(BuiltinFunctions &set) {
 //===--------------------------------------------------------------------===//
 struct GammaOperator {
 	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return std::tgamma(left);
+	static inline TR Operation(TA input) {
+		if (input == 0) {
+			throw OutOfRangeException("cannot take gamma of zero");
+		}
+		return std::tgamma(input);
 	}
 };
 
 void GammaFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(ScalarFunction("gamma", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               UnaryDoubleFunctionWrapper<double, GammaOperator>));
+	                               ScalarFunction::UnaryFunction<double, double, GammaOperator>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88673,14 +88858,17 @@ void GammaFun::RegisterFunction(BuiltinFunctions &set) {
 //===--------------------------------------------------------------------===//
 struct LogGammaOperator {
 	template <class TA, class TR>
-	static inline TR Operation(TA left) {
-		return std::lgamma(left);
+	static inline TR Operation(TA input) {
+		if (input == 0) {
+			throw OutOfRangeException("cannot take log gamma of zero");
+		}
+		return std::lgamma(input);
 	}
 };
 
 void LogGammaFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(ScalarFunction("lgamma", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               UnaryDoubleFunctionWrapper<double, LogGammaOperator>));
+	                               ScalarFunction::UnaryFunction<double, double, LogGammaOperator>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88730,7 +88918,7 @@ struct EvenOperator {
 
 void EvenFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(ScalarFunction("even", {LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                               UnaryDoubleFunctionWrapper<double, EvenOperator>));
+	                               ScalarFunction::UnaryFunction<double, double, EvenOperator>));
 }
 
 } // namespace duckdb
@@ -88870,6 +89058,10 @@ void BuiltinFunctions::RegisterMathFunctions() {
 	Register<NextAfterFun>();
 
 	Register<EvenFun>();
+
+	Register<IsNanFun>();
+	Register<IsInfiniteFun>();
+	Register<IsFiniteFun>();
 }
 
 } // namespace duckdb
@@ -88915,7 +89107,7 @@ namespace duckdb {
 template <>
 float AddOperator::Operation(float left, float right) {
 	auto result = left + right;
-	if (!Value::FloatIsValid(result)) {
+	if (!Value::FloatIsFinite(result)) {
 		throw OutOfRangeException("Overflow in addition of float!");
 	}
 	return result;
@@ -88924,7 +89116,7 @@ float AddOperator::Operation(float left, float right) {
 template <>
 double AddOperator::Operation(double left, double right) {
 	auto result = left + right;
-	if (!Value::DoubleIsValid(result)) {
+	if (!Value::DoubleIsFinite(result)) {
 		throw OutOfRangeException("Overflow in addition of double!");
 	}
 	return result;
@@ -89551,6 +89743,16 @@ struct NegateOperator {
 	}
 };
 
+template <>
+bool NegateOperator::CanNegate(float input) {
+	return Value::FloatIsFinite(input);
+}
+
+template <>
+bool NegateOperator::CanNegate(double input) {
+	return Value::DoubleIsFinite(input);
+}
+
 template <>
 interval_t NegateOperator::Operation(interval_t input) {
 	interval_t result;
@@ -89876,7 +90078,7 @@ void MultiplyFun::RegisterFunction(BuiltinFunctions &set) {
 template <>
 float DivideOperator::Operation(float left, float right) {
 	auto result = left / right;
-	if (!Value::FloatIsValid(result)) {
+	if (!Value::FloatIsFinite(result)) {
 		throw OutOfRangeException("Overflow in division of float!");
 	}
 	return result;
@@ -89885,7 +90087,7 @@ float DivideOperator::Operation(float left, float right) {
 template <>
 double DivideOperator::Operation(double left, double right) {
 	auto result = left / right;
-	if (!Value::DoubleIsValid(result)) {
+	if (!Value::DoubleIsFinite(result)) {
 		throw OutOfRangeException("Overflow in division of double!");
 	}
 	return result;
@@ -89997,13 +90199,21 @@ void DivideFun::RegisterFunction(BuiltinFunctions &set) {
 template <>
 float ModuloOperator::Operation(float left, float right) {
 	D_ASSERT(right != 0);
-	return std::fmod(left, right);
+	auto result = std::fmod(left, right);
+	if (!Value::FloatIsFinite(result)) {
+		throw OutOfRangeException("Overflow in modulo of float!");
+	}
+	return result;
 }
 
 template <>
 double ModuloOperator::Operation(double left, double right) {
 	D_ASSERT(right != 0);
-	return std::fmod(left, right);
+	auto result = std::fmod(left, right);
+	if (!Value::DoubleIsFinite(result)) {
+		throw OutOfRangeException("Overflow in modulo of double!");
+	}
+	return result;
 }
 
 template <>
@@ -90246,7 +90456,7 @@ namespace duckdb {
 template <>
 float MultiplyOperator::Operation(float left, float right) {
 	auto result = left * right;
-	if (!Value::FloatIsValid(result)) {
+	if (!Value::FloatIsFinite(result)) {
 		throw OutOfRangeException("Overflow in multiplication of float!");
 	}
 	return result;
@@ -90255,7 +90465,7 @@ float MultiplyOperator::Operation(float left, float right) {
 template <>
 double MultiplyOperator::Operation(double left, double right) {
 	auto result = left * right;
-	if (!Value::DoubleIsValid(result)) {
+	if (!Value::DoubleIsFinite(result)) {
 		throw OutOfRangeException("Overflow in multiplication of double!");
 	}
 	return result;
@@ -90479,7 +90689,7 @@ namespace duckdb {
 template <>
 float SubtractOperator::Operation(float left, float right) {
 	auto result = left - right;
-	if (!Value::FloatIsValid(result)) {
+	if (!Value::FloatIsFinite(result)) {
 		throw OutOfRangeException("Overflow in subtraction of float!");
 	}
 	return result;
@@ -90488,7 +90698,7 @@ float SubtractOperator::Operation(float left, float right) {
 template <>
 double SubtractOperator::Operation(double left, double right) {
 	auto result = left - right;
-	if (!Value::DoubleIsValid(result)) {
+	if (!Value::DoubleIsFinite(result)) {
 		throw OutOfRangeException("Overflow in subtraction of double!");
 	}
 	return result;
@@ -97190,6 +97400,7 @@ void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanState &scan
 	case LogicalTypeId::SMALLINT:
 	case LogicalTypeId::INTEGER:
 	case LogicalTypeId::FLOAT:
+	case LogicalTypeId::DOUBLE:
 	case LogicalTypeId::UTINYINT:
 	case LogicalTypeId::USMALLINT:
 	case LogicalTypeId::UINTEGER:
@@ -97203,18 +97414,6 @@ void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanState &scan
 		DirectConversion(vector, array, scan_state, nested_offset);
 		break;
 	}
-	case LogicalTypeId::DOUBLE: {
-		DirectConversion(vector, array, scan_state, nested_offset);
-		//! Need to check if there are NaNs, if yes, must turn that to null
-		auto data = (double *)vector.GetData();
-		auto &mask = FlatVector::Validity(vector);
-		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-			if (!Value::DoubleIsValid(data[row_idx])) {
-				mask.SetInvalid(row_idx);
-			}
-		}
-		break;
-	}
 	case LogicalTypeId::JSON:
 	case LogicalTypeId::VARCHAR: {
 		auto original_type = arrow_convert_data[col_idx]->variable_sz_type[arrow_convert_idx.first++];
@@ -102200,6 +102399,8 @@ void PragmaTableInfo::RegisterFunction(BuiltinFunctions &set) {
 } // namespace duckdb
 
 
+#include <cmath>
+#include <limits>
 
 namespace duckdb {
 
@@ -102302,6 +102503,13 @@ static vector<TestType> GetTestTypes() {
 	                             Value(LogicalType::INTEGER), Value::INTEGER(-42)});
 	result.emplace_back(int_list_type, "int_array", empty_int_list, int_list);
 
+	auto double_list_type = LogicalType::LIST(LogicalType::DOUBLE);
+	auto empty_double_list = Value::EMPTYLIST(LogicalType::DOUBLE);
+	auto double_list = Value::LIST(
+	    {Value::DOUBLE(42), Value::DOUBLE(NAN), Value::DOUBLE(std::numeric_limits<double>::infinity()),
+	     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 varchar_list_type = LogicalType::LIST(LogicalType::VARCHAR);
 	auto empty_varchar_list = Value::EMPTYLIST(LogicalType::VARCHAR);
 	auto varchar_list =
@@ -103339,17 +103547,11 @@ void BaseAppender::Append(string_t value) {
 
 template <>
 void BaseAppender::Append(float value) {
-	if (!Value::FloatIsValid(value)) {
-		throw InvalidInputException("Float value is out of range!");
-	}
 	AppendValueInternal<float>(value);
 }
 
 template <>
 void BaseAppender::Append(double value) {
-	if (!Value::DoubleIsValid(value)) {
-		throw InvalidInputException("Double value is out of range!");
-	}
 	AppendValueInternal<double>(value);
 }
 
@@ -104435,7 +104637,7 @@ double duckdb_hugeint_to_double(duckdb_hugeint val) {
 
 duckdb_hugeint duckdb_double_to_hugeint(double val) {
 	hugeint_t internal_result;
-	if (!Value::DoubleIsValid(val) || !Hugeint::TryConvert<double>(val, internal_result)) {
+	if (!Value::DoubleIsFinite(val) || !Hugeint::TryConvert<double>(val, internal_result)) {
 		internal_result.lower = 0;
 		internal_result.upper = 0;
 	}
@@ -104725,16 +104927,10 @@ duckdb_state duckdb_bind_uint64(duckdb_prepared_statement prepared_statement, id
 }
 
 duckdb_state duckdb_bind_float(duckdb_prepared_statement prepared_statement, idx_t param_idx, float val) {
-	if (!Value::FloatIsValid(val)) {
-		return DuckDBError;
-	}
 	return duckdb_bind_value(prepared_statement, param_idx, Value::FLOAT(val));
 }
 
 duckdb_state duckdb_bind_double(duckdb_prepared_statement prepared_statement, idx_t param_idx, double val) {
-	if (!Value::DoubleIsValid(val)) {
-		return DuckDBError;
-	}
 	return duckdb_bind_value(prepared_statement, param_idx, Value::DOUBLE(val));
 }
 
@@ -117960,7 +118156,7 @@ void OperatorProfiler::AddTiming(const PhysicalOperator *op, double time, idx_t
 	if (!enabled) {
 		return;
 	}
-	if (!Value::DoubleIsValid(time)) {
+	if (!Value::DoubleIsFinite(time)) {
 		return;
 	}
 	auto entry = timings.find(op);
@@ -146715,9 +146911,6 @@ unique_ptr<ConstantExpression> Transformer::TransformValue(duckdb_libpgquery::PG
 		}
 		// if there is a decimal or the value is too big to cast as either hugeint or bigint
 		double dbl_value = Cast::Operation<string_t, double>(str_val);
-		if (!Value::DoubleIsValid(dbl_value)) {
-			throw ParserException("Double value \"%s\" is out of range!", val.val.str);
-		}
 		return make_unique<ConstantExpression>(Value::DOUBLE(dbl_value));
 	}
 	case duckdb_libpgquery::T_PGNull:
@@ -164173,6 +164366,7 @@ void WriteOverflowStringsToDisk::AllocateNewBlock(block_id_t new_block_id) {
 
 
 
+
 
 
 namespace duckdb {
@@ -164322,38 +164516,41 @@ void CheckpointManager::WriteSchema(SchemaCatalogEntry &schema) {
 		}
 	});
 
+	FieldWriter writer(*metadata_writer);
+	writer.WriteField<uint32_t>(custom_types.size());
+	writer.WriteField<uint32_t>(sequences.size());
+	writer.WriteField<uint32_t>(tables.size());
+	writer.WriteField<uint32_t>(views.size());
+	writer.WriteField<uint32_t>(macros.size());
+	writer.WriteField<uint32_t>(table_macros.size());
+	writer.Finalize();
+
 	// write the custom_types
-	metadata_writer->Write<uint32_t>(custom_types.size());
 	for (auto &custom_type : custom_types) {
 		WriteType(*custom_type);
 	}
 
 	// write the sequences
-	metadata_writer->Write<uint32_t>(sequences.size());
 	for (auto &seq : sequences) {
 		WriteSequence(*seq);
 	}
 	// reorder tables because of foreign key constraint
 	ReorderTableEntries(tables);
 	// now write the tables
-	metadata_writer->Write<uint32_t>(tables.size());
 	for (auto &table : tables) {
 		WriteTable(*table);
 	}
 	// now write the views
-	metadata_writer->Write<uint32_t>(views.size());
 	for (auto &view : views) {
 		WriteView(*view);
 	}
 
 	// finally write the macro's
-	metadata_writer->Write<uint32_t>(macros.size());
 	for (auto &macro : macros) {
 		WriteMacro(*macro);
 	}
 
 	// finally write the macro's
-	metadata_writer->Write<uint32_t>(table_macros.size());
 	for (auto &macro : table_macros) {
 		WriteTableMacro(*macro);
 	}
@@ -164368,35 +164565,39 @@ void CheckpointManager::ReadSchema(ClientContext &context, MetaBlockReader &read
 	info->on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
 	catalog.CreateSchema(context, info.get());
 
+	// first read all the counts
+	FieldReader field_reader(reader);
+	uint32_t enum_count = field_reader.ReadRequired<uint32_t>();
+	uint32_t seq_count = field_reader.ReadRequired<uint32_t>();
+	uint32_t table_count = field_reader.ReadRequired<uint32_t>();
+	uint32_t view_count = field_reader.ReadRequired<uint32_t>();
+	uint32_t macro_count = field_reader.ReadRequired<uint32_t>();
+	uint32_t table_macro_count = field_reader.ReadRequired<uint32_t>();
+	field_reader.Finalize();
+
 	// now read the enums
-	uint32_t enum_count = reader.Read<uint32_t>();
 	for (uint32_t i = 0; i < enum_count; i++) {
 		ReadType(context, reader);
 	}
 
 	// read the sequences
-	uint32_t seq_count = reader.Read<uint32_t>();
 	for (uint32_t i = 0; i < seq_count; i++) {
 		ReadSequence(context, reader);
 	}
 	// read the table count and recreate the tables
-	uint32_t table_count = reader.Read<uint32_t>();
 	for (uint32_t i = 0; i < table_count; i++) {
 		ReadTable(context, reader);
 	}
 	// now read the views
-	uint32_t view_count = reader.Read<uint32_t>();
 	for (uint32_t i = 0; i < view_count; i++) {
 		ReadView(context, reader);
 	}
 
 	// finally read the macro's
-	uint32_t macro_count = reader.Read<uint32_t>();
 	for (uint32_t i = 0; i < macro_count; i++) {
 		ReadMacro(context, reader);
 	}
 
-	uint32_t table_macro_count = reader.Read<uint32_t>();
 	for (uint32_t i = 0; i < table_macro_count; i++) {
 		ReadTableMacro(context, reader);
 	}
@@ -172777,7 +172978,7 @@ string ValidityStatistics::ToString() const {
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 32;
+const uint64_t VERSION_NUMBER = 33;
 
 } // namespace duckdb