duckdb 0.3.3-dev1232.0 → 0.3.3-dev1273.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 {
@@ -64051,14 +64145,15 @@ class DataTable;
 class PhysicalDelete : public PhysicalOperator {
 public:
 	PhysicalDelete(vector<LogicalType> types, TableCatalogEntry &tableref, DataTable &table, idx_t row_id_index,
-	               idx_t estimated_cardinality)
+	               idx_t estimated_cardinality, bool return_chunk)
 	    : PhysicalOperator(PhysicalOperatorType::DELETE_OPERATOR, move(types), estimated_cardinality),
-	      tableref(tableref), table(table), row_id_index(row_id_index) {
+	      tableref(tableref), table(table), row_id_index(row_id_index), return_chunk(return_chunk) {
 	}
 
 	TableCatalogEntry &tableref;
 	DataTable &table;
 	idx_t row_id_index;
+	bool return_chunk;
 
 public:
 	// Source interface
@@ -64069,6 +64164,7 @@ public:
 public:
 	// Sink interface
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
+	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
 	                    DataChunk &input) const override;
 
@@ -64088,6 +64184,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
@@ -64095,21 +64192,46 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 class DeleteGlobalState : public GlobalSinkState {
 public:
-	DeleteGlobalState() : deleted_count(0) {
+	DeleteGlobalState() : deleted_count(0), returned_chunk_count(0) {
 	}
 
 	mutex delete_lock;
 	idx_t deleted_count;
+	ChunkCollection return_chunk_collection;
+	idx_t returned_chunk_count;
+};
+
+class DeleteLocalState : public LocalSinkState {
+public:
+	explicit DeleteLocalState(const vector<LogicalType> &table_types) {
+		delete_chunk.Initialize(table_types);
+	}
+	DataChunk delete_chunk;
 };
 
 SinkResultType PhysicalDelete::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
                                     DataChunk &input) const {
 	auto &gstate = (DeleteGlobalState &)state;
+	auto &ustate = (DeleteLocalState &)lstate;
+
+	// get rows and
+	auto &transaction = Transaction::GetTransaction(context.client);
+	auto &row_identifiers = input.data[row_id_index];
+
+	vector<column_t> column_ids;
+	for (idx_t i = 0; i < table.column_definitions.size(); i++) {
+		column_ids.emplace_back(i);
+	};
+	auto cfs = ColumnFetchState();
 
-	// delete data in the base table
-	// the row ids are given to us as the last column of the child chunk
 	lock_guard<mutex> delete_guard(gstate.delete_lock);
-	gstate.deleted_count += table.Delete(tableref, context.client, input.data[row_id_index], input.size());
+	if (return_chunk) {
+		row_identifiers.Normalify(input.size());
+		table.Fetch(transaction, ustate.delete_chunk, column_ids, row_identifiers, input.size(), cfs);
+		gstate.return_chunk_collection.Append(ustate.delete_chunk);
+	}
+	gstate.deleted_count += table.Delete(tableref, context.client, row_identifiers, input.size());
+
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
@@ -64117,6 +64239,10 @@ unique_ptr<GlobalSinkState> PhysicalDelete::GetGlobalSinkState(ClientContext &co
 	return make_unique<DeleteGlobalState>();
 }
 
+unique_ptr<LocalSinkState> PhysicalDelete::GetLocalSinkState(ExecutionContext &context) const {
+	return make_unique<DeleteLocalState>(table.GetTypes());
+}
+
 //===--------------------------------------------------------------------===//
 // Source
 //===--------------------------------------------------------------------===//
@@ -64140,9 +64266,22 @@ void PhysicalDelete::GetData(ExecutionContext &context, DataChunk &chunk, Global
 		return;
 	}
 
-	chunk.SetCardinality(1);
-	chunk.SetValue(0, 0, Value::BIGINT(g.deleted_count));
-	state.finished = true;
+	if (!return_chunk) {
+		chunk.SetCardinality(1);
+		chunk.SetValue(0, 0, Value::BIGINT(g.deleted_count));
+		state.finished = true;
+	}
+
+	idx_t chunk_return = g.returned_chunk_count;
+	if (chunk_return >= g.return_chunk_collection.Chunks().size()) {
+		return;
+	}
+	chunk.Reference(g.return_chunk_collection.GetChunk(chunk_return));
+	chunk.SetCardinality((g.return_chunk_collection.GetChunk(chunk_return)).size());
+	g.returned_chunk_count += 1;
+	if (g.returned_chunk_count >= g.return_chunk_collection.Chunks().size()) {
+		state.finished = true;
+	}
 }
 
 } // namespace duckdb
@@ -64589,10 +64728,10 @@ class PhysicalUpdate : public PhysicalOperator {
 public:
 	PhysicalUpdate(vector<LogicalType> types, TableCatalogEntry &tableref, DataTable &table, vector<column_t> columns,
 	               vector<unique_ptr<Expression>> expressions, vector<unique_ptr<Expression>> bound_defaults,
-	               idx_t estimated_cardinality)
+	               idx_t estimated_cardinality, bool return_chunk)
 	    : PhysicalOperator(PhysicalOperatorType::UPDATE, move(types), estimated_cardinality), tableref(tableref),
 	      table(table), columns(std::move(columns)), expressions(move(expressions)),
-	      bound_defaults(move(bound_defaults)) {
+	      bound_defaults(move(bound_defaults)), return_chunk(return_chunk) {
 	}
 
 	TableCatalogEntry &tableref;
@@ -64601,6 +64740,8 @@ public:
 	vector<unique_ptr<Expression>> expressions;
 	vector<unique_ptr<Expression>> bound_defaults;
 	bool update_is_del_and_insert;
+	//! If the returning statement is present, return the whole chunk
+	bool return_chunk;
 
 public:
 	// Source interface
@@ -64634,6 +64775,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
@@ -64641,12 +64783,14 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 class UpdateGlobalState : public GlobalSinkState {
 public:
-	UpdateGlobalState() : updated_count(0) {
+	UpdateGlobalState() : updated_count(0), returned_chunk_count(0) {
 	}
 
 	mutex lock;
 	idx_t updated_count;
 	unordered_set<row_t> updated_columns;
+	ChunkCollection return_chunk_collection;
+	idx_t returned_chunk_count;
 };
 
 class UpdateLocalState : public LocalSinkState {
@@ -64726,9 +64870,21 @@ SinkResultType PhysicalUpdate::Sink(ExecutionContext &context, GlobalSinkState &
 		}
 		table.Append(tableref, context.client, mock_chunk);
 	} else {
+		if (return_chunk) {
+			mock_chunk.SetCardinality(update_chunk);
+			for (idx_t i = 0; i < columns.size(); i++) {
+				mock_chunk.data[columns[i]].Reference(update_chunk.data[i]);
+			}
+		}
 		table.Update(tableref, context.client, row_ids, columns, update_chunk);
 	}
+
+	if (return_chunk) {
+		gstate.return_chunk_collection.Append(mock_chunk);
+	}
+
 	gstate.updated_count += chunk.size();
+
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
@@ -64769,10 +64925,22 @@ void PhysicalUpdate::GetData(ExecutionContext &context, DataChunk &chunk, Global
 	if (state.finished) {
 		return;
 	}
+	if (!return_chunk) {
+		chunk.SetCardinality(1);
+		chunk.SetValue(0, 0, Value::BIGINT(g.updated_count));
+		state.finished = true;
+	}
 
-	chunk.SetCardinality(1);
-	chunk.SetValue(0, 0, Value::BIGINT(g.updated_count));
-	state.finished = true;
+	idx_t chunk_return = g.returned_chunk_count;
+	if (chunk_return >= g.return_chunk_collection.Chunks().size()) {
+		return;
+	}
+	chunk.Reference(g.return_chunk_collection.GetChunk(chunk_return));
+	chunk.SetCardinality((g.return_chunk_collection.GetChunk(chunk_return)).size());
+	g.returned_chunk_count += 1;
+	if (g.returned_chunk_count >= g.return_chunk_collection.Chunks().size()) {
+		state.finished = true;
+	}
 }
 
 } // namespace duckdb
@@ -68395,14 +68563,27 @@ namespace duckdb {
 class LogicalDelete : public LogicalOperator {
 public:
 	explicit LogicalDelete(TableCatalogEntry *table)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_DELETE), table(table) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_DELETE), table(table), table_index(0), return_chunk(false) {
 	}
 
 	TableCatalogEntry *table;
+	idx_t table_index;
+	bool return_chunk;
 
 protected:
+	vector<ColumnBinding> GetColumnBindings() override {
+		if (return_chunk) {
+			return GenerateColumnBindings(table_index, table->columns.size());
+		}
+		return {ColumnBinding(0, 0)};
+	}
+
 	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BIGINT);
+		if (return_chunk) {
+			types = table->GetTypes();
+		} else {
+			types.emplace_back(LogicalType::BIGINT);
+		}
 	}
 };
 } // namespace duckdb
@@ -68421,8 +68602,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelete &op
 	auto &bound_ref = (BoundReferenceExpression &)*op.expressions[0];
 
 	dependencies.insert(op.table);
-	auto del =
-	    make_unique<PhysicalDelete>(op.types, *op.table, *op.table->storage, bound_ref.index, op.estimated_cardinality);
+	auto del = make_unique<PhysicalDelete>(op.types, *op.table, *op.table->storage, bound_ref.index,
+	                                       op.estimated_cardinality, op.return_chunk);
 	del->children.push_back(move(plan));
 	return move(del);
 }
@@ -70711,17 +70892,33 @@ namespace duckdb {
 class LogicalUpdate : public LogicalOperator {
 public:
 	explicit LogicalUpdate(TableCatalogEntry *table)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_UPDATE), table(table) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_UPDATE), table(table), table_index(0), return_chunk(false) {
 	}
 
+	//! The base table to update
 	TableCatalogEntry *table;
+	//! table catalog index
+	idx_t table_index;
+	//! if returning option is used, return the update chunk
+	bool return_chunk;
 	vector<column_t> columns;
 	vector<unique_ptr<Expression>> bound_defaults;
 	bool update_is_del_and_insert;
 
 protected:
+	vector<ColumnBinding> GetColumnBindings() override {
+		if (return_chunk) {
+			return GenerateColumnBindings(table_index, table->columns.size());
+		}
+		return {ColumnBinding(0, 0)};
+	}
+
 	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BIGINT);
+		if (return_chunk) {
+			types = table->GetTypes();
+		} else {
+			types.emplace_back(LogicalType::BIGINT);
+		}
 	}
 };
 } // namespace duckdb
@@ -70736,7 +70933,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalUpdate &op
 
 	dependencies.insert(op.table);
 	auto update = make_unique<PhysicalUpdate>(op.types, *op.table, *op.table->storage, op.columns, move(op.expressions),
-	                                          move(op.bound_defaults), op.estimated_cardinality);
+	                                          move(op.bound_defaults), op.estimated_cardinality, op.return_chunk);
+
 	update->update_is_del_and_insert = op.update_is_del_and_insert;
 	update->children.push_back(move(plan));
 	return move(update);
@@ -72276,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);
@@ -72290,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);
@@ -72534,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!");
 			}
 		}
@@ -72548,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!");
 			}
 		}
@@ -72562,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!");
 			}
 		}
@@ -72576,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!");
 			}
 		}
@@ -72590,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!");
 			}
 		}
@@ -72654,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);
@@ -74223,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!");
 		}
 	}
 
@@ -74937,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!");
 		}
 	}
 
@@ -75147,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;
@@ -78827,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) {
@@ -78952,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) {
@@ -78960,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) {
@@ -79041,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);
@@ -84589,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>();
@@ -84606,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);
@@ -84625,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);
 }
@@ -87646,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
 
 
@@ -87704,6 +87924,7 @@ struct Atan2Fun {
 
 
 
+
 #include <cmath>
 #include <errno.h>
 
@@ -87734,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
 //===--------------------------------------------------------------------===//
@@ -87799,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);
 }
 
@@ -87892,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;
@@ -87903,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()) {
@@ -88282,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>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88297,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);
@@ -88312,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>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88334,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>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88343,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>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88358,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>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88373,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>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88408,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>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88423,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) {
@@ -88437,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>>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88452,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>>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88467,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>>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88485,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>>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88501,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>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88516,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>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88530,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>>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88545,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>>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88554,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>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88569,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>));
 }
 
 //===--------------------------------------------------------------------===//
@@ -88626,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
@@ -88766,6 +89058,10 @@ void BuiltinFunctions::RegisterMathFunctions() {
 	Register<NextAfterFun>();
 
 	Register<EvenFun>();
+
+	Register<IsNanFun>();
+	Register<IsInfiniteFun>();
+	Register<IsFiniteFun>();
 }
 
 } // namespace duckdb
@@ -88811,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;
@@ -88820,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;
@@ -89447,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;
@@ -89772,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;
@@ -89781,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;
@@ -89893,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 <>
@@ -90142,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;
@@ -90151,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;
@@ -90375,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;
@@ -90384,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;
@@ -97086,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:
@@ -97099,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++];
@@ -102096,6 +102399,8 @@ void PragmaTableInfo::RegisterFunction(BuiltinFunctions &set) {
 } // namespace duckdb
 
 
+#include <cmath>
+#include <limits>
 
 namespace duckdb {
 
@@ -102198,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 =
@@ -103235,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);
 }
 
@@ -104331,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;
 	}
@@ -104621,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));
 }
 
@@ -117856,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);
@@ -119089,6 +119389,7 @@ public:
 	unique_ptr<ParsedExpression> condition;
 	unique_ptr<TableRef> table;
 	vector<unique_ptr<TableRef>> using_clauses;
+	vector<unique_ptr<ParsedExpression>> returning_list;
 
 protected:
 	DeleteStatement(const DeleteStatement &other);
@@ -120393,6 +120694,8 @@ public:
 	unique_ptr<TableRef> from_table;
 	vector<string> columns;
 	vector<unique_ptr<ParsedExpression>> expressions;
+	//! keep track of optional returningList if statement contains a RETURNING keyword
+	vector<unique_ptr<ParsedExpression>> returning_list;
 
 protected:
 	UpdateStatement(const UpdateStatement &other);
@@ -127788,10 +128091,14 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 		remove.VisitOperator(*op.children[0]);
 		return;
 	}
-	case LogicalOperatorType::LOGICAL_INSERT: {
-		//! When RETURNING is used, a PROJECTION is the top level operator
-		//! We still need to project all values from the insert so the projection
-		//! on top of the INSERT can select from only that table values being inserted
+	case LogicalOperatorType::LOGICAL_INSERT:
+	case LogicalOperatorType::LOGICAL_UPDATE:
+	case LogicalOperatorType::LOGICAL_DELETE: {
+		//! When RETURNING is used, a PROJECTION is the top level operator for INSERTS, UPDATES, and DELETES
+		//! We still need to project all values from these operators so the projection
+		//! on top of them can select from only the table values being inserted.
+		//! TODO: Push down the projections from the returning statement
+		//! TODO: Be careful because you might be adding expressions when a user returns *
 		RemoveUnusedColumns remove(binder, context, true);
 		remove.VisitOperatorExpressions(op);
 		remove.VisitOperator(*op.children[0]);
@@ -146604,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:
@@ -149736,6 +150040,10 @@ unique_ptr<DeleteStatement> Transformer::TransformDelete(duckdb_libpgquery::PGNo
 			result->using_clauses.push_back(move(using_entry));
 		}
 	}
+
+	if (stmt->returningList) {
+		Transformer::TransformExpressionList(*(stmt->returningList), result->returning_list);
+	}
 	return result;
 }
 
@@ -150500,6 +150808,11 @@ unique_ptr<UpdateStatement> Transformer::TransformUpdate(duckdb_libpgquery::PGNo
 		result->expressions.push_back(TransformExpression(target->val));
 	}
 
+	// Grab and transform the returning columns from the parser.
+	if (stmt->returningList) {
+		Transformer::TransformExpressionList(*(stmt->returningList), result->returning_list);
+	}
+
 	result->condition = TransformExpression(stmt->whereClause);
 	return result;
 }
@@ -155700,6 +156013,32 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/expression_binder/returning_binder.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+//! The RETURNING binder is responsible for binding expressions within the RETURNING statement
+class ReturningBinder : public ExpressionBinder {
+public:
+	ReturningBinder(Binder &binder, ClientContext &context);
+
+protected:
+	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	                          bool root_expression = false) override;
+};
+
+} // namespace duckdb
+
 
 
 
@@ -155774,10 +156113,21 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 	    LogicalType::ROW_TYPE, ColumnBinding(get.table_index, get.column_ids.size())));
 	get.column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
 
-	result.plan = move(del);
-	result.names = {"Count"};
-	result.types = {LogicalType::BIGINT};
-	this->allow_stream_result = false;
+	if (!stmt.returning_list.empty()) {
+		del->return_chunk = true;
+
+		auto update_table_index = GenerateTableIndex();
+		del->table_index = update_table_index;
+
+		unique_ptr<LogicalOperator> del_as_logicaloperator = move(del);
+		return BindReturning(move(stmt.returning_list), table, update_table_index, move(del_as_logicaloperator),
+		                     move(result));
+	} else {
+		result.plan = move(del);
+		result.names = {"Count"};
+		result.types = {LogicalType::BIGINT};
+		this->allow_stream_result = false;
+	}
 	return result;
 }
 
@@ -156100,31 +156450,6 @@ protected:
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/returning_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! The RETURNING binder is responsible for binding expressions within the RETURNING statement
-class ReturningBinder : public ExpressionBinder {
-public:
-	ReturningBinder(Binder &binder, ClientContext &context);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-};
-
-} // namespace duckdb
 
 
 namespace duckdb {
@@ -156245,57 +156570,15 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 
 	if (!stmt.returning_list.empty()) {
 		insert->return_chunk = true;
-		// clear result type and names because returning list will update them
 		result.types.clear();
 		result.names.clear();
-
 		auto insert_table_index = GenerateTableIndex();
 		insert->table_index = insert_table_index;
+		unique_ptr<LogicalOperator> index_as_logicaloperator = move(insert);
 
-		auto binder = Binder::CreateBinder(context);
-		auto types = table->GetTypes();
-		vector<std::string> names;
-		for (auto &col : table->columns) {
-			names.push_back(col.name);
-		}
-
-		binder->bind_context.AddGenericBinding(insert->table_index, stmt.table, names, types);
-		ReturningBinder returning_binder(*binder, context);
-
-		unique_ptr<LogicalOperator> insert_as_logicaloperator = move(insert);
-
-		vector<unique_ptr<Expression>> projection_expressions;
-		LogicalType result_type;
-		for (auto &returning_expr : stmt.returning_list) {
-			auto expr_type = returning_expr->GetExpressionType();
-			if (expr_type == ExpressionType::STAR) {
-				auto generated_star_list = vector<unique_ptr<ParsedExpression>>();
-				binder->bind_context.GenerateAllColumnExpressions((StarExpression &)*returning_expr,
-				                                                  generated_star_list);
-
-				for (auto &star_column : generated_star_list) {
-					auto star_expr = returning_binder.Bind(star_column, &result_type);
-					result.types.push_back(result_type);
-					result.names.push_back(star_expr->GetName());
-					projection_expressions.push_back(move(star_expr));
-				}
-			} else {
-				auto expr = returning_binder.Bind(returning_expr, &result_type);
-				result.names.push_back(expr->GetName());
-				result.types.push_back(result_type);
-				projection_expressions.push_back(move(expr));
-			}
-		}
-
-		auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), move(projection_expressions));
-		projection->AddChild(move(insert_as_logicaloperator));
-		result.plan = move(projection);
-		D_ASSERT(result.types.size() == result.names.size());
-		this->allow_stream_result = true;
-		return result;
+		return BindReturning(move(stmt.returning_list), table, insert_table_index, move(index_as_logicaloperator),
+		                     move(result));
 	} else {
-		insert->table_index = 0;
-		insert->return_chunk = false;
 		D_ASSERT(result.types.size() == result.names.size());
 		result.plan = move(insert);
 		this->allow_stream_result = false;
@@ -156750,6 +157033,8 @@ static void BindUpdateConstraints(TableCatalogEntry &table, LogicalGet &get, Log
 	}
 	// for index updates we always turn any update into an insert and a delete
 	// we thus need all the columns to be available, hence we check if the update touches any index columns
+	// If the returning keyword is used, we need access to the whole row in case the user requests it.
+	// Therefore switch the update to a delete and insert.
 	update.update_is_del_and_insert = false;
 	table.storage->info->indexes.Scan([&](Index &index) {
 		if (index.IndexIsUpdated(update.columns)) {
@@ -156767,8 +157052,9 @@ static void BindUpdateConstraints(TableCatalogEntry &table, LogicalGet &get, Log
 		}
 	}
 
-	if (update.update_is_del_and_insert) {
-		// the update updates a column required by an index, push projections for all columns
+	if (update.update_is_del_and_insert || update.return_chunk) {
+		// the update updates a column required by an index or requires returning the updated rows,
+		// push projections for all columns
 		unordered_set<column_t> all_columns;
 		for (idx_t i = 0; i < table.storage->column_definitions.size(); i++) {
 			all_columns.insert(i);
@@ -156806,6 +157092,11 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 		this->read_only = false;
 	}
 	auto update = make_unique<LogicalUpdate>(table);
+
+	// set return_chunk boolean early because it needs uses update_is_del_and_insert logic
+	if (!stmt.returning_list.empty()) {
+		update->return_chunk = true;
+	}
 	// bind the default values
 	BindDefaultValues(table->columns, update->bound_defaults);
 
@@ -156824,6 +157115,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 
 	auto proj_index = GenerateTableIndex();
 	vector<unique_ptr<Expression>> projection_expressions;
+
 	for (idx_t i = 0; i < stmt.columns.size(); i++) {
 		auto &colname = stmt.columns[i];
 		auto &expr = stmt.expressions[i];
@@ -156849,6 +157141,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 			projection_expressions.push_back(move(bound_expr));
 		}
 	}
+
 	// now create the projection
 	auto proj = make_unique<LogicalProjection>(proj_index, move(projection_expressions));
 	proj->AddChild(move(root));
@@ -156864,10 +157157,21 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	// set the projection as child of the update node and finalize the result
 	update->AddChild(move(proj));
 
-	result.names = {"Count"};
-	result.types = {LogicalType::BIGINT};
-	result.plan = move(update);
-	this->allow_stream_result = false;
+	if (!stmt.returning_list.empty()) {
+		auto update_table_index = GenerateTableIndex();
+		update->table_index = update_table_index;
+		unique_ptr<LogicalOperator> update_as_logicaloperator = move(update);
+
+		return BindReturning(move(stmt.returning_list), table, update_table_index, move(update_as_logicaloperator),
+		                     move(result));
+
+	} else {
+		update->table_index = 0;
+		result.names = {"Count"};
+		result.types = {LogicalType::BIGINT};
+		result.plan = move(update);
+		this->allow_stream_result = false;
+	}
 	return result;
 }
 
@@ -158130,6 +158434,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableFunction &ref) {
 
 
 
+
 #include <algorithm>
 
 
@@ -158498,6 +158803,53 @@ string Binder::FormatErrorRecursive(idx_t query_location, const string &message,
 	return context.FormatErrorRecursive(message, values);
 }
 
+BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry *table,
+                                     idx_t update_table_index, unique_ptr<LogicalOperator> child_operator,
+                                     BoundStatement result) {
+
+	vector<LogicalType> types;
+	vector<std::string> names;
+
+	auto binder = Binder::CreateBinder(context);
+
+	for (auto &col : table->columns) {
+		names.push_back(col.name);
+		types.push_back(col.type);
+	}
+
+	binder->bind_context.AddGenericBinding(update_table_index, table->name, names, types);
+	ReturningBinder returning_binder(*binder, context);
+
+	vector<unique_ptr<Expression>> projection_expressions;
+	LogicalType result_type;
+	for (auto &returning_expr : returning_list) {
+		auto expr_type = returning_expr->GetExpressionType();
+		if (expr_type == ExpressionType::STAR) {
+			auto generated_star_list = vector<unique_ptr<ParsedExpression>>();
+			binder->bind_context.GenerateAllColumnExpressions((StarExpression &)*returning_expr, generated_star_list);
+
+			for (auto &star_column : generated_star_list) {
+				auto star_expr = returning_binder.Bind(star_column, &result_type);
+				result.types.push_back(result_type);
+				result.names.push_back(star_expr->GetName());
+				projection_expressions.push_back(move(star_expr));
+			}
+		} else {
+			auto expr = returning_binder.Bind(returning_expr, &result_type);
+			result.names.push_back(expr->GetName());
+			result.types.push_back(result_type);
+			projection_expressions.push_back(move(expr));
+		}
+	}
+
+	auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), move(projection_expressions));
+	projection->AddChild(move(child_operator));
+	D_ASSERT(result.types.size() == result.names.size());
+	result.plan = move(projection);
+	this->allow_stream_result = true;
+	return result;
+}
+
 } // namespace duckdb