duckdb 1.1.2-dev6.0 → 1.1.4-dev11.0

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

@@ -1,11 +1,8 @@
 #include "duckdb/common/types/value.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/to_string.hpp"
 #include "duckdb/common/limits.hpp"
-#include "duckdb/common/operator/aggregate_operators.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
 
 #include "duckdb/common/uhugeint.hpp"
 #include "utf8proc_wrapper.hpp"
@@ -17,7 +14,6 @@
 #include "duckdb/common/types/hugeint.hpp"
 #include "duckdb/common/types/uuid.hpp"
 #include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/types/null_value.hpp"
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/common/types/bit.hpp"
@@ -26,7 +22,6 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/cast_helpers.hpp"
-#include "duckdb/common/types/hash.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/main/error_manager.hpp"
 #include "duckdb/common/types/varint.hpp"
@@ -227,32 +222,37 @@ 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::TIMESTAMP:
-		return Value::TIMESTAMP(Date::FromDate(Timestamp::MIN_YEAR, Timestamp::MIN_MONTH, Timestamp::MIN_DAY),
-		                        dtime_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));
+	}
 	case LogicalTypeId::TIMESTAMP_SEC: {
-		//	Casting rounds up, which will overflow
-		const auto min_us = MinimumValue(LogicalType::TIMESTAMP).GetValue<timestamp_t>();
-		return Value::TIMESTAMPSEC(timestamp_t(Timestamp::GetEpochSeconds(min_us)));
+		// Get the minimum timestamp and cast it to timestamp_sec_t.
+		const auto min_ts = MinimumValue(LogicalType::TIMESTAMP).GetValue<timestamp_t>();
+		const auto ts = Cast::Operation<timestamp_t, timestamp_sec_t>(min_ts);
+		return Value::TIMESTAMPSEC(ts);
 	}
 	case LogicalTypeId::TIMESTAMP_MS: {
-		//	Casting rounds up, which will overflow
-		const auto min_us = MinimumValue(LogicalType::TIMESTAMP).GetValue<timestamp_t>();
-		return Value::TIMESTAMPMS(timestamp_t(Timestamp::GetEpochMs(min_us)));
+		// Get the minimum timestamp and cast it to timestamp_ms_t.
+		const auto min_ts = MinimumValue(LogicalType::TIMESTAMP).GetValue<timestamp_t>();
+		const auto ts = Cast::Operation<timestamp_t, timestamp_ms_t>(min_ts);
+		return Value::TIMESTAMPMS(ts);
 	}
 	case LogicalTypeId::TIMESTAMP_NS: {
 		// Clear the fractional day.
 		auto min_ns = NumericLimits<int64_t>::Minimum();
 		min_ns /= Interval::NANOS_PER_DAY;
 		min_ns *= Interval::NANOS_PER_DAY;
-		return Value::TIMESTAMPNS(timestamp_t(min_ns));
+		return Value::TIMESTAMPNS(timestamp_ns_t(min_ns));
 	}
 	case LogicalTypeId::TIME_TZ:
 		//	"00:00:00+1559" from the PG docs, but actually 00:00:00+15:59:59
 		return Value::TIMETZ(dtime_tz_t(dtime_t(0), dtime_tz_t::MAX_OFFSET));
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return Value::TIMESTAMPTZ(Timestamp::FromDatetime(
-		    Date::FromDate(Timestamp::MIN_YEAR, Timestamp::MIN_MONTH, Timestamp::MIN_DAY), dtime_t(0)));
+	case LogicalTypeId::TIMESTAMP_TZ: {
+		const auto date = Date::FromDate(Timestamp::MIN_YEAR, Timestamp::MIN_MONTH, Timestamp::MIN_DAY);
+		const auto ts = Timestamp::FromDatetime(date, dtime_t(0));
+		return Value::TIMESTAMPTZ(timestamp_tz_t(ts));
+	}
 	case LogicalTypeId::FLOAT:
 		return Value::FLOAT(NumericLimits<float>::Minimum());
 	case LogicalTypeId::DOUBLE:
@@ -319,23 +319,27 @@ Value Value::MaximumValue(const LogicalType &type) {
 		return Value::TIME(dtime_t(Interval::MICROS_PER_DAY));
 	case LogicalTypeId::TIMESTAMP:
 		return Value::TIMESTAMP(timestamp_t(NumericLimits<int64_t>::Maximum() - 1));
+	case LogicalTypeId::TIMESTAMP_SEC: {
+		// Get the maximum timestamp and cast it to timestamp_s_t.
+		const auto max_ts = MaximumValue(LogicalType::TIMESTAMP).GetValue<timestamp_t>();
+		const auto ts = Cast::Operation<timestamp_t, timestamp_sec_t>(max_ts);
+		return Value::TIMESTAMPSEC(ts);
+	}
 	case LogicalTypeId::TIMESTAMP_MS: {
-		//	Casting rounds up, which will overflow
-		const auto max_us = MaximumValue(LogicalType::TIMESTAMP).GetValue<timestamp_t>();
-		return Value::TIMESTAMPMS(timestamp_t(Timestamp::GetEpochMs(max_us)));
+		// Get the maximum timestamp and cast it to timestamp_ms_t.
+		const auto max_ts = MaximumValue(LogicalType::TIMESTAMP).GetValue<timestamp_t>();
+		const auto ts = Cast::Operation<timestamp_t, timestamp_ms_t>(max_ts);
+		return Value::TIMESTAMPMS(ts);
 	}
-	case LogicalTypeId::TIMESTAMP_NS:
-		return Value::TIMESTAMPNS(timestamp_t(NumericLimits<int64_t>::Maximum() - 1));
-	case LogicalTypeId::TIMESTAMP_SEC: {
-		//	Casting rounds up, which will overflow
-		const auto max_us = MaximumValue(LogicalType::TIMESTAMP).GetValue<timestamp_t>();
-		return Value::TIMESTAMPSEC(timestamp_t(Timestamp::GetEpochSeconds(max_us)));
+	case LogicalTypeId::TIMESTAMP_NS: {
+		const auto ts = timestamp_ns_t(NumericLimits<int64_t>::Maximum() - 1);
+		return Value::TIMESTAMPNS(ts);
 	}
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return Value::TIMESTAMPTZ(timestamp_tz_t(NumericLimits<int64_t>::Maximum() - 1));
 	case LogicalTypeId::TIME_TZ:
-		//	"24:00:00-1559" from the PG docs but actually "24:00:00-15:59:59"
+		// "24:00:00-1559" from the PG docs but actually "24:00:00-15:59:59".
 		return Value::TIMETZ(dtime_tz_t(dtime_t(Interval::MICROS_PER_DAY), dtime_tz_t::MIN_OFFSET));
-	case LogicalTypeId::TIMESTAMP_TZ:
-		return MaximumValue(LogicalType::TIMESTAMP);
 	case LogicalTypeId::FLOAT:
 		return Value::FLOAT(NumericLimits<float>::Maximum());
 	case LogicalTypeId::DOUBLE:
@@ -376,14 +380,14 @@ Value Value::Infinity(const LogicalType &type) {
 		return Value::DATE(date_t::infinity());
 	case LogicalTypeId::TIMESTAMP:
 		return Value::TIMESTAMP(timestamp_t::infinity());
+	case LogicalTypeId::TIMESTAMP_SEC:
+		return Value::TIMESTAMPSEC(timestamp_sec_t(timestamp_t::infinity().value));
 	case LogicalTypeId::TIMESTAMP_MS:
-		return Value::TIMESTAMPMS(timestamp_t::infinity());
+		return Value::TIMESTAMPMS(timestamp_ms_t(timestamp_t::infinity().value));
 	case LogicalTypeId::TIMESTAMP_NS:
-		return Value::TIMESTAMPNS(timestamp_t::infinity());
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return Value::TIMESTAMPSEC(timestamp_t::infinity());
+		return Value::TIMESTAMPNS(timestamp_ns_t(timestamp_t::infinity().value));
 	case LogicalTypeId::TIMESTAMP_TZ:
-		return Value::TIMESTAMPTZ(timestamp_t::infinity());
+		return Value::TIMESTAMPTZ(timestamp_tz_t(timestamp_t::infinity()));
 	case LogicalTypeId::FLOAT:
 		return Value::FLOAT(std::numeric_limits<float>::infinity());
 	case LogicalTypeId::DOUBLE:
@@ -399,14 +403,14 @@ Value Value::NegativeInfinity(const LogicalType &type) {
 		return Value::DATE(date_t::ninfinity());
 	case LogicalTypeId::TIMESTAMP:
 		return Value::TIMESTAMP(timestamp_t::ninfinity());
+	case LogicalTypeId::TIMESTAMP_SEC:
+		return Value::TIMESTAMPSEC(timestamp_sec_t(timestamp_t::ninfinity().value));
 	case LogicalTypeId::TIMESTAMP_MS:
-		return Value::TIMESTAMPMS(timestamp_t::ninfinity());
+		return Value::TIMESTAMPMS(timestamp_ms_t(timestamp_t::ninfinity().value));
 	case LogicalTypeId::TIMESTAMP_NS:
-		return Value::TIMESTAMPNS(timestamp_t::ninfinity());
-	case LogicalTypeId::TIMESTAMP_SEC:
-		return Value::TIMESTAMPSEC(timestamp_t::ninfinity());
+		return Value::TIMESTAMPNS(timestamp_ns_t(timestamp_t::ninfinity().value));
 	case LogicalTypeId::TIMESTAMP_TZ:
-		return Value::TIMESTAMPTZ(timestamp_t::ninfinity());
+		return Value::TIMESTAMPTZ(timestamp_tz_t(timestamp_t::ninfinity()));
 	case LogicalTypeId::FLOAT:
 		return Value::FLOAT(-std::numeric_limits<float>::infinity());
 	case LogicalTypeId::DOUBLE:
@@ -545,6 +549,26 @@ bool Value::IsFinite(timestamp_t input) {
 	return Timestamp::IsFinite(input);
 }
 
+template <>
+bool Value::IsFinite(timestamp_sec_t input) {
+	return Timestamp::IsFinite(input);
+}
+
+template <>
+bool Value::IsFinite(timestamp_ms_t input) {
+	return Timestamp::IsFinite(input);
+}
+
+template <>
+bool Value::IsFinite(timestamp_ns_t input) {
+	return Timestamp::IsFinite(input);
+}
+
+template <>
+bool Value::IsFinite(timestamp_tz_t input) {
+	return Timestamp::IsFinite(input);
+}
+
 bool Value::StringIsValid(const char *str, idx_t length) {
 	auto utf_type = Utf8Proc::Analyze(str, length);
 	return utf_type != UnicodeType::INVALID;
@@ -652,30 +676,30 @@ Value Value::TIMESTAMP(timestamp_t value) {
 	return result;
 }
 
-Value Value::TIMESTAMPTZ(timestamp_t value) {
-	Value result(LogicalType::TIMESTAMP_TZ);
-	result.value_.timestamp = value;
+Value Value::TIMESTAMPSEC(timestamp_sec_t timestamp) {
+	Value result(LogicalType::TIMESTAMP_S);
+	result.value_.timestamp_s = timestamp;
 	result.is_null = false;
 	return result;
 }
 
-Value Value::TIMESTAMPNS(timestamp_t timestamp) {
-	Value result(LogicalType::TIMESTAMP_NS);
-	result.value_.timestamp = timestamp;
+Value Value::TIMESTAMPMS(timestamp_ms_t timestamp) {
+	Value result(LogicalType::TIMESTAMP_MS);
+	result.value_.timestamp_ms = timestamp;
 	result.is_null = false;
 	return result;
 }
 
-Value Value::TIMESTAMPMS(timestamp_t timestamp) {
-	Value result(LogicalType::TIMESTAMP_MS);
-	result.value_.timestamp = timestamp;
+Value Value::TIMESTAMPNS(timestamp_ns_t timestamp) {
+	Value result(LogicalType::TIMESTAMP_NS);
+	result.value_.timestamp_ns = timestamp;
 	result.is_null = false;
 	return result;
 }
 
-Value Value::TIMESTAMPSEC(timestamp_t timestamp) {
-	Value result(LogicalType::TIMESTAMP_S);
-	result.value_.timestamp = timestamp;
+Value Value::TIMESTAMPTZ(timestamp_tz_t value) {
+	Value result(LogicalType::TIMESTAMP_TZ);
+	result.value_.timestamp_tz = value;
 	result.is_null = false;
 	return result;
 }
@@ -686,7 +710,9 @@ Value Value::TIMESTAMP(date_t date, dtime_t time) {
 
 Value Value::TIMESTAMP(int32_t year, int32_t month, int32_t day, int32_t hour, int32_t min, int32_t sec,
                        int32_t micros) {
-	auto val = Value::TIMESTAMP(Date::FromDate(year, month, day), Time::FromTime(hour, min, sec, micros));
+	auto date = Date::FromDate(year, month, day);
+	auto time = Time::FromTime(hour, min, sec, micros);
+	auto val = Value::TIMESTAMP(date, time);
 	val.type_ = LogicalType::TIMESTAMP;
 	return val;
 }
@@ -702,6 +728,7 @@ Value Value::STRUCT(const LogicalType &type, vector<Value> struct_values) {
 	result.is_null = false;
 	return result;
 }
+
 Value Value::STRUCT(child_list_t<Value> values) {
 	child_list_t<LogicalType> child_types;
 	vector<Value> struct_values;
@@ -712,16 +739,37 @@ 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) {
+	// 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()) {
+		MapVector::EvalMapInvalidReason(MapInvalidReason::DUPLICATE_KEY);
+	}
+	unique_keys.insert(key_hash);
+}
+
 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;
+
 	for (auto &val : values) {
 		D_ASSERT(val.type().InternalType() == PhysicalType::STRUCT);
 		auto &children = StructValue::GetChildren(val);
 		D_ASSERT(children.size() == 2);
-		map_keys.push_back(children[0]);
+
+		auto &key = children[0];
+		MapKeyCheck(unique_keys, key);
+
+		map_keys.push_back(key);
 		map_values.push_back(children[1]);
 	}
+
 	auto &key_type = StructType::GetChildType(child_type, 0);
 	auto &value_type = StructType::GetChildType(child_type, 1);
 	return Value::MAP(key_type, value_type, std::move(map_keys), std::move(map_values));
@@ -733,13 +781,26 @@ 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;
+
 	for (idx_t i = 0; i < keys.size(); i++) {
-		child_list_t<Value> new_children;
+		child_list_t<LogicalType> struct_types;
+		vector<Value> new_children;
+		struct_types.reserve(2);
 		new_children.reserve(2);
-		new_children.push_back(std::make_pair("key", std::move(keys[i])));
-		new_children.push_back(std::make_pair("value", std::move(values[i])));
-		values[i] = Value::STRUCT(std::move(new_children));
+
+		struct_types.push_back(make_pair("key", key_type));
+		struct_types.push_back(make_pair("value", value_type));
+
+		auto key = keys[i].DefaultCastAs(key_type);
+		MapKeyCheck(unique_keys, key);
+
+		new_children.push_back(key);
+		new_children.push_back(values[i]);
+		auto struct_type = LogicalType::STRUCT(std::move(struct_types));
+		values[i] = Value::STRUCT(struct_type, std::move(new_children));
 	}
+
 	result.value_info_ = make_shared_ptr<NestedValueInfo>(std::move(values));
 	return result;
 }
@@ -781,72 +842,33 @@ Value Value::UNION(child_list_t<LogicalType> members, uint8_t tag, Value value)
 	return result;
 }
 
-Value Value::LIST(vector<Value> values) {
-	if (values.empty()) {
-		throw InternalException("Value::LIST without providing a child-type requires a non-empty list of values. Use "
-		                        "Value::LIST(child_type, list) instead.");
-	}
-#ifdef DEBUG
-	for (idx_t i = 1; i < values.size(); i++) {
-		D_ASSERT(values[i].type() == values[0].type());
-	}
-#endif
+Value Value::LIST(const LogicalType &child_type, vector<Value> values) {
 	Value result;
-	result.type_ = LogicalType::LIST(values[0].type());
-	result.value_info_ = make_shared_ptr<NestedValueInfo>(std::move(values));
+	result.type_ = LogicalType::LIST(child_type);
 	result.is_null = false;
-	return result;
-}
-
-Value Value::LIST(const LogicalType &child_type, vector<Value> values) {
-	if (values.empty()) {
-		return Value::EMPTYLIST(child_type);
-	}
 	for (auto &val : values) {
 		val = val.DefaultCastAs(child_type);
 	}
-	return Value::LIST(std::move(values));
-}
-
-Value Value::EMPTYLIST(const LogicalType &child_type) {
-	Value result;
-	result.type_ = LogicalType::LIST(child_type);
-	result.value_info_ = make_shared_ptr<NestedValueInfo>();
-	result.is_null = false;
+	result.value_info_ = make_shared_ptr<NestedValueInfo>(std::move(values));
 	return result;
 }
 
-Value Value::ARRAY(vector<Value> values) {
+Value Value::LIST(vector<Value> values) {
 	if (values.empty()) {
-		throw InternalException("Value::ARRAY without providing a child-type requires a non-empty list of values. Use "
-		                        "Value::ARRAY(child_type, list) instead.");
+		throw InternalException(
+		    "Value::LIST(values) cannot be used to make an empty list - use Value::LIST(type, values) instead");
 	}
-#ifdef DEBUG
-	for (idx_t i = 1; i < values.size(); i++) {
-		D_ASSERT(values[i].type() == values[0].type());
-	}
-#endif
-	Value result;
-	result.type_ = LogicalType::ARRAY(values[0].type(), values.size());
-	result.value_info_ = make_shared_ptr<NestedValueInfo>(std::move(values));
-	result.is_null = false;
-	return result;
+	auto &type = values[0].type();
+	return Value::LIST(type, std::move(values));
 }
 
 Value Value::ARRAY(const LogicalType &child_type, vector<Value> values) {
-	if (values.empty()) {
-		return Value::EMPTYARRAY(child_type, 0);
-	}
+	Value result;
+	result.type_ = LogicalType::ARRAY(child_type, values.size());
 	for (auto &val : values) {
 		val = val.DefaultCastAs(child_type);
 	}
-	return Value::ARRAY(std::move(values));
-}
-
-Value Value::EMPTYARRAY(const LogicalType &child_type, uint32_t size) {
-	Value result;
-	result.type_ = LogicalType::ARRAY(child_type, size);
-	result.value_info_ = make_shared_ptr<NestedValueInfo>();
+	result.value_info_ = make_shared_ptr<NestedValueInfo>(std::move(values));
 	result.is_null = false;
 	return result;
 }
@@ -1094,17 +1116,21 @@ T Value::GetValueInternal() const {
 	case LogicalTypeId::TIME_TZ:
 		return Cast::Operation<dtime_tz_t, T>(value_.timetz);
 	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
 		return Cast::Operation<timestamp_t, T>(value_.timestamp);
+	case LogicalTypeId::TIMESTAMP_SEC:
+		return Cast::Operation<timestamp_sec_t, T>(value_.timestamp_s);
+	case LogicalTypeId::TIMESTAMP_MS:
+		return Cast::Operation<timestamp_ms_t, T>(value_.timestamp_ms);
+	case LogicalTypeId::TIMESTAMP_NS:
+		return Cast::Operation<timestamp_ns_t, T>(value_.timestamp_ns);
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return Cast::Operation<timestamp_tz_t, T>(value_.timestamp_tz);
 	case LogicalTypeId::UTINYINT:
 		return Cast::Operation<uint8_t, T>(value_.utinyint);
 	case LogicalTypeId::USMALLINT:
 		return Cast::Operation<uint16_t, T>(value_.usmallint);
 	case LogicalTypeId::UINTEGER:
 		return Cast::Operation<uint32_t, T>(value_.uinteger);
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::TIMESTAMP_SEC:
 	case LogicalTypeId::UBIGINT:
 		return Cast::Operation<uint64_t, T>(value_.ubigint);
 	case LogicalTypeId::FLOAT:
@@ -1160,11 +1186,16 @@ int64_t Value::GetValue() const {
 	}
 	switch (type_.id()) {
 	case LogicalTypeId::TIMESTAMP:
+		return value_.timestamp.value;
 	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_NS:
+		return value_.timestamp_s.value;
 	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIME:
+		return value_.timestamp_ms.value;
+	case LogicalTypeId::TIMESTAMP_NS:
+		return value_.timestamp_ns.value;
 	case LogicalTypeId::TIMESTAMP_TZ:
+		return value_.timestamp_tz.value;
+	case LogicalTypeId::TIME:
 		return value_.bigint;
 	default:
 		return GetValueInternal<int64_t>();
@@ -1214,10 +1245,32 @@ template <>
 dtime_t Value::GetValue() const {
 	return GetValueInternal<dtime_t>();
 }
+
 template <>
 timestamp_t Value::GetValue() const {
 	return GetValueInternal<timestamp_t>();
 }
+
+template <>
+timestamp_sec_t Value::GetValue() const {
+	return GetValueInternal<timestamp_sec_t>();
+}
+
+template <>
+timestamp_ms_t Value::GetValue() const {
+	return GetValueInternal<timestamp_ms_t>();
+}
+
+template <>
+timestamp_ns_t Value::GetValue() const {
+	return GetValueInternal<timestamp_ns_t>();
+}
+
+template <>
+timestamp_tz_t Value::GetValue() const {
+	return GetValueInternal<timestamp_tz_t>();
+}
+
 template <>
 dtime_tz_t Value::GetValue() const {
 	return GetValueInternal<dtime_tz_t>();
@@ -1285,14 +1338,14 @@ Value Value::Numeric(const LogicalType &type, int64_t value) {
 		return Value::TIME(dtime_t(value));
 	case LogicalTypeId::TIMESTAMP:
 		return Value::TIMESTAMP(timestamp_t(value));
-	case LogicalTypeId::TIMESTAMP_NS:
-		return Value::TIMESTAMPNS(timestamp_t(value));
-	case LogicalTypeId::TIMESTAMP_MS:
-		return Value::TIMESTAMPMS(timestamp_t(value));
 	case LogicalTypeId::TIMESTAMP_SEC:
-		return Value::TIMESTAMPSEC(timestamp_t(value));
+		return Value::TIMESTAMPSEC(timestamp_sec_t(value));
+	case LogicalTypeId::TIMESTAMP_MS:
+		return Value::TIMESTAMPMS(timestamp_ms_t(value));
+	case LogicalTypeId::TIMESTAMP_NS:
+		return Value::TIMESTAMPNS(timestamp_ns_t(value));
 	case LogicalTypeId::TIMESTAMP_TZ:
-		return Value::TIMESTAMPTZ(timestamp_t(value));
+		return Value::TIMESTAMPTZ(timestamp_tz_t(value));
 	case LogicalTypeId::ENUM:
 		switch (type.InternalType()) {
 		case PhysicalType::UINT8:
@@ -1457,6 +1510,30 @@ timestamp_t Value::GetValueUnsafe() const {
 	return value_.timestamp;
 }
 
+template <>
+timestamp_sec_t Value::GetValueUnsafe() const {
+	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
+	return value_.timestamp_s;
+}
+
+template <>
+timestamp_ms_t Value::GetValueUnsafe() const {
+	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
+	return value_.timestamp_ms;
+}
+
+template <>
+timestamp_ns_t Value::GetValueUnsafe() const {
+	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
+	return value_.timestamp_ns;
+}
+
+template <>
+timestamp_tz_t Value::GetValueUnsafe() const {
+	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
+	return value_.timestamp_tz;
+}
+
 template <>
 interval_t Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::INTERVAL);
@@ -1471,7 +1548,7 @@ hash_t Value::Hash() const {
 		return 0;
 	}
 	Vector input(*this);
-	Vector result(LogicalType::HASH);
+	Vector result(LogicalType::HASH, 1);
 	VectorOperations::Hash(input, result, 1);
 
 	auto data = FlatVector::GetData<hash_t>(result);
@@ -1503,8 +1580,13 @@ string Value::ToSQLString() const {
 	case LogicalTypeId::BLOB:
 		return "'" + ToString() + "'::" + type_.ToString();
 	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::ENUM:
+	case LogicalTypeId::ENUM: {
+		auto str_val = ToString();
+		if (str_val.size() == 1 && str_val[0] == '\0') {
+			return "chr(0)";
+		}
 		return "'" + StringUtil::Replace(ToString(), "'", "''") + "'";
+	}
 	case LogicalTypeId::STRUCT: {
 		bool is_unnamed = StructType::IsUnnamed(type_);
 		string ret = is_unnamed ? "(" : "{";
@@ -1648,6 +1730,22 @@ timestamp_t TimestampValue::Get(const Value &value) {
 	return value.GetValueUnsafe<timestamp_t>();
 }
 
+timestamp_sec_t TimestampSValue::Get(const Value &value) {
+	return value.GetValueUnsafe<timestamp_sec_t>();
+}
+
+timestamp_ms_t TimestampMSValue::Get(const Value &value) {
+	return value.GetValueUnsafe<timestamp_ms_t>();
+}
+
+timestamp_ns_t TimestampNSValue::Get(const Value &value) {
+	return value.GetValueUnsafe<timestamp_ns_t>();
+}
+
+timestamp_tz_t TimestampTZValue::Get(const Value &value) {
+	return value.GetValueUnsafe<timestamp_tz_t>();
+}
+
 interval_t IntervalValue::Get(const Value &value) {
 	return value.GetValueUnsafe<interval_t>();
 }
@@ -1817,6 +1915,9 @@ bool Value::DefaultTryCastAs(const LogicalType &target_type, Value &new_value, s
 
 Value Value::CastAs(CastFunctionSet &set, GetCastFunctionInput &get_input, const LogicalType &target_type,
                     bool strict) const {
+	if (target_type.id() == LogicalTypeId::ANY) {
+		return *this;
+	}
 	Value new_value;
 	string error_message;
 	if (!TryCastAs(set, get_input, target_type, new_value, &error_message, strict)) {
@@ -1865,89 +1966,136 @@ void Value::Reinterpret(LogicalType new_type) {
 	this->type_ = std::move(new_type);
 }
 
-void Value::Serialize(Serializer &serializer) const {
-	serializer.WriteProperty(100, "type", type_);
-	serializer.WriteProperty(101, "is_null", is_null);
-	if (!IsNull()) {
-		switch (type_.InternalType()) {
-		case PhysicalType::BIT:
-			throw InternalException("BIT type should not be serialized");
-		case PhysicalType::BOOL:
-			serializer.WriteProperty(102, "value", value_.boolean);
-			break;
-		case PhysicalType::INT8:
-			serializer.WriteProperty(102, "value", value_.tinyint);
-			break;
-		case PhysicalType::INT16:
-			serializer.WriteProperty(102, "value", value_.smallint);
-			break;
-		case PhysicalType::INT32:
-			serializer.WriteProperty(102, "value", value_.integer);
-			break;
-		case PhysicalType::INT64:
-			serializer.WriteProperty(102, "value", value_.bigint);
-			break;
-		case PhysicalType::UINT8:
-			serializer.WriteProperty(102, "value", value_.utinyint);
-			break;
-		case PhysicalType::UINT16:
-			serializer.WriteProperty(102, "value", value_.usmallint);
-			break;
-		case PhysicalType::UINT32:
-			serializer.WriteProperty(102, "value", value_.uinteger);
-			break;
-		case PhysicalType::UINT64:
-			serializer.WriteProperty(102, "value", value_.ubigint);
-			break;
-		case PhysicalType::INT128:
-			serializer.WriteProperty(102, "value", value_.hugeint);
-			break;
-		case PhysicalType::UINT128:
-			serializer.WriteProperty(102, "value", value_.uhugeint);
-			break;
-		case PhysicalType::FLOAT:
-			serializer.WriteProperty(102, "value", value_.float_);
-			break;
-		case PhysicalType::DOUBLE:
-			serializer.WriteProperty(102, "value", value_.double_);
-			break;
-		case PhysicalType::INTERVAL:
-			serializer.WriteProperty(102, "value", value_.interval);
-			break;
-		case PhysicalType::VARCHAR: {
-			if (type_.id() == LogicalTypeId::BLOB) {
-				auto blob_str = Blob::ToString(StringValue::Get(*this));
-				serializer.WriteProperty(102, "value", blob_str);
-			} else {
-				serializer.WriteProperty(102, "value", StringValue::Get(*this));
+const LogicalType &GetChildType(const LogicalType &parent_type, idx_t i) {
+	switch (parent_type.InternalType()) {
+	case PhysicalType::LIST:
+		return ListType::GetChildType(parent_type);
+	case PhysicalType::STRUCT:
+		return StructType::GetChildType(parent_type, i);
+	case PhysicalType::ARRAY:
+		return ArrayType::GetChildType(parent_type);
+	default:
+		throw InternalException("Parent type is not a nested type");
+	}
+}
+
+bool SerializeTypeMatches(const LogicalType &expected_type, const LogicalType &actual_type) {
+	if (expected_type.id() != actual_type.id()) {
+		// type id needs to be the same
+		return false;
+	}
+	if (expected_type.IsNested()) {
+		// for nested types that is enough - we will recurse into the children and check there again anyway
+		return true;
+	}
+	// otherwise we do a deep comparison of the type (e.g. decimal flags need to be consistent)
+	return expected_type == actual_type;
+}
+
+void Value::SerializeChildren(Serializer &serializer, const vector<Value> &children, const LogicalType &parent_type) {
+	serializer.WriteObject(102, "value", [&](Serializer &child_serializer) {
+		child_serializer.WriteList(100, "children", children.size(), [&](Serializer::List &list, idx_t i) {
+			auto &value_type = GetChildType(parent_type, i);
+			bool serialize_type = value_type.InternalType() == PhysicalType::INVALID;
+			if (!serialize_type && !SerializeTypeMatches(value_type, children[i].type())) {
+				throw InternalException("Error when serializing type - serializing a child of a nested value with type "
+				                        "%s, but expected type %s",
+				                        children[i].type(), value_type);
 			}
-		} break;
-		case PhysicalType::LIST: {
-			serializer.WriteObject(102, "value", [&](Serializer &serializer) {
-				auto &children = ListValue::GetChildren(*this);
-				serializer.WriteProperty(100, "children", children);
+			list.WriteObject([&](Serializer &element_serializer) {
+				children[i].SerializeInternal(element_serializer, serialize_type);
 			});
-		} break;
-		case PhysicalType::STRUCT: {
-			serializer.WriteObject(102, "value", [&](Serializer &serializer) {
-				auto &children = StructValue::GetChildren(*this);
-				serializer.WriteProperty(100, "children", children);
-			});
-		} break;
-		case PhysicalType::ARRAY: {
-			serializer.WriteObject(102, "value", [&](Serializer &serializer) {
-				auto &children = ArrayValue::GetChildren(*this);
-				serializer.WriteProperty(100, "children", children);
-			});
-		} break;
-		default:
-			throw NotImplementedException("Unimplemented type for Serialize");
+		});
+	});
+}
+
+void Value::SerializeInternal(Serializer &serializer, bool serialize_type) const {
+	if (serialize_type || !serializer.ShouldSerialize(4)) {
+		// only the root value needs to serialize its type
+		// for forwards compatibility reasons, we also serialize the type always when targeting versions < v1.2.0
+		serializer.WriteProperty(100, "type", type_);
+	}
+	serializer.WriteProperty(101, "is_null", is_null);
+	if (IsNull()) {
+		return;
+	}
+	switch (type_.InternalType()) {
+	case PhysicalType::BIT:
+		throw InternalException("BIT type should not be serialized");
+	case PhysicalType::BOOL:
+		serializer.WriteProperty(102, "value", value_.boolean);
+		break;
+	case PhysicalType::INT8:
+		serializer.WriteProperty(102, "value", value_.tinyint);
+		break;
+	case PhysicalType::INT16:
+		serializer.WriteProperty(102, "value", value_.smallint);
+		break;
+	case PhysicalType::INT32:
+		serializer.WriteProperty(102, "value", value_.integer);
+		break;
+	case PhysicalType::INT64:
+		serializer.WriteProperty(102, "value", value_.bigint);
+		break;
+	case PhysicalType::UINT8:
+		serializer.WriteProperty(102, "value", value_.utinyint);
+		break;
+	case PhysicalType::UINT16:
+		serializer.WriteProperty(102, "value", value_.usmallint);
+		break;
+	case PhysicalType::UINT32:
+		serializer.WriteProperty(102, "value", value_.uinteger);
+		break;
+	case PhysicalType::UINT64:
+		serializer.WriteProperty(102, "value", value_.ubigint);
+		break;
+	case PhysicalType::INT128:
+		serializer.WriteProperty(102, "value", value_.hugeint);
+		break;
+	case PhysicalType::UINT128:
+		serializer.WriteProperty(102, "value", value_.uhugeint);
+		break;
+	case PhysicalType::FLOAT:
+		serializer.WriteProperty(102, "value", value_.float_);
+		break;
+	case PhysicalType::DOUBLE:
+		serializer.WriteProperty(102, "value", value_.double_);
+		break;
+	case PhysicalType::INTERVAL:
+		serializer.WriteProperty(102, "value", value_.interval);
+		break;
+	case PhysicalType::VARCHAR: {
+		if (type_.id() == LogicalTypeId::BLOB) {
+			auto blob_str = Blob::ToString(StringValue::Get(*this));
+			serializer.WriteProperty(102, "value", blob_str);
+		} else {
+			serializer.WriteProperty(102, "value", StringValue::Get(*this));
 		}
+	} break;
+	case PhysicalType::LIST:
+		SerializeChildren(serializer, ListValue::GetChildren(*this), type_);
+		break;
+	case PhysicalType::STRUCT:
+		SerializeChildren(serializer, StructValue::GetChildren(*this), type_);
+		break;
+	case PhysicalType::ARRAY:
+		SerializeChildren(serializer, ArrayValue::GetChildren(*this), type_);
+		break;
+	default:
+		throw NotImplementedException("Unimplemented type for Serialize");
 	}
 }
 
+void Value::Serialize(Serializer &serializer) const {
+	// serialize the value - the top-level value always needs to serialize its type
+	SerializeInternal(serializer, true);
+}
+
 Value Value::Deserialize(Deserializer &deserializer) {
-	auto type = deserializer.ReadProperty<LogicalType>(100, "type");
+	auto type = deserializer.ReadPropertyWithExplicitDefault<LogicalType>(100, "type", LogicalTypeId::INVALID);
+	if (type.InternalType() == PhysicalType::INVALID) {
+		type = deserializer.Get<const LogicalType &>();
+	}
 	auto is_null = deserializer.ReadProperty<bool>(101, "is_null");
 	Value new_value = Value(type);
 	if (is_null) {
@@ -2008,22 +2156,32 @@ Value Value::Deserialize(Deserializer &deserializer) {
 		}
 	} break;
 	case PhysicalType::LIST: {
+		deserializer.Set<const LogicalType &>(ListType::GetChildType(type));
 		deserializer.ReadObject(102, "value", [&](Deserializer &obj) {
 			auto children = obj.ReadProperty<vector<Value>>(100, "children");
 			new_value.value_info_ = make_shared_ptr<NestedValueInfo>(children);
 		});
+		deserializer.Unset<LogicalType>();
 	} break;
 	case PhysicalType::STRUCT: {
 		deserializer.ReadObject(102, "value", [&](Deserializer &obj) {
-			auto children = obj.ReadProperty<vector<Value>>(100, "children");
+			vector<Value> children;
+			obj.ReadList(100, "children", [&](Deserializer::List &list, idx_t i) {
+				deserializer.Set<const LogicalType &>(StructType::GetChildType(type, i));
+				auto child = list.ReadElement<Value>();
+				deserializer.Unset<LogicalType>();
+				children.push_back(std::move(child));
+			});
 			new_value.value_info_ = make_shared_ptr<NestedValueInfo>(children);
 		});
 	} break;
 	case PhysicalType::ARRAY: {
+		deserializer.Set<const LogicalType &>(ArrayType::GetChildType(type));
 		deserializer.ReadObject(102, "value", [&](Deserializer &obj) {
 			auto children = obj.ReadProperty<vector<Value>>(100, "children");
 			new_value.value_info_ = make_shared_ptr<NestedValueInfo>(children);
 		});
+		deserializer.Unset<LogicalType>();
 	} break;
 	default:
 		throw NotImplementedException("Unimplemented type for Deserialize");