duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/common/types/hugeint.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/common/types/hugeint.hpp"
+#include "duckdb/common/types/uhugeint.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/algorithm.hpp"
 #include "duckdb/common/hugeint.hpp"
@@ -56,6 +57,29 @@ const hugeint_t Hugeint::POWERS_OF_TEN[] {
     hugeint_t(1000000000000000000) * hugeint_t(1000000000000000000) * hugeint_t(10),
     hugeint_t(1000000000000000000) * hugeint_t(1000000000000000000) * hugeint_t(100)};
 
+//===--------------------------------------------------------------------===//
+// Negate
+//===--------------------------------------------------------------------===//
+
+template <>
+void Hugeint::NegateInPlace<false>(hugeint_t &input) {
+	input.lower = NumericLimits<uint64_t>::Maximum() - input.lower + 1;
+	input.upper = -1 - input.upper + (input.lower == 0);
+}
+
+bool Hugeint::TryNegate(hugeint_t input, hugeint_t &result) {
+	if (input.upper == NumericLimits<int64_t>::Minimum() && input.lower == 0) {
+		return false;
+	}
+	NegateInPlace<false>(input);
+	result = input;
+	return true;
+}
+
+//===--------------------------------------------------------------------===//
+// Divide
+//===--------------------------------------------------------------------===//
+
 static uint8_t PositiveHugeintHighestBit(hugeint_t bits) {
 	uint8_t out = 0;
 	if (bits.upper) {
@@ -83,7 +107,7 @@ static bool PositiveHugeintIsBitSet(hugeint_t lhs, uint8_t bit_position) {
 	}
 }
 
-hugeint_t PositiveHugeintLeftShift(hugeint_t lhs, uint32_t amount) {
+static hugeint_t PositiveHugeintLeftShift(hugeint_t lhs, uint32_t amount) {
 	D_ASSERT(amount > 0 && amount < 64);
 	hugeint_t result;
 	result.lower = lhs.lower << amount;
@@ -129,6 +153,9 @@ hugeint_t Hugeint::DivModPositive(hugeint_t lhs, uint64_t rhs, uint64_t &remaind
 string Hugeint::ToString(hugeint_t input) {
 	uint64_t remainder;
 	string result;
+	if (input == NumericLimits<hugeint_t>::Minimum()) {
+		return string(Hugeint::HUGEINT_MINIMUM_STRING);
+	}
 	bool negative = input.upper < 0;
 	if (negative) {
 		NegateInPlace(input);
@@ -150,15 +177,32 @@ string Hugeint::ToString(hugeint_t input) {
 //===--------------------------------------------------------------------===//
 // Multiply
 //===--------------------------------------------------------------------===//
+
+// Multiply with overflow checks
 bool Hugeint::TryMultiply(hugeint_t lhs, hugeint_t rhs, hugeint_t &result) {
+	// Check if one of the sides is hugeint_t minimum, as that can't be negated.
+	// You can only multiply the minimum by 0 or 1, any other value will result in overflow
+	if (lhs == NumericLimits<hugeint_t>::Minimum() || rhs == NumericLimits<hugeint_t>::Minimum()) {
+		if (lhs == 0 || rhs == 0) {
+			result = 0;
+			return true;
+		}
+		if (lhs == 1 || rhs == 1) {
+			result = NumericLimits<hugeint_t>::Minimum();
+			return true;
+		}
+		return false;
+	}
+
 	bool lhs_negative = lhs.upper < 0;
 	bool rhs_negative = rhs.upper < 0;
-	if (lhs_negative) {
-		NegateInPlace(lhs);
+	if (lhs_negative && !TryNegate(lhs, lhs)) {
+		return false;
 	}
-	if (rhs_negative) {
-		NegateInPlace(rhs);
+	if (rhs_negative && !TryNegate(rhs, rhs)) {
+		return false;
 	}
+
 #if ((__GNUC__ >= 5) || defined(__clang__)) && defined(__SIZEOF_INT128__)
 	__uint128_t left = __uint128_t(lhs.lower) + (__uint128_t(lhs.upper) << 64);
 	__uint128_t right = __uint128_t(rhs.lower) + (__uint128_t(rhs.upper) << 64);
@@ -241,15 +285,85 @@ bool Hugeint::TryMultiply(hugeint_t lhs, hugeint_t rhs, hugeint_t &result) {
 	result.upper = (first32 << 32) | second32;
 #endif
 	if (lhs_negative ^ rhs_negative) {
-		NegateInPlace(result);
+		NegateInPlace<false>(result);
 	}
 	return true;
 }
 
-hugeint_t Hugeint::Multiply(hugeint_t lhs, hugeint_t rhs) {
+// Multiply without overflow check
+template <>
+hugeint_t Hugeint::Multiply<false>(hugeint_t lhs, hugeint_t rhs) {
 	hugeint_t result;
-	if (!TryMultiply(lhs, rhs, result)) {
-		throw OutOfRangeException("Overflow in HUGEINT multiplication!");
+	bool lhs_negative = lhs.upper < 0;
+	bool rhs_negative = rhs.upper < 0;
+	if (lhs_negative) {
+		NegateInPlace<false>(lhs);
+	}
+	if (rhs_negative) {
+		NegateInPlace<false>(rhs);
+	}
+
+#if ((__GNUC__ >= 5) || defined(__clang__)) && defined(__SIZEOF_INT128__)
+	__uint128_t left = __uint128_t(lhs.lower) + (__uint128_t(lhs.upper) << 64);
+	__uint128_t right = __uint128_t(rhs.lower) + (__uint128_t(rhs.upper) << 64);
+	__uint128_t result_i128;
+	result_i128 = left * right;
+	uint64_t upper = uint64_t(result_i128 >> 64);
+	result.upper = int64_t(upper);
+	result.lower = uint64_t(result_i128 & 0xffffffffffffffff);
+#else
+	// Multiply code adapted from:
+	// https://github.com/calccrypto/uint128_t/blob/master/uint128_t.cpp
+
+	// split values into 4 32-bit parts
+	uint64_t top[4] = {uint64_t(lhs.upper) >> 32, uint64_t(lhs.upper) & 0xffffffff, lhs.lower >> 32,
+	                   lhs.lower & 0xffffffff};
+	uint64_t bottom[4] = {uint64_t(rhs.upper) >> 32, uint64_t(rhs.upper) & 0xffffffff, rhs.lower >> 32,
+	                      rhs.lower & 0xffffffff};
+	uint64_t products[4][4];
+
+	// multiply each component of the values
+	for (auto x = 0; x < 4; x++) {
+		for (auto y = 0; y < 4; y++) {
+			products[x][y] = top[x] * bottom[y];
+		}
+	}
+
+	// first row
+	uint64_t fourth32 = (products[3][3] & 0xffffffff);
+	uint64_t third32 = (products[3][2] & 0xffffffff) + (products[3][3] >> 32);
+	uint64_t second32 = (products[3][1] & 0xffffffff) + (products[3][2] >> 32);
+	uint64_t first32 = (products[3][0] & 0xffffffff) + (products[3][1] >> 32);
+
+	// second row
+	third32 += (products[2][3] & 0xffffffff);
+	second32 += (products[2][2] & 0xffffffff) + (products[2][3] >> 32);
+	first32 += (products[2][1] & 0xffffffff) + (products[2][2] >> 32);
+
+	// third row
+	second32 += (products[1][3] & 0xffffffff);
+	first32 += (products[1][2] & 0xffffffff) + (products[1][3] >> 32);
+
+	// fourth row
+	first32 += (products[0][3] & 0xffffffff);
+
+	// move carry to next digit
+	third32 += fourth32 >> 32;
+	second32 += third32 >> 32;
+	first32 += second32 >> 32;
+
+	// remove carry from current digit
+	fourth32 &= 0xffffffff;
+	third32 &= 0xffffffff;
+	second32 &= 0xffffffff;
+	first32 &= 0xffffffff;
+
+	// combine components
+	result.lower = (third32 << 32) | fourth32;
+	result.upper = (first32 << 32) | second32;
+#endif
+	if (lhs_negative ^ rhs_negative) {
+		NegateInPlace<false>(result);
 	}
 	return result;
 }
@@ -257,17 +371,59 @@ hugeint_t Hugeint::Multiply(hugeint_t lhs, hugeint_t rhs) {
 //===--------------------------------------------------------------------===//
 // Divide
 //===--------------------------------------------------------------------===//
+
+int Sign(hugeint_t n) {
+	return ((n > 0) - (n < 0));
+}
+
+hugeint_t Abs(hugeint_t n) {
+	D_ASSERT(n != NumericLimits<hugeint_t>::Minimum());
+	return (n * Sign(n));
+}
+
+static hugeint_t DivModMinimum(hugeint_t lhs, hugeint_t rhs, hugeint_t &remainder) {
+	D_ASSERT(lhs == NumericLimits<hugeint_t>::Minimum() || rhs == NumericLimits<hugeint_t>::Minimum());
+	if (rhs == NumericLimits<hugeint_t>::Minimum()) {
+		if (lhs == NumericLimits<hugeint_t>::Minimum()) {
+			remainder = 0;
+			return 1;
+		}
+		remainder = lhs;
+		return 0;
+	}
+
+	// Add 1 to minimum and run through DivMod again
+	hugeint_t result = Hugeint::DivMod(NumericLimits<hugeint_t>::Minimum() + 1, rhs, remainder);
+
+	// If the 1 mattered we need to adjust the result, otherwise the remainder
+	if (Abs(remainder) + 1 == Abs(rhs)) {
+		result -= Sign(rhs);
+		remainder = 0;
+	} else {
+		remainder -= 1;
+	}
+	return result;
+}
+
+// No overflow checks
 hugeint_t Hugeint::DivMod(hugeint_t lhs, hugeint_t rhs, hugeint_t &remainder) {
-	// division by zero not allowed
-	D_ASSERT(!(rhs.upper == 0 && rhs.lower == 0));
+	if (rhs == 0) {
+		remainder = lhs;
+		return hugeint_t(0);
+	}
+
+	// Check if one of the sides is hugeint_t minimum, as that can't be negated.
+	if (lhs == NumericLimits<hugeint_t>::Minimum() || rhs == NumericLimits<hugeint_t>::Minimum()) {
+		return DivModMinimum(lhs, rhs, remainder);
+	}
 
 	bool lhs_negative = lhs.upper < 0;
 	bool rhs_negative = rhs.upper < 0;
 	if (lhs_negative) {
-		Hugeint::NegateInPlace(lhs);
+		Hugeint::NegateInPlace<false>(lhs);
 	}
 	if (rhs_negative) {
-		Hugeint::NegateInPlace(rhs);
+		Hugeint::NegateInPlace<false>(rhs);
 	}
 	// DivMod code adapted from:
 	// https://github.com/calccrypto/uint128_t/blob/master/uint128_t.cpp
@@ -288,39 +444,55 @@ hugeint_t Hugeint::DivMod(hugeint_t lhs, hugeint_t rhs, hugeint_t &remainder) {
 
 		// we get the value of the bit at position X, where position 0 is the least-significant bit
 		if (PositiveHugeintIsBitSet(lhs, x - 1)) {
-			// increment the remainder
-			Hugeint::AddInPlace(remainder, 1);
+			remainder += 1;
 		}
 		if (Hugeint::GreaterThanEquals(remainder, rhs)) {
 			// the remainder has passed the division multiplier: add one to the divide result
-			remainder = Hugeint::Subtract(remainder, rhs);
-			Hugeint::AddInPlace(div_result, 1);
+			remainder -= rhs;
+			div_result += 1;
 		}
 	}
 	if (lhs_negative ^ rhs_negative) {
-		Hugeint::NegateInPlace(div_result);
+		Hugeint::NegateInPlace<false>(div_result);
 	}
 	if (lhs_negative) {
-		Hugeint::NegateInPlace(remainder);
+		Hugeint::NegateInPlace<false>(remainder);
 	}
 	return div_result;
 }
 
-hugeint_t Hugeint::Divide(hugeint_t lhs, hugeint_t rhs) {
+bool Hugeint::TryDivMod(hugeint_t lhs, hugeint_t rhs, hugeint_t &result, hugeint_t &remainder) {
+	// No division by zero
+	if (rhs == 0) {
+		return false;
+	}
+
+	// division only has one reason to overflow: MINIMUM / -1
+	if (lhs == NumericLimits<hugeint_t>::Minimum() && rhs == -1) {
+		return false;
+	}
+
+	result = Hugeint::DivMod(lhs, rhs, remainder);
+	return true;
+}
+
+template <>
+hugeint_t Hugeint::Divide<false>(hugeint_t lhs, hugeint_t rhs) {
 	hugeint_t remainder;
 	return Hugeint::DivMod(lhs, rhs, remainder);
 }
 
-hugeint_t Hugeint::Modulo(hugeint_t lhs, hugeint_t rhs) {
+template <>
+hugeint_t Hugeint::Modulo<false>(hugeint_t lhs, hugeint_t rhs) {
 	hugeint_t remainder;
-	Hugeint::DivMod(lhs, rhs, remainder);
+	(void)Hugeint::DivMod(lhs, rhs, remainder);
 	return remainder;
 }
 
 //===--------------------------------------------------------------------===//
 // Add/Subtract
 //===--------------------------------------------------------------------===//
-bool Hugeint::AddInPlace(hugeint_t &lhs, hugeint_t rhs) {
+bool Hugeint::TryAddInPlace(hugeint_t &lhs, hugeint_t rhs) {
 	int overflow = lhs.lower + rhs.lower < lhs.lower;
 	if (rhs.upper >= 0) {
 		// RHS is positive: check for overflow
@@ -336,13 +508,10 @@ bool Hugeint::AddInPlace(hugeint_t &lhs, hugeint_t rhs) {
 		lhs.upper = lhs.upper + (overflow + rhs.upper);
 	}
 	lhs.lower += rhs.lower;
-	if (lhs.upper == std::numeric_limits<int64_t>::min() && lhs.lower == 0) {
-		return false;
-	}
 	return true;
 }
 
-bool Hugeint::SubtractInPlace(hugeint_t &lhs, hugeint_t rhs) {
+bool Hugeint::TrySubtractInPlace(hugeint_t &lhs, hugeint_t rhs) {
 	// underflow
 	int underflow = lhs.lower - rhs.lower > lhs.lower;
 	if (rhs.upper >= 0) {
@@ -360,24 +529,17 @@ bool Hugeint::SubtractInPlace(hugeint_t &lhs, hugeint_t rhs) {
 		lhs.upper = lhs.upper - (rhs.upper + underflow);
 	}
 	lhs.lower -= rhs.lower;
-	if (lhs.upper == std::numeric_limits<int64_t>::min() && lhs.lower == 0) {
-		return false;
-	}
 	return true;
 }
 
-hugeint_t Hugeint::Add(hugeint_t lhs, hugeint_t rhs) {
-	if (!AddInPlace(lhs, rhs)) {
-		throw OutOfRangeException("Overflow in HUGEINT addition");
-	}
-	return lhs;
+template <>
+hugeint_t Hugeint::Add<false>(hugeint_t lhs, hugeint_t rhs) {
+	return lhs + rhs;
 }
 
-hugeint_t Hugeint::Subtract(hugeint_t lhs, hugeint_t rhs) {
-	if (!SubtractInPlace(lhs, rhs)) {
-		throw OutOfRangeException("Underflow in HUGEINT addition");
-	}
-	return lhs;
+template <>
+hugeint_t Hugeint::Subtract<false>(hugeint_t lhs, hugeint_t rhs) {
+	return lhs - rhs;
 }
 
 //===--------------------------------------------------------------------===//
@@ -455,6 +617,17 @@ bool Hugeint::TryCast(hugeint_t input, hugeint_t &result) {
 	return true;
 }
 
+template <>
+bool Hugeint::TryCast(hugeint_t input, uhugeint_t &result) {
+	if (input < 0) {
+		return false;
+	}
+
+	result.lower = input.lower;
+	result.upper = input.upper;
+	return true;
+}
+
 template <>
 bool Hugeint::TryCast(hugeint_t input, float &result) {
 	double dbl_result;
@@ -621,27 +794,29 @@ bool hugeint_t::operator>=(const hugeint_t &rhs) const {
 }
 
 hugeint_t hugeint_t::operator+(const hugeint_t &rhs) const {
-	return Hugeint::Add(*this, rhs);
+	return hugeint_t(upper + rhs.upper + ((lower + rhs.lower) < lower), lower + rhs.lower);
 }
 
 hugeint_t hugeint_t::operator-(const hugeint_t &rhs) const {
-	return Hugeint::Subtract(*this, rhs);
+	return hugeint_t(upper - rhs.upper - ((lower - rhs.lower) > lower), lower - rhs.lower);
 }
 
 hugeint_t hugeint_t::operator*(const hugeint_t &rhs) const {
-	return Hugeint::Multiply(*this, rhs);
+	hugeint_t result = *this;
+	result *= rhs;
+	return result;
 }
 
 hugeint_t hugeint_t::operator/(const hugeint_t &rhs) const {
-	return Hugeint::Divide(*this, rhs);
+	return Hugeint::Divide<false>(*this, rhs);
 }
 
 hugeint_t hugeint_t::operator%(const hugeint_t &rhs) const {
-	return Hugeint::Modulo(*this, rhs);
+	return Hugeint::Modulo<false>(*this, rhs);
 }
 
 hugeint_t hugeint_t::operator-() const {
-	return Hugeint::Negate(*this);
+	return Hugeint::Negate<false>(*this);
 }
 
 hugeint_t hugeint_t::operator>>(const hugeint_t &rhs) const {
@@ -721,23 +896,23 @@ hugeint_t hugeint_t::operator~() const {
 }
 
 hugeint_t &hugeint_t::operator+=(const hugeint_t &rhs) {
-	Hugeint::AddInPlace(*this, rhs);
+	*this = *this + rhs;
 	return *this;
 }
 hugeint_t &hugeint_t::operator-=(const hugeint_t &rhs) {
-	Hugeint::SubtractInPlace(*this, rhs);
+	*this = *this - rhs;
 	return *this;
 }
 hugeint_t &hugeint_t::operator*=(const hugeint_t &rhs) {
-	*this = Hugeint::Multiply(*this, rhs);
+	*this = Hugeint::Multiply<false>(*this, rhs);
 	return *this;
 }
 hugeint_t &hugeint_t::operator/=(const hugeint_t &rhs) {
-	*this = Hugeint::Divide(*this, rhs);
+	*this = Hugeint::Divide<false>(*this, rhs);
 	return *this;
 }
 hugeint_t &hugeint_t::operator%=(const hugeint_t &rhs) {
-	*this = Hugeint::Modulo(*this, rhs);
+	*this = Hugeint::Modulo<false>(*this, rhs);
 	return *this;
 }
 hugeint_t &hugeint_t::operator>>=(const hugeint_t &rhs) {
@@ -802,6 +977,9 @@ hugeint_t::operator int32_t() const {
 hugeint_t::operator int64_t() const {
 	return NarrowCast<int64_t>(*this);
 }
+hugeint_t::operator uhugeint_t() const {
+	return {static_cast<uint64_t>(this->upper), this->lower};
+}
 
 string hugeint_t::ToString() const {
 	return Hugeint::ToString(*this);

package/src/duckdb/src/common/types/hyperloglog.cpp

@@ -54,7 +54,7 @@ HyperLogLog *HyperLogLog::MergePointer(HyperLogLog &other) {
 	hlls[1] = other.hll;
 	auto new_hll = duckdb_hll::hll_merge(hlls, 2);
 	if (!new_hll) {
-		throw Exception("Could not merge HLLs");
+		throw InternalException("Could not merge HLLs");
 	}
 	return new HyperLogLog(new_hll);
 }
@@ -129,6 +129,12 @@ inline uint64_t TemplatedHash(const hugeint_t &elem) {
 	       TemplatedHash<uint64_t>(elem.lower);
 }
 
+template <>
+inline uint64_t TemplatedHash(const uhugeint_t &elem) {
+	return TemplatedHash<uint64_t>(Load<uint64_t>(const_data_ptr_cast(&elem.upper))) ^
+	       TemplatedHash<uint64_t>(elem.lower);
+}
+
 template <idx_t rest>
 inline void CreateIntegerRecursive(const_data_ptr_t &data, uint64_t &x) {
 	x ^= (uint64_t)data[rest - 1] << ((rest - 1) * 8);
@@ -226,9 +232,10 @@ static void ComputeHashes(UnifiedVectorFormat &vdata, const LogicalType &type, u
 	case PhysicalType::DOUBLE:
 		return TemplatedComputeHashes<uint64_t>(vdata, count, hashes);
 	case PhysicalType::INT128:
+	case PhysicalType::UINT128:
 	case PhysicalType::INTERVAL:
-		static_assert(sizeof(hugeint_t) == sizeof(interval_t), "ComputeHashes assumes these are the same size!");
-		return TemplatedComputeHashes<hugeint_t>(vdata, count, hashes);
+		static_assert(sizeof(uhugeint_t) == sizeof(interval_t), "ComputeHashes assumes these are the same size!");
+		return TemplatedComputeHashes<uhugeint_t>(vdata, count, hashes);
 	case PhysicalType::VARCHAR:
 		return TemplatedComputeHashes<string_t>(vdata, count, hashes);
 	default:

package/src/duckdb/src/common/types/interval.cpp

@@ -22,7 +22,7 @@ bool Interval::FromString(const string &str, interval_t &result) {
 }
 
 template <class T>
-void IntervalTryAddition(T &target, int64_t input, int64_t multiplier) {
+void IntervalTryAddition(T &target, int64_t input, int64_t multiplier, int64_t fraction = 0) {
 	int64_t addition;
 	if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(input, multiplier, addition)) {
 		throw OutOfRangeException("interval value is out of range");
@@ -31,6 +31,15 @@ void IntervalTryAddition(T &target, int64_t input, int64_t multiplier) {
 	if (!TryAddOperator::Operation<T, T, T>(target, addition_base, target)) {
 		throw OutOfRangeException("interval value is out of range");
 	}
+	if (fraction) {
+		//	Add in (fraction * multiplier) / MICROS_PER_SEC
+		//	This is always in range
+		addition = (fraction * multiplier) / Interval::MICROS_PER_SEC;
+		addition_base = Cast::Operation<int64_t, T>(addition);
+		if (!TryAddOperator::Operation<T, T, T>(target, addition_base, target)) {
+			throw OutOfRangeException("interval fraction is out of range");
+		}
+	}
 }
 
 bool Interval::FromCString(const char *str, idx_t len, interval_t &result, string *error_message, bool strict) {
@@ -39,6 +48,7 @@ bool Interval::FromCString(const char *str, idx_t len, interval_t &result, strin
 	bool negative;
 	bool found_any = false;
 	int64_t number;
+	int64_t fraction;
 	DatePartSpecifier specifier;
 	string specifier_str;
 
@@ -103,8 +113,19 @@ interval_parse_number:
 			// finished the number, parse it from the string
 			string_t nr_string(str + start_pos, pos - start_pos);
 			number = Cast::Operation<string_t, int64_t>(nr_string);
+			fraction = 0;
+			if (c == '.') {
+				// we expect some microseconds
+				int32_t mult = 100000;
+				for (++pos; pos < len && StringUtil::CharacterIsDigit(str[pos]); ++pos, mult /= 10) {
+					if (mult > 0) {
+						fraction += int64_t(str[pos] - '0') * mult;
+					}
+				}
+			}
 			if (negative) {
 				number = -number;
+				fraction = -fraction;
 			}
 			goto interval_parse_identifier;
 		}
@@ -114,7 +135,7 @@ interval_parse_time : {
 	// parse the remainder of the time as a Time type
 	dtime_t time;
 	idx_t pos;
-	if (!Time::TryConvertTime(str + start_pos, len - start_pos, pos, time)) {
+	if (!Time::TryConvertInterval(str + start_pos, len - start_pos, pos, time)) {
 		return false;
 	}
 	result.micros += time.micros;
@@ -146,6 +167,24 @@ interval_parse_identifier:
 		}
 	}
 	specifier_str = string(str + start_pos, pos - start_pos);
+
+	// Special case SS[.FFFFFF] - implied SECONDS/MICROSECONDS
+	if (specifier_str.empty() && !found_any) {
+		IntervalTryAddition<int64_t>(result.micros, number, MICROS_PER_SEC);
+		IntervalTryAddition<int64_t>(result.micros, fraction, 1);
+		found_any = true;
+		// parse any trailing whitespace
+		for (; pos < len; pos++) {
+			char c = str[pos];
+			if (c == ' ' || c == '\t' || c == '\n') {
+				continue;
+			} else {
+				return false;
+			}
+		}
+		goto end_of_string;
+	}
+
 	if (!TryGetDatePartSpecifier(specifier_str, specifier)) {
 		HandleCastError::AssignError(StringUtil::Format("extract specifier \"%s\" not recognized", specifier_str),
 		                             error_message);
@@ -154,43 +193,55 @@ interval_parse_identifier:
 	// add the specifier to the interval
 	switch (specifier) {
 	case DatePartSpecifier::MILLENNIUM:
-		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_MILLENIUM);
+		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_MILLENIUM, fraction);
 		break;
 	case DatePartSpecifier::CENTURY:
-		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_CENTURY);
+		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_CENTURY, fraction);
 		break;
 	case DatePartSpecifier::DECADE:
-		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_DECADE);
+		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_DECADE, fraction);
 		break;
 	case DatePartSpecifier::YEAR:
-		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_YEAR);
+		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_YEAR, fraction);
 		break;
 	case DatePartSpecifier::QUARTER:
-		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_QUARTER);
+		IntervalTryAddition<int32_t>(result.months, number, MONTHS_PER_QUARTER, fraction);
+		// Reduce to fraction of a month
+		fraction *= MONTHS_PER_QUARTER;
+		fraction %= MICROS_PER_SEC;
+		IntervalTryAddition<int32_t>(result.days, 0, DAYS_PER_MONTH, fraction);
 		break;
 	case DatePartSpecifier::MONTH:
 		IntervalTryAddition<int32_t>(result.months, number, 1);
+		IntervalTryAddition<int32_t>(result.days, 0, DAYS_PER_MONTH, fraction);
 		break;
 	case DatePartSpecifier::DAY:
 		IntervalTryAddition<int32_t>(result.days, number, 1);
+		IntervalTryAddition<int64_t>(result.micros, 0, MICROS_PER_DAY, fraction);
 		break;
 	case DatePartSpecifier::WEEK:
-		IntervalTryAddition<int32_t>(result.days, number, DAYS_PER_WEEK);
+		IntervalTryAddition<int32_t>(result.days, number, DAYS_PER_WEEK, fraction);
+		// Reduce to fraction of a day
+		fraction *= DAYS_PER_WEEK;
+		fraction %= MICROS_PER_SEC;
+		IntervalTryAddition<int64_t>(result.micros, 0, MICROS_PER_DAY, fraction);
 		break;
 	case DatePartSpecifier::MICROSECONDS:
+		// Round the fraction
+		number += (fraction * 2) / MICROS_PER_SEC;
 		IntervalTryAddition<int64_t>(result.micros, number, 1);
 		break;
 	case DatePartSpecifier::MILLISECONDS:
-		IntervalTryAddition<int64_t>(result.micros, number, MICROS_PER_MSEC);
+		IntervalTryAddition<int64_t>(result.micros, number, MICROS_PER_MSEC, fraction);
 		break;
 	case DatePartSpecifier::SECOND:
-		IntervalTryAddition<int64_t>(result.micros, number, MICROS_PER_SEC);
+		IntervalTryAddition<int64_t>(result.micros, number, MICROS_PER_SEC, fraction);
 		break;
 	case DatePartSpecifier::MINUTE:
-		IntervalTryAddition<int64_t>(result.micros, number, MICROS_PER_MINUTE);
+		IntervalTryAddition<int64_t>(result.micros, number, MICROS_PER_MINUTE, fraction);
 		break;
 	case DatePartSpecifier::HOUR:
-		IntervalTryAddition<int64_t>(result.micros, number, MICROS_PER_HOUR);
+		IntervalTryAddition<int64_t>(result.micros, number, MICROS_PER_HOUR, fraction);
 		break;
 	default:
 		HandleCastError::AssignError(
@@ -462,6 +513,10 @@ dtime_t Interval::Add(dtime_t left, interval_t right, date_t &date) {
 	return left;
 }
 
+dtime_tz_t Interval::Add(dtime_tz_t left, interval_t right, date_t &date) {
+	return dtime_tz_t(Interval::Add(left.time(), right, date), left.offset());
+}
+
 timestamp_t Interval::Add(timestamp_t left, interval_t right) {
 	if (!Timestamp::IsFinite(left)) {
 		return left;