duckdb 0.3.2-dev890.0 → 0.3.2-dev930.0

package/src/duckdb.cpp

@@ -1861,6 +1861,7 @@ void EncodeStringDataPrefix(data_ptr_t dataptr, string_t value, idx_t prefix_len
 
 
 
+
 namespace duckdb {
 
 class Key {
@@ -1877,6 +1878,11 @@ public:
 		return make_unique<Key>(move(data), sizeof(element));
 	}
 
+	template <class T>
+	static unique_ptr<Key> CreateKey(const Value &element, bool is_little_endian) {
+		return CreateKey(element.GetValueUnsafe<T>(), is_little_endian);
+	}
+
 public:
 	data_t &operator[](std::size_t i) {
 		return data[i];
@@ -1889,8 +1895,6 @@ public:
 	bool operator>=(const Key &k) const;
 	bool operator==(const Key &k) const;
 
-	string ToString(bool is_little_endian, PhysicalType type);
-
 private:
 	template <class T>
 	static unique_ptr<data_t[]> CreateData(T value, bool is_little_endian) {
@@ -29285,23 +29289,6 @@ int NumericHelper::UnsignedLength(uint64_t value) {
 namespace duckdb {
 
 struct ValueOperations {
-	//===--------------------------------------------------------------------===//
-	// Numeric Operations
-	//===--------------------------------------------------------------------===//
-	// A + B
-	static Value Add(const Value &left, const Value &right);
-	// A - B
-	static Value Subtract(const Value &left, const Value &right);
-	// A * B
-	static Value Multiply(const Value &left, const Value &right);
-	// A / B
-	static Value Divide(const Value &left, const Value &right);
-	// A % B
-	static Value Modulo(const Value &left, const Value &right);
-	// // MIN(A, B)
-	// static Value Min(const Value &left, const Value &right);
-	// // MAX(A, B)
-	// static Value Max(const Value &left, const Value &right);
 	//===--------------------------------------------------------------------===//
 	// Comparison Operations
 	//===--------------------------------------------------------------------===//
@@ -29332,11 +29319,6 @@ struct ValueOperations {
 	static bool DistinctLessThan(const Value &left, const Value &right);
 	// A <= B, NULLs last
 	static bool DistinctLessThanEquals(const Value &left, const Value &right);
-	//===--------------------------------------------------------------------===//
-	// Hash functions
-	//===--------------------------------------------------------------------===//
-	// result = HASH(A)
-	static hash_t Hash(const Value &left);
 };
 } // namespace duckdb
 
@@ -33979,6 +33961,7 @@ hugeint_t ModuloOperator::Operation(hugeint_t left, hugeint_t right);
 
 
 
+
 namespace duckdb {
 
 Value::Value(LogicalType type) : type_(move(type)), is_null(true) {
@@ -34021,6 +34004,39 @@ Value::Value(string val) : type_(LogicalType::VARCHAR), is_null(false), str_valu
 	}
 }
 
+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) {
+}
+
+Value::Value(Value &&other) noexcept
+    : type_(move(other.type_)), is_null(other.is_null), value_(other.value_), str_value(move(other.str_value)),
+      struct_value(move(other.struct_value)), list_value(move(other.list_value)) {
+}
+
+Value &Value::operator=(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;
+	return *this;
+}
+
+Value &Value::operator=(Value &&other) noexcept {
+	type_ = move(other.type_);
+	is_null = other.is_null;
+	value_ = other.value_;
+	str_value = move(other.str_value);
+	struct_value = move(other.struct_value);
+	list_value = move(other.list_value);
+	return *this;
+}
+
 Value Value::MinimumValue(const LogicalType &type) {
 	switch (type.id()) {
 	case LogicalTypeId::BOOLEAN:
@@ -34625,7 +34641,7 @@ Value Value::CreateValue(Value value) {
 //===--------------------------------------------------------------------===//
 template <class T>
 T Value::GetValueInternal() const {
-	if (is_null) {
+	if (IsNull()) {
 		return NullValue<T>();
 	}
 	switch (type_.id()) {
@@ -34780,24 +34796,31 @@ uintptr_t Value::GetPointer() const {
 
 Value Value::Numeric(const LogicalType &type, int64_t value) {
 	switch (type.id()) {
+	case LogicalTypeId::BOOLEAN:
+		D_ASSERT(value == 0 || value == 1);
+		return Value::BOOLEAN(value ? 1 : 0);
 	case LogicalTypeId::TINYINT:
-		D_ASSERT(value <= NumericLimits<int8_t>::Maximum());
+		D_ASSERT(value >= NumericLimits<int8_t>::Minimum() && value <= NumericLimits<int8_t>::Maximum());
 		return Value::TINYINT((int8_t)value);
 	case LogicalTypeId::SMALLINT:
-		D_ASSERT(value <= NumericLimits<int16_t>::Maximum());
+		D_ASSERT(value >= NumericLimits<int16_t>::Minimum() && value <= NumericLimits<int16_t>::Maximum());
 		return Value::SMALLINT((int16_t)value);
 	case LogicalTypeId::INTEGER:
-		D_ASSERT(value <= NumericLimits<int32_t>::Maximum());
+		D_ASSERT(value >= NumericLimits<int32_t>::Minimum() && value <= NumericLimits<int32_t>::Maximum());
 		return Value::INTEGER((int32_t)value);
 	case LogicalTypeId::BIGINT:
 		return Value::BIGINT(value);
 	case LogicalTypeId::UTINYINT:
+		D_ASSERT(value >= NumericLimits<uint8_t>::Minimum() && value <= NumericLimits<uint8_t>::Maximum());
 		return Value::UTINYINT((uint8_t)value);
 	case LogicalTypeId::USMALLINT:
+		D_ASSERT(value >= NumericLimits<uint16_t>::Minimum() && value <= NumericLimits<uint16_t>::Maximum());
 		return Value::USMALLINT((uint16_t)value);
 	case LogicalTypeId::UINTEGER:
+		D_ASSERT(value >= NumericLimits<uint32_t>::Minimum() && value <= NumericLimits<uint32_t>::Maximum());
 		return Value::UINTEGER((uint32_t)value);
 	case LogicalTypeId::UBIGINT:
+		D_ASSERT(value >= 0);
 		return Value::UBIGINT(value);
 	case LogicalTypeId::HUGEINT:
 		return Value::HUGEINT(value);
@@ -34812,7 +34835,7 @@ Value Value::Numeric(const LogicalType &type, int64_t value) {
 	case LogicalTypeId::POINTER:
 		return Value::POINTER(value);
 	case LogicalTypeId::DATE:
-		D_ASSERT(value <= NumericLimits<int32_t>::Maximum());
+		D_ASSERT(value >= NumericLimits<int32_t>::Minimum() && value <= NumericLimits<int32_t>::Maximum());
 		return Value::DATE(date_t(value));
 	case LogicalTypeId::TIME:
 		return Value::TIME(dtime_t(value));
@@ -34831,10 +34854,13 @@ Value Value::Numeric(const LogicalType &type, int64_t value) {
 	case LogicalTypeId::ENUM:
 		switch (type.InternalType()) {
 		case PhysicalType::UINT8:
+			D_ASSERT(value >= NumericLimits<uint8_t>::Minimum() && value <= NumericLimits<uint8_t>::Maximum());
 			return Value::UTINYINT((uint8_t)value);
 		case PhysicalType::UINT16:
+			D_ASSERT(value >= NumericLimits<uint16_t>::Minimum() && value <= NumericLimits<uint16_t>::Maximum());
 			return Value::USMALLINT((uint16_t)value);
 		case PhysicalType::UINT32:
+			D_ASSERT(value >= NumericLimits<uint32_t>::Minimum() && value <= NumericLimits<uint32_t>::Maximum());
 			return Value::UINTEGER((uint32_t)value);
 		default:
 			throw InternalException("Enum doesn't accept this physical type");
@@ -34844,116 +34870,284 @@ Value Value::Numeric(const LogicalType &type, int64_t value) {
 	}
 }
 
+Value Value::Numeric(const LogicalType &type, hugeint_t value) {
+#ifdef DEBUG
+	// perform a throwing cast to verify that the type fits
+	Value::HUGEINT(value).CastAs(type);
+#endif
+	switch (type.id()) {
+	case LogicalTypeId::HUGEINT:
+		return Value::HUGEINT(value);
+	case LogicalTypeId::UBIGINT:
+		return Value::UBIGINT(Hugeint::Cast<uint64_t>(value));
+	default:
+		return Value::Numeric(type, Hugeint::Cast<int64_t>(value));
+	}
+}
+
 //===--------------------------------------------------------------------===//
 // GetValueUnsafe
 //===--------------------------------------------------------------------===//
 template <>
-int8_t &Value::GetValueUnsafe() {
+DUCKDB_API bool Value::GetValueUnsafe() const {
+	D_ASSERT(type_.InternalType() == PhysicalType::BOOL);
+	return value_.boolean;
+}
+
+template <>
+int8_t Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::INT8 || type_.InternalType() == PhysicalType::BOOL);
 	return value_.tinyint;
 }
 
 template <>
-int16_t &Value::GetValueUnsafe() {
+int16_t Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::INT16);
 	return value_.smallint;
 }
 
 template <>
-int32_t &Value::GetValueUnsafe() {
+int32_t Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::INT32);
 	return value_.integer;
 }
 
 template <>
-int64_t &Value::GetValueUnsafe() {
+int64_t Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
 	return value_.bigint;
 }
 
 template <>
-hugeint_t &Value::GetValueUnsafe() {
+hugeint_t Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::INT128);
 	return value_.hugeint;
 }
 
 template <>
-uint8_t &Value::GetValueUnsafe() {
+uint8_t Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::UINT8);
 	return value_.utinyint;
 }
 
 template <>
-uint16_t &Value::GetValueUnsafe() {
+uint16_t Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::UINT16);
 	return value_.usmallint;
 }
 
 template <>
-uint32_t &Value::GetValueUnsafe() {
+uint32_t Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::UINT32);
 	return value_.uinteger;
 }
 
 template <>
-uint64_t &Value::GetValueUnsafe() {
+uint64_t Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::UINT64);
 	return value_.ubigint;
 }
 
 template <>
-string &Value::GetValueUnsafe() {
+string Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::VARCHAR);
 	return str_value;
 }
 
 template <>
-float &Value::GetValueUnsafe() {
+DUCKDB_API string_t Value::GetValueUnsafe() const {
+	D_ASSERT(type_.InternalType() == PhysicalType::VARCHAR);
+	return string_t(str_value);
+}
+
+template <>
+float Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::FLOAT);
 	return value_.float_;
 }
 
 template <>
-double &Value::GetValueUnsafe() {
+double Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::DOUBLE);
 	return value_.double_;
 }
 
 template <>
-date_t &Value::GetValueUnsafe() {
+date_t Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::INT32);
 	return value_.date;
 }
 
 template <>
-dtime_t &Value::GetValueUnsafe() {
+dtime_t Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
 	return value_.time;
 }
 
 template <>
-timestamp_t &Value::GetValueUnsafe() {
+timestamp_t Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::INT64);
 	return value_.timestamp;
 }
 
 template <>
-interval_t &Value::GetValueUnsafe() {
+interval_t Value::GetValueUnsafe() const {
 	D_ASSERT(type_.InternalType() == PhysicalType::INTERVAL);
 	return value_.interval;
 }
 
-Value Value::Numeric(const LogicalType &type, hugeint_t value) {
-	switch (type.id()) {
-	case LogicalTypeId::HUGEINT:
-		return Value::HUGEINT(value);
+//===--------------------------------------------------------------------===//
+// 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
+//===--------------------------------------------------------------------===//
+hash_t Value::Hash() const {
+	if (IsNull()) {
+		return 0;
+	}
+	switch (type_.InternalType()) {
+	case PhysicalType::BOOL:
+		return duckdb::Hash(value_.boolean);
+	case PhysicalType::INT8:
+		return duckdb::Hash(value_.tinyint);
+	case PhysicalType::INT16:
+		return duckdb::Hash(value_.smallint);
+	case PhysicalType::INT32:
+		return duckdb::Hash(value_.integer);
+	case PhysicalType::INT64:
+		return duckdb::Hash(value_.bigint);
+	case PhysicalType::UINT8:
+		return duckdb::Hash(value_.utinyint);
+	case PhysicalType::UINT16:
+		return duckdb::Hash(value_.usmallint);
+	case PhysicalType::UINT32:
+		return duckdb::Hash(value_.uinteger);
+	case PhysicalType::UINT64:
+		return duckdb::Hash(value_.ubigint);
+	case PhysicalType::INT128:
+		return duckdb::Hash(value_.hugeint);
+	case PhysicalType::FLOAT:
+		return duckdb::Hash(value_.float_);
+	case PhysicalType::DOUBLE:
+		return duckdb::Hash(value_.double_);
+	case PhysicalType::INTERVAL:
+		return duckdb::Hash(value_.interval);
+	case PhysicalType::VARCHAR:
+		return duckdb::Hash(string_t(StringValue::Get(*this)));
+	case PhysicalType::STRUCT: {
+		auto &struct_children = StructValue::GetChildren(*this);
+		hash_t hash = 0;
+		for (auto &entry : struct_children) {
+			hash ^= entry.Hash();
+		}
+		return hash;
+	}
+	case PhysicalType::LIST: {
+		auto &list_children = ListValue::GetChildren(*this);
+		hash_t hash = 0;
+		for (auto &entry : list_children) {
+			hash ^= entry.Hash();
+		}
+		return hash;
+	}
 	default:
-		return Value::Numeric(type, Hugeint::Cast<int64_t>(value));
+		throw InternalException("Unimplemented type for value hash");
 	}
 }
 
 string Value::ToString() const {
-	if (is_null) {
+	if (IsNull()) {
 		return "NULL";
 	}
 	switch (type_.id()) {
@@ -35086,27 +35280,110 @@ string Value::ToString() const {
 }
 
 //===--------------------------------------------------------------------===//
-// Numeric Operators
+// Type-specific getters
 //===--------------------------------------------------------------------===//
-Value Value::operator+(const Value &rhs) const {
-	return ValueOperations::Add(*this, rhs);
+bool BooleanValue::Get(const Value &value) {
+	return value.GetValueUnsafe<bool>();
+}
+
+int8_t TinyIntValue::Get(const Value &value) {
+	return value.GetValueUnsafe<int8_t>();
+}
+
+int16_t SmallIntValue::Get(const Value &value) {
+	return value.GetValueUnsafe<int16_t>();
+}
+
+int32_t IntegerValue::Get(const Value &value) {
+	return value.GetValueUnsafe<int32_t>();
+}
+
+int64_t BigIntValue::Get(const Value &value) {
+	return value.GetValueUnsafe<int64_t>();
+}
+
+hugeint_t HugeIntValue::Get(const Value &value) {
+	return value.GetValueUnsafe<hugeint_t>();
+}
+
+uint8_t UTinyIntValue::Get(const Value &value) {
+	return value.GetValueUnsafe<uint8_t>();
+}
+
+uint16_t USmallIntValue::Get(const Value &value) {
+	return value.GetValueUnsafe<uint16_t>();
 }
 
-Value Value::operator-(const Value &rhs) const {
-	return ValueOperations::Subtract(*this, rhs);
+uint32_t UIntegerValue::Get(const Value &value) {
+	return value.GetValueUnsafe<uint32_t>();
 }
 
-Value Value::operator*(const Value &rhs) const {
-	return ValueOperations::Multiply(*this, rhs);
+uint64_t UBigIntValue::Get(const Value &value) {
+	return value.GetValueUnsafe<uint64_t>();
 }
 
-Value Value::operator/(const Value &rhs) const {
-	return ValueOperations::Divide(*this, rhs);
+float FloatValue::Get(const Value &value) {
+	return value.GetValueUnsafe<float>();
 }
 
-Value Value::operator%(const Value &rhs) const {
-	throw NotImplementedException("value modulo");
-	// return ValueOperations::Modulo(*this, rhs);
+double DoubleValue::Get(const Value &value) {
+	return value.GetValueUnsafe<double>();
+}
+
+const string &StringValue::Get(const Value &value) {
+	D_ASSERT(value.type().InternalType() == PhysicalType::VARCHAR);
+	return value.str_value;
+}
+
+date_t DateValue::Get(const Value &value) {
+	return value.GetValueUnsafe<date_t>();
+}
+
+dtime_t TimeValue::Get(const Value &value) {
+	return value.GetValueUnsafe<dtime_t>();
+}
+
+timestamp_t TimestampValue::Get(const Value &value) {
+	return value.GetValueUnsafe<timestamp_t>();
+}
+
+interval_t IntervalValue::Get(const Value &value) {
+	return value.GetValueUnsafe<interval_t>();
+}
+
+const vector<Value> &StructValue::GetChildren(const Value &value) {
+	D_ASSERT(value.type().InternalType() == PhysicalType::STRUCT);
+	return value.struct_value;
+}
+
+const vector<Value> &ListValue::GetChildren(const Value &value) {
+	D_ASSERT(value.type().InternalType() == PhysicalType::LIST);
+	return value.list_value;
+}
+
+hugeint_t IntegralValue::Get(const Value &value) {
+	switch (value.type().InternalType()) {
+	case PhysicalType::INT8:
+		return TinyIntValue::Get(value);
+	case PhysicalType::INT16:
+		return SmallIntValue::Get(value);
+	case PhysicalType::INT32:
+		return IntegerValue::Get(value);
+	case PhysicalType::INT64:
+		return BigIntValue::Get(value);
+	case PhysicalType::INT128:
+		return HugeIntValue::Get(value);
+	case PhysicalType::UINT8:
+		return UTinyIntValue::Get(value);
+	case PhysicalType::UINT16:
+		return USmallIntValue::Get(value);
+	case PhysicalType::UINT32:
+		return UIntegerValue::Get(value);
+	case PhysicalType::UINT64:
+		return UBigIntValue::Get(value);
+	default:
+		throw InternalException("Invalid internal type \"%s\" for IntegralValue::Get", value.type().ToString());
+	}
 }
 
 //===--------------------------------------------------------------------===//
@@ -35200,8 +35477,8 @@ bool Value::TryCastAs(const LogicalType &target_type, bool strict) {
 
 void Value::Serialize(Serializer &serializer) {
 	type_.Serialize(serializer);
-	serializer.Write<bool>(is_null);
-	if (!is_null) {
+	serializer.Write<bool>(IsNull());
+	if (!IsNull()) {
 		switch (type_.InternalType()) {
 		case PhysicalType::BOOL:
 			serializer.Write<int8_t>(value_.boolean);
@@ -35319,10 +35596,10 @@ void Value::Print() const {
 }
 
 bool Value::ValuesAreEqual(const Value &result_value, const Value &value) {
-	if (result_value.is_null != value.is_null) {
+	if (result_value.IsNull() != value.IsNull()) {
 		return false;
 	}
-	if (result_value.is_null && value.is_null) {
+	if (result_value.IsNull() && value.IsNull()) {
 		// NULL = NULL in checking code
 		return true;
 	}
@@ -35440,12 +35717,13 @@ void Vector::Reference(const Value &value) {
 		auto struct_buffer = make_unique<VectorStructBuffer>();
 		auto &child_types = StructType::GetChildTypes(value.type());
 		auto &child_vectors = struct_buffer->GetChildren();
+		auto &value_children = StructValue::GetChildren(value);
 		for (idx_t i = 0; i < child_types.size(); i++) {
-			auto vector = make_unique<Vector>(value.is_null ? Value(child_types[i].second) : value.struct_value[i]);
+			auto vector = make_unique<Vector>(value.IsNull() ? Value(child_types[i].second) : value_children[i]);
 			child_vectors.push_back(move(vector));
 		}
 		auxiliary = move(struct_buffer);
-		if (value.is_null) {
+		if (value.IsNull()) {
 			SetValue(0, value);
 		}
 	} else if (internal_type == PhysicalType::LIST) {
@@ -35663,100 +35941,66 @@ void Vector::SetValue(idx_t index, const Value &val) {
 	}
 
 	validity.EnsureWritable();
-	validity.Set(index, !val.is_null);
-	if (val.is_null && GetType().InternalType() != PhysicalType::STRUCT) {
+	validity.Set(index, !val.IsNull());
+	if (val.IsNull() && GetType().InternalType() != PhysicalType::STRUCT) {
 		// for structs we still need to set the child-entries to NULL
 		// so we do not bail out yet
 		return;
 	}
 
-	switch (GetType().id()) {
-	case LogicalTypeId::BOOLEAN:
-		((bool *)data)[index] = val.value_.boolean;
-		break;
-	case LogicalTypeId::TINYINT:
-		((int8_t *)data)[index] = val.value_.tinyint;
-		break;
-	case LogicalTypeId::SMALLINT:
-		((int16_t *)data)[index] = val.value_.smallint;
+	switch (GetType().InternalType()) {
+	case PhysicalType::BOOL:
+		((bool *)data)[index] = val.GetValueUnsafe<bool>();
 		break;
-	case LogicalTypeId::DATE:
-	case LogicalTypeId::INTEGER:
-		((int32_t *)data)[index] = val.value_.integer;
+	case PhysicalType::INT8:
+		((int8_t *)data)[index] = val.GetValueUnsafe<int8_t>();
 		break;
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_SEC:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::HASH:
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIME_TZ:
-		((int64_t *)data)[index] = val.value_.bigint;
+	case PhysicalType::INT16:
+		((int16_t *)data)[index] = val.GetValueUnsafe<int16_t>();
 		break;
-	case LogicalTypeId::UTINYINT:
-		((uint8_t *)data)[index] = val.value_.utinyint;
+	case PhysicalType::INT32:
+		((int32_t *)data)[index] = val.GetValueUnsafe<int32_t>();
 		break;
-	case LogicalTypeId::USMALLINT:
-		((uint16_t *)data)[index] = val.value_.usmallint;
+	case PhysicalType::INT64:
+		((int64_t *)data)[index] = val.GetValueUnsafe<int64_t>();
 		break;
-	case LogicalTypeId::UINTEGER:
-		((uint32_t *)data)[index] = val.value_.uinteger;
+	case PhysicalType::INT128:
+		((hugeint_t *)data)[index] = val.GetValueUnsafe<hugeint_t>();
 		break;
-	case LogicalTypeId::UBIGINT:
-		((uint64_t *)data)[index] = val.value_.ubigint;
+	case PhysicalType::UINT8:
+		((uint8_t *)data)[index] = val.GetValueUnsafe<uint8_t>();
 		break;
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::UUID:
-		((hugeint_t *)data)[index] = val.value_.hugeint;
+	case PhysicalType::UINT16:
+		((uint16_t *)data)[index] = val.GetValueUnsafe<uint16_t>();
 		break;
-	case LogicalTypeId::DECIMAL:
-		D_ASSERT(DecimalType::GetWidth(GetType()) == DecimalType::GetWidth(val.type()));
-		D_ASSERT(DecimalType::GetScale(GetType()) == DecimalType::GetScale(val.type()));
-		switch (GetType().InternalType()) {
-		case PhysicalType::INT16:
-			((int16_t *)data)[index] = val.value_.smallint;
-			break;
-		case PhysicalType::INT32:
-			((int32_t *)data)[index] = val.value_.integer;
-			break;
-		case PhysicalType::INT64:
-			((int64_t *)data)[index] = val.value_.bigint;
-			break;
-		case PhysicalType::INT128:
-			((hugeint_t *)data)[index] = val.value_.hugeint;
-			break;
-		default:
-			throw InternalException("Widths bigger than 38 are not supported");
-		}
+	case PhysicalType::UINT32:
+		((uint32_t *)data)[index] = val.GetValueUnsafe<uint32_t>();
 		break;
-	case LogicalTypeId::FLOAT:
-		((float *)data)[index] = val.value_.float_;
+	case PhysicalType::UINT64:
+		((uint64_t *)data)[index] = val.GetValueUnsafe<uint64_t>();
 		break;
-	case LogicalTypeId::DOUBLE:
-		((double *)data)[index] = val.value_.double_;
+	case PhysicalType::FLOAT:
+		((float *)data)[index] = val.GetValueUnsafe<float>();
 		break;
-	case LogicalTypeId::POINTER:
-		((uintptr_t *)data)[index] = val.value_.pointer;
+	case PhysicalType::DOUBLE:
+		((double *)data)[index] = val.GetValueUnsafe<double>();
 		break;
-	case LogicalTypeId::INTERVAL:
-		((interval_t *)data)[index] = val.value_.interval;
+	case PhysicalType::INTERVAL:
+		((interval_t *)data)[index] = val.GetValueUnsafe<interval_t>();
 		break;
-	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::BLOB:
-		((string_t *)data)[index] = StringVector::AddStringOrBlob(*this, val.str_value);
+	case PhysicalType::VARCHAR:
+		((string_t *)data)[index] = StringVector::AddStringOrBlob(*this, StringValue::Get(val));
 		break;
-	case LogicalTypeId::MAP:
-	case LogicalTypeId::STRUCT: {
+	case PhysicalType::STRUCT: {
 		D_ASSERT(GetVectorType() == VectorType::CONSTANT_VECTOR || GetVectorType() == VectorType::FLAT_VECTOR);
 
 		auto &children = StructVector::GetEntries(*this);
-		D_ASSERT(val.is_null || children.size() == val.struct_value.size());
+		auto &val_children = StructValue::GetChildren(val);
+		D_ASSERT(val.IsNull() || children.size() == val_children.size());
 		for (size_t i = 0; i < children.size(); i++) {
 			auto &vec_child = children[i];
-			if (!val.is_null) {
-				auto &struct_child = val.struct_value[i];
+			if (!val.IsNull()) {
+				auto &struct_child = val_children[i];
 				vec_child->SetValue(index, struct_child);
 			} else {
 				vec_child->SetValue(index, Value());
@@ -35764,36 +36008,20 @@ void Vector::SetValue(idx_t index, const Value &val) {
 		}
 		break;
 	}
-	case LogicalTypeId::LIST: {
+	case PhysicalType::LIST: {
 		auto offset = ListVector::GetListSize(*this);
-		if (!val.list_value.empty()) {
-			for (idx_t i = 0; i < val.list_value.size(); i++) {
-				Value v(val.list_value[i]);
-				ListVector::PushBack(*this, v);
+		auto &val_children = ListValue::GetChildren(val);
+		if (!val_children.empty()) {
+			for (idx_t i = 0; i < val_children.size(); i++) {
+				ListVector::PushBack(*this, val_children[i]);
 			}
 		}
 		//! now set the pointer
 		auto &entry = ((list_entry_t *)data)[index];
-		entry.length = val.list_value.size();
+		entry.length = val_children.size();
 		entry.offset = offset;
 		break;
 	}
-	case LogicalTypeId::ENUM: {
-		switch (type.InternalType()) {
-		case PhysicalType::UINT8:
-			((uint8_t *)data)[index] = val.value_.utinyint;
-			break;
-		case PhysicalType::UINT16:
-			((uint16_t *)data)[index] = val.value_.usmallint;
-			break;
-		case PhysicalType::UINT32:
-			((uint32_t *)data)[index] = val.value_.uinteger;
-			break;
-		default:
-			throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
-		}
-		break;
-	}
 	default:
 		throw InternalException("Unimplemented type for Vector::SetValue");
 	}
@@ -35909,26 +36137,31 @@ Value Vector::GetValue(idx_t index) const {
 		auto str = ((string_t *)data)[index];
 		return Value::BLOB((const_data_ptr_t)str.GetDataUnsafe(), str.GetSize());
 	}
-	case LogicalTypeId::MAP:
+	case LogicalTypeId::MAP: {
+		auto &child_entries = StructVector::GetEntries(*this);
+		Value key = child_entries[0]->GetValue(index);
+		Value value = child_entries[1]->GetValue(index);
+		return Value::MAP(move(key), move(value));
+	}
 	case LogicalTypeId::STRUCT: {
-		Value ret(GetType());
-		ret.is_null = false;
 		// we can derive the value schema from the vector schema
 		auto &child_entries = StructVector::GetEntries(*this);
-		for (auto &struct_child : child_entries) {
-			ret.struct_value.push_back(struct_child->GetValue(index));
+		child_list_t<Value> children;
+		for (idx_t child_idx = 0; child_idx < child_entries.size(); child_idx++) {
+			auto &struct_child = child_entries[child_idx];
+			children.push_back(
+			    make_pair(StructType::GetChildName(GetType(), child_idx), struct_child->GetValue(index)));
 		}
-		return ret;
+		return Value::STRUCT(move(children));
 	}
 	case LogicalTypeId::LIST: {
-		Value ret(GetType());
-		ret.is_null = false;
 		auto offlen = ((list_entry_t *)data)[index];
 		auto &child_vec = ListVector::GetEntry(*this);
+		vector<Value> children;
 		for (idx_t i = offlen.offset; i < offlen.offset + offlen.length; i++) {
-			ret.list_value.push_back(child_vec.GetValue(i));
+			children.push_back(child_vec.GetValue(i));
 		}
-		return ret;
+		return Value::LIST(ListType::GetChildType(GetType()), move(children));
 	}
 	default:
 		throw InternalException("Unimplemented type for value access");
@@ -36786,7 +37019,14 @@ void TemplatedSearchInMap(Vector &list, T key, vector<idx_t> &offsets, bool is_k
 	}
 }
 
-void SearchString(Vector &list, string &key, vector<idx_t> &offsets, bool is_key_null, idx_t offset, idx_t length) {
+template <class T>
+void TemplatedSearchInMap(Vector &list, const Value &key, vector<idx_t> &offsets, bool is_key_null, idx_t offset,
+                          idx_t length) {
+	TemplatedSearchInMap<T>(list, key.template GetValueUnsafe<T>(), offsets, is_key_null, offset, length);
+}
+
+void SearchStringInMap(Vector &list, const string &key, vector<idx_t> &offsets, bool is_key_null, idx_t offset,
+                       idx_t length) {
 	auto &list_vector = ListVector::GetEntry(list);
 	VectorData vector_data;
 	list_vector.Orrify(ListVector::GetListSize(list), vector_data);
@@ -36811,80 +37051,49 @@ void SearchString(Vector &list, string &key, vector<idx_t> &offsets, bool is_key
 	}
 }
 
-vector<idx_t> ListVector::Search(Vector &list, Value &key, idx_t row) {
+vector<idx_t> ListVector::Search(Vector &list, const Value &key, idx_t row) {
 	vector<idx_t> offsets;
 
 	auto &list_vector = ListVector::GetEntry(list);
 	auto &entry = ((list_entry_t *)list.GetData())[row];
-	switch (list_vector.GetType().id()) {
 
-	case LogicalTypeId::SQLNULL:
-		if (key.is_null) {
-			for (idx_t i = entry.offset; i < entry.offset + entry.length; i++) {
-				offsets.push_back(i);
-			}
-		}
-		break;
-	case LogicalTypeId::UTINYINT:
-		::duckdb::TemplatedSearchInMap<uint8_t>(list, key.value_.utinyint, offsets, key.is_null, entry.offset,
-		                                        entry.length);
-		break;
-	case LogicalTypeId::TINYINT:
-		::duckdb::TemplatedSearchInMap<int8_t>(list, key.value_.tinyint, offsets, key.is_null, entry.offset,
-		                                       entry.length);
-		break;
-	case LogicalTypeId::USMALLINT:
-		::duckdb::TemplatedSearchInMap<uint16_t>(list, key.value_.usmallint, offsets, key.is_null, entry.offset,
-		                                         entry.length);
-		break;
-	case LogicalTypeId::SMALLINT:
-		::duckdb::TemplatedSearchInMap<int16_t>(list, key.value_.smallint, offsets, key.is_null, entry.offset,
-		                                        entry.length);
+	switch (list_vector.GetType().InternalType()) {
+	case PhysicalType::BOOL:
+	case PhysicalType::INT8:
+		TemplatedSearchInMap<int8_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
-	case LogicalTypeId::UINTEGER:
-		::duckdb::TemplatedSearchInMap<uint32_t>(list, key.value_.uinteger, offsets, key.is_null, entry.offset,
-		                                         entry.length);
+	case PhysicalType::INT16:
+		TemplatedSearchInMap<int16_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
-	case LogicalTypeId::INTEGER:
-		::duckdb::TemplatedSearchInMap<int32_t>(list, key.value_.integer, offsets, key.is_null, entry.offset,
-		                                        entry.length);
+	case PhysicalType::INT32:
+		TemplatedSearchInMap<int32_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
-	case LogicalTypeId::UBIGINT:
-		::duckdb::TemplatedSearchInMap<uint64_t>(list, key.value_.ubigint, offsets, key.is_null, entry.offset,
-		                                         entry.length);
+	case PhysicalType::INT64:
+		TemplatedSearchInMap<int64_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
-	case LogicalTypeId::BIGINT:
-		::duckdb::TemplatedSearchInMap<int64_t>(list, key.value_.bigint, offsets, key.is_null, entry.offset,
-		                                        entry.length);
+	case PhysicalType::INT128:
+		TemplatedSearchInMap<hugeint_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
-	case LogicalTypeId::HUGEINT:
-		::duckdb::TemplatedSearchInMap<hugeint_t>(list, key.value_.hugeint, offsets, key.is_null, entry.offset,
-		                                          entry.length);
+	case PhysicalType::UINT8:
+		TemplatedSearchInMap<uint8_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
-	case LogicalTypeId::FLOAT:
-		::duckdb::TemplatedSearchInMap<float>(list, key.value_.float_, offsets, key.is_null, entry.offset,
-		                                      entry.length);
+	case PhysicalType::UINT16:
+		TemplatedSearchInMap<uint16_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
-	case LogicalTypeId::DOUBLE:
-		::duckdb::TemplatedSearchInMap<double>(list, key.value_.double_, offsets, key.is_null, entry.offset,
-		                                       entry.length);
+	case PhysicalType::UINT32:
+		TemplatedSearchInMap<uint32_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
-	case LogicalTypeId::DATE:
-		::duckdb::TemplatedSearchInMap<date_t>(list, key.value_.date, offsets, key.is_null, entry.offset, entry.length);
+	case PhysicalType::UINT64:
+		TemplatedSearchInMap<uint64_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		::duckdb::TemplatedSearchInMap<dtime_t>(list, key.value_.time, offsets, key.is_null, entry.offset,
-		                                        entry.length);
+	case PhysicalType::FLOAT:
+		TemplatedSearchInMap<float>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		::duckdb::TemplatedSearchInMap<timestamp_t>(list, key.value_.timestamp, offsets, key.is_null, entry.offset,
-		                                            entry.length);
+	case PhysicalType::DOUBLE:
+		TemplatedSearchInMap<double>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
-	case LogicalTypeId::BLOB:
-	case LogicalTypeId::VARCHAR:
-		::duckdb::SearchString(list, key.str_value, offsets, key.is_null, entry.offset, entry.length);
+	case PhysicalType::VARCHAR:
+		SearchStringInMap(list, StringValue::Get(key), offsets, key.IsNull(), entry.offset, entry.length);
 		break;
 	default:
 		throw InvalidTypeException(list.GetType().id(), "Invalid type for List Vector Search");
@@ -36893,13 +37102,13 @@ vector<idx_t> ListVector::Search(Vector &list, Value &key, idx_t row) {
 }
 
 Value ListVector::GetValuesFromOffsets(Vector &list, vector<idx_t> &offsets) {
-	Value ret(ListType::GetChildType(list.GetType()));
-	ret.is_null = false;
 	auto &child_vec = ListVector::GetEntry(list);
+	vector<Value> list_values;
+	list_values.reserve(offsets.size());
 	for (auto &offset : offsets) {
-		ret.list_value.push_back(child_vec.GetValue(offset));
+		list_values.push_back(child_vec.GetValue(offset));
 	}
-	return ret;
+	return Value::LIST(ListType::GetChildType(list.GetType()), move(list_values));
 }
 
 idx_t ListVector::GetListSize(const Vector &vec) {
@@ -36947,7 +37156,7 @@ void ListVector::Append(Vector &target, const Vector &source, const SelectionVec
 	target_buffer.Append(source, sel, source_size, source_offset);
 }
 
-void ListVector::PushBack(Vector &target, Value &insert) {
+void ListVector::PushBack(Vector &target, const Value &insert) {
 	auto &target_buffer = (VectorListBuffer &)*target.auxiliary;
 	target_buffer.PushBack(insert);
 }
@@ -37032,7 +37241,7 @@ void VectorListBuffer::Append(const Vector &to_append, const SelectionVector &se
 	size += to_append_size - source_offset;
 }
 
-void VectorListBuffer::PushBack(Value &insert) {
+void VectorListBuffer::PushBack(const Value &insert) {
 	if (size + 1 > capacity) {
 		child->Resize(capacity, capacity * 2);
 		capacity *= 2;
@@ -38348,16 +38557,7 @@ int64_t EnumType::GetPos(const LogicalType &type, const string &key) {
 const string EnumType::GetValue(const Value &val) {
 	auto info = val.type().AuxInfo();
 	auto &values_insert_order = ((EnumTypeInfo &)*info).values_insert_order;
-	switch (val.type().InternalType()) {
-	case PhysicalType::UINT8:
-		return values_insert_order.GetValue(val.value_.utinyint).ToString();
-	case PhysicalType::UINT16:
-		return values_insert_order.GetValue(val.value_.usmallint).ToString();
-	case PhysicalType::UINT32:
-		return values_insert_order.GetValue(val.value_.uinteger).ToString();
-	default:
-		throw InternalException("Invalid Internal Type for ENUMs");
-	}
+	return StringValue::Get(values_insert_order.GetValue(val.GetValue<uint32_t>()));
 }
 
 Vector &EnumType::GetValuesInsertOrder(const LogicalType &type) {
@@ -38592,56 +38792,60 @@ static bool TemplatedBooleanOperation(const Value &left, const Value &right) {
 	}
 	switch (left_type.InternalType()) {
 	case PhysicalType::BOOL:
-		return OP::Operation(left.value_.boolean, right.value_.boolean);
+		return OP::Operation(left.GetValueUnsafe<bool>(), right.GetValueUnsafe<bool>());
 	case PhysicalType::INT8:
-		return OP::Operation(left.value_.tinyint, right.value_.tinyint);
+		return OP::Operation(left.GetValueUnsafe<int8_t>(), right.GetValueUnsafe<int8_t>());
 	case PhysicalType::INT16:
-		return OP::Operation(left.value_.smallint, right.value_.smallint);
+		return OP::Operation(left.GetValueUnsafe<int16_t>(), right.GetValueUnsafe<int16_t>());
 	case PhysicalType::INT32:
-		return OP::Operation(left.value_.integer, right.value_.integer);
+		return OP::Operation(left.GetValueUnsafe<int32_t>(), right.GetValueUnsafe<int32_t>());
 	case PhysicalType::INT64:
-		return OP::Operation(left.value_.bigint, right.value_.bigint);
+		return OP::Operation(left.GetValueUnsafe<int64_t>(), right.GetValueUnsafe<int64_t>());
 	case PhysicalType::UINT8:
-		return OP::Operation(left.value_.utinyint, right.value_.utinyint);
+		return OP::Operation(left.GetValueUnsafe<uint8_t>(), right.GetValueUnsafe<uint8_t>());
 	case PhysicalType::UINT16:
-		return OP::Operation(left.value_.usmallint, right.value_.usmallint);
+		return OP::Operation(left.GetValueUnsafe<uint16_t>(), right.GetValueUnsafe<uint16_t>());
 	case PhysicalType::UINT32:
-		return OP::Operation(left.value_.uinteger, right.value_.uinteger);
+		return OP::Operation(left.GetValueUnsafe<uint32_t>(), right.GetValueUnsafe<uint32_t>());
 	case PhysicalType::UINT64:
-		return OP::Operation(left.value_.ubigint, right.value_.ubigint);
+		return OP::Operation(left.GetValueUnsafe<uint64_t>(), right.GetValueUnsafe<uint64_t>());
 	case PhysicalType::INT128:
-		return OP::Operation(left.value_.hugeint, right.value_.hugeint);
+		return OP::Operation(left.GetValueUnsafe<hugeint_t>(), right.GetValueUnsafe<hugeint_t>());
 	case PhysicalType::FLOAT:
-		return OP::Operation(left.value_.float_, right.value_.float_);
+		return OP::Operation(left.GetValueUnsafe<float>(), right.GetValueUnsafe<float>());
 	case PhysicalType::DOUBLE:
-		return OP::Operation(left.value_.double_, right.value_.double_);
+		return OP::Operation(left.GetValueUnsafe<double>(), right.GetValueUnsafe<double>());
 	case PhysicalType::INTERVAL:
-		return OP::Operation(left.value_.interval, right.value_.interval);
+		return OP::Operation(left.GetValueUnsafe<interval_t>(), right.GetValueUnsafe<interval_t>());
 	case PhysicalType::VARCHAR:
-		return OP::Operation(left.str_value, right.str_value);
+		return OP::Operation(StringValue::Get(left), StringValue::Get(right));
 	case PhysicalType::STRUCT: {
+		auto &left_children = StructValue::GetChildren(left);
+		auto &right_children = StructValue::GetChildren(right);
 		// this should be enforced by the type
-		D_ASSERT(left.struct_value.size() == right.struct_value.size());
+		D_ASSERT(left_children.size() == right_children.size());
 		idx_t i = 0;
-		for (; i < left.struct_value.size() - 1; ++i) {
-			if (ValuePositionComparator::Definite<OP>(left.struct_value[i], right.struct_value[i])) {
+		for (; i < left_children.size() - 1; ++i) {
+			if (ValuePositionComparator::Definite<OP>(left_children[i], right_children[i])) {
 				return true;
 			}
-			if (!ValuePositionComparator::Possible<OP>(left.struct_value[i], right.struct_value[i])) {
+			if (!ValuePositionComparator::Possible<OP>(left_children[i], right_children[i])) {
 				return false;
 			}
 		}
-		return ValuePositionComparator::Final<OP>(left.struct_value[i], right.struct_value[i]);
+		return ValuePositionComparator::Final<OP>(left_children[i], right_children[i]);
 	}
 	case PhysicalType::LIST: {
+		auto &left_children = ListValue::GetChildren(left);
+		auto &right_children = ListValue::GetChildren(right);
 		for (idx_t pos = 0;; ++pos) {
-			if (pos == left.list_value.size() || pos == right.list_value.size()) {
-				return ValuePositionComparator::TieBreak<OP>(left.list_value.size(), right.list_value.size());
+			if (pos == left_children.size() || pos == right_children.size()) {
+				return ValuePositionComparator::TieBreak<OP>(left_children.size(), right_children.size());
 			}
-			if (ValuePositionComparator::Definite<OP>(left.list_value[pos], right.list_value[pos])) {
+			if (ValuePositionComparator::Definite<OP>(left_children[pos], right_children[pos])) {
 				return true;
 			}
-			if (!ValuePositionComparator::Possible<OP>(left.list_value[pos], right.list_value[pos])) {
+			if (!ValuePositionComparator::Possible<OP>(left_children[pos], right_children[pos])) {
 				return false;
 			}
 		}
@@ -38653,7 +38857,7 @@ static bool TemplatedBooleanOperation(const Value &left, const Value &right) {
 }
 
 bool ValueOperations::Equals(const Value &left, const Value &right) {
-	if (left.is_null || right.is_null) {
+	if (left.IsNull() || right.IsNull()) {
 		throw InternalException("Comparison on NULL values");
 	}
 	return TemplatedBooleanOperation<duckdb::Equals>(left, right);
@@ -38664,14 +38868,14 @@ bool ValueOperations::NotEquals(const Value &left, const Value &right) {
 }
 
 bool ValueOperations::GreaterThan(const Value &left, const Value &right) {
-	if (left.is_null || right.is_null) {
+	if (left.IsNull() || right.IsNull()) {
 		throw InternalException("Comparison on NULL values");
 	}
 	return TemplatedBooleanOperation<duckdb::GreaterThan>(left, right);
 }
 
 bool ValueOperations::GreaterThanEquals(const Value &left, const Value &right) {
-	if (left.is_null || right.is_null) {
+	if (left.IsNull() || right.IsNull()) {
 		throw InternalException("Comparison on NULL values");
 	}
 	return TemplatedBooleanOperation<duckdb::GreaterThanEquals>(left, right);
@@ -38686,10 +38890,10 @@ bool ValueOperations::LessThanEquals(const Value &left, const Value &right) {
 }
 
 bool ValueOperations::NotDistinctFrom(const Value &left, const Value &right) {
-	if (left.is_null && right.is_null) {
+	if (left.IsNull() && right.IsNull()) {
 		return true;
 	}
-	if (left.is_null != right.is_null) {
+	if (left.IsNull() != right.IsNull()) {
 		return false;
 	}
 	return TemplatedBooleanOperation<duckdb::Equals>(left, right);
@@ -38700,20 +38904,20 @@ bool ValueOperations::DistinctFrom(const Value &left, const Value &right) {
 }
 
 bool ValueOperations::DistinctGreaterThan(const Value &left, const Value &right) {
-	if (left.is_null && right.is_null) {
+	if (left.IsNull() && right.IsNull()) {
 		return false;
-	} else if (right.is_null) {
+	} else if (right.IsNull()) {
 		return false;
-	} else if (left.is_null) {
+	} else if (left.IsNull()) {
 		return true;
 	}
 	return TemplatedBooleanOperation<duckdb::GreaterThan>(left, right);
 }
 
 bool ValueOperations::DistinctGreaterThanEquals(const Value &left, const Value &right) {
-	if (left.is_null) {
+	if (left.IsNull()) {
 		return true;
-	} else if (right.is_null) {
+	} else if (right.IsNull()) {
 		return false;
 	}
 	return TemplatedBooleanOperation<duckdb::GreaterThanEquals>(left, right);
@@ -38728,297 +38932,6 @@ bool ValueOperations::DistinctLessThanEquals(const Value &left, const Value &rig
 }
 
 } // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-hash_t ValueOperations::Hash(const Value &op) {
-	if (op.is_null) {
-		return 0;
-	}
-	switch (op.type().InternalType()) {
-	case PhysicalType::BOOL:
-		return duckdb::Hash(op.value_.boolean);
-	case PhysicalType::INT8:
-		return duckdb::Hash(op.value_.tinyint);
-	case PhysicalType::INT16:
-		return duckdb::Hash(op.value_.smallint);
-	case PhysicalType::INT32:
-		return duckdb::Hash(op.value_.integer);
-	case PhysicalType::INT64:
-		return duckdb::Hash(op.value_.bigint);
-	case PhysicalType::UINT8:
-		return duckdb::Hash(op.value_.utinyint);
-	case PhysicalType::UINT16:
-		return duckdb::Hash(op.value_.usmallint);
-	case PhysicalType::UINT32:
-		return duckdb::Hash(op.value_.uinteger);
-	case PhysicalType::UINT64:
-		return duckdb::Hash(op.value_.ubigint);
-	case PhysicalType::INT128:
-		return duckdb::Hash(op.value_.hugeint);
-	case PhysicalType::FLOAT:
-		return duckdb::Hash(op.value_.float_);
-	case PhysicalType::DOUBLE:
-		return duckdb::Hash(op.value_.double_);
-	case PhysicalType::INTERVAL:
-		return duckdb::Hash(op.value_.interval);
-	case PhysicalType::VARCHAR:
-		return duckdb::Hash(op.str_value.c_str());
-	case PhysicalType::LIST: {
-		hash_t hash = 0;
-		for (auto &entry : op.list_value) {
-			hash ^= ValueOperations::Hash(entry);
-		}
-		return hash;
-	}
-	case PhysicalType::STRUCT: {
-		hash_t hash = 0;
-		for (auto &entry : op.struct_value) {
-			hash ^= ValueOperations::Hash(entry);
-		}
-		return hash;
-	}
-	default:
-		throw InternalException("Unimplemented type for value hash");
-	}
-}
-
-} // namespace duckdb
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/subtract.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct SubtractOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return left - right;
-	}
-};
-
-template <>
-float SubtractOperator::Operation(float left, float right);
-template <>
-double SubtractOperator::Operation(double left, double right);
-template <>
-interval_t SubtractOperator::Operation(interval_t left, interval_t right);
-template <>
-int64_t SubtractOperator::Operation(date_t left, date_t right);
-template <>
-date_t SubtractOperator::Operation(date_t left, int32_t right);
-template <>
-date_t SubtractOperator::Operation(date_t left, interval_t right);
-template <>
-timestamp_t SubtractOperator::Operation(timestamp_t left, interval_t right);
-template <>
-interval_t SubtractOperator::Operation(timestamp_t left, timestamp_t right);
-
-struct TrySubtractOperator {
-	template <class TA, class TB, class TR>
-	static inline bool Operation(TA left, TB right, TR &result) {
-		throw InternalException("Unimplemented type for TrySubtractOperator");
-	}
-};
-
-template <>
-bool TrySubtractOperator::Operation(uint8_t left, uint8_t right, uint8_t &result);
-template <>
-bool TrySubtractOperator::Operation(uint16_t left, uint16_t right, uint16_t &result);
-template <>
-bool TrySubtractOperator::Operation(uint32_t left, uint32_t right, uint32_t &result);
-template <>
-bool TrySubtractOperator::Operation(uint64_t left, uint64_t right, uint64_t &result);
-
-template <>
-bool TrySubtractOperator::Operation(int8_t left, int8_t right, int8_t &result);
-template <>
-bool TrySubtractOperator::Operation(int16_t left, int16_t right, int16_t &result);
-template <>
-bool TrySubtractOperator::Operation(int32_t left, int32_t right, int32_t &result);
-template <>
-bool TrySubtractOperator::Operation(int64_t left, int64_t right, int64_t &result);
-
-struct SubtractOperatorOverflowCheck {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		TR result;
-		if (!TrySubtractOperator::Operation(left, right, result)) {
-			throw OutOfRangeException("Overflow in subtraction of %s (%d - %d)!", TypeIdToString(GetTypeId<TA>()), left,
-			                          right);
-		}
-		return result;
-	}
-};
-
-struct TryDecimalSubtract {
-	template <class TA, class TB, class TR>
-	static inline bool Operation(TA left, TB right, TR &result) {
-		throw InternalException("Unimplemented type for TryDecimalSubtract");
-	}
-};
-
-template <>
-bool TryDecimalSubtract::Operation(int16_t left, int16_t right, int16_t &result);
-template <>
-bool TryDecimalSubtract::Operation(int32_t left, int32_t right, int32_t &result);
-template <>
-bool TryDecimalSubtract::Operation(int64_t left, int64_t right, int64_t &result);
-template <>
-bool TryDecimalSubtract::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
-
-struct DecimalSubtractOverflowCheck {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		TR result;
-		if (!TryDecimalSubtract::Operation<TA, TB, TR>(left, right, result)) {
-			throw OutOfRangeException("Overflow in subtract of DECIMAL(18) (%d - %d). You might want to add an "
-			                          "explicit cast to a bigger decimal.",
-			                          left, right);
-		}
-		return result;
-	}
-};
-
-template <>
-hugeint_t DecimalSubtractOverflowCheck::Operation(hugeint_t left, hugeint_t right);
-
-struct SubtractTimeOperator {
-	template <class TA, class TB, class TR>
-	static TR Operation(TA left, TB right);
-};
-
-template <>
-dtime_t SubtractTimeOperator::Operation(dtime_t left, interval_t right);
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-template <class OP>
-static Value BinaryValueOperation(const Value &left, const Value &right) {
-	auto left_type = left.type();
-	auto right_type = right.type();
-	LogicalType result_type = left_type;
-	if (left_type != right_type) {
-		result_type = LogicalType::MaxLogicalType(left.type(), right.type());
-		Value left_cast = left.CastAs(result_type);
-		Value right_cast = right.CastAs(result_type);
-		return BinaryValueOperation<OP>(left_cast, right_cast);
-	}
-	if (left.is_null || right.is_null) {
-		return Value().CastAs(result_type);
-	}
-	if (TypeIsIntegral(result_type.InternalType())) {
-		hugeint_t left_hugeint;
-		hugeint_t right_hugeint;
-		switch (result_type.InternalType()) {
-		case PhysicalType::INT8:
-			left_hugeint = Hugeint::Convert(left.value_.tinyint);
-			right_hugeint = Hugeint::Convert(right.value_.tinyint);
-			break;
-		case PhysicalType::INT16:
-			left_hugeint = Hugeint::Convert(left.value_.smallint);
-			right_hugeint = Hugeint::Convert(right.value_.smallint);
-			break;
-		case PhysicalType::INT32:
-			left_hugeint = Hugeint::Convert(left.value_.integer);
-			right_hugeint = Hugeint::Convert(right.value_.integer);
-			break;
-		case PhysicalType::INT64:
-			left_hugeint = Hugeint::Convert(left.value_.bigint);
-			right_hugeint = Hugeint::Convert(right.value_.bigint);
-			break;
-		case PhysicalType::UINT8:
-			left_hugeint = Hugeint::Convert(left.value_.utinyint);
-			right_hugeint = Hugeint::Convert(right.value_.utinyint);
-			break;
-		case PhysicalType::UINT16:
-			left_hugeint = Hugeint::Convert(left.value_.usmallint);
-			right_hugeint = Hugeint::Convert(right.value_.usmallint);
-			break;
-		case PhysicalType::UINT32:
-			left_hugeint = Hugeint::Convert(left.value_.uinteger);
-			right_hugeint = Hugeint::Convert(right.value_.uinteger);
-			break;
-		case PhysicalType::UINT64:
-			left_hugeint = Hugeint::Convert(left.value_.ubigint);
-			right_hugeint = Hugeint::Convert(right.value_.ubigint);
-			break;
-		case PhysicalType::INT128:
-			left_hugeint = left.value_.hugeint;
-			right_hugeint = right.value_.hugeint;
-			break;
-		default:
-			throw NotImplementedException("Unimplemented type for value binary op");
-		}
-		// integer addition
-		return Value::Numeric(result_type,
-		                      OP::template Operation<hugeint_t, hugeint_t, hugeint_t>(left_hugeint, right_hugeint));
-	} else if (result_type.InternalType() == PhysicalType::FLOAT) {
-		return Value::FLOAT(
-		    OP::template Operation<float, float, float>(left.GetValue<float>(), right.GetValue<float>()));
-	} else if (result_type.InternalType() == PhysicalType::DOUBLE) {
-		return Value::DOUBLE(
-		    OP::template Operation<double, double, double>(left.GetValue<double>(), right.GetValue<double>()));
-	} else {
-		throw NotImplementedException("Unimplemented type for value binary op");
-	}
-}
-
-//===--------------------------------------------------------------------===//
-// Numeric Operations
-//===--------------------------------------------------------------------===//
-Value ValueOperations::Add(const Value &left, const Value &right) {
-	return BinaryValueOperation<duckdb::AddOperator>(left, right);
-}
-
-Value ValueOperations::Subtract(const Value &left, const Value &right) {
-	return BinaryValueOperation<duckdb::SubtractOperator>(left, right);
-}
-
-Value ValueOperations::Multiply(const Value &left, const Value &right) {
-	return BinaryValueOperation<duckdb::MultiplyOperator>(left, right);
-}
-
-Value ValueOperations::Modulo(const Value &left, const Value &right) {
-	if (right == 0) {
-		return Value(right.type());
-	} else {
-		return BinaryValueOperation<duckdb::ModuloOperator>(left, right);
-	}
-}
-
-Value ValueOperations::Divide(const Value &left, const Value &right) {
-	if (right == 0) {
-		return Value(right.type());
-	} else {
-		return BinaryValueOperation<duckdb::DivideOperator>(left, right);
-	}
-}
-
-} // namespace duckdb
 //===--------------------------------------------------------------------===//
 // boolean_operators.cpp
 // Description: This file contains the implementation of the boolean
@@ -41592,7 +41505,7 @@ void EnumToVarchar(Vector &source, Vector &result, idx_t count, PhysicalType enu
 
 	for (idx_t i = 0; i < count; i++) {
 		auto src_val = source.GetValue(i);
-		if (src_val.is_null) {
+		if (src_val.IsNull()) {
 			result.SetValue(i, Value());
 			continue;
 		}
@@ -41600,13 +41513,13 @@ void EnumToVarchar(Vector &source, Vector &result, idx_t count, PhysicalType enu
 		uint64_t enum_idx;
 		switch (enum_physical_type) {
 		case PhysicalType::UINT8:
-			enum_idx = src_val.value_.utinyint;
+			enum_idx = UTinyIntValue::Get(src_val);
 			break;
 		case PhysicalType::UINT16:
-			enum_idx = src_val.value_.usmallint;
+			enum_idx = USmallIntValue::Get(src_val);
 			break;
 		case PhysicalType::UINT32:
-			enum_idx = src_val.value_.uinteger;
+			enum_idx = UIntegerValue::Get(src_val);
 			break;
 		default:
 			throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
@@ -45710,32 +45623,31 @@ static unique_ptr<Key> CreateKey(ART &art, PhysicalType type, Value &value) {
 	D_ASSERT(type == value.type().InternalType());
 	switch (type) {
 	case PhysicalType::BOOL:
-		return Key::CreateKey<bool>(value.value_.boolean, art.is_little_endian);
+		return Key::CreateKey<bool>(value, art.is_little_endian);
 	case PhysicalType::INT8:
-		return Key::CreateKey<int8_t>(value.value_.tinyint, art.is_little_endian);
+		return Key::CreateKey<int8_t>(value, art.is_little_endian);
 	case PhysicalType::INT16:
-		return Key::CreateKey<int16_t>(value.value_.smallint, art.is_little_endian);
+		return Key::CreateKey<int16_t>(value, art.is_little_endian);
 	case PhysicalType::INT32:
-		return Key::CreateKey<int32_t>(value.value_.integer, art.is_little_endian);
+		return Key::CreateKey<int32_t>(value, art.is_little_endian);
 	case PhysicalType::INT64:
-		return Key::CreateKey<int64_t>(value.value_.bigint, art.is_little_endian);
+		return Key::CreateKey<int64_t>(value, art.is_little_endian);
 	case PhysicalType::UINT8:
-		return Key::CreateKey<uint8_t>(value.value_.utinyint, art.is_little_endian);
+		return Key::CreateKey<uint8_t>(value, art.is_little_endian);
 	case PhysicalType::UINT16:
-		return Key::CreateKey<uint16_t>(value.value_.usmallint, art.is_little_endian);
+		return Key::CreateKey<uint16_t>(value, art.is_little_endian);
 	case PhysicalType::UINT32:
-		return Key::CreateKey<uint32_t>(value.value_.uinteger, art.is_little_endian);
+		return Key::CreateKey<uint32_t>(value, art.is_little_endian);
 	case PhysicalType::UINT64:
-		return Key::CreateKey<uint64_t>(value.value_.ubigint, art.is_little_endian);
+		return Key::CreateKey<uint64_t>(value, art.is_little_endian);
 	case PhysicalType::INT128:
-		return Key::CreateKey<hugeint_t>(value.value_.hugeint, art.is_little_endian);
+		return Key::CreateKey<hugeint_t>(value, art.is_little_endian);
 	case PhysicalType::FLOAT:
-		return Key::CreateKey<float>(value.value_.float_, art.is_little_endian);
+		return Key::CreateKey<float>(value, art.is_little_endian);
 	case PhysicalType::DOUBLE:
-		return Key::CreateKey<double>(value.value_.double_, art.is_little_endian);
+		return Key::CreateKey<double>(value, art.is_little_endian);
 	case PhysicalType::VARCHAR:
-		return Key::CreateKey<string_t>(string_t(value.str_value.c_str(), value.str_value.size()),
-		                                art.is_little_endian);
+		return Key::CreateKey<string_t>(value, art.is_little_endian);
 	default:
 		throw InternalException("Invalid type for index");
 	}
@@ -46074,7 +45986,7 @@ bool ART::Scan(Transaction &transaction, DataTable &table, IndexScanState &table
 
 	vector<row_t> row_ids;
 	bool success = true;
-	if (state->values[1].is_null) {
+	if (state->values[1].IsNull()) {
 		lock_guard<mutex> l(lock);
 		// single predicate
 		switch (state->expressions[0]) {
@@ -48958,7 +48870,7 @@ PhysicalPerfectHashAggregate::PhysicalPerfectHashAggregate(ClientContext &contex
 	for (auto &stats : group_stats) {
 		D_ASSERT(stats);
 		auto &nstats = (NumericStatistics &)*stats;
-		D_ASSERT(!nstats.min.is_null);
+		D_ASSERT(!nstats.min.IsNull());
 		group_minima.push_back(move(nstats.min));
 	}
 	for (auto &expr : groups) {
@@ -51490,7 +51402,7 @@ SinkResultType PhysicalLimit::Sink(ExecutionContext &context, GlobalSinkState &g
 	if (limit == DConstants::INVALID_INDEX) {
 		limit = 1ULL << 62ULL;
 		Value val = GetDelimiter(input, limit_expression.get());
-		if (!val.is_null) {
+		if (!val.IsNull()) {
 			limit = val.GetValue<idx_t>();
 		}
 		if (limit > 1ULL << 62ULL) {
@@ -51500,7 +51412,7 @@ SinkResultType PhysicalLimit::Sink(ExecutionContext &context, GlobalSinkState &g
 	if (offset == DConstants::INVALID_INDEX) {
 		offset = 0;
 		Value val = GetDelimiter(input, offset_expression.get());
-		if (!val.is_null) {
+		if (!val.IsNull()) {
 			offset = val.GetValue<idx_t>();
 		}
 		if (offset > 1ULL << 62ULL) {
@@ -51708,7 +51620,7 @@ SinkResultType PhysicalLimitPercent::Sink(ExecutionContext &context, GlobalSinkS
 	// get the next chunk from the child
 	if (!state.is_limit_percent_delimited) {
 		Value val = PhysicalLimit::GetDelimiter(input, limit_expression.get());
-		if (!val.is_null) {
+		if (!val.IsNull()) {
 			limit_percent = val.GetValue<double>();
 		}
 		if (limit_percent < 0.0) {
@@ -51718,7 +51630,7 @@ SinkResultType PhysicalLimitPercent::Sink(ExecutionContext &context, GlobalSinkS
 	}
 	if (!state.is_offset_delimited) {
 		Value val = PhysicalLimit::GetDelimiter(input, offset_expression.get());
-		if (!val.is_null) {
+		if (!val.IsNull()) {
 			offset = val.GetValue<idx_t>();
 		}
 		if (offset > 1ULL << 62ULL) {
@@ -52939,7 +52851,7 @@ bool PerfectHashJoinExecutor::FillSelectionVectorSwitchBuild(Vector &source, Sel
 template <typename T>
 bool PerfectHashJoinExecutor::TemplatedFillSelectionVectorBuild(Vector &source, SelectionVector &sel_vec,
                                                                 SelectionVector &seq_sel_vec, idx_t count) {
-	if (perfect_join_statistics.build_min.is_null || perfect_join_statistics.build_max.is_null) {
+	if (perfect_join_statistics.build_min.IsNull() || perfect_join_statistics.build_max.IsNull()) {
 		return false;
 	}
 	auto min_value = perfect_join_statistics.build_min.GetValueUnsafe<T>();
@@ -54506,7 +54418,7 @@ void PhysicalIndexJoin::GetRHSMatches(ExecutionContext &context, DataChunk &inpu
 		auto equal_value = state.join_keys.GetValue(0, i);
 		auto index_state = art.InitializeScanSinglePredicate(transaction, equal_value, ExpressionType::COMPARE_EQUAL);
 		state.rhs_rows[i].clear();
-		if (!equal_value.is_null) {
+		if (!equal_value.IsNull()) {
 			if (fetch_types.empty()) {
 				IndexLock lock;
 				index->InitializeLock(lock);
@@ -56688,9 +56600,9 @@ static string GetLineNumberStr(idx_t linenr, bool linenr_estimated) {
 	return to_string(linenr + 1) + estimated;
 }
 
-static bool StartsWithNumericDate(string &separator, const string_t &value) {
-	auto begin = value.GetDataUnsafe();
-	auto end = begin + value.GetSize();
+static bool StartsWithNumericDate(string &separator, const string &value) {
+	auto begin = value.c_str();
+	auto end = begin + value.size();
 
 	//	StrpTimeFormat::Parse will skip whitespace, so we can too
 	auto field1 = std::find_if_not(begin, end, StringUtil::CharacterIsSpace);
@@ -57073,12 +56985,13 @@ bool BufferedCSVReader::TryCastValue(const Value &value, const LogicalType &sql_
 	if (options.has_format[LogicalTypeId::DATE] && sql_type.id() == LogicalTypeId::DATE) {
 		date_t result;
 		string error_message;
-		return options.date_format[LogicalTypeId::DATE].TryParseDate(string_t(value.str_value), result, error_message);
+		return options.date_format[LogicalTypeId::DATE].TryParseDate(string_t(StringValue::Get(value)), result,
+		                                                             error_message);
 	} else if (options.has_format[LogicalTypeId::TIMESTAMP] && sql_type.id() == LogicalTypeId::TIMESTAMP) {
 		timestamp_t result;
 		string error_message;
-		return options.date_format[LogicalTypeId::TIMESTAMP].TryParseTimestamp(string_t(value.str_value), result,
-		                                                                       error_message);
+		return options.date_format[LogicalTypeId::TIMESTAMP].TryParseTimestamp(string_t(StringValue::Get(value)),
+		                                                                       result, error_message);
 	} else {
 		Value new_value;
 		string error_message;
@@ -57314,7 +57227,7 @@ void BufferedCSVReader::DetectCandidateTypes(const vector<LogicalType> &type_can
 					// try formatting for date types if the user did not specify one and it starts with numeric values.
 					string separator;
 					if (has_format_candidates.count(sql_type.id()) && !original_options.has_format[sql_type.id()] &&
-					    StartsWithNumericDate(separator, dummy_val.str_value)) {
+					    StartsWithNumericDate(separator, StringValue::Get(dummy_val))) {
 						// generate date format candidates the first time through
 						auto &type_format_candidates = format_candidates[sql_type.id()];
 						const auto had_format_candidates = has_format_candidates[sql_type.id()];
@@ -57343,7 +57256,7 @@ void BufferedCSVReader::DetectCandidateTypes(const vector<LogicalType> &type_can
 						while (!type_format_candidates.empty()) {
 							//	avoid using exceptions for flow control...
 							auto &current_format = options.date_format[sql_type.id()];
-							if (current_format.Parse(dummy_val.str_value, result)) {
+							if (current_format.Parse(StringValue::Get(dummy_val), result)) {
 								break;
 							}
 							//	doesn't work - move to the next one
@@ -57430,7 +57343,7 @@ void BufferedCSVReader::DetectHeader(const vector<vector<LogicalType>> &best_sql
 	first_row_nulls = true;
 	for (idx_t col = 0; col < best_sql_types_candidates.size(); col++) {
 		auto dummy_val = best_header_row.GetValue(col, 0);
-		if (!dummy_val.is_null) {
+		if (!dummy_val.IsNull()) {
 			first_row_nulls = false;
 		}
 
@@ -57451,7 +57364,7 @@ void BufferedCSVReader::DetectHeader(const vector<vector<LogicalType>> &best_sql
 			string col_name = val.ToString();
 
 			// generate name if field is empty
-			if (col_name.empty() || val.is_null) {
+			if (col_name.empty() || val.IsNull()) {
 				col_name = GenerateColumnName(options.num_cols, col);
 			}
 
@@ -61573,6 +61486,123 @@ unique_ptr<GlobalSinkState> PhysicalOperator::GetGlobalSinkState(ClientContext &
 
 } // namespace duckdb
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/operator/subtract.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+struct SubtractOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		return left - right;
+	}
+};
+
+template <>
+float SubtractOperator::Operation(float left, float right);
+template <>
+double SubtractOperator::Operation(double left, double right);
+template <>
+interval_t SubtractOperator::Operation(interval_t left, interval_t right);
+template <>
+int64_t SubtractOperator::Operation(date_t left, date_t right);
+template <>
+date_t SubtractOperator::Operation(date_t left, int32_t right);
+template <>
+date_t SubtractOperator::Operation(date_t left, interval_t right);
+template <>
+timestamp_t SubtractOperator::Operation(timestamp_t left, interval_t right);
+template <>
+interval_t SubtractOperator::Operation(timestamp_t left, timestamp_t right);
+
+struct TrySubtractOperator {
+	template <class TA, class TB, class TR>
+	static inline bool Operation(TA left, TB right, TR &result) {
+		throw InternalException("Unimplemented type for TrySubtractOperator");
+	}
+};
+
+template <>
+bool TrySubtractOperator::Operation(uint8_t left, uint8_t right, uint8_t &result);
+template <>
+bool TrySubtractOperator::Operation(uint16_t left, uint16_t right, uint16_t &result);
+template <>
+bool TrySubtractOperator::Operation(uint32_t left, uint32_t right, uint32_t &result);
+template <>
+bool TrySubtractOperator::Operation(uint64_t left, uint64_t right, uint64_t &result);
+
+template <>
+bool TrySubtractOperator::Operation(int8_t left, int8_t right, int8_t &result);
+template <>
+bool TrySubtractOperator::Operation(int16_t left, int16_t right, int16_t &result);
+template <>
+bool TrySubtractOperator::Operation(int32_t left, int32_t right, int32_t &result);
+template <>
+bool TrySubtractOperator::Operation(int64_t left, int64_t right, int64_t &result);
+
+struct SubtractOperatorOverflowCheck {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		TR result;
+		if (!TrySubtractOperator::Operation(left, right, result)) {
+			throw OutOfRangeException("Overflow in subtraction of %s (%d - %d)!", TypeIdToString(GetTypeId<TA>()), left,
+			                          right);
+		}
+		return result;
+	}
+};
+
+struct TryDecimalSubtract {
+	template <class TA, class TB, class TR>
+	static inline bool Operation(TA left, TB right, TR &result) {
+		throw InternalException("Unimplemented type for TryDecimalSubtract");
+	}
+};
+
+template <>
+bool TryDecimalSubtract::Operation(int16_t left, int16_t right, int16_t &result);
+template <>
+bool TryDecimalSubtract::Operation(int32_t left, int32_t right, int32_t &result);
+template <>
+bool TryDecimalSubtract::Operation(int64_t left, int64_t right, int64_t &result);
+template <>
+bool TryDecimalSubtract::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
+
+struct DecimalSubtractOverflowCheck {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		TR result;
+		if (!TryDecimalSubtract::Operation<TA, TB, TR>(left, right, result)) {
+			throw OutOfRangeException("Overflow in subtract of DECIMAL(18) (%d - %d). You might want to add an "
+			                          "explicit cast to a bigger decimal.",
+			                          left, right);
+		}
+		return result;
+	}
+};
+
+template <>
+hugeint_t DecimalSubtractOverflowCheck::Operation(hugeint_t left, hugeint_t right);
+
+struct SubtractTimeOperator {
+	template <class TA, class TB, class TR>
+	static TR Operation(TA left, TB right);
+};
+
+template <>
+dtime_t SubtractTimeOperator::Operation(dtime_t left, interval_t right);
+
+} // namespace duckdb
 
 
 
@@ -61822,7 +61852,7 @@ static bool CanUsePerfectHashAggregate(ClientContext &context, LogicalAggregate
 		}
 		auto &nstats = (NumericStatistics &)*stats;
 
-		if (nstats.min.is_null || nstats.max.is_null) {
+		if (nstats.min.IsNull() || nstats.max.IsNull()) {
 			return false;
 		}
 		// we have a min and a max value for the stats: use that to figure out how many bits we have
@@ -62166,7 +62196,7 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 
 	// and when the build range is smaller than the threshold
 	auto stats_build = reinterpret_cast<NumericStatistics *>(op.join_stats[0].get()); // lhs stats
-	if (stats_build->min.is_null || stats_build->max.is_null) {
+	if (stats_build->min.IsNull() || stats_build->max.IsNull()) {
 		return;
 	}
 	int64_t min_value, max_value;
@@ -62189,7 +62219,7 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 	join_state.build_max = stats_build->max;
 	join_state.estimated_cardinality = op.estimated_cardinality;
 	join_state.build_range = build_range;
-	if (join_state.build_range > MAX_BUILD_SIZE || stats_probe->max.is_null || stats_probe->min.is_null) {
+	if (join_state.build_range > MAX_BUILD_SIZE || stats_probe->max.IsNull() || stats_probe->min.IsNull()) {
 		return;
 	}
 	if (stats_build->min <= stats_probe->min && stats_probe->max <= stats_build->max) {
@@ -69346,7 +69376,7 @@ unique_ptr<BaseStatistics> SumPropagateStats(ClientContext &context, BoundAggreg
                                              NodeStatistics *node_stats) {
 	if (child_stats[0] && node_stats && node_stats->has_max_cardinality) {
 		auto &numeric_stats = (NumericStatistics &)*child_stats[0];
-		if (numeric_stats.min.is_null || numeric_stats.max.is_null) {
+		if (numeric_stats.min.IsNull() || numeric_stats.max.IsNull()) {
 			return nullptr;
 		}
 		auto internal_type = numeric_stats.min.type().InternalType();
@@ -70328,7 +70358,7 @@ unique_ptr<FunctionData> BindApproxQuantile(ClientContext &context, AggregateFun
 	Value quantile_val = ExpressionExecutor::EvaluateScalar(*arguments[1]);
 	auto quantile = quantile_val.GetValue<float>();
 
-	if (quantile_val.is_null || quantile < 0 || quantile > 1) {
+	if (quantile_val.IsNull() || quantile < 0 || quantile > 1) {
 		throw BinderException("APPROXIMATE QUANTILE can only take parameters in range [0, 1]");
 	}
 	// remove the quantile argument so we can use the unary aggregate
@@ -71840,7 +71870,7 @@ unique_ptr<FunctionData> BindMedianAbsoluteDeviationDecimal(ClientContext &conte
 static double CheckQuantile(const Value &quantile_val) {
 	auto quantile = quantile_val.GetValue<double>();
 
-	if (quantile_val.is_null || quantile < 0 || quantile > 1) {
+	if (quantile_val.IsNull() || quantile < 0 || quantile > 1) {
 		throw BinderException("QUANTILE can only take parameters in the range [0, 1]");
 	}
 
@@ -71857,7 +71887,7 @@ unique_ptr<FunctionData> BindQuantile(ClientContext &context, AggregateFunction
 	if (quantile_val.type().id() != LogicalTypeId::LIST) {
 		quantiles.push_back(CheckQuantile(quantile_val));
 	} else {
-		for (const auto &element_val : quantile_val.list_value) {
+		for (const auto &element_val : ListValue::GetChildren(quantile_val)) {
 			quantiles.push_back(CheckQuantile(element_val));
 		}
 	}
@@ -72192,7 +72222,7 @@ unique_ptr<FunctionData> BindReservoirQuantile(ClientContext &context, Aggregate
 	Value quantile_val = ExpressionExecutor::EvaluateScalar(*arguments[1]);
 	auto quantile = quantile_val.GetValue<double>();
 
-	if (quantile_val.is_null || quantile < 0 || quantile > 1) {
+	if (quantile_val.IsNull() || quantile < 0 || quantile > 1) {
 		throw BinderException("QUANTILE can only take parameters in range [0, 1]");
 	}
 	if (arguments.size() <= 2) {
@@ -72205,7 +72235,7 @@ unique_ptr<FunctionData> BindReservoirQuantile(ClientContext &context, Aggregate
 	Value sample_size_val = ExpressionExecutor::EvaluateScalar(*arguments[2]);
 	auto sample_size = sample_size_val.GetValue<int32_t>();
 
-	if (sample_size_val.is_null || sample_size <= 0) {
+	if (sample_size_val.IsNull() || sample_size <= 0) {
 		throw BinderException("Percentage of the sample must be bigger than 0");
 	}
 
@@ -75010,6 +75040,10 @@ struct EpochFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct MakeDateFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct StrfTimeFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
@@ -75690,7 +75724,7 @@ static unique_ptr<BaseStatistics> PropagateDatePartStatistics(vector<unique_ptr<
 		return nullptr;
 	}
 	auto &nstats = (NumericStatistics &)*child_stats[0];
-	if (nstats.min.is_null || nstats.max.is_null) {
+	if (nstats.min.IsNull() || nstats.max.IsNull()) {
 		return nullptr;
 	}
 	// run the operator on both the min and the max, this gives us the [min, max] bound
@@ -76789,11 +76823,12 @@ struct StructDatePart {
 
 		Value parts_list = ExpressionExecutor::EvaluateScalar(*arguments[0]);
 		if (parts_list.type().id() == LogicalTypeId::LIST) {
-			if (parts_list.list_value.empty()) {
+			auto &list_children = ListValue::GetChildren(parts_list);
+			if (list_children.empty()) {
 				throw BinderException("%s requires non-empty lists of part names", bound_function.name);
 			}
-			for (const auto &part_value : parts_list.list_value) {
-				if (part_value.is_null) {
+			for (const auto &part_value : list_children) {
+				if (part_value.IsNull()) {
 					throw BinderException("NULL struct entry name in %s", bound_function.name);
 				}
 				const auto part_name = part_value.ToString();
@@ -77822,6 +77857,189 @@ void EpochFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/vector_operations/senary_executor.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+struct SenaryExecutor {
+	static const size_t NCOLS = 6;
+
+	template <class TA, class TB, class TC, class TD, class TE, class TF, class TR,
+	          class FUN = std::function<TR(TA, TB, TC, TD, TE, TF)>>
+	static void Execute(DataChunk &input, Vector &result, FUN fun) {
+		D_ASSERT(input.ColumnCount() >= NCOLS);
+		const auto count = input.size();
+
+		bool all_constant = true;
+		bool any_null = false;
+		for (const auto &v : input.data) {
+			if (v.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+				if (ConstantVector::IsNull(v)) {
+					any_null = true;
+				}
+			} else {
+				all_constant = false;
+				break;
+			}
+		}
+
+		if (all_constant) {
+			result.SetVectorType(VectorType::CONSTANT_VECTOR);
+			if (any_null) {
+				ConstantVector::SetNull(result, true);
+			} else {
+				auto adata = ConstantVector::GetData<TA>(input.data[0]);
+				auto bdata = ConstantVector::GetData<TB>(input.data[1]);
+				auto cdata = ConstantVector::GetData<TC>(input.data[2]);
+				auto ddata = ConstantVector::GetData<TD>(input.data[3]);
+				auto edata = ConstantVector::GetData<TE>(input.data[4]);
+				auto fdata = ConstantVector::GetData<TF>(input.data[5]);
+				auto result_data = ConstantVector::GetData<TR>(result);
+				result_data[0] = fun(*adata, *bdata, *cdata, *ddata, *edata, *fdata);
+			}
+		} else {
+			result.SetVectorType(VectorType::FLAT_VECTOR);
+			auto result_data = FlatVector::GetData<TR>(result);
+			auto &result_validity = FlatVector::Validity(result);
+
+			bool all_valid = true;
+			vector<VectorData> vdata(NCOLS);
+			for (size_t c = 0; c < NCOLS; ++c) {
+				input.data[c].Orrify(count, vdata[c]);
+				all_valid = all_valid && vdata[c].validity.AllValid();
+			}
+
+			auto adata = (const TA *)(vdata[0].data);
+			auto bdata = (const TB *)(vdata[1].data);
+			auto cdata = (const TC *)(vdata[2].data);
+			auto ddata = (const TD *)(vdata[3].data);
+			auto edata = (const TE *)(vdata[4].data);
+			auto fdata = (const TF *)(vdata[5].data);
+
+			vector<idx_t> idx(NCOLS);
+			if (all_valid) {
+				for (idx_t r = 0; r < count; ++r) {
+					for (size_t c = 0; c < NCOLS; ++c) {
+						idx[c] = vdata[c].sel->get_index(r);
+					}
+					result_data[r] =
+					    fun(adata[idx[0]], bdata[idx[1]], cdata[idx[2]], ddata[idx[3]], edata[idx[4]], fdata[idx[5]]);
+				}
+			} else {
+				for (idx_t r = 0; r < count; ++r) {
+					all_valid = true;
+					for (size_t c = 0; c < NCOLS; ++c) {
+						idx[c] = vdata[c].sel->get_index(r);
+						if (!vdata[c].validity.RowIsValid(idx[c])) {
+							result_validity.SetInvalid(r);
+							all_valid = false;
+							break;
+						}
+					}
+					if (all_valid) {
+						result_data[r] = fun(adata[idx[0]], bdata[idx[1]], cdata[idx[2]], ddata[idx[3]], edata[idx[4]],
+						                     fdata[idx[5]]);
+					}
+				}
+			}
+		}
+	}
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+
+struct MakeDateOperator {
+	template <typename YYYY, typename MM, typename DD, typename RESULT_TYPE>
+	static RESULT_TYPE Operation(YYYY yyyy, MM mm, DD dd) {
+		return Date::FromDate(yyyy, mm, dd);
+	}
+};
+
+template <typename T>
+static void ExecuteMakeDate(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.ColumnCount() == 3);
+	auto &yyyy = input.data[0];
+	auto &mm = input.data[1];
+	auto &dd = input.data[2];
+
+	TernaryExecutor::Execute<T, T, T, date_t>(yyyy, mm, dd, result, input.size(),
+	                                          MakeDateOperator::Operation<T, T, T, date_t>);
+}
+
+struct MakeTimeOperator {
+	template <typename HH, typename MM, typename SS, typename RESULT_TYPE>
+	static RESULT_TYPE Operation(HH hh, MM mm, SS ss) {
+		int64_t secs = ss;
+		int64_t micros = std::round((ss - secs) * Interval::MICROS_PER_SEC);
+		return Time::FromTime(hh, mm, secs, micros);
+	}
+};
+
+template <typename T>
+static void ExecuteMakeTime(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.ColumnCount() == 3);
+	auto &yyyy = input.data[0];
+	auto &mm = input.data[1];
+	auto &dd = input.data[2];
+
+	TernaryExecutor::Execute<T, T, double, dtime_t>(yyyy, mm, dd, result, input.size(),
+	                                                MakeTimeOperator::Operation<T, T, double, dtime_t>);
+}
+
+struct MakeTimestampOperator {
+	template <typename YYYY, typename MM, typename DD, typename HR, typename MN, typename SS, typename RESULT_TYPE>
+	static RESULT_TYPE Operation(YYYY yyyy, MM mm, DD dd, HR hr, MN mn, SS ss) {
+		const auto d = MakeDateOperator::Operation<YYYY, MM, DD, date_t>(yyyy, mm, dd);
+		const auto t = MakeTimeOperator::Operation<HR, MN, SS, dtime_t>(hr, mn, ss);
+		return Timestamp::FromDatetime(d, t);
+	}
+};
+
+template <typename T>
+static void ExecuteMakeTimestamp(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.ColumnCount() == 6);
+
+	auto func = MakeTimestampOperator::Operation<T, T, T, T, T, double, timestamp_t>;
+	SenaryExecutor::Execute<T, T, T, T, T, double, timestamp_t>(input, result, func);
+}
+
+void MakeDateFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet make_date("make_date");
+	make_date.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT},
+	                                     LogicalType::DATE, ExecuteMakeDate<int64_t>));
+	set.AddFunction(make_date);
+
+	ScalarFunctionSet make_time("make_time");
+	make_time.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE},
+	                                     LogicalType::TIME, ExecuteMakeTime<int64_t>));
+	set.AddFunction(make_time);
+
+	ScalarFunctionSet make_timestamp("make_timestamp");
+	make_timestamp.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT,
+	                                           LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE},
+	                                          LogicalType::TIMESTAMP, ExecuteMakeTimestamp<int64_t>));
+	set.AddFunction(make_timestamp);
+}
+
+} // namespace duckdb
+
+
+
+
+
 
 
 
@@ -78406,7 +78624,7 @@ static unique_ptr<FunctionData> StrfTimeBindFunction(ClientContext &context, Sca
 	}
 	Value options_str = ExpressionExecutor::EvaluateScalar(*arguments[1]);
 	StrfTimeFormat format;
-	if (!options_str.is_null && options_str.type().id() == LogicalTypeId::VARCHAR) {
+	if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
 		auto format_string = options_str.GetValue<string>();
 		string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
 		if (!error.empty()) {
@@ -78915,7 +79133,7 @@ static unique_ptr<FunctionData> StrpTimeBindFunction(ClientContext &context, Sca
 	}
 	Value options_str = ExpressionExecutor::EvaluateScalar(*arguments[1]);
 	StrpTimeFormat format;
-	if (!options_str.is_null && options_str.type().id() == LogicalTypeId::VARCHAR) {
+	if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
 		string format_string = options_str.ToString();
 		format.format_specifier = format_string;
 		string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
@@ -79152,6 +79370,7 @@ void BuiltinFunctions::RegisterDateFunctions() {
 	Register<CurrentDateFun>();
 	Register<CurrentTimestampFun>();
 	Register<EpochFun>();
+	Register<MakeDateFun>();
 	Register<StrfTimeFun>();
 	Register<StrpTimeFun>();
 	Register<ToIntervalFun>();
@@ -79227,15 +79446,15 @@ static void EnumRangeBoundaryFunction(DataChunk &input, ExpressionState &state,
 	auto first_param = input.GetValue(0, 0);
 	auto second_param = input.GetValue(1, 0);
 
-	auto &enum_vector = first_param.is_null ? EnumType::GetValuesInsertOrder(input.GetTypes()[1])
-	                                        : EnumType::GetValuesInsertOrder(input.GetTypes()[0]);
+	auto &enum_vector = first_param.IsNull() ? EnumType::GetValuesInsertOrder(input.GetTypes()[1])
+	                                         : EnumType::GetValuesInsertOrder(input.GetTypes()[0]);
 
-	if (first_param.is_null) {
+	if (first_param.IsNull()) {
 		start = 0;
 	} else {
 		start = first_param.GetValue<uint32_t>();
 	}
-	if (second_param.is_null) {
+	if (second_param.IsNull()) {
 		end = EnumType::GetSize(input.GetTypes()[0]);
 	} else {
 		end = second_param.GetValue<uint32_t>() + 1;
@@ -79501,14 +79720,15 @@ unique_ptr<FunctionData> CurrentSettingBind(ClientContext &context, ScalarFuncti
 	}
 	Value key_val = ExpressionExecutor::EvaluateScalar(*key_child.get());
 	D_ASSERT(key_val.type().id() == LogicalTypeId::VARCHAR);
-	if (key_val.is_null || key_val.str_value.empty()) {
+	auto &key_str = StringValue::Get(key_val);
+	if (key_val.IsNull() || key_str.empty()) {
 		throw ParserException("Key name for current_setting needs to be neither NULL nor empty");
 	}
 
-	auto key = StringUtil::Lower(key_val.str_value);
+	auto key = StringUtil::Lower(key_str);
 	Value val;
 	if (!context.TryGetCurrentSetting(key, val)) {
-		throw InvalidInputException("unrecognized configuration parameter \"%s\"", key_val.str_value);
+		throw InvalidInputException("unrecognized configuration parameter \"%s\"", key_str);
 	}
 
 	bound_function.return_type = val.type();
@@ -80844,13 +81064,14 @@ void FillResult(Value &values, Vector &result, idx_t row) {
 	//! First Initialize List Vector
 	idx_t current_offset = ListVector::GetListSize(result);
 	//! Push Values to List Vector
-	for (idx_t i = 0; i < values.list_value.size(); i++) {
-		ListVector::PushBack(result, values.list_value[i]);
+	auto &list_values = ListValue::GetChildren(values);
+	for (idx_t i = 0; i < list_values.size(); i++) {
+		ListVector::PushBack(result, list_values[i]);
 	}
 
 	//! now set the pointer
 	auto &entry = ((list_entry_t *)result.GetData())[row];
-	entry.length = values.list_value.size();
+	entry.length = list_values.size();
 	entry.offset = current_offset;
 }
 
@@ -81569,7 +81790,7 @@ unique_ptr<FunctionData> BindDecimalRoundPrecision(ClientContext &context, Scala
 		throw NotImplementedException("ROUND(DECIMAL, INTEGER) with non-constant precision is not supported");
 	}
 	Value val = ExpressionExecutor::EvaluateScalar(*arguments[1]).CastAs(LogicalType::INTEGER);
-	if (val.is_null) {
+	if (val.IsNull()) {
 		throw NotImplementedException("ROUND(DECIMAL, INTEGER) with non-constant precision is not supported");
 	}
 	// our new precision becomes the round value
@@ -81577,7 +81798,7 @@ unique_ptr<FunctionData> BindDecimalRoundPrecision(ClientContext &context, Scala
 	// but ONLY if the round value is positive
 	// if it is negative the scale becomes zero
 	// i.e. ROUND(DECIMAL(18,3), -1) -> DECIMAL(18,0)
-	int32_t round_value = val.value_.integer;
+	int32_t round_value = IntegerValue::Get(val);
 	uint8_t target_scale;
 	auto width = DecimalType::GetWidth(decimal_type);
 	auto scale = DecimalType::GetScale(decimal_type);
@@ -82576,7 +82797,7 @@ static unique_ptr<BaseStatistics> PropagateNumericStats(ClientContext &context,
 	auto &rstats = (NumericStatistics &)*child_stats[1];
 	Value new_min, new_max;
 	bool potential_overflow = true;
-	if (!lstats.min.is_null && !lstats.max.is_null && !rstats.min.is_null && !rstats.max.is_null) {
+	if (!lstats.min.IsNull() && !lstats.max.IsNull() && !rstats.min.IsNull() && !rstats.max.IsNull()) {
 		switch (expr.return_type.InternalType()) {
 		case PhysicalType::INT8:
 			potential_overflow =
@@ -82791,11 +83012,16 @@ void AddFun::RegisterFunction(BuiltinFunctions &set) {
 // - [subtract]
 //===--------------------------------------------------------------------===//
 struct NegateOperator {
+	template <class T>
+	static bool CanNegate(T input) {
+		using Limits = std::numeric_limits<T>;
+		return !(Limits::is_integer && Limits::is_signed && Limits::lowest() == input);
+	}
+
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
-		using Limits = std::numeric_limits<TR>;
 		auto cast = (TR)input;
-		if (Limits::is_integer && Limits::is_signed && Limits::lowest() == cast) {
+		if (!CanNegate<TR>(cast)) {
 			throw OutOfRangeException("Overflow in negation of integer!");
 		}
 		return -cast;
@@ -82833,11 +83059,17 @@ unique_ptr<FunctionData> DecimalNegateBind(ClientContext &context, ScalarFunctio
 
 struct NegatePropagateStatistics {
 	template <class T>
-	static void Operation(LogicalType type, NumericStatistics &istats, Value &new_min, Value &new_max) {
+	static bool Operation(LogicalType type, NumericStatistics &istats, Value &new_min, Value &new_max) {
+		auto max_value = istats.max.GetValueUnsafe<T>();
+		auto min_value = istats.min.GetValueUnsafe<T>();
+		if (!NegateOperator::CanNegate<T>(min_value) || !NegateOperator::CanNegate<T>(max_value)) {
+			return true;
+		}
 		// new min is -max
-		new_min = Value::Numeric(type, NegateOperator::Operation<T, T>(istats.max.GetValueUnsafe<T>()));
+		new_min = Value::Numeric(type, NegateOperator::Operation<T, T>(max_value));
 		// new max is -min
-		new_max = Value::Numeric(type, NegateOperator::Operation<T, T>(istats.min.GetValueUnsafe<T>()));
+		new_max = Value::Numeric(type, NegateOperator::Operation<T, T>(min_value));
+		return false;
 	}
 };
 
@@ -82851,24 +83083,33 @@ static unique_ptr<BaseStatistics> NegateBindStatistics(ClientContext &context, B
 	}
 	auto &istats = (NumericStatistics &)*child_stats[0];
 	Value new_min, new_max;
-	if (!istats.min.is_null && !istats.max.is_null) {
+	bool potential_overflow = true;
+	if (!istats.min.IsNull() && !istats.max.IsNull()) {
 		switch (expr.return_type.InternalType()) {
 		case PhysicalType::INT8:
-			NegatePropagateStatistics::Operation<int8_t>(expr.return_type, istats, new_min, new_max);
+			potential_overflow =
+			    NegatePropagateStatistics::Operation<int8_t>(expr.return_type, istats, new_min, new_max);
 			break;
 		case PhysicalType::INT16:
-			NegatePropagateStatistics::Operation<int16_t>(expr.return_type, istats, new_min, new_max);
+			potential_overflow =
+			    NegatePropagateStatistics::Operation<int16_t>(expr.return_type, istats, new_min, new_max);
 			break;
 		case PhysicalType::INT32:
-			NegatePropagateStatistics::Operation<int32_t>(expr.return_type, istats, new_min, new_max);
+			potential_overflow =
+			    NegatePropagateStatistics::Operation<int32_t>(expr.return_type, istats, new_min, new_max);
 			break;
 		case PhysicalType::INT64:
-			NegatePropagateStatistics::Operation<int64_t>(expr.return_type, istats, new_min, new_max);
+			potential_overflow =
+			    NegatePropagateStatistics::Operation<int64_t>(expr.return_type, istats, new_min, new_max);
 			break;
 		default:
 			return nullptr;
 		}
 	}
+	if (potential_overflow) {
+		new_min = Value(expr.return_type);
+		new_max = Value(expr.return_type);
+	}
 	auto stats = make_unique<NumericStatistics>(expr.return_type, move(new_min), move(new_max));
 	if (istats.validity_stats) {
 		stats->validity_stats = istats.validity_stats->Copy();
@@ -84091,10 +84332,10 @@ static unique_ptr<FunctionData> NextValBind(ClientContext &context, ScalarFuncti
 	if (arguments[0]->IsFoldable()) {
 		// parameter to nextval function is a foldable constant
 		// evaluate the constant and perform the catalog lookup already
-		Value seqname = ExpressionExecutor::EvaluateScalar(*arguments[0]);
-		if (!seqname.is_null) {
+		auto seqname = ExpressionExecutor::EvaluateScalar(*arguments[0]);
+		if (!seqname.IsNull()) {
 			D_ASSERT(seqname.type().id() == LogicalTypeId::VARCHAR);
-			auto qname = QualifiedName::Parse(seqname.str_value);
+			auto qname = QualifiedName::Parse(StringValue::Get(seqname));
 			sequence = Catalog::GetCatalog(context).GetEntry<SequenceCatalogEntry>(context, qname.schema, qname.name);
 		}
 	}
@@ -87482,7 +87723,7 @@ static inline duckdb_re2::StringPiece CreateStringPiece(string_t &input) {
 	return duckdb_re2::StringPiece(input.GetDataUnsafe(), input.GetSize());
 }
 
-static void ParseRegexOptions(string &options, duckdb_re2::RE2::Options &result, bool *global_replace = nullptr) {
+static void ParseRegexOptions(const string &options, duckdb_re2::RE2::Options &result, bool *global_replace = nullptr) {
 	for (idx_t i = 0; i < options.size(); i++) {
 		switch (options[i]) {
 		case 'c':
@@ -87593,15 +87834,15 @@ static unique_ptr<FunctionData> RegexpMatchesBind(ClientContext &context, Scalar
 			throw InvalidInputException("Regex options field must be a constant");
 		}
 		Value options_str = ExpressionExecutor::EvaluateScalar(*arguments[2]);
-		if (!options_str.is_null && options_str.type().id() == LogicalTypeId::VARCHAR) {
-			ParseRegexOptions(options_str.str_value, options);
+		if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
+			ParseRegexOptions(StringValue::Get(options_str), options);
 		}
 	}
 
 	if (arguments[1]->IsFoldable()) {
 		Value pattern_str = ExpressionExecutor::EvaluateScalar(*arguments[1]);
-		if (!pattern_str.is_null && pattern_str.type().id() == LogicalTypeId::VARCHAR) {
-			return make_unique<RegexpMatchesBindData>(options, pattern_str.str_value);
+		if (!pattern_str.IsNull() && pattern_str.type().id() == LogicalTypeId::VARCHAR) {
+			return make_unique<RegexpMatchesBindData>(options, StringValue::Get(pattern_str));
 		}
 	}
 	return make_unique<RegexpMatchesBindData>(options, "");
@@ -87644,8 +87885,8 @@ static unique_ptr<FunctionData> RegexReplaceBind(ClientContext &context, ScalarF
 			throw InvalidInputException("Regex options field must be a constant");
 		}
 		Value options_str = ExpressionExecutor::EvaluateScalar(*arguments[3]);
-		if (!options_str.is_null && options_str.type().id() == LogicalTypeId::VARCHAR) {
-			ParseRegexOptions(options_str.str_value, data->options, &data->global_replace);
+		if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
+			ParseRegexOptions(StringValue::Get(options_str), data->options, &data->global_replace);
 		}
 	}
 
@@ -87706,8 +87947,8 @@ static unique_ptr<FunctionData> RegexExtractBind(ClientContext &context, ScalarF
 	string pattern = "";
 	if (constant_pattern) {
 		Value pattern_str = ExpressionExecutor::EvaluateScalar(*arguments[1]);
-		if (!pattern_str.is_null && pattern_str.type().id() == LogicalTypeId::VARCHAR) {
-			pattern = pattern_str.str_value;
+		if (!pattern_str.IsNull() && pattern_str.type().id() == LogicalTypeId::VARCHAR) {
+			pattern = StringValue::Get(pattern_str);
 		}
 	}
 
@@ -87717,7 +87958,7 @@ static unique_ptr<FunctionData> RegexExtractBind(ClientContext &context, ScalarF
 			throw InvalidInputException("Group index field field must be a constant!");
 		}
 		Value group = ExpressionExecutor::EvaluateScalar(*arguments[2]);
-		if (!group.is_null) {
+		if (!group.IsNull()) {
 			auto group_idx = group.GetValue<int32_t>();
 			if (group_idx < 0 || group_idx > 9) {
 				throw InvalidInputException("Group index must be between 0 and 9!");
@@ -88837,10 +89078,11 @@ static unique_ptr<FunctionData> StructExtractBind(ClientContext &context, Scalar
 	}
 	Value key_val = ExpressionExecutor::EvaluateScalar(*key_child.get());
 	D_ASSERT(key_val.type().id() == LogicalTypeId::VARCHAR);
-	if (key_val.is_null || key_val.str_value.length() < 1) {
+	auto &key_str = StringValue::Get(key_val);
+	if (key_val.IsNull() || key_str.empty()) {
 		throw BinderException("Key name for struct_extract needs to be neither NULL nor empty");
 	}
-	string key = StringUtil::Lower(key_val.str_value);
+	string key = StringUtil::Lower(key_str);
 
 	LogicalType return_type;
 	idx_t key_index = 0;
@@ -89576,16 +89818,12 @@ unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &contex
                                                            vector<LogicalType> &input_table_types,
                                                            vector<string> &input_table_names,
                                                            vector<LogicalType> &return_types, vector<string> &names) {
-	auto stream_factory_ptr = inputs[0].GetPointer();
-	unique_ptr<ArrowArrayStreamWrapper> (*stream_factory_produce)(
+	typedef unique_ptr<ArrowArrayStreamWrapper> (*stream_factory_produce_t)(
 	    uintptr_t stream_factory_ptr,
 	    std::pair<std::unordered_map<idx_t, string>, std::vector<string>> & project_columns,
-	    TableFilterCollection * filters) =
-	    (unique_ptr<ArrowArrayStreamWrapper>(*)(uintptr_t stream_factory_ptr,
-	                                            std::pair<std::unordered_map<idx_t, string>, std::vector<string>> &
-	                                                project_columns,
-	                                            TableFilterCollection * filters)) inputs[1]
-	        .GetPointer();
+	    TableFilterCollection * filters);
+	auto stream_factory_ptr = inputs[0].GetPointer();
+	auto stream_factory_produce = (stream_factory_produce_t)inputs[1].GetPointer();
 	auto rows_per_thread = inputs[2].GetValue<uint64_t>();
 	std::pair<std::unordered_map<idx_t, string>, std::vector<string>> project_columns;
 #ifndef DUCKDB_NO_THREADS
@@ -90709,7 +90947,7 @@ static bool ParseBoolean(vector<Value> &set) {
 	    set[0].type().id() == LogicalTypeId::DECIMAL) {
 		throw BinderException("Expected a boolean value (e.g. TRUE or 1)");
 	}
-	return set[0].CastAs(LogicalType::BOOLEAN).value_.boolean;
+	return BooleanValue::Get(set[0].CastAs(LogicalType::BOOLEAN));
 }
 
 static string ParseString(vector<Value> &set) {
@@ -91242,7 +91480,7 @@ static unique_ptr<FunctionData> GlobFunctionBind(ClientContext &context, vector<
 	}
 	auto result = make_unique<GlobFunctionBindData>();
 	auto &fs = FileSystem::GetFileSystem(context);
-	result->files = fs.Glob(inputs[0].str_value);
+	result->files = fs.Glob(StringValue::Get(inputs[0]));
 	return_types.emplace_back(LogicalType::VARCHAR);
 	names.emplace_back("file");
 	return move(result);
@@ -91960,7 +92198,7 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value
 	auto result = make_unique<ReadCSVData>();
 	auto &options = result->options;
 
-	string file_pattern = inputs[0].str_value;
+	auto &file_pattern = StringValue::Get(inputs[0]);
 
 	auto &fs = FileSystem::GetFileSystem(context);
 	result->files = fs.Glob(file_pattern);
@@ -91970,20 +92208,20 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value
 
 	for (auto &kv : named_parameters) {
 		if (kv.first == "auto_detect") {
-			options.auto_detect = kv.second.value_.boolean;
+			options.auto_detect = BooleanValue::Get(kv.second);
 		} else if (kv.first == "sep" || kv.first == "delim") {
-			options.SetDelimiter(kv.second.str_value);
+			options.SetDelimiter(StringValue::Get(kv.second));
 		} else if (kv.first == "header") {
-			options.header = kv.second.value_.boolean;
+			options.header = BooleanValue::Get(kv.second);
 			options.has_header = true;
 		} else if (kv.first == "quote") {
-			options.quote = kv.second.str_value;
+			options.quote = StringValue::Get(kv.second);
 			options.has_quote = true;
 		} else if (kv.first == "escape") {
-			options.escape = kv.second.str_value;
+			options.escape = StringValue::Get(kv.second);
 			options.has_escape = true;
 		} else if (kv.first == "nullstr") {
-			options.null_str = kv.second.str_value;
+			options.null_str = StringValue::Get(kv.second);
 		} else if (kv.first == "sample_size") {
 			int64_t sample_size = kv.second.GetValue<int64_t>();
 			if (sample_size < 1 && sample_size != -1) {
@@ -92014,11 +92252,11 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value
 				throw BinderException("Unsupported parameter for SAMPLE_CHUNKS: cannot be smaller than 1");
 			}
 		} else if (kv.first == "all_varchar") {
-			options.all_varchar = kv.second.value_.boolean;
+			options.all_varchar = BooleanValue::Get(kv.second);
 		} else if (kv.first == "dateformat") {
 			options.has_format[LogicalTypeId::DATE] = true;
 			auto &date_format = options.date_format[LogicalTypeId::DATE];
-			date_format.format_specifier = kv.second.str_value;
+			date_format.format_specifier = StringValue::Get(kv.second);
 			string error = StrTimeFormat::ParseFormatSpecifier(date_format.format_specifier, date_format);
 			if (!error.empty()) {
 				throw InvalidInputException("Could not parse DATEFORMAT: %s", error.c_str());
@@ -92026,35 +92264,36 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value
 		} else if (kv.first == "timestampformat") {
 			options.has_format[LogicalTypeId::TIMESTAMP] = true;
 			auto &timestamp_format = options.date_format[LogicalTypeId::TIMESTAMP];
-			timestamp_format.format_specifier = kv.second.str_value;
+			timestamp_format.format_specifier = StringValue::Get(kv.second);
 			string error = StrTimeFormat::ParseFormatSpecifier(timestamp_format.format_specifier, timestamp_format);
 			if (!error.empty()) {
 				throw InvalidInputException("Could not parse TIMESTAMPFORMAT: %s", error.c_str());
 			}
 		} else if (kv.first == "normalize_names") {
-			options.normalize_names = kv.second.value_.boolean;
+			options.normalize_names = BooleanValue::Get(kv.second);
 		} else if (kv.first == "columns") {
 			auto &child_type = kv.second.type();
 			if (child_type.id() != LogicalTypeId::STRUCT) {
 				throw BinderException("read_csv columns requires a a struct as input");
 			}
-			D_ASSERT(StructType::GetChildCount(child_type) == kv.second.struct_value.size());
-			for (idx_t i = 0; i < kv.second.struct_value.size(); i++) {
+			auto &struct_children = StructValue::GetChildren(kv.second);
+			D_ASSERT(StructType::GetChildCount(child_type) == struct_children.size());
+			for (idx_t i = 0; i < struct_children.size(); i++) {
 				auto &name = StructType::GetChildName(child_type, i);
-				auto &val = kv.second.struct_value[i];
+				auto &val = struct_children[i];
 				names.push_back(name);
 				if (val.type().id() != LogicalTypeId::VARCHAR) {
 					throw BinderException("read_csv requires a type specification as string");
 				}
-				return_types.emplace_back(TransformStringToLogicalType(val.str_value.c_str()));
+				return_types.emplace_back(TransformStringToLogicalType(StringValue::Get(val)));
 			}
 			if (names.empty()) {
 				throw BinderException("read_csv requires at least a single column as input!");
 			}
 		} else if (kv.first == "compression") {
-			options.compression = FileCompressionTypeFromString(kv.second.str_value);
+			options.compression = FileCompressionTypeFromString(StringValue::Get(kv.second));
 		} else if (kv.first == "filename") {
-			result->include_file_name = kv.second.value_.boolean;
+			result->include_file_name = BooleanValue::Get(kv.second);
 		} else if (kv.first == "skip") {
 			options.skip_rows = kv.second.GetValue<int64_t>();
 		}
@@ -94969,7 +95208,7 @@ static vector<TestType> GetTestTypes() {
 	result.emplace_back(LogicalType::DOUBLE, "double");
 	result.emplace_back(LogicalType::DECIMAL(4, 1), "dec_4_1");
 	result.emplace_back(LogicalType::DECIMAL(9, 4), "dec_9_4");
-	result.emplace_back(LogicalType::DECIMAL(18, 6), "dec_18_3");
+	result.emplace_back(LogicalType::DECIMAL(18, 6), "dec_18_6");
 	result.emplace_back(LogicalType::DECIMAL(38, 10), "dec38_10");
 	result.emplace_back(LogicalType::UUID, "uuid");
 	// interval
@@ -95536,23 +95775,23 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 				break;
 			}
 		}
-		if (!equal_value.is_null || !low_value.is_null || !high_value.is_null) {
+		if (!equal_value.IsNull() || !low_value.IsNull() || !high_value.IsNull()) {
 			// we can scan this index using this predicate: try a scan
 			auto &transaction = Transaction::GetTransaction(context);
 			unique_ptr<IndexScanState> index_state;
-			if (!equal_value.is_null) {
+			if (!equal_value.IsNull()) {
 				// equality predicate
 				index_state =
 				    index.InitializeScanSinglePredicate(transaction, equal_value, ExpressionType::COMPARE_EQUAL);
-			} else if (!low_value.is_null && !high_value.is_null) {
+			} else if (!low_value.IsNull() && !high_value.IsNull()) {
 				// two-sided predicate
 				index_state = index.InitializeScanTwoPredicates(transaction, low_value, low_comparison_type, high_value,
 				                                                high_comparison_type);
-			} else if (!low_value.is_null) {
+			} else if (!low_value.IsNull()) {
 				// less than predicate
 				index_state = index.InitializeScanSinglePredicate(transaction, low_value, low_comparison_type);
 			} else {
-				D_ASSERT(!high_value.is_null);
+				D_ASSERT(!high_value.IsNull());
 				index_state = index.InitializeScanSinglePredicate(transaction, high_value, high_comparison_type);
 			}
 			if (index.Scan(transaction, storage, *index_state, STANDARD_VECTOR_SIZE, bind_data.result_ids)) {
@@ -95645,7 +95884,7 @@ static void UnnestFunction(ClientContext &context, const FunctionData *bind_data
 	auto &bind_data = (UnnestFunctionData &)*bind_data_p;
 	auto &state = (UnnestOperatorData &)*operator_state;
 
-	auto &list_value = bind_data.value.list_value;
+	auto &list_value = ListValue::GetChildren(bind_data.value);
 	idx_t count = 0;
 	for (; state.current_count < list_value.size() && count < STANDARD_VECTOR_SIZE; state.current_count++) {
 		output.data[0].SetValue(count, list_value[state.current_count]);
@@ -96416,7 +96655,7 @@ idx_t duckdb_arrow_rows_changed(duckdb_arrow result) {
 	idx_t row_count = wrapper->result->collection.Count();
 	if (row_count > 0 && StatementTypeReturnChanges(wrapper->result->statement_type)) {
 		auto row_changes = wrapper->result->GetValue(0, 0);
-		if (!row_changes.is_null && row_changes.TryCastAs(LogicalType::BIGINT)) {
+		if (!row_changes.IsNull() && row_changes.TryCastAs(LogicalType::BIGINT)) {
 			rows_changed = row_changes.GetValue<int64_t>();
 		}
 	}
@@ -96980,7 +97219,7 @@ namespace duckdb {
 template <class T>
 void WriteData(duckdb_result *out, ChunkCollection &source, idx_t col) {
 	idx_t row = 0;
-	auto target = (T *)out->columns[col].data;
+	auto target = (T *)out->__deprecated_columns[col].__deprecated_data;
 	for (auto &chunk : source.Chunks()) {
 		auto source = FlatVector::GetData<T>(chunk->data[col]);
 		auto &mask = FlatVector::Validity(chunk->data[col]);
@@ -97003,46 +97242,49 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 	memset(out, 0, sizeof(duckdb_result));
 	if (!result->success) {
 		// write the error message
-		out->error_message = strdup(result->error.c_str());
+		out->__deprecated_error_message = strdup(result->error.c_str());
 		return DuckDBError;
 	}
 	// copy the data
 	// first write the meta data
-	out->column_count = result->types.size();
-	out->row_count = result->collection.Count();
-	out->rows_changed = 0;
-	if (out->row_count > 0 && StatementTypeReturnChanges(result->statement_type)) {
+	out->__deprecated_column_count = result->types.size();
+	out->__deprecated_row_count = result->collection.Count();
+	out->__deprecated_rows_changed = 0;
+	if (out->__deprecated_row_count > 0 && StatementTypeReturnChanges(result->statement_type)) {
 		// update total changes
 		auto row_changes = result->GetValue(0, 0);
-		if (!row_changes.is_null && row_changes.TryCastAs(LogicalType::BIGINT)) {
-			out->rows_changed = row_changes.GetValue<int64_t>();
+		if (!row_changes.IsNull() && row_changes.TryCastAs(LogicalType::BIGINT)) {
+			out->__deprecated_rows_changed = row_changes.GetValue<int64_t>();
 		}
 	}
-	out->columns = (duckdb_column *)duckdb_malloc(sizeof(duckdb_column) * out->column_count);
-	if (!out->columns) { // LCOV_EXCL_START
+	out->__deprecated_columns = (duckdb_column *)duckdb_malloc(sizeof(duckdb_column) * out->__deprecated_column_count);
+	if (!out->__deprecated_columns) { // LCOV_EXCL_START
 		// malloc failure
 		return DuckDBError;
 	} // LCOV_EXCL_STOP
 
 	// zero initialize the columns (so we can cleanly delete it in case a malloc fails)
-	memset(out->columns, 0, sizeof(duckdb_column) * out->column_count);
-	for (idx_t i = 0; i < out->column_count; i++) {
-		out->columns[i].type = ConvertCPPTypeToC(result->types[i]);
-		out->columns[i].name = strdup(result->names[i].c_str());
-		out->columns[i].nullmask = (bool *)duckdb_malloc(sizeof(bool) * out->row_count);
-		out->columns[i].data = duckdb_malloc(GetCTypeSize(out->columns[i].type) * out->row_count);
-		if (!out->columns[i].nullmask || !out->columns[i].name || !out->columns[i].data) { // LCOV_EXCL_START
+	memset(out->__deprecated_columns, 0, sizeof(duckdb_column) * out->__deprecated_column_count);
+	for (idx_t i = 0; i < out->__deprecated_column_count; i++) {
+		out->__deprecated_columns[i].__deprecated_type = ConvertCPPTypeToC(result->types[i]);
+		out->__deprecated_columns[i].__deprecated_name = strdup(result->names[i].c_str());
+		out->__deprecated_columns[i].__deprecated_nullmask =
+		    (bool *)duckdb_malloc(sizeof(bool) * out->__deprecated_row_count);
+		out->__deprecated_columns[i].__deprecated_data =
+		    duckdb_malloc(GetCTypeSize(out->__deprecated_columns[i].__deprecated_type) * out->__deprecated_row_count);
+		if (!out->__deprecated_columns[i].__deprecated_nullmask || !out->__deprecated_columns[i].__deprecated_name ||
+		    !out->__deprecated_columns[i].__deprecated_data) { // LCOV_EXCL_START
 			// malloc failure
 			return DuckDBError;
 		} // LCOV_EXCL_STOP
 	}
 	// now write the data
-	for (idx_t col = 0; col < out->column_count; col++) {
+	for (idx_t col = 0; col < out->__deprecated_column_count; col++) {
 		// first set the nullmask
 		idx_t row = 0;
 		for (auto &chunk : result->collection.Chunks()) {
 			for (idx_t k = 0; k < chunk->size(); k++) {
-				out->columns[col].nullmask[row++] = FlatVector::IsNull(chunk->data[col], k);
+				out->__deprecated_columns[col].__deprecated_nullmask[row++] = FlatVector::IsNull(chunk->data[col], k);
 			}
 		}
 		// then write the data
@@ -97093,7 +97335,7 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 			break;
 		case LogicalTypeId::VARCHAR: {
 			idx_t row = 0;
-			auto target = (const char **)out->columns[col].data;
+			auto target = (const char **)out->__deprecated_columns[col].__deprecated_data;
 			for (auto &chunk : result->collection.Chunks()) {
 				auto source = FlatVector::GetData<string_t>(chunk->data[col]);
 				for (idx_t k = 0; k < chunk->size(); k++) {
@@ -97113,7 +97355,7 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 		}
 		case LogicalTypeId::BLOB: {
 			idx_t row = 0;
-			auto target = (duckdb_blob *)out->columns[col].data;
+			auto target = (duckdb_blob *)out->__deprecated_columns[col].__deprecated_data;
 			for (auto &chunk : result->collection.Chunks()) {
 				auto source = FlatVector::GetData<string_t>(chunk->data[col]);
 				for (idx_t k = 0; k < chunk->size(); k++) {
@@ -97135,7 +97377,7 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 		case LogicalTypeId::TIMESTAMP_MS:
 		case LogicalTypeId::TIMESTAMP_SEC: {
 			idx_t row = 0;
-			auto target = (timestamp_t *)out->columns[col].data;
+			auto target = (timestamp_t *)out->__deprecated_columns[col].__deprecated_data;
 			for (auto &chunk : result->collection.Chunks()) {
 				auto source = FlatVector::GetData<timestamp_t>(chunk->data[col]);
 
@@ -97157,7 +97399,7 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 		}
 		case LogicalTypeId::HUGEINT: {
 			idx_t row = 0;
-			auto target = (duckdb_hugeint *)out->columns[col].data;
+			auto target = (duckdb_hugeint *)out->__deprecated_columns[col].__deprecated_data;
 			for (auto &chunk : result->collection.Chunks()) {
 				auto source = FlatVector::GetData<hugeint_t>(chunk->data[col]);
 				for (idx_t k = 0; k < chunk->size(); k++) {
@@ -97172,7 +97414,7 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 		}
 		case LogicalTypeId::INTERVAL: {
 			idx_t row = 0;
-			auto target = (duckdb_interval *)out->columns[col].data;
+			auto target = (duckdb_interval *)out->__deprecated_columns[col].__deprecated_data;
 			for (auto &chunk : result->collection.Chunks()) {
 				auto source = FlatVector::GetData<interval_t>(chunk->data[col]);
 				for (idx_t k = 0; k < chunk->size(); k++) {
@@ -97198,101 +97440,101 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 } // namespace duckdb
 
 static void DuckdbDestroyColumn(duckdb_column column, idx_t count) {
-	if (column.data) {
-		if (column.type == DUCKDB_TYPE_VARCHAR) {
+	if (column.__deprecated_data) {
+		if (column.__deprecated_type == DUCKDB_TYPE_VARCHAR) {
 			// varchar, delete individual strings
-			auto data = (char **)column.data;
+			auto data = (char **)column.__deprecated_data;
 			for (idx_t i = 0; i < count; i++) {
 				if (data[i]) {
 					duckdb_free(data[i]);
 				}
 			}
-		} else if (column.type == DUCKDB_TYPE_BLOB) {
+		} else if (column.__deprecated_type == DUCKDB_TYPE_BLOB) {
 			// blob, delete individual blobs
-			auto data = (duckdb_blob *)column.data;
+			auto data = (duckdb_blob *)column.__deprecated_data;
 			for (idx_t i = 0; i < count; i++) {
 				if (data[i].data) {
 					duckdb_free((void *)data[i].data);
 				}
 			}
 		}
-		duckdb_free(column.data);
+		duckdb_free(column.__deprecated_data);
 	}
-	if (column.nullmask) {
-		duckdb_free(column.nullmask);
+	if (column.__deprecated_nullmask) {
+		duckdb_free(column.__deprecated_nullmask);
 	}
-	if (column.name) {
-		duckdb_free(column.name);
+	if (column.__deprecated_name) {
+		duckdb_free(column.__deprecated_name);
 	}
 }
 
 void duckdb_destroy_result(duckdb_result *result) {
-	if (result->error_message) {
-		duckdb_free(result->error_message);
+	if (result->__deprecated_error_message) {
+		duckdb_free(result->__deprecated_error_message);
 	}
-	if (result->columns) {
-		for (idx_t i = 0; i < result->column_count; i++) {
-			DuckdbDestroyColumn(result->columns[i], result->row_count);
+	if (result->__deprecated_columns) {
+		for (idx_t i = 0; i < result->__deprecated_column_count; i++) {
+			DuckdbDestroyColumn(result->__deprecated_columns[i], result->__deprecated_row_count);
 		}
-		duckdb_free(result->columns);
+		duckdb_free(result->__deprecated_columns);
 	}
 	memset(result, 0, sizeof(duckdb_result));
 }
 
 const char *duckdb_column_name(duckdb_result *result, idx_t col) {
-	if (!result || col >= result->column_count) {
+	if (!result || col >= result->__deprecated_column_count) {
 		return nullptr;
 	}
-	return result->columns[col].name;
+	return result->__deprecated_columns[col].__deprecated_name;
 }
 
 duckdb_type duckdb_column_type(duckdb_result *result, idx_t col) {
-	if (!result || col >= result->column_count) {
+	if (!result || col >= result->__deprecated_column_count) {
 		return DUCKDB_TYPE_INVALID;
 	}
-	return result->columns[col].type;
+	return result->__deprecated_columns[col].__deprecated_type;
 }
 
 idx_t duckdb_column_count(duckdb_result *result) {
 	if (!result) {
 		return 0;
 	}
-	return result->column_count;
+	return result->__deprecated_column_count;
 }
 
 idx_t duckdb_row_count(duckdb_result *result) {
 	if (!result) {
 		return 0;
 	}
-	return result->row_count;
+	return result->__deprecated_row_count;
 }
 
 idx_t duckdb_rows_changed(duckdb_result *result) {
 	if (!result) {
 		return 0;
 	}
-	return result->rows_changed;
+	return result->__deprecated_rows_changed;
 }
 
 void *duckdb_column_data(duckdb_result *result, idx_t col) {
-	if (!result || col >= result->column_count) {
+	if (!result || col >= result->__deprecated_column_count) {
 		return nullptr;
 	}
-	return result->columns[col].data;
+	return result->__deprecated_columns[col].__deprecated_data;
 }
 
 bool *duckdb_nullmask_data(duckdb_result *result, idx_t col) {
-	if (!result || col >= result->column_count) {
+	if (!result || col >= result->__deprecated_column_count) {
 		return nullptr;
 	}
-	return result->columns[col].nullmask;
+	return result->__deprecated_columns[col].__deprecated_nullmask;
 }
 
 char *duckdb_result_error(duckdb_result *result) {
 	if (!result) {
 		return nullptr;
 	}
-	return result->error_message;
+	return result->__deprecated_error_message;
 }
 
 
@@ -97323,8 +97565,8 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 template <class T>
 T UnsafeFetch(duckdb_result *result, idx_t col, idx_t row) {
-	D_ASSERT(row < result->row_count);
-	return ((T *)result->columns[col].data)[row];
+	D_ASSERT(row < result->__deprecated_row_count);
+	return ((T *)result->__deprecated_columns[col].__deprecated_data)[row];
 }
 
 //===--------------------------------------------------------------------===//
@@ -97445,10 +97687,10 @@ RESULT_TYPE TryCastCInternal(duckdb_result *result, idx_t col, idx_t row) {
 }
 
 static bool CanFetchValue(duckdb_result *result, idx_t col, idx_t row) {
-	if (!result || col >= result->column_count || row >= result->row_count) {
+	if (!result || col >= result->__deprecated_column_count || row >= result->__deprecated_row_count) {
 		return false;
 	}
-	if (result->columns[col].nullmask[row]) {
+	if (result->__deprecated_columns[col].__deprecated_nullmask[row]) {
 		return false;
 	}
 	return true;
@@ -97459,7 +97701,7 @@ static RESULT_TYPE GetInternalCValue(duckdb_result *result, idx_t col, idx_t row
 	if (!CanFetchValue(result, col, row)) {
 		return FetchDefaultValue::Operation<RESULT_TYPE>();
 	}
-	switch (result->columns[col].type) {
+	switch (result->__deprecated_columns[col].__deprecated_type) {
 	case DUCKDB_TYPE_BOOLEAN:
 		return TryCastCInternal<bool, RESULT_TYPE, OP>(result, col, row);
 	case DUCKDB_TYPE_TINYINT:
@@ -97600,7 +97842,7 @@ char *duckdb_value_varchar_internal(duckdb_result *result, idx_t col, idx_t row)
 }
 
 duckdb_blob duckdb_value_blob(duckdb_result *result, idx_t col, idx_t row) {
-	if (CanFetchValue(result, col, row) && result->columns[col].type == DUCKDB_TYPE_BLOB) {
+	if (CanFetchValue(result, col, row) && result->__deprecated_columns[col].__deprecated_type == DUCKDB_TYPE_BLOB) {
 		auto internal_result = UnsafeFetch<duckdb_blob>(result, col, row);
 
 		duckdb_blob result_blob;
@@ -97613,10 +97855,10 @@ duckdb_blob duckdb_value_blob(duckdb_result *result, idx_t col, idx_t row) {
 }
 
 bool duckdb_value_is_null(duckdb_result *result, idx_t col, idx_t row) {
-	if (!result || col >= result->column_count || row >= result->row_count) {
+	if (!result || col >= result->__deprecated_column_count || row >= result->__deprecated_row_count) {
 		return false;
 	}
-	return result->columns[col].nullmask[row];
+	return result->__deprecated_columns[col].__deprecated_nullmask[row];
 }
 
 //===----------------------------------------------------------------------===//
@@ -108149,7 +108391,7 @@ string MaterializedQueryResult::ToString() {
 		for (idx_t j = 0; j < collection.Count(); j++) {
 			for (idx_t i = 0; i < collection.ColumnCount(); i++) {
 				auto val = collection.GetValue(i, j);
-				result += val.is_null ? "NULL" : val.ToString();
+				result += val.IsNull() ? "NULL" : val.ToString();
 				result += "\t";
 			}
 			result += "\n";
@@ -113781,7 +114023,7 @@ bool FilterCombiner::HasFilters() {
 // 					break;
 // 				} else {
 // 					auto &const_value_expr = (BoundConstantExpression &)*comp_in_exp.children[i].get();
-// 					if (const_value_expr.value.is_null) {
+// 					if (const_value_expr.value.IsNull()) {
 // 						return checks;
 // 					}
 // 					if (!min && !max) {
@@ -113943,18 +114185,16 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 				//! This is a like function.
 				auto &column_ref = (BoundColumnRefExpression &)*func.children[0].get();
 				auto &constant_value_expr = (BoundConstantExpression &)*func.children[1].get();
-				string like_string = constant_value_expr.value.str_value;
+				auto like_string = StringValue::Get(constant_value_expr.value);
 				if (like_string.empty()) {
 					continue;
 				}
 				auto column_index = column_ids[column_ref.binding.column_index];
-				auto const_value = constant_value_expr.value.Copy();
-				const_value.str_value = like_string;
 				//! Here the like must be transformed to a BOUND COMPARISON geq le
 				auto lower_bound =
-				    make_unique<ConstantFilter>(ExpressionType::COMPARE_GREATERTHANOREQUALTO, const_value);
-				const_value.str_value[const_value.str_value.size() - 1]++;
-				auto upper_bound = make_unique<ConstantFilter>(ExpressionType::COMPARE_LESSTHAN, const_value);
+				    make_unique<ConstantFilter>(ExpressionType::COMPARE_GREATERTHANOREQUALTO, Value(like_string));
+				like_string[like_string.size() - 1]++;
+				auto upper_bound = make_unique<ConstantFilter>(ExpressionType::COMPARE_LESSTHAN, Value(like_string));
 				table_filters.PushFilter(column_index, move(lower_bound));
 				table_filters.PushFilter(column_index, move(upper_bound));
 				table_filters.PushFilter(column_index, make_unique<IsNotNullFilter>());
@@ -113964,8 +114204,7 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 				//! This is a like function.
 				auto &column_ref = (BoundColumnRefExpression &)*func.children[0].get();
 				auto &constant_value_expr = (BoundConstantExpression &)*func.children[1].get();
-				string like_string = constant_value_expr.value.str_value;
-				auto const_value = constant_value_expr.value.Copy();
+				auto &like_string = StringValue::Get(constant_value_expr.value);
 				if (like_string[0] == '%' || like_string[0] == '_') {
 					//! We have no prefix so nothing to pushdown
 					break;
@@ -113979,19 +114218,18 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 					}
 					prefix += c;
 				}
-				const_value.str_value = prefix;
 				auto column_index = column_ids[column_ref.binding.column_index];
 				if (equality) {
 					//! Here the like can be transformed to an equality query
-					auto equal_filter = make_unique<ConstantFilter>(ExpressionType::COMPARE_EQUAL, const_value);
+					auto equal_filter = make_unique<ConstantFilter>(ExpressionType::COMPARE_EQUAL, Value(prefix));
 					table_filters.PushFilter(column_index, move(equal_filter));
 					table_filters.PushFilter(column_index, make_unique<IsNotNullFilter>());
 				} else {
 					//! Here the like must be transformed to a BOUND COMPARISON geq le
 					auto lower_bound =
-					    make_unique<ConstantFilter>(ExpressionType::COMPARE_GREATERTHANOREQUALTO, const_value);
-					const_value.str_value[const_value.str_value.size() - 1]++;
-					auto upper_bound = make_unique<ConstantFilter>(ExpressionType::COMPARE_LESSTHAN, const_value);
+					    make_unique<ConstantFilter>(ExpressionType::COMPARE_GREATERTHANOREQUALTO, Value(prefix));
+					prefix[prefix.size() - 1]++;
+					auto upper_bound = make_unique<ConstantFilter>(ExpressionType::COMPARE_LESSTHAN, Value(prefix));
 					table_filters.PushFilter(column_index, move(lower_bound));
 					table_filters.PushFilter(column_index, move(upper_bound));
 					table_filters.PushFilter(column_index, make_unique<IsNotNullFilter>());
@@ -113999,7 +114237,7 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 			}
 		} else if (remaining_filter->type == ExpressionType::COMPARE_IN) {
 			auto &func = (BoundOperatorExpression &)*remaining_filter;
-			vector<Value> in_values;
+			vector<hugeint_t> in_values;
 			D_ASSERT(func.children.size() > 1);
 			if (func.children[0]->expression_class != ExpressionClass::BOUND_COLUMN_REF) {
 				continue;
@@ -114020,31 +114258,31 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 				continue;
 			}
 			auto &fst_const_value_expr = (BoundConstantExpression &)*func.children[1].get();
+			auto &type = fst_const_value_expr.value.type();
 
 			//! Check if values are consecutive, if yes transform them to >= <= (only for integers)
 			// e.g. if we have x IN (1, 2, 3, 4, 5) we transform this into x >= 1 AND x <= 5
-			if (!fst_const_value_expr.value.type().IsIntegral()) {
+			if (!type.IsIntegral()) {
 				continue;
 			}
 
 			bool can_simplify_in_clause = true;
 			for (idx_t i = 1; i < func.children.size(); i++) {
 				auto &const_value_expr = (BoundConstantExpression &)*func.children[i].get();
-				if (const_value_expr.value.is_null) {
+				if (const_value_expr.value.IsNull()) {
 					can_simplify_in_clause = false;
 					break;
 				}
-				in_values.push_back(const_value_expr.value);
+				in_values.push_back(const_value_expr.value.GetValue<hugeint_t>());
 			}
 			if (!can_simplify_in_clause || in_values.empty()) {
 				continue;
 			}
-			Value one(1);
 
 			sort(in_values.begin(), in_values.end());
 
 			for (idx_t in_val_idx = 1; in_val_idx < in_values.size(); in_val_idx++) {
-				if (in_values[in_val_idx] - in_values[in_val_idx - 1] > one || in_values[in_val_idx - 1].is_null) {
+				if (in_values[in_val_idx] - in_values[in_val_idx - 1] > 1) {
 					can_simplify_in_clause = false;
 					break;
 				}
@@ -114052,9 +114290,10 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 			if (!can_simplify_in_clause) {
 				continue;
 			}
-			auto lower_bound =
-			    make_unique<ConstantFilter>(ExpressionType::COMPARE_GREATERTHANOREQUALTO, in_values.front());
-			auto upper_bound = make_unique<ConstantFilter>(ExpressionType::COMPARE_LESSTHANOREQUALTO, in_values.back());
+			auto lower_bound = make_unique<ConstantFilter>(ExpressionType::COMPARE_GREATERTHANOREQUALTO,
+			                                               Value::Numeric(type, in_values.front()));
+			auto upper_bound = make_unique<ConstantFilter>(ExpressionType::COMPARE_LESSTHANOREQUALTO,
+			                                               Value::Numeric(type, in_values.back()));
 			table_filters.PushFilter(column_index, move(lower_bound));
 			table_filters.PushFilter(column_index, move(upper_bound));
 			table_filters.PushFilter(column_index, make_unique<IsNotNullFilter>());
@@ -114095,7 +114334,7 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
 		idx_t equivalence_set = GetEquivalenceSet(node);
 		auto scalar = left_is_scalar ? comparison.left.get() : comparison.right.get();
 		auto constant_value = ExpressionExecutor::EvaluateScalar(*scalar);
-		if (constant_value.is_null) {
+		if (constant_value.IsNull()) {
 			// comparisons with null are always null (i.e. will never result in rows)
 			return FilterResult::UNSATISFIABLE;
 		}
@@ -114177,7 +114416,7 @@ FilterResult FilterCombiner::AddFilter(Expression *expr) {
 		// scalar condition, evaluate it
 		auto result = ExpressionExecutor::EvaluateScalar(*expr).CastAs(LogicalType::BOOLEAN);
 		// check if the filter passes
-		if (result.is_null || !result.value_.boolean) {
+		if (result.IsNull() || !BooleanValue::Get(result)) {
 			// the filter does not pass the scalar test, create an empty result
 			return FilterResult::UNSATISFIABLE;
 		} else {
@@ -117804,7 +118043,7 @@ static bool FilterRemovesNull(ExpressionRewriter &rewriter, Expression *expr, un
 		// if the result of the expression with all expressions replaced with NULL is "NULL" or "false"
 		// then any extra entries generated by the LEFT OUTER JOIN will be filtered out!
 		// hence the LEFT OUTER JOIN is equivalent to an inner join
-		if (val.is_null || !val.value_.boolean) {
+		if (val.IsNull() || !BooleanValue::Get(val)) {
 			return true;
 		}
 	}
@@ -118492,7 +118731,7 @@ unique_ptr<Expression> ArithmeticSimplificationRule::Apply(LogicalOperator &op,
 	D_ASSERT(root->children.size() == 2);
 	(void)root;
 	// any arithmetic operator involving NULL is always NULL
-	if (constant->value.is_null) {
+	if (constant->value.IsNull()) {
 		return make_unique<BoundConstantExpression>(Value(root->return_type));
 	}
 	auto &func_name = root->function.name;
@@ -118557,7 +118796,7 @@ unique_ptr<Expression> CaseSimplificationRule::Apply(LogicalOperator &op, vector
 
 			// fold based on the constant condition
 			auto condition = constant_value.CastAs(LogicalType::BOOLEAN);
-			if (condition.is_null || !condition.value_.boolean) {
+			if (condition.IsNull() || !BooleanValue::Get(condition)) {
 				// the condition is always false: remove this case check
 				root->case_checks.erase(root->case_checks.begin() + i);
 				i--;
@@ -118609,8 +118848,8 @@ unique_ptr<Expression> ComparisonSimplificationRule::Apply(LogicalOperator &op,
 	if (!ExpressionExecutor::TryEvaluateScalar(*constant_expr, constant_value)) {
 		return nullptr;
 	}
-	if (constant_value.is_null && !(expr->type == ExpressionType::COMPARE_NOT_DISTINCT_FROM ||
-	                                expr->type == ExpressionType::COMPARE_DISTINCT_FROM)) {
+	if (constant_value.IsNull() && !(expr->type == ExpressionType::COMPARE_NOT_DISTINCT_FROM ||
+	                                 expr->type == ExpressionType::COMPARE_DISTINCT_FROM)) {
 		// comparison with constant NULL, return NULL
 		return make_unique<BoundConstantExpression>(Value(LogicalType::BOOLEAN));
 	}
@@ -118683,12 +118922,12 @@ unique_ptr<Expression> ConjunctionSimplificationRule::Apply(LogicalOperator &op,
 		return nullptr;
 	}
 	constant_value = constant_value.CastAs(LogicalType::BOOLEAN);
-	if (constant_value.is_null) {
+	if (constant_value.IsNull()) {
 		// we can't simplify conjunctions with a constant NULL
 		return nullptr;
 	}
 	if (conjunction->type == ExpressionType::CONJUNCTION_AND) {
-		if (!constant_value.value_.boolean) {
+		if (!BooleanValue::Get(constant_value)) {
 			// FALSE in AND, result of expression is false
 			return make_unique<BoundConstantExpression>(Value::BOOLEAN(false));
 		} else {
@@ -118697,7 +118936,7 @@ unique_ptr<Expression> ConjunctionSimplificationRule::Apply(LogicalOperator &op,
 		}
 	} else {
 		D_ASSERT(conjunction->type == ExpressionType::CONJUNCTION_OR);
-		if (!constant_value.value_.boolean) {
+		if (!BooleanValue::Get(constant_value)) {
 			// FALSE in OR, remove the expression from the set
 			return RemoveExpression(*conjunction, constant_expr);
 		} else {
@@ -118741,7 +118980,6 @@ unique_ptr<Expression> ConstantFoldingRule::Apply(LogicalOperator &op, vector<Ex
 	D_ASSERT(root->IsFoldable() && root->type != ExpressionType::VALUE_CONSTANT);
 
 	// use an ExpressionExecutor to execute the expression
-
 	Value result_value;
 	if (!ExpressionExecutor::TryEvaluateScalar(*root, result_value)) {
 		return nullptr;
@@ -118779,12 +119017,12 @@ unique_ptr<Expression> DatePartSimplificationRule::Apply(LogicalOperator &op, ve
 	auto &constant_expr = (BoundConstantExpression &)*bindings[1];
 	auto &constant = constant_expr.value;
 
-	if (constant.is_null) {
+	if (constant.IsNull()) {
 		// NULL specifier: return constant NULL
 		return make_unique<BoundConstantExpression>(Value(date_part.return_type));
 	}
 	// otherwise check the specifier
-	auto specifier = GetDatePartSpecifier(constant.str_value);
+	auto specifier = GetDatePartSpecifier(StringValue::Get(constant));
 	string new_function_name;
 	switch (specifier) {
 	case DatePartSpecifier::YEAR:
@@ -119031,12 +119269,12 @@ unique_ptr<Expression> EmptyNeedleRemovalRule::Apply(LogicalOperator &op, vector
 
 	auto prefix_value = ExpressionExecutor::EvaluateScalar(*prefix_expr);
 
-	if (prefix_value.is_null) {
+	if (prefix_value.IsNull()) {
 		return make_unique<BoundConstantExpression>(Value(LogicalType::BOOLEAN));
 	}
 
 	D_ASSERT(prefix_value.type() == prefix_expr->return_type);
-	auto needle_string = prefix_value.str_value;
+	auto &needle_string = StringValue::Get(prefix_value);
 
 	// PREFIX('xyz', '') is TRUE
 	// PREFIX(NULL, '') is NULL
@@ -119313,7 +119551,7 @@ unique_ptr<Expression> LikeOptimizationRule::Apply(LogicalOperator &op, vector<E
 	auto constant_expr = (BoundConstantExpression *)bindings[2];
 	D_ASSERT(root->children.size() == 2);
 
-	if (constant_expr->value.is_null) {
+	if (constant_expr->value.IsNull()) {
 		return make_unique<BoundConstantExpression>(Value(root->return_type));
 	}
 
@@ -119324,7 +119562,7 @@ unique_ptr<Expression> LikeOptimizationRule::Apply(LogicalOperator &op, vector<E
 
 	auto constant_value = ExpressionExecutor::EvaluateScalar(*constant_expr);
 	D_ASSERT(constant_value.type() == constant_expr->return_type);
-	auto patt_str = constant_value.str_value;
+	auto &patt_str = StringValue::Get(constant_value);
 
 	bool is_not_like = root->function.name == "!~~";
 	if (PatternIsConstant(patt_str)) {
@@ -119376,6 +119614,7 @@ unique_ptr<Expression> LikeOptimizationRule::ApplyRule(BoundFunctionExpression *
 
 
 
+
 namespace duckdb {
 
 MoveConstantsRule::MoveConstantsRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
@@ -119403,31 +119642,63 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<Expr
 	auto outer_constant = (BoundConstantExpression *)bindings[1];
 	auto arithmetic = (BoundFunctionExpression *)bindings[2];
 	auto inner_constant = (BoundConstantExpression *)bindings[3];
-	if (!arithmetic->return_type.IsNumeric()) {
+	if (!TypeIsIntegral(arithmetic->return_type.InternalType())) {
 		return nullptr;
 	}
-	if (inner_constant->value.is_null || outer_constant->value.is_null) {
+	if (inner_constant->value.IsNull() || outer_constant->value.IsNull()) {
 		return make_unique<BoundConstantExpression>(Value(comparison->return_type));
 	}
+	auto &constant_type = outer_constant->return_type;
+	hugeint_t outer_value = IntegralValue::Get(outer_constant->value);
+	hugeint_t inner_value = IntegralValue::Get(inner_constant->value);
 
-	int arithmetic_child_index = arithmetic->children[0].get() == inner_constant ? 1 : 0;
+	idx_t arithmetic_child_index = arithmetic->children[0].get() == inner_constant ? 1 : 0;
 	auto &op_type = arithmetic->function.name;
 	if (op_type == "+") {
 		// [x + 1 COMP 10] OR [1 + x COMP 10]
 		// order does not matter in addition:
 		// simply change right side to 10-1 (outer_constant - inner_constant)
-		outer_constant->value = outer_constant->value - inner_constant->value;
+		if (!Hugeint::SubtractInPlace(outer_value, inner_value)) {
+			return nullptr;
+		}
+		auto result_value = Value::HUGEINT(outer_value);
+		if (!result_value.TryCastAs(constant_type)) {
+			// if the cast is not possible then the comparison is not possible
+			// for example, if we have x + 5 = 3, where x is an unsigned number, we will get x = -2
+			// since this is not possible we can remove the entire branch here
+			return ExpressionRewriter::ConstantOrNull(move(arithmetic->children[arithmetic_child_index]),
+			                                          Value::BOOLEAN(false));
+		}
+		outer_constant->value = move(result_value);
 	} else if (op_type == "-") {
 		// [x - 1 COMP 10] O R [1 - x COMP 10]
 		// order matters in subtraction:
 		if (arithmetic_child_index == 0) {
 			// [x - 1 COMP 10]
 			// change right side to 10+1 (outer_constant + inner_constant)
-			outer_constant->value = outer_constant->value + inner_constant->value;
+			if (!Hugeint::AddInPlace(outer_value, inner_value)) {
+				return nullptr;
+			}
+			auto result_value = Value::HUGEINT(outer_value);
+			if (!result_value.TryCastAs(constant_type)) {
+				// if the cast is not possible then the comparison is not possible
+				return ExpressionRewriter::ConstantOrNull(move(arithmetic->children[arithmetic_child_index]),
+				                                          Value::BOOLEAN(false));
+			}
+			outer_constant->value = move(result_value);
 		} else {
 			// [1 - x COMP 10]
 			// change right side to 1-10=-9
-			outer_constant->value = inner_constant->value - outer_constant->value;
+			if (!Hugeint::SubtractInPlace(inner_value, outer_value)) {
+				return nullptr;
+			}
+			auto result_value = Value::HUGEINT(inner_value);
+			if (!result_value.TryCastAs(constant_type)) {
+				// if the cast is not possible then the comparison is not possible
+				return ExpressionRewriter::ConstantOrNull(move(arithmetic->children[arithmetic_child_index]),
+				                                          Value::BOOLEAN(false));
+			}
+			outer_constant->value = move(result_value);
 			// in this case, we should also flip the comparison
 			// e.g. if we have [4 - x < 2] then we should have [x > 2]
 			comparison->type = FlipComparisionExpression(comparison->type);
@@ -119438,24 +119709,39 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<Expr
 		// order does not matter in multiplication:
 		// change right side to 10/2 (outer_constant / inner_constant)
 		// but ONLY if outer_constant is cleanly divisible by the inner_constant
-		if (inner_constant->value == 0) {
+		if (inner_value == 0) {
 			// x * 0, the result is either 0 or NULL
-			// thus the final result will be either [TRUE, FALSE] or [NULL], depending
-			// on if 0 matches the comparison criteria with the RHS
-			// for now we don't fold, but we can fold to "ConstantOrNull"
+			// we let the arithmetic_simplification rule take care of simplifying this first
 			return nullptr;
 		}
-		if (ValueOperations::Modulo(outer_constant->value, inner_constant->value) != 0) {
-			// not cleanly divisible, the result will be either FALSE or NULL
-			// for now, we don't do anything
-			return nullptr;
+		if (outer_value % inner_value != 0) {
+			// not cleanly divisible
+			bool is_equality = comparison->type == ExpressionType::COMPARE_EQUAL;
+			bool is_inequality = comparison->type == ExpressionType::COMPARE_NOTEQUAL;
+			if (is_equality || is_inequality) {
+				// we know the values are not equal
+				// the result will be either FALSE or NULL (if COMPARE_EQUAL)
+				// or TRUE or NULL (if COMPARE_NOTEQUAL)
+				return ExpressionRewriter::ConstantOrNull(move(arithmetic->children[arithmetic_child_index]),
+				                                          Value::BOOLEAN(is_inequality));
+			} else {
+				// not cleanly divisible and we are doing > >= < <=, skip the simplification for now
+				return nullptr;
+			}
 		}
-		if (inner_constant->value < 0) {
+		if (inner_value < 0) {
 			// multiply by negative value, need to flip expression
 			comparison->type = FlipComparisionExpression(comparison->type);
 		}
 		// else divide the RHS by the LHS
-		outer_constant->value = outer_constant->value / inner_constant->value;
+		// we need to do a range check on the cast even though we do a division
+		// because e.g. -128 / -1 = 128, which is out of range
+		auto result_value = Value::HUGEINT(outer_value / inner_value);
+		if (!result_value.TryCastAs(constant_type)) {
+			return ExpressionRewriter::ConstantOrNull(move(arithmetic->children[arithmetic_child_index]),
+			                                          Value::BOOLEAN(false));
+		}
+		outer_constant->value = move(result_value);
 	}
 	// replace left side with x
 	// first extract x from the arithmetic expression
@@ -119503,7 +119789,7 @@ namespace duckdb {
 
 unique_ptr<Expression> CastHugeintToSmallestType(unique_ptr<Expression> expr, NumericStatistics &num_stats) {
 	// Compute range
-	if (num_stats.min.is_null || num_stats.max.is_null) {
+	if (num_stats.min.IsNull() || num_stats.max.IsNull()) {
 		return expr;
 	}
 
@@ -119551,7 +119837,7 @@ unique_ptr<Expression> CastHugeintToSmallestType(unique_ptr<Expression> expr, Nu
 template <class T>
 unique_ptr<Expression> TemplatedCastToSmallestType(unique_ptr<Expression> expr, NumericStatistics &num_stats) {
 	// Compute range
-	if (num_stats.min.is_null || num_stats.max.is_null) {
+	if (num_stats.min.IsNull() || num_stats.max.IsNull()) {
 		return expr;
 	}
 
@@ -119825,7 +120111,7 @@ FilterPropagateResult StatisticsPropagator::PropagateComparison(BaseStatistics &
 	}
 	auto &lstats = (NumericStatistics &)left;
 	auto &rstats = (NumericStatistics &)right;
-	if (lstats.min.is_null || lstats.max.is_null || rstats.min.is_null || rstats.max.is_null) {
+	if (lstats.min.IsNull() || lstats.max.IsNull() || rstats.min.IsNull() || rstats.max.IsNull()) {
 		// no stats available: nothing to prune
 		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
 	}
@@ -119951,40 +120237,42 @@ unique_ptr<BaseStatistics> StatisticsPropagator::StatisticsFromValue(const Value
 	case PhysicalType::FLOAT:
 	case PhysicalType::DOUBLE: {
 		auto result = make_unique<NumericStatistics>(input.type(), input, input);
-		result->validity_stats = make_unique<ValidityStatistics>(input.is_null, !input.is_null);
+		result->validity_stats = make_unique<ValidityStatistics>(input.IsNull(), !input.IsNull());
 		return move(result);
 	}
 	case PhysicalType::VARCHAR: {
 		auto result = make_unique<StringStatistics>(input.type());
-		result->validity_stats = make_unique<ValidityStatistics>(input.is_null, !input.is_null);
-		if (!input.is_null) {
-			string_t str(input.str_value.c_str(), input.str_value.size());
-			result->Update(str);
+		result->validity_stats = make_unique<ValidityStatistics>(input.IsNull(), !input.IsNull());
+		if (!input.IsNull()) {
+			auto &string_value = StringValue::Get(input);
+			result->Update(string_t(string_value));
 		}
 		return move(result);
 	}
 	case PhysicalType::STRUCT: {
 		auto result = make_unique<StructStatistics>(input.type());
-		result->validity_stats = make_unique<ValidityStatistics>(input.is_null, !input.is_null);
-		if (input.is_null) {
+		result->validity_stats = make_unique<ValidityStatistics>(input.IsNull(), !input.IsNull());
+		if (input.IsNull()) {
 			for (auto &child_stat : result->child_stats) {
 				child_stat.reset();
 			}
 		} else {
-			D_ASSERT(result->child_stats.size() == input.struct_value.size());
+			auto &struct_children = StructValue::GetChildren(input);
+			D_ASSERT(result->child_stats.size() == struct_children.size());
 			for (idx_t i = 0; i < result->child_stats.size(); i++) {
-				result->child_stats[i] = StatisticsFromValue(input.struct_value[i]);
+				result->child_stats[i] = StatisticsFromValue(struct_children[i]);
 			}
 		}
 		return move(result);
 	}
 	case PhysicalType::LIST: {
 		auto result = make_unique<ListStatistics>(input.type());
-		result->validity_stats = make_unique<ValidityStatistics>(input.is_null, !input.is_null);
-		if (input.is_null) {
+		result->validity_stats = make_unique<ValidityStatistics>(input.IsNull(), !input.IsNull());
+		if (input.IsNull()) {
 			result->child_stats.reset();
 		} else {
-			for (auto &child_element : input.list_value) {
+			auto &list_children = ListValue::GetChildren(input);
+			for (auto &child_element : list_children) {
 				auto child_element_stats = StatisticsFromValue(child_element);
 				if (child_element_stats) {
 					result->child_stats->Merge(*child_element_stats);
@@ -120208,7 +120496,7 @@ void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &stats, Express
 		return;
 	}
 	auto &numeric_stats = (NumericStatistics &)stats;
-	if (numeric_stats.min.is_null || numeric_stats.max.is_null) {
+	if (numeric_stats.min.IsNull() || numeric_stats.max.IsNull()) {
 		// no stats available: skip this
 		return;
 	}
@@ -120248,7 +120536,7 @@ void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &lstats, BaseSt
 	}
 	auto &left_stats = (NumericStatistics &)lstats;
 	auto &right_stats = (NumericStatistics &)rstats;
-	if (left_stats.min.is_null || left_stats.max.is_null || right_stats.min.is_null || right_stats.max.is_null) {
+	if (left_stats.min.IsNull() || left_stats.max.IsNull() || right_stats.min.IsNull() || right_stats.max.IsNull()) {
 		// no stats available: skip this
 		return;
 	}
@@ -120700,7 +120988,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalJoin
 	// LEFT, FULL and RIGHT OUTER joins can introduce null values
 	// this requires us to alter the statistics after this point in the query plan
 	if (IsLeftOuterJoin(join_type)) {
-		// left or full outer join: set is_null to true for all rhs statistics
+		// left or full outer join: set IsNull() to true for all rhs statistics
 		for (auto &binding : right_bindings) {
 			auto stats = statistics_map.find(binding);
 			if (stats != statistics_map.end()) {
@@ -120709,7 +120997,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalJoin
 		}
 	}
 	if (IsRightOuterJoin(join_type)) {
-		// right or full outer join: set is_null to true for all lhs statistics
+		// right or full outer join: set IsNull() to true for all lhs statistics
 		for (auto &binding : left_bindings) {
 			auto stats = statistics_map.find(binding);
 			if (stats != statistics_map.end()) {
@@ -137717,7 +138005,7 @@ unique_ptr<ParsedExpression> Transformer::TransformAExpr(duckdb_libpgquery::PGAE
 			throw NotImplementedException("Custom escape in SIMILAR TO");
 		}
 		auto &constant = (ConstantExpression &)*similar_func.children[1];
-		if (!constant.value.is_null) {
+		if (!constant.value.IsNull()) {
 			throw NotImplementedException("Custom escape in SIMILAR TO");
 		}
 		// take the child of the similar_func
@@ -141850,12 +142138,12 @@ static void InvertPercentileFractions(unique_ptr<ParsedExpression> &fractions) {
 	Value value = ExpressionExecutor::EvaluateScalar(*bound.expr);
 	if (value.type().id() == LogicalTypeId::LIST) {
 		vector<Value> values;
-		for (const auto &element_val : value.list_value) {
-			values.emplace_back(Value(1) - element_val);
+		for (const auto &element_val : ListValue::GetChildren(value)) {
+			values.push_back(Value::DOUBLE(1 - element_val.GetValue<double>()));
 		}
 		bound.expr = make_unique<BoundConstantExpression>(Value::LIST(values));
 	} else {
-		bound.expr = make_unique<BoundConstantExpression>(Value(1) - value);
+		bound.expr = make_unique<BoundConstantExpression>(Value::DOUBLE(1 - value.GetValue<double>()));
 	}
 }
 
@@ -148783,7 +149071,7 @@ bool BoundConstantExpression::Equals(const BaseExpression *other_p) const {
 
 hash_t BoundConstantExpression::Hash() const {
 	hash_t result = Expression::Hash();
-	return CombineHash(ValueOperations::Hash(value), result);
+	return CombineHash(value.Hash(), result);
 }
 
 unique_ptr<Expression> BoundConstantExpression::Copy() {
@@ -156226,6 +156514,7 @@ CompressionFunction GetBitpackingFunction(PhysicalType data_type) {
 
 CompressionFunction BitpackingFun::GetFunction(PhysicalType type) {
 	switch (type) {
+	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
 		return GetBitpackingFunction<int8_t>(type);
 	case PhysicalType::INT16:
@@ -156234,7 +156523,6 @@ CompressionFunction BitpackingFun::GetFunction(PhysicalType type) {
 		return GetBitpackingFunction<int32_t>(type);
 	case PhysicalType::INT64:
 		return GetBitpackingFunction<int64_t>(type);
-	case PhysicalType::BOOL:
 	case PhysicalType::UINT8:
 		return GetBitpackingFunction<uint8_t>(type);
 	case PhysicalType::UINT16:
@@ -160014,7 +160302,13 @@ MetaBlockWriter::MetaBlockWriter(DatabaseInstance &db, block_id_t initial_block_
 }
 
 MetaBlockWriter::~MetaBlockWriter() {
-	Flush();
+	if (Exception::UncaughtException()) {
+		return;
+	}
+	try {
+		Flush();
+	} catch (...) {
+	}
 }
 
 block_id_t MetaBlockWriter::GetNextBlockId() {
@@ -160811,72 +161105,6 @@ void ListStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t co
 
 namespace duckdb {
 
-template <>
-void NumericStatistics::Update<int8_t>(SegmentStatistics &stats, int8_t new_value) {
-	auto &nstats = (NumericStatistics &)*stats.statistics;
-	UpdateValue<int8_t>(new_value, nstats.min.value_.tinyint, nstats.max.value_.tinyint);
-}
-
-template <>
-void NumericStatistics::Update<int16_t>(SegmentStatistics &stats, int16_t new_value) {
-	auto &nstats = (NumericStatistics &)*stats.statistics;
-	UpdateValue<int16_t>(new_value, nstats.min.value_.smallint, nstats.max.value_.smallint);
-}
-
-template <>
-void NumericStatistics::Update<int32_t>(SegmentStatistics &stats, int32_t new_value) {
-	auto &nstats = (NumericStatistics &)*stats.statistics;
-	UpdateValue<int32_t>(new_value, nstats.min.value_.integer, nstats.max.value_.integer);
-}
-
-template <>
-void NumericStatistics::Update<int64_t>(SegmentStatistics &stats, int64_t new_value) {
-	auto &nstats = (NumericStatistics &)*stats.statistics;
-	UpdateValue<int64_t>(new_value, nstats.min.value_.bigint, nstats.max.value_.bigint);
-}
-
-template <>
-void NumericStatistics::Update<uint8_t>(SegmentStatistics &stats, uint8_t new_value) {
-	auto &nstats = (NumericStatistics &)*stats.statistics;
-	UpdateValue<uint8_t>(new_value, nstats.min.value_.utinyint, nstats.max.value_.utinyint);
-}
-
-template <>
-void NumericStatistics::Update<uint16_t>(SegmentStatistics &stats, uint16_t new_value) {
-	auto &nstats = (NumericStatistics &)*stats.statistics;
-	UpdateValue<uint16_t>(new_value, nstats.min.value_.usmallint, nstats.max.value_.usmallint);
-}
-
-template <>
-void NumericStatistics::Update<uint32_t>(SegmentStatistics &stats, uint32_t new_value) {
-	auto &nstats = (NumericStatistics &)*stats.statistics;
-	UpdateValue<uint32_t>(new_value, nstats.min.value_.uinteger, nstats.max.value_.uinteger);
-}
-
-template <>
-void NumericStatistics::Update<uint64_t>(SegmentStatistics &stats, uint64_t new_value) {
-	auto &nstats = (NumericStatistics &)*stats.statistics;
-	UpdateValue<uint64_t>(new_value, nstats.min.value_.ubigint, nstats.max.value_.ubigint);
-}
-
-template <>
-void NumericStatistics::Update<hugeint_t>(SegmentStatistics &stats, hugeint_t new_value) {
-	auto &nstats = (NumericStatistics &)*stats.statistics;
-	UpdateValue<hugeint_t>(new_value, nstats.min.value_.hugeint, nstats.max.value_.hugeint);
-}
-
-template <>
-void NumericStatistics::Update<float>(SegmentStatistics &stats, float new_value) {
-	auto &nstats = (NumericStatistics &)*stats.statistics;
-	UpdateValue<float>(new_value, nstats.min.value_.float_, nstats.max.value_.float_);
-}
-
-template <>
-void NumericStatistics::Update<double>(SegmentStatistics &stats, double new_value) {
-	auto &nstats = (NumericStatistics &)*stats.statistics;
-	UpdateValue<double>(new_value, nstats.min.value_.double_, nstats.max.value_.double_);
-}
-
 template <>
 void NumericStatistics::Update<interval_t>(SegmentStatistics &stats, interval_t new_value) {
 }
@@ -160898,23 +161126,23 @@ NumericStatistics::NumericStatistics(LogicalType type_p, Value min_p, Value max_
 void NumericStatistics::Merge(const BaseStatistics &other_p) {
 	BaseStatistics::Merge(other_p);
 	auto &other = (const NumericStatistics &)other_p;
-	if (other.min.is_null || min.is_null) {
-		min.is_null = true;
+	if (other.min.IsNull() || min.IsNull()) {
+		min = Value(type);
 	} else if (other.min < min) {
 		min = other.min;
 	}
-	if (other.max.is_null || max.is_null) {
-		max.is_null = true;
+	if (other.max.IsNull() || max.IsNull()) {
+		max = Value(type);
 	} else if (other.max > max) {
 		max = other.max;
 	}
 }
 
 FilterPropagateResult NumericStatistics::CheckZonemap(ExpressionType comparison_type, const Value &constant) {
-	if (constant.is_null) {
+	if (constant.IsNull()) {
 		return FilterPropagateResult::FILTER_ALWAYS_FALSE;
 	}
-	if (min.is_null || max.is_null) {
+	if (min.IsNull() || max.IsNull()) {
 		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
 	}
 	switch (comparison_type) {
@@ -161024,11 +161252,11 @@ void NumericStatistics::TemplatedVerify(Vector &vector, const SelectionVector &s
 		if (!vdata.validity.RowIsValid(index)) {
 			continue;
 		}
-		if (!min.is_null && LessThan::Operation(data[index], min.GetValueUnsafe<T>())) { // LCOV_EXCL_START
+		if (!min.IsNull() && LessThan::Operation(data[index], min.GetValueUnsafe<T>())) { // LCOV_EXCL_START
 			throw InternalException("Statistics mismatch: value is smaller than min.\nStatistics: %s\nVector: %s",
 			                        ToString(), vector.ToString(count));
 		} // LCOV_EXCL_STOP
-		if (!max.is_null && GreaterThan::Operation(data[index], max.GetValueUnsafe<T>())) {
+		if (!max.IsNull() && GreaterThan::Operation(data[index], max.GetValueUnsafe<T>())) {
 			throw InternalException("Statistics mismatch: value is bigger than max.\nStatistics: %s\nVector: %s",
 			                        ToString(), vector.ToString(count));
 		}
@@ -163573,7 +163801,7 @@ idx_t ColumnSegment::FilterSelection(SelectionVector &sel, Vector &result, const
 		}
 		case PhysicalType::VARCHAR: {
 			auto result_flat = FlatVector::GetData<string_t>(result);
-			Vector predicate_vector(constant_filter.constant.str_value);
+			Vector predicate_vector(constant_filter.constant);
 			auto predicate = FlatVector::GetData<string_t>(predicate_vector);
 			FilterSelectionSwitch<string_t>(result_flat, predicate, sel, approved_tuple_count,
 			                                constant_filter.comparison_type, mask);