duckdb 0.7.2-dev12.0 → 0.7.2-dev1244.0

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

@@ -30,11 +30,102 @@
 #include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/main/error_manager.hpp"
 
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+
 #include <utility>
 #include <cmath>
 
 namespace duckdb {
 
+//===--------------------------------------------------------------------===//
+// Extra Value Info
+//===--------------------------------------------------------------------===//
+enum class ExtraValueInfoType : uint8_t { INVALID_TYPE_INFO = 0, STRING_VALUE_INFO = 1, NESTED_VALUE_INFO = 2 };
+
+struct ExtraValueInfo {
+	explicit ExtraValueInfo(ExtraValueInfoType type) : type(type) {
+	}
+	virtual ~ExtraValueInfo() {
+	}
+
+	ExtraValueInfoType type;
+
+public:
+	bool Equals(ExtraValueInfo *other_p) const {
+		if (!other_p) {
+			return false;
+		}
+		if (type != other_p->type) {
+			return false;
+		}
+		return EqualsInternal(other_p);
+	}
+
+	template <class T>
+	T &Get() {
+		if (type != T::TYPE) {
+			throw InternalException("ExtraValueInfo type mismatch");
+		}
+		return (T &)*this;
+	}
+
+protected:
+	virtual bool EqualsInternal(ExtraValueInfo *other_p) const {
+		return true;
+	}
+};
+
+//===--------------------------------------------------------------------===//
+// String Value Info
+//===--------------------------------------------------------------------===//
+struct StringValueInfo : public ExtraValueInfo {
+	static constexpr const ExtraValueInfoType TYPE = ExtraValueInfoType::STRING_VALUE_INFO;
+
+public:
+	explicit StringValueInfo(string str_p)
+	    : ExtraValueInfo(ExtraValueInfoType::STRING_VALUE_INFO), str(std::move(str_p)) {
+	}
+
+	const string &GetString() {
+		return str;
+	}
+
+protected:
+	bool EqualsInternal(ExtraValueInfo *other_p) const override {
+		return other_p->Get<StringValueInfo>().str == str;
+	}
+
+	string str;
+};
+
+//===--------------------------------------------------------------------===//
+// Nested Value Info
+//===--------------------------------------------------------------------===//
+struct NestedValueInfo : public ExtraValueInfo {
+	static constexpr const ExtraValueInfoType TYPE = ExtraValueInfoType::NESTED_VALUE_INFO;
+
+public:
+	NestedValueInfo() : ExtraValueInfo(ExtraValueInfoType::NESTED_VALUE_INFO) {
+	}
+	explicit NestedValueInfo(vector<Value> values_p)
+	    : ExtraValueInfo(ExtraValueInfoType::NESTED_VALUE_INFO), values(std::move(values_p)) {
+	}
+
+	const vector<Value> &GetValues() {
+		return values;
+	}
+
+protected:
+	bool EqualsInternal(ExtraValueInfo *other_p) const override {
+		return other_p->Get<NestedValueInfo>().values == values;
+	}
+
+	vector<Value> values;
+};
+//===--------------------------------------------------------------------===//
+// Value
+//===--------------------------------------------------------------------===//
 Value::Value(LogicalType type) : type_(std::move(type)), is_null(true) {
 }
 
@@ -60,36 +151,36 @@ Value::Value(const char *val) : Value(val ? string(val) : string()) {
 Value::Value(std::nullptr_t val) : Value(LogicalType::VARCHAR) {
 }
 
-Value::Value(string_t val) : Value(string(val.GetDataUnsafe(), val.GetSize())) {
+Value::Value(string_t val) : Value(val.GetString()) {
 }
 
-Value::Value(string val) : type_(LogicalType::VARCHAR), is_null(false), str_value(std::move(val)) {
-	if (!Value::StringIsValid(str_value.c_str(), str_value.size())) {
-		throw Exception(ErrorManager::InvalidUnicodeError(str_value, "value construction"));
+Value::Value(string val) : type_(LogicalType::VARCHAR), is_null(false) {
+	if (!Value::StringIsValid(val.c_str(), val.size())) {
+		throw Exception(ErrorManager::InvalidUnicodeError(val, "value construction"));
 	}
+	value_info_ = make_shared<StringValueInfo>(std::move(val));
 }
 
 Value::~Value() {
 }
 
 Value::Value(const Value &other)
-    : type_(other.type_), is_null(other.is_null), value_(other.value_), str_value(other.str_value),
-      struct_value(other.struct_value), list_value(other.list_value) {
+    : type_(other.type_), is_null(other.is_null), value_(other.value_), value_info_(other.value_info_) {
 }
 
 Value::Value(Value &&other) noexcept
     : type_(std::move(other.type_)), is_null(other.is_null), value_(other.value_),
-      str_value(std::move(other.str_value)), struct_value(std::move(other.struct_value)),
-      list_value(std::move(other.list_value)) {
+      value_info_(std::move(other.value_info_)) {
 }
 
 Value &Value::operator=(const Value &other) {
+	if (this == &other) {
+		return *this;
+	}
 	type_ = other.type_;
 	is_null = other.is_null;
 	value_ = other.value_;
-	str_value = other.str_value;
-	struct_value = other.struct_value;
-	list_value = other.list_value;
+	value_info_ = other.value_info_;
 	return *this;
 }
 
@@ -97,9 +188,7 @@ Value &Value::operator=(Value &&other) noexcept {
 	type_ = std::move(other.type_);
 	is_null = other.is_null;
 	value_ = other.value_;
-	str_value = std::move(other.str_value);
-	struct_value = std::move(other.struct_value);
-	list_value = std::move(other.list_value);
+	value_info_ = std::move(other.value_info_);
 	return *this;
 }
 
@@ -241,9 +330,55 @@ Value Value::MaximumValue(const LogicalType &type) {
 	}
 }
 
+Value Value::Infinity(const LogicalType &type) {
+	switch (type.id()) {
+	case LogicalTypeId::DATE:
+		return Value::DATE(date_t::infinity());
+	case LogicalTypeId::TIMESTAMP:
+		return Value::TIMESTAMP(timestamp_t::infinity());
+	case LogicalTypeId::TIMESTAMP_MS:
+		return Value::TIMESTAMPMS(timestamp_t::infinity());
+	case LogicalTypeId::TIMESTAMP_NS:
+		return Value::TIMESTAMPNS(timestamp_t::infinity());
+	case LogicalTypeId::TIMESTAMP_SEC:
+		return Value::TIMESTAMPSEC(timestamp_t::infinity());
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return Value::TIMESTAMPTZ(timestamp_t::infinity());
+	case LogicalTypeId::FLOAT:
+		return Value::FLOAT(std::numeric_limits<float>::infinity());
+	case LogicalTypeId::DOUBLE:
+		return Value::DOUBLE(std::numeric_limits<double>::infinity());
+	default:
+		throw InvalidTypeException(type, "Infinity requires numeric type");
+	}
+}
+
+Value Value::NegativeInfinity(const LogicalType &type) {
+	switch (type.id()) {
+	case LogicalTypeId::DATE:
+		return Value::DATE(date_t::ninfinity());
+	case LogicalTypeId::TIMESTAMP:
+		return Value::TIMESTAMP(timestamp_t::ninfinity());
+	case LogicalTypeId::TIMESTAMP_MS:
+		return Value::TIMESTAMPMS(timestamp_t::ninfinity());
+	case LogicalTypeId::TIMESTAMP_NS:
+		return Value::TIMESTAMPNS(timestamp_t::ninfinity());
+	case LogicalTypeId::TIMESTAMP_SEC:
+		return Value::TIMESTAMPSEC(timestamp_t::ninfinity());
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return Value::TIMESTAMPTZ(timestamp_t::ninfinity());
+	case LogicalTypeId::FLOAT:
+		return Value::FLOAT(-std::numeric_limits<float>::infinity());
+	case LogicalTypeId::DOUBLE:
+		return Value::DOUBLE(-std::numeric_limits<double>::infinity());
+	default:
+		throw InvalidTypeException(type, "NegativeInfinity requires numeric type");
+	}
+}
+
 Value Value::BOOLEAN(int8_t value) {
 	Value result(LogicalType::BOOLEAN);
-	result.value_.boolean = value ? true : false;
+	result.value_.boolean = bool(value);
 	result.is_null = false;
 	return result;
 }
@@ -512,30 +647,28 @@ Value Value::TIMESTAMP(int32_t year, int32_t month, int32_t day, int32_t hour, i
 Value Value::STRUCT(child_list_t<Value> values) {
 	Value result;
 	child_list_t<LogicalType> child_types;
+	vector<Value> struct_values;
 	for (auto &child : values) {
 		child_types.push_back(make_pair(std::move(child.first), child.second.type()));
-		result.struct_value.push_back(std::move(child.second));
+		struct_values.push_back(std::move(child.second));
 	}
-	result.type_ = LogicalType::STRUCT(std::move(child_types));
-
+	result.value_info_ = make_shared<NestedValueInfo>(std::move(struct_values));
+	result.type_ = LogicalType::STRUCT(child_types);
 	result.is_null = false;
 	return result;
 }
 
-Value Value::MAP(LogicalType child_type, vector<Value> values) {
+Value Value::MAP(const LogicalType &child_type, vector<Value> values) {
 	Value result;
 
-	result.type_ = LogicalType::MAP(std::move(child_type));
+	result.type_ = LogicalType::MAP(child_type);
 	result.is_null = false;
-	if (values.empty()) {
-		return result;
-	}
-	result.list_value = std::move(values);
+	result.value_info_ = make_shared<NestedValueInfo>(std::move(values));
 	return result;
 }
 
 Value Value::UNION(child_list_t<LogicalType> members, uint8_t tag, Value value) {
-	D_ASSERT(members.size() > 0);
+	D_ASSERT(!members.empty());
 	D_ASSERT(members.size() <= UnionType::MAX_UNION_MEMBERS);
 	D_ASSERT(members.size() > tag);
 
@@ -544,16 +677,17 @@ Value Value::UNION(child_list_t<LogicalType> members, uint8_t tag, Value value)
 	Value result;
 	result.is_null = false;
 	// add the tag to the front of the struct
-	result.struct_value.emplace_back(Value::TINYINT(tag));
+	vector<Value> union_values;
+	union_values.emplace_back(Value::TINYINT(tag));
 	for (idx_t i = 0; i < members.size(); i++) {
 		if (i != tag) {
-			result.struct_value.emplace_back(members[i].second);
+			union_values.emplace_back(members[i].second);
 		} else {
-			result.struct_value.emplace_back(nullptr);
+			union_values.emplace_back(nullptr);
 		}
 	}
-	result.struct_value[tag + 1] = std::move(value);
-
+	union_values[tag + 1] = std::move(value);
+	result.value_info_ = make_shared<NestedValueInfo>(std::move(union_values));
 	result.type_ = LogicalType::UNION(std::move(members));
 	return result;
 }
@@ -570,14 +704,14 @@ Value Value::LIST(vector<Value> values) {
 #endif
 	Value result;
 	result.type_ = LogicalType::LIST(values[0].type());
-	result.list_value = std::move(values);
+	result.value_info_ = make_shared<NestedValueInfo>(std::move(values));
 	result.is_null = false;
 	return result;
 }
 
-Value Value::LIST(LogicalType child_type, vector<Value> values) {
+Value Value::LIST(const LogicalType &child_type, vector<Value> values) {
 	if (values.empty()) {
-		return Value::EMPTYLIST(std::move(child_type));
+		return Value::EMPTYLIST(child_type);
 	}
 	for (auto &val : values) {
 		val = val.DefaultCastAs(child_type);
@@ -585,9 +719,10 @@ Value Value::LIST(LogicalType child_type, vector<Value> values) {
 	return Value::LIST(std::move(values));
 }
 
-Value Value::EMPTYLIST(LogicalType child_type) {
+Value Value::EMPTYLIST(const LogicalType &child_type) {
 	Value result;
-	result.type_ = LogicalType::LIST(std::move(child_type));
+	result.type_ = LogicalType::LIST(child_type);
+	result.value_info_ = make_shared<NestedValueInfo>();
 	result.is_null = false;
 	return result;
 }
@@ -595,28 +730,28 @@ Value Value::EMPTYLIST(LogicalType child_type) {
 Value Value::BLOB(const_data_ptr_t data, idx_t len) {
 	Value result(LogicalType::BLOB);
 	result.is_null = false;
-	result.str_value = string((const char *)data, len);
+	result.value_info_ = make_shared<StringValueInfo>(string((const char *)data, len));
 	return result;
 }
 
 Value Value::BLOB(const string &data) {
 	Value result(LogicalType::BLOB);
 	result.is_null = false;
-	result.str_value = Blob::ToBlob(string_t(data));
+	result.value_info_ = make_shared<StringValueInfo>(Blob::ToBlob(string_t(data)));
 	return result;
 }
 
 Value Value::BIT(const_data_ptr_t data, idx_t len) {
 	Value result(LogicalType::BIT);
 	result.is_null = false;
-	result.str_value = string((const char *)data, len);
+	result.value_info_ = make_shared<StringValueInfo>(string((const char *)data, len));
 	return result;
 }
 
 Value Value::BIT(const string &data) {
 	Value result(LogicalType::BIT);
 	result.is_null = false;
-	result.str_value = Bit::ToBit(string_t(data));
+	result.value_info_ = make_shared<StringValueInfo>(Bit::ToBit(string_t(data)));
 	return result;
 }
 
@@ -827,7 +962,7 @@ T Value::GetValueInternal() const {
 	case LogicalTypeId::DOUBLE:
 		return Cast::Operation<double, T>(value_.double_);
 	case LogicalTypeId::VARCHAR:
-		return Cast::Operation<string_t, T>(str_value.c_str());
+		return Cast::Operation<string_t, T>(StringValue::Get(*this).c_str());
 	case LogicalTypeId::INTERVAL:
 		return Cast::Operation<interval_t, T>(value_.interval);
 	case LogicalTypeId::DECIMAL:
@@ -1100,14 +1235,12 @@ uint64_t Value::GetValueUnsafe() const {
 
 template <>
 string Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::VARCHAR);
-	return str_value;
+	return StringValue::Get(*this);
 }
 
 template <>
 DUCKDB_API string_t Value::GetValueUnsafe() const {
-	D_ASSERT(type_.InternalType() == PhysicalType::VARCHAR);
-	return string_t(str_value);
+	return string_t(StringValue::Get(*this));
 }
 
 template <>
@@ -1146,99 +1279,6 @@ interval_t Value::GetValueUnsafe() const {
 	return value_.interval;
 }
 
-//===--------------------------------------------------------------------===//
-// GetReferenceUnsafe
-//===--------------------------------------------------------------------===//
-template <>
-int8_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT8 || type_.InternalType() == PhysicalType::BOOL);
-	return value_.tinyint;
-}
-
-template <>
-int16_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT16);
-	return value_.smallint;
-}
-
-template <>
-int32_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT32);
-	return value_.integer;
-}
-
-template <>
-int64_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
-	return value_.bigint;
-}
-
-template <>
-hugeint_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT128);
-	return value_.hugeint;
-}
-
-template <>
-uint8_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::UINT8);
-	return value_.utinyint;
-}
-
-template <>
-uint16_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::UINT16);
-	return value_.usmallint;
-}
-
-template <>
-uint32_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::UINT32);
-	return value_.uinteger;
-}
-
-template <>
-uint64_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::UINT64);
-	return value_.ubigint;
-}
-
-template <>
-float &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::FLOAT);
-	return value_.float_;
-}
-
-template <>
-double &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::DOUBLE);
-	return value_.double_;
-}
-
-template <>
-date_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT32);
-	return value_.date;
-}
-
-template <>
-dtime_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
-	return value_.time;
-}
-
-template <>
-timestamp_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
-	return value_.timestamp;
-}
-
-template <>
-interval_t &Value::GetReferenceUnsafe() {
-	D_ASSERT(type_.InternalType() == PhysicalType::INTERVAL);
-	return value_.interval;
-}
-
 //===--------------------------------------------------------------------===//
 // Hash
 //===--------------------------------------------------------------------===//
@@ -1258,7 +1298,7 @@ string Value::ToString() const {
 	if (IsNull()) {
 		return "NULL";
 	}
-	return DefaultCastAs(LogicalType::VARCHAR).str_value;
+	return StringValue::Get(DefaultCastAs(LogicalType::VARCHAR));
 }
 
 string Value::ToSQLString() const {
@@ -1283,11 +1323,12 @@ string Value::ToSQLString() const {
 	case LogicalTypeId::STRUCT: {
 		string ret = "{";
 		auto &child_types = StructType::GetChildTypes(type_);
-		for (size_t i = 0; i < struct_value.size(); i++) {
+		auto &struct_values = StructValue::GetChildren(*this);
+		for (size_t i = 0; i < struct_values.size(); i++) {
 			auto &name = child_types[i].first;
-			auto &child = struct_value[i];
+			auto &child = struct_values[i];
 			ret += "'" + name + "': " + child.ToSQLString();
-			if (i < struct_value.size() - 1) {
+			if (i < struct_values.size() - 1) {
 				ret += ", ";
 			}
 		}
@@ -1312,10 +1353,11 @@ string Value::ToSQLString() const {
 	}
 	case LogicalTypeId::LIST: {
 		string ret = "[";
-		for (size_t i = 0; i < list_value.size(); i++) {
-			auto &child = list_value[i];
+		auto &list_values = ListValue::GetChildren(*this);
+		for (size_t i = 0; i < list_values.size(); i++) {
+			auto &child = list_values[i];
 			ret += child.ToSQLString();
-			if (i < list_value.size() - 1) {
+			if (i < list_values.size() - 1) {
 				ret += ", ";
 			}
 		}
@@ -1379,8 +1421,12 @@ double DoubleValue::Get(const Value &value) {
 }
 
 const string &StringValue::Get(const Value &value) {
+	if (value.is_null) {
+		throw InternalException("Calling StringValue::Get on a NULL value");
+	}
 	D_ASSERT(value.type().InternalType() == PhysicalType::VARCHAR);
-	return value.str_value;
+	D_ASSERT(value.value_info_);
+	return value.value_info_->Get<StringValueInfo>().GetString();
 }
 
 date_t DateValue::Get(const Value &value) {
@@ -1400,13 +1446,21 @@ interval_t IntervalValue::Get(const Value &value) {
 }
 
 const vector<Value> &StructValue::GetChildren(const Value &value) {
+	if (value.is_null) {
+		throw InternalException("Calling StructValue::GetChildren on a NULL value");
+	}
 	D_ASSERT(value.type().InternalType() == PhysicalType::STRUCT);
-	return value.struct_value;
+	D_ASSERT(value.value_info_);
+	return value.value_info_->Get<NestedValueInfo>().GetValues();
 }
 
 const vector<Value> &ListValue::GetChildren(const Value &value) {
+	if (value.is_null) {
+		throw InternalException("Calling ListValue::GetChildren on a NULL value");
+	}
 	D_ASSERT(value.type().InternalType() == PhysicalType::LIST);
-	return value.list_value;
+	D_ASSERT(value.value_info_);
+	return value.value_info_->Get<NestedValueInfo>().GetValues();
 }
 
 const Value &UnionValue::GetValue(const Value &value) {
@@ -1559,9 +1613,7 @@ bool Value::TryCastAs(CastFunctionSet &set, GetCastFunctionInput &get_input, con
 	type_ = target_type;
 	is_null = new_value.is_null;
 	value_ = new_value.value_;
-	str_value = new_value.str_value;
-	struct_value = new_value.struct_value;
-	list_value = new_value.list_value;
+	value_info_ = std::move(new_value.value_info_);
 	return true;
 }
 
@@ -1627,7 +1679,7 @@ void Value::Serialize(Serializer &main_serializer) const {
 			serializer.Write<interval_t>(value_.interval);
 			break;
 		case PhysicalType::VARCHAR:
-			serializer.WriteString(str_value);
+			serializer.WriteString(StringValue::Get(*this));
 			break;
 		default: {
 			Vector v(*this);
@@ -1691,7 +1743,7 @@ Value Value::Deserialize(Deserializer &main_source) {
 		new_value.value_.interval = source.Read<interval_t>();
 		break;
 	case PhysicalType::VARCHAR:
-		new_value.str_value = source.Read<string>();
+		new_value.value_info_ = make_shared<StringValueInfo>(source.Read<string>());
 		break;
 	default: {
 		Vector v(type);
@@ -1704,6 +1756,120 @@ Value Value::Deserialize(Deserializer &main_source) {
 	return new_value;
 }
 
+void Value::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("type", type_);
+	serializer.WriteProperty("is_null", is_null);
+	if (!IsNull()) {
+		switch (type_.InternalType()) {
+		case PhysicalType::BOOL:
+			serializer.WriteProperty("value", value_.boolean);
+			break;
+		case PhysicalType::INT8:
+			serializer.WriteProperty("value", value_.tinyint);
+			break;
+		case PhysicalType::INT16:
+			serializer.WriteProperty("value", value_.smallint);
+			break;
+		case PhysicalType::INT32:
+			serializer.WriteProperty("value", value_.integer);
+			break;
+		case PhysicalType::INT64:
+			serializer.WriteProperty("value", value_.bigint);
+			break;
+		case PhysicalType::UINT8:
+			serializer.WriteProperty("value", value_.utinyint);
+			break;
+		case PhysicalType::UINT16:
+			serializer.WriteProperty("value", value_.usmallint);
+			break;
+		case PhysicalType::UINT32:
+			serializer.WriteProperty("value", value_.uinteger);
+			break;
+		case PhysicalType::UINT64:
+			serializer.WriteProperty("value", value_.ubigint);
+			break;
+		case PhysicalType::INT128:
+			serializer.WriteProperty("value", value_.hugeint);
+			break;
+		case PhysicalType::FLOAT:
+			serializer.WriteProperty("value", value_.float_);
+			break;
+		case PhysicalType::DOUBLE:
+			serializer.WriteProperty("value", value_.double_);
+			break;
+		case PhysicalType::INTERVAL:
+			serializer.WriteProperty("value", value_.interval);
+			break;
+		case PhysicalType::VARCHAR:
+			serializer.WriteProperty("value", StringValue::Get(*this));
+			break;
+		default: {
+			Vector v(*this);
+			v.FormatSerialize(serializer, 1);
+			break;
+		}
+		}
+	}
+}
+
+Value Value::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto type = deserializer.ReadProperty<LogicalType>("type");
+	auto is_null = deserializer.ReadProperty<bool>("is_null");
+	Value new_value = Value(type);
+	if (is_null) {
+		return new_value;
+	}
+	new_value.is_null = false;
+	switch (type.InternalType()) {
+	case PhysicalType::BOOL:
+		new_value.value_.boolean = deserializer.ReadProperty<bool>("value");
+		break;
+	case PhysicalType::UINT8:
+		new_value.value_.utinyint = deserializer.ReadProperty<uint8_t>("value");
+		break;
+	case PhysicalType::INT8:
+		new_value.value_.tinyint = deserializer.ReadProperty<int8_t>("value");
+		break;
+	case PhysicalType::UINT16:
+		new_value.value_.usmallint = deserializer.ReadProperty<uint16_t>("value");
+		break;
+	case PhysicalType::INT16:
+		new_value.value_.smallint = deserializer.ReadProperty<int16_t>("value");
+		break;
+	case PhysicalType::UINT32:
+		new_value.value_.uinteger = deserializer.ReadProperty<uint32_t>("value");
+		break;
+	case PhysicalType::INT32:
+		new_value.value_.integer = deserializer.ReadProperty<int32_t>("value");
+		break;
+	case PhysicalType::UINT64:
+		new_value.value_.ubigint = deserializer.ReadProperty<uint64_t>("value");
+		break;
+	case PhysicalType::INT64:
+		new_value.value_.bigint = deserializer.ReadProperty<int64_t>("value");
+		break;
+	case PhysicalType::FLOAT:
+		new_value.value_.float_ = deserializer.ReadProperty<float>("value");
+		break;
+	case PhysicalType::DOUBLE:
+		new_value.value_.double_ = deserializer.ReadProperty<double>("value");
+		break;
+	case PhysicalType::INTERVAL:
+		new_value.value_.interval = deserializer.ReadProperty<interval_t>("value");
+		break;
+	case PhysicalType::VARCHAR:
+		new_value.value_info_ = make_shared<StringValueInfo>(deserializer.ReadProperty<string>("value"));
+		break;
+	default: {
+		Vector v(type);
+		v.FormatDeserialize(deserializer, 1);
+		new_value = v.GetValue(0);
+		break;
+	}
+	}
+	return new_value;
+}
+
 void Value::Print() const {
 	Printer::Print(ToString());
 }
@@ -1747,8 +1913,8 @@ bool Value::ValuesAreEqual(CastFunctionSet &set, GetCastFunctionInput &get_input
 	}
 	case LogicalTypeId::VARCHAR: {
 		auto other = result_value.CastAs(set, get_input, LogicalType::VARCHAR);
-		string left = SanitizeValue(other.str_value);
-		string right = SanitizeValue(value.str_value);
+		string left = SanitizeValue(StringValue::Get(other));
+		string right = SanitizeValue(StringValue::Get(value));
 		return left == right;
 	}
 	default: