duckdb 1.3.4 → 1.4.0

package/src/duckdb/src/common/types/row/tuple_data_segment.cpp

@@ -38,7 +38,7 @@ TupleDataChunk &TupleDataChunk::operator=(TupleDataChunk &&other) noexcept {
 TupleDataChunkPart &TupleDataChunk::AddPart(TupleDataSegment &segment, TupleDataChunkPart &&part) {
 	count += part.count;
 	row_block_ids.Insert(part.row_block_index);
-	if (!segment.layout.get().AllConstant() && part.total_heap_size > 0) {
+	if (!segment.layout.AllConstant() && part.total_heap_size > 0) {
 		heap_block_ids.Insert(part.heap_block_index);
 	}
 	part.lock = *lock;
@@ -48,7 +48,7 @@ TupleDataChunkPart &TupleDataChunk::AddPart(TupleDataSegment &segment, TupleData
 }
 
 void TupleDataChunk::Verify(const TupleDataSegment &segment) const {
-#ifdef DEBUG
+#ifdef D_ASSERT_IS_ENABLED
 	idx_t total_count = 0;
 	for (auto part_id = part_ids.Start(); part_id < part_ids.End(); part_id++) {
 		total_count += segment.chunk_parts[part_id].count;
@@ -66,15 +66,15 @@ void TupleDataChunk::MergeLastChunkPart(TupleDataSegment &segment) {
 	auto &second_to_last = segment.chunk_parts[part_ids.End() - 2];
 	auto &last = segment.chunk_parts[part_ids.End() - 1];
 
-	auto rows_align = last.row_block_index == second_to_last.row_block_index &&
-	                  last.row_block_offset ==
-	                      second_to_last.row_block_offset + second_to_last.count * segment.layout.get().GetRowWidth();
+	auto rows_align =
+	    last.row_block_index == second_to_last.row_block_index &&
+	    last.row_block_offset == second_to_last.row_block_offset + second_to_last.count * segment.layout.GetRowWidth();
 
 	if (!rows_align) { // If rows don't align we can never merge
 		return;
 	}
 
-	if (segment.layout.get().AllConstant()) { // No heap and rows align - merge
+	if (segment.layout.AllConstant()) { // No heap and rows align - merge
 		second_to_last.count += last.count;
 		if (segment.chunk_parts.size() == part_ids.End()) {
 			// Can only remove if the part we're merging was the last added chunk part
@@ -115,26 +115,6 @@ TupleDataSegment::~TupleDataSegment() {
 	allocator.reset();
 }
 
-void SwapTupleDataSegment(TupleDataSegment &a, TupleDataSegment &b) {
-	std::swap(a.allocator, b.allocator);
-	std::swap(a.layout, b.layout);
-	std::swap(a.chunks, b.chunks);
-	std::swap(a.chunk_parts, b.chunk_parts);
-	std::swap(a.count, b.count);
-	std::swap(a.data_size, b.data_size);
-	std::swap(a.pinned_row_handles, b.pinned_row_handles);
-	std::swap(a.pinned_heap_handles, b.pinned_heap_handles);
-}
-
-TupleDataSegment::TupleDataSegment(TupleDataSegment &&other) noexcept : layout(other.layout) {
-	SwapTupleDataSegment(*this, other);
-}
-
-TupleDataSegment &TupleDataSegment::operator=(TupleDataSegment &&other) noexcept {
-	SwapTupleDataSegment(*this, other);
-	return *this;
-}
-
 idx_t TupleDataSegment::ChunkCount() const {
 	return chunks.size();
 }
@@ -150,7 +130,7 @@ void TupleDataSegment::Unpin() {
 }
 
 void TupleDataSegment::Verify() const {
-#ifdef DEBUG
+#ifdef D_ASSERT_IS_ENABLED
 	const auto &layout = allocator->GetLayout();
 
 	idx_t total_count = 0;
@@ -172,7 +152,7 @@ void TupleDataSegment::Verify() const {
 }
 
 void TupleDataSegment::VerifyEverythingPinned() const {
-#ifdef DEBUG
+#ifdef D_ASSERT_IS_ENABLED
 	D_ASSERT(pinned_row_handles.size() == allocator->RowBlockCount());
 	D_ASSERT(pinned_heap_handles.size() == allocator->HeapBlockCount());
 #endif

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

@@ -143,7 +143,7 @@ bool Time::TryConvertTime(const char *buf, idx_t len, idx_t &pos, dtime_t &resul
 		if (!strict) {
 			// last chance, check if we can parse as timestamp
 			timestamp_t timestamp;
-			if (Timestamp::TryConvertTimestamp(buf, len, timestamp, nanos) == TimestampCastResult::SUCCESS) {
+			if (Timestamp::TryConvertTimestamp(buf, len, timestamp, false, nanos) == TimestampCastResult::SUCCESS) {
 				if (!Timestamp::IsFinite(timestamp)) {
 					return false;
 				}
@@ -164,7 +164,7 @@ bool Time::TryConvertTimeTZ(const char *buf, idx_t len, idx_t &pos, dtime_tz_t &
 		if (!strict) {
 			// last chance, check if we can parse as timestamp
 			timestamp_t timestamp;
-			if (Timestamp::TryConvertTimestamp(buf, len, timestamp, nanos) == TimestampCastResult::SUCCESS) {
+			if (Timestamp::TryConvertTimestamp(buf, len, timestamp, true, nanos) == TimestampCastResult::SUCCESS) {
 				if (!Timestamp::IsFinite(timestamp)) {
 					return false;
 				}

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

@@ -64,8 +64,8 @@ timestamp_t &timestamp_t::operator-=(const int64_t &delta) {
 	return *this;
 }
 
-TimestampCastResult Timestamp::TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &result, bool &has_offset,
-                                                     string_t &tz, optional_ptr<int32_t> nanos) {
+TimestampCastResult Timestamp::TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &result, bool use_offset,
+                                                     bool &has_offset, string_t &tz, optional_ptr<int32_t> nanos) {
 	idx_t pos;
 	date_t date;
 	dtime_t time;
@@ -118,7 +118,7 @@ TimestampCastResult Timestamp::TryConvertTimestampTZ(const char *str, idx_t len,
 		} else if (Timestamp::TryParseUTCOffset(str, pos, len, hh, mm, ss)) {
 			const int64_t delta =
 			    hh * Interval::MICROS_PER_HOUR + mm * Interval::MICROS_PER_MINUTE + ss * Interval::MICROS_PER_SEC;
-			if (!TrySubtractOperator::Operation(result.value, delta, result.value)) {
+			if (use_offset && !TrySubtractOperator::Operation(result.value, delta, result.value)) {
 				return TimestampCastResult::ERROR_RANGE;
 			}
 			has_offset = true;
@@ -149,12 +149,12 @@ TimestampCastResult Timestamp::TryConvertTimestampTZ(const char *str, idx_t len,
 	return TimestampCastResult::SUCCESS;
 }
 
-TimestampCastResult Timestamp::TryConvertTimestamp(const char *str, idx_t len, timestamp_t &result,
+TimestampCastResult Timestamp::TryConvertTimestamp(const char *str, idx_t len, timestamp_t &result, bool use_offset,
                                                    optional_ptr<int32_t> nanos, bool strict) {
 	string_t tz(nullptr, 0);
 	bool has_offset = false;
 	// We don't understand TZ without an extension, so fail if one was provided.
-	auto success = TryConvertTimestampTZ(str, len, result, has_offset, tz, nanos);
+	auto success = TryConvertTimestampTZ(str, len, result, use_offset, has_offset, tz, nanos);
 	if (success != TimestampCastResult::SUCCESS) {
 		return success;
 	}
@@ -198,7 +198,7 @@ bool Timestamp::TryFromTimestampNanos(timestamp_t input, int32_t nanos, timestam
 
 TimestampCastResult Timestamp::TryConvertTimestamp(const char *str, idx_t len, timestamp_ns_t &result) {
 	int32_t nanos = 0;
-	auto success = TryConvertTimestamp(str, len, result, &nanos);
+	auto success = TryConvertTimestamp(str, len, result, true, &nanos);
 	if (success != TimestampCastResult::SUCCESS) {
 		return success;
 	}
@@ -236,9 +236,9 @@ string Timestamp::RangeError(string_t str) {
 	return Timestamp::RangeError(str.GetString());
 }
 
-timestamp_t Timestamp::FromCString(const char *str, idx_t len, optional_ptr<int32_t> nanos) {
+timestamp_t Timestamp::FromCString(const char *str, idx_t len, bool use_offset, optional_ptr<int32_t> nanos) {
 	timestamp_t result;
-	switch (Timestamp::TryConvertTimestamp(str, len, result, nanos)) {
+	switch (Timestamp::TryConvertTimestamp(str, len, result, use_offset, nanos)) {
 	case TimestampCastResult::SUCCESS:
 	case TimestampCastResult::STRICT_UTC:
 		break;
@@ -324,16 +324,16 @@ bool Timestamp::TryParseUTCOffset(const char *str, idx_t &pos, idx_t len, int &h
 	return true;
 }
 
-timestamp_t Timestamp::FromString(const string &str) {
-	return Timestamp::FromCString(str.c_str(), str.size());
+timestamp_t Timestamp::FromString(const string &str, bool use_offset) {
+	return Timestamp::FromCString(str.c_str(), str.size(), use_offset);
 }
 
 string Timestamp::ToString(timestamp_t timestamp) {
 	if (timestamp == timestamp_t::infinity()) {
-		return Date::PINF;
+		return Date::PINF.str;
 	}
 	if (timestamp == timestamp_t::ninfinity()) {
-		return Date::NINF;
+		return Date::NINF.str;
 	}
 
 	date_t date;
@@ -361,6 +361,18 @@ dtime_t Timestamp::GetTime(timestamp_t timestamp) {
 	return dtime_t(timestamp.value - (int64_t(date.days) * int64_t(Interval::MICROS_PER_DAY)));
 }
 
+dtime_ns_t Timestamp::GetTimeNs(timestamp_ns_t input) {
+	if (!IsFinite(input)) {
+		throw ConversionException("Can't get TIME_NS of infinite TIMESTAMP");
+	}
+	date_t date = Timestamp::GetDate(Timestamp::FromEpochNanoSeconds(input.value));
+	int64_t nanos;
+	if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(date.days, Interval::NANOS_PER_DAY, nanos)) {
+		throw ConversionException("Overflow extracting TIME_NS of TIMESTAMP");
+	}
+	return dtime_ns_t(input.value - nanos);
+}
+
 bool Timestamp::TryFromDatetime(date_t date, dtime_t time, timestamp_t &result) {
 	if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(date.days, Interval::MICROS_PER_DAY, result.value)) {
 		return false;
@@ -417,8 +429,8 @@ void Timestamp::Convert(timestamp_ns_t input, date_t &out_date, dtime_t &out_tim
 
 timestamp_t Timestamp::GetCurrentTimestamp() {
 	auto now = system_clock::now();
-	auto epoch_ms = duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
-	return Timestamp::FromEpochMs(epoch_ms);
+	auto epoch_micros = duration_cast<microseconds>(now.time_since_epoch()).count();
+	return FromEpochMicroSeconds(epoch_micros);
 }
 
 timestamp_t Timestamp::FromEpochSecondsPossiblyInfinite(int64_t sec) {

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

@@ -133,7 +133,7 @@ hugeint_t BaseUUID::Convert(const std::array<uint8_t, 16> &bytes) {
 	result.upper |= ((int64_t)bytes[4] << 24);
 	result.upper |= ((int64_t)bytes[5] << 16);
 	result.upper |= ((int64_t)bytes[6] << 8);
-	result.upper |= bytes[7];
+	result.upper |= (int64_t)bytes[7];
 	result.lower = 0;
 	result.lower |= ((uint64_t)bytes[8] << 56);
 	result.lower |= ((uint64_t)bytes[9] << 48);
@@ -142,7 +142,7 @@ hugeint_t BaseUUID::Convert(const std::array<uint8_t, 16> &bytes) {
 	result.lower |= ((uint64_t)bytes[12] << 24);
 	result.lower |= ((uint64_t)bytes[13] << 16);
 	result.lower |= ((uint64_t)bytes[14] << 8);
-	result.lower |= bytes[15];
+	result.lower |= (uint64_t)bytes[15];
 	return result;
 }
 
@@ -222,4 +222,35 @@ hugeint_t UUIDv7::GenerateRandomUUID() {
 	return GenerateRandomUUID(engine);
 }
 
+hugeint_t BaseUUID::FromBlob(const_data_ptr_t input) {
+	// Based on UUIDValueConversion::ReadParquetUUID from parquet extension
+	hugeint_t result;
+	result.lower = 0;
+	uint64_t unsigned_upper = 0;
+	for (idx_t i = 0; i < sizeof(uint64_t); i++) {
+		unsigned_upper <<= 8;
+		unsigned_upper += static_cast<uint64_t>(input[i]);
+	}
+	for (idx_t i = sizeof(uint64_t); i < sizeof(hugeint_t); i++) {
+		result.lower <<= 8;
+		result.lower += static_cast<uint64_t>(input[i]);
+	}
+	result.upper = static_cast<int64_t>(unsigned_upper ^ (uint64_t(1) << 63));
+	return result;
+}
+
+void BaseUUID::ToBlob(hugeint_t input, data_ptr_t output) {
+	// Based on ParquetUUIDOperator::Operation from parquet extension
+	uint64_t high_bytes = static_cast<uint64_t>(input.upper) ^ (uint64_t(1) << 63);
+	uint64_t low_bytes = input.lower;
+	for (idx_t i = 0; i < sizeof(uint64_t); i++) {
+		auto shift_count = (sizeof(uint64_t) - i - 1) * 8;
+		output[i] = static_cast<uint8_t>((high_bytes >> shift_count) & 0xFF);
+	}
+	for (idx_t i = 0; i < sizeof(uint64_t); i++) {
+		auto shift_count = (sizeof(uint64_t) - i - 1) * 8;
+		output[sizeof(uint64_t) + i] = static_cast<uint8_t>((low_bytes >> shift_count) & 0xFF);
+	}
+}
+
 } // namespace duckdb

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

@@ -6,7 +6,6 @@
 
 #include "duckdb/common/uhugeint.hpp"
 #include "utf8proc_wrapper.hpp"
-#include "duckdb/common/operator/numeric_binary_operators.hpp"
 #include "duckdb/common/printer.hpp"
 #include "duckdb/common/types/blob.hpp"
 #include "duckdb/common/types/date.hpp"
@@ -24,9 +23,11 @@
 #include "duckdb/common/types/cast_helpers.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/main/error_manager.hpp"
-#include "duckdb/common/types/varint.hpp"
+#include "duckdb/common/types/bignum.hpp"
 #include "duckdb/common/serializer/serializer.hpp"
 #include "duckdb/common/serializer/deserializer.hpp"
+#include "duckdb/common/types/string.hpp"
+#include "duckdb/common/types/value_map.hpp"
 
 #include <utility>
 #include <cmath>
@@ -160,6 +161,13 @@ Value::Value(string val) : type_(LogicalType::VARCHAR), is_null(false) {
 	value_info_ = make_shared_ptr<StringValueInfo>(std::move(val));
 }
 
+Value::Value(String val) : type_(LogicalType::VARCHAR), is_null(false) {
+	if (!Value::StringIsValid(val.c_str(), val.size())) {
+		throw ErrorManager::InvalidUnicodeError(val, "value construction");
+	}
+	value_info_ = make_shared_ptr<StringValueInfo>(val.ToStdString());
+}
+
 Value::~Value() {
 }
 
@@ -222,6 +230,8 @@ Value Value::MinimumValue(const LogicalType &type) {
 		return Value::DATE(Date::FromDate(Date::DATE_MIN_YEAR, Date::DATE_MIN_MONTH, Date::DATE_MIN_DAY));
 	case LogicalTypeId::TIME:
 		return Value::TIME(dtime_t(0));
+	case LogicalTypeId::TIME_NS:
+		return Value::TIME_NS(dtime_ns_t(0));
 	case LogicalTypeId::TIMESTAMP: {
 		const auto date = Date::FromDate(Timestamp::MIN_YEAR, Timestamp::MIN_MONTH, Timestamp::MIN_DAY);
 		return Value::TIMESTAMP(date, dtime_t(0));
@@ -275,8 +285,8 @@ Value Value::MinimumValue(const LogicalType &type) {
 	}
 	case LogicalTypeId::ENUM:
 		return Value::ENUM(0, type);
-	case LogicalTypeId::VARINT:
-		return Value::VARINT(Varint::VarcharToVarInt(
+	case LogicalTypeId::BIGNUM:
+		return Value::BIGNUM(Bignum::VarcharToBignum(
 		    "-179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540"
 		    "4589535143824642343213268894641827684675467035375169860499105765512820762454900903893289440758685084551339"
 		    "42304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368"));
@@ -317,6 +327,9 @@ Value Value::MaximumValue(const LogicalType &type) {
 	case LogicalTypeId::TIME:
 		//	24:00:00 according to PG
 		return Value::TIME(dtime_t(Interval::MICROS_PER_DAY));
+	case LogicalTypeId::TIME_NS:
+		//	24:00:00 according to PG
+		return Value::TIME_NS(dtime_ns_t(Interval::NANOS_PER_DAY));
 	case LogicalTypeId::TIMESTAMP:
 		return Value::TIMESTAMP(timestamp_t(NumericLimits<int64_t>::Maximum() - 1));
 	case LogicalTypeId::TIMESTAMP_SEC: {
@@ -364,8 +377,8 @@ Value Value::MaximumValue(const LogicalType &type) {
 		auto enum_size = EnumType::GetSize(type);
 		return Value::ENUM(enum_size - (enum_size ? 1 : 0), type);
 	}
-	case LogicalTypeId::VARINT:
-		return Value::VARINT(Varint::VarcharToVarInt(
+	case LogicalTypeId::BIGNUM:
+		return Value::BIGNUM(Bignum::VarcharToBignum(
 		    "1797693134862315708145274237317043567980705675258449965989174768031572607800285387605895586327668781715404"
 		    "5895351438246423432132688946418276846754670353751698604991057655128207624549009038932894407586850845513394"
 		    "2304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368"));
@@ -658,6 +671,13 @@ Value Value::TIME(dtime_t value) {
 	return result;
 }
 
+Value Value::TIME_NS(dtime_ns_t value) {
+	Value result(LogicalType::TIME_NS);
+	result.value_.time_ns = value;
+	result.is_null = false;
+	return result;
+}
+
 Value Value::TIMETZ(dtime_tz_t value) {
 	Value result(LogicalType::TIME_TZ);
 	result.value_.timetz = value;
@@ -739,24 +759,32 @@ Value Value::STRUCT(child_list_t<Value> values) {
 	return Value::STRUCT(LogicalType::STRUCT(child_types), std::move(struct_values));
 }
 
-void MapKeyCheck(unordered_set<hash_t> &unique_keys, const Value &key) {
+Value Value::VARIANT(vector<Value> val) {
+	D_ASSERT(val.size() == 4);
+	D_ASSERT(val[0].type().id() == LogicalTypeId::LIST);
+	D_ASSERT(val[1].type().id() == LogicalTypeId::LIST);
+	D_ASSERT(val[2].type().id() == LogicalTypeId::LIST);
+	D_ASSERT(val[3].type().id() == LogicalTypeId::BLOB);
+	return Value::STRUCT(LogicalType::VARIANT(), std::move(val));
+}
+
+void MapKeyCheck(value_set_t &unique_keys, const Value &key) {
 	// NULL key check.
 	if (key.IsNull()) {
 		MapVector::EvalMapInvalidReason(MapInvalidReason::NULL_KEY);
 	}
 
 	// Duplicate key check.
-	auto key_hash = key.Hash();
-	if (unique_keys.find(key_hash) != unique_keys.end()) {
+	if (unique_keys.find(key) != unique_keys.end()) {
 		MapVector::EvalMapInvalidReason(MapInvalidReason::DUPLICATE_KEY);
 	}
-	unique_keys.insert(key_hash);
+	unique_keys.insert(key);
 }
 
 Value Value::MAP(const LogicalType &child_type, vector<Value> values) { // NOLINT
 	vector<Value> map_keys;
 	vector<Value> map_values;
-	unordered_set<hash_t> unique_keys;
+	value_set_t unique_keys;
 
 	for (auto &val : values) {
 		D_ASSERT(val.type().InternalType() == PhysicalType::STRUCT);
@@ -781,7 +809,7 @@ Value Value::MAP(const LogicalType &key_type, const LogicalType &value_type, vec
 
 	result.type_ = LogicalType::MAP(key_type, value_type);
 	result.is_null = false;
-	unordered_set<hash_t> unique_keys;
+	value_set_t unique_keys;
 
 	for (idx_t i = 0; i < keys.size(); i++) {
 		child_list_t<LogicalType> struct_types;
@@ -880,12 +908,12 @@ Value Value::BLOB(const_data_ptr_t data, idx_t len) {
 	return result;
 }
 
-Value Value::VARINT(const_data_ptr_t data, idx_t len) {
-	return VARINT(string(const_char_ptr_cast(data), len));
+Value Value::BIGNUM(const_data_ptr_t data, idx_t len) {
+	return BIGNUM(string(const_char_ptr_cast(data), len));
 }
 
-Value Value::VARINT(const string &data) {
-	Value result(LogicalType::VARINT);
+Value Value::BIGNUM(const string &data) {
+	Value result(LogicalType::BIGNUM);
 	result.is_null = false;
 	result.value_info_ = make_shared_ptr<StringValueInfo>(data);
 	return result;
@@ -1020,6 +1048,11 @@ Value Value::CreateValue(dtime_t value) {
 	return Value::TIME(value);
 }
 
+template <>
+Value Value::CreateValue(dtime_ns_t value) {
+	return Value::TIME_NS(value);
+}
+
 template <>
 Value Value::CreateValue(dtime_tz_t value) {
 	return Value::TIMETZ(value);
@@ -1113,6 +1146,8 @@ T Value::GetValueInternal() const {
 		return Cast::Operation<date_t, T>(value_.date);
 	case LogicalTypeId::TIME:
 		return Cast::Operation<dtime_t, T>(value_.time);
+	case LogicalTypeId::TIME_NS:
+		return Cast::Operation<dtime_ns_t, T>(value_.time_ns);
 	case LogicalTypeId::TIME_TZ:
 		return Cast::Operation<dtime_tz_t, T>(value_.timetz);
 	case LogicalTypeId::TIMESTAMP:
@@ -1246,6 +1281,11 @@ dtime_t Value::GetValue() const {
 	return GetValueInternal<dtime_t>();
 }
 
+template <>
+dtime_ns_t Value::GetValue() const {
+	return GetValueInternal<dtime_ns_t>();
+}
+
 template <>
 timestamp_t Value::GetValue() const {
 	return GetValueInternal<timestamp_t>();
@@ -1336,6 +1376,8 @@ Value Value::Numeric(const LogicalType &type, int64_t value) {
 		return Value::DATE(date_t(NumericCast<int32_t>(value)));
 	case LogicalTypeId::TIME:
 		return Value::TIME(dtime_t(value));
+	case LogicalTypeId::TIME_NS:
+		return Value::TIME_NS(dtime_ns_t(value));
 	case LogicalTypeId::TIMESTAMP:
 		return Value::TIMESTAMP(timestamp_t(value));
 	case LogicalTypeId::TIMESTAMP_SEC:
@@ -1462,6 +1504,11 @@ DUCKDB_API string_t Value::GetValueUnsafe() const {
 	return string_t(StringValue::Get(*this));
 }
 
+template <>
+DUCKDB_API bignum_t Value::GetValueUnsafe() const {
+	return bignum_t(StringValue::Get(*this));
+}
+
 template <>
 float Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::FLOAT);
@@ -1486,6 +1533,12 @@ dtime_t Value::GetValueUnsafe() const {
 	return value_.time;
 }
 
+template <>
+dtime_ns_t Value::GetValueUnsafe() const {
+	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
+	return value_.time_ns;
+}
+
 template <>
 dtime_tz_t Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
@@ -1575,6 +1628,7 @@ string Value::ToSQLString() const {
 		}
 		return "'" + StringUtil::Replace(ToString(), "'", "''") + "'";
 	}
+	case LogicalTypeId::VARIANT:
 	case LogicalTypeId::STRUCT: {
 		bool is_unnamed = StructType::IsUnnamed(type_);
 		string ret = is_unnamed ? "(" : "{";
@@ -1637,6 +1691,15 @@ string Value::ToSQLString() const {
 		ret += "]";
 		return ret;
 	}
+	case LogicalTypeId::UNION: {
+		string ret = "union_value(";
+		auto union_tag = UnionValue::GetTag(*this);
+		auto &tag_name = UnionType::GetMemberName(type(), union_tag);
+		ret += tag_name + " := ";
+		ret += UnionValue::GetValue(*this).ToSQLString();
+		ret += ")";
+		return ret;
+	}
 	default:
 		return ToString();
 	}