duckdb 0.7.2-dev12.0 → 0.7.2-dev1238.0

package/src/duckdb/src/include/duckdb/common/serializer/serialization_traits.hpp

@@ -0,0 +1,126 @@
+#pragma once
+#include <type_traits>
+#include "duckdb/common/vector.hpp"
+#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/unordered_set.hpp"
+
+namespace duckdb {
+
+class FormatSerializer;   // Forward declare
+class FormatDeserializer; // Forward declare
+
+// Backport to c++11
+template <class...>
+using void_t = void;
+
+// Check for anything implementing a `void FormatSerialize(FormatSerializer &FormatSerializer)` method
+template <typename T, typename = void_t<>>
+struct has_serialize : std::false_type {};
+
+template <typename T>
+struct has_serialize<T, void_t<decltype(std::declval<T>().FormatSerialize(std::declval<FormatSerializer &>()))>>
+    : std::true_type {};
+
+template <typename T>
+constexpr bool has_serialize_v() {
+	return has_serialize<T>::value;
+}
+
+// Check for anything implementing a static `T FormatDeserialize(FormatDeserializer&)` method
+/*
+template <typename T, typename = void_t<>>
+struct has_deserialize : std::false_type {};
+
+template <typename T>
+struct has_deserialize<T, void_t<decltype(T::FormatDeserialize)>> : std::true_type {};
+
+template <typename T>
+constexpr bool has_deserialize_v() {
+    return has_deserialize<T>::value;
+}*/
+
+template <typename T, typename = T>
+struct has_deserialize : std::false_type {};
+
+// Accept `static unique_ptr<T> FormatDeserialize(FormatDeserializer& deserializer)`
+template <typename T>
+struct has_deserialize<
+    T, typename std::enable_if<std::is_same<decltype(T::FormatDeserialize), unique_ptr<T>(FormatDeserializer &)>::value,
+                               T>::type> : std::true_type {};
+
+// Accept `static shared_ptr<T> FormatDeserialize(FormatDeserializer& deserializer)`
+template <typename T>
+struct has_deserialize<
+    T, typename std::enable_if<std::is_same<decltype(T::FormatDeserialize), shared_ptr<T>(FormatDeserializer &)>::value,
+                               T>::type> : std::true_type {};
+
+// Accept `static T FormatDeserialize(FormatDeserializer& deserializer)`
+template <typename T>
+struct has_deserialize<
+    T, typename std::enable_if<std::is_same<decltype(T::FormatDeserialize), T(FormatDeserializer &)>::value, T>::type>
+    : std::true_type {};
+
+// Check if T is a vector, and provide access to the inner type
+template <typename T>
+struct is_vector : std::false_type {};
+template <typename T>
+struct is_vector<typename std::vector<T>> : std::true_type {
+	typedef T ELEMENT_TYPE;
+};
+
+// Check if T is a unordered map, and provide access to the inner type
+template <typename T>
+struct is_unordered_map : std::false_type {};
+template <typename... Args>
+struct is_unordered_map<typename std::unordered_map<Args...>> : std::true_type {
+	typedef typename std::tuple_element<0, std::tuple<Args...>>::type KEY_TYPE;
+	typedef typename std::tuple_element<1, std::tuple<Args...>>::type VALUE_TYPE;
+	typedef typename std::tuple_element<2, std::tuple<Args...>>::type HASH_TYPE;
+	typedef typename std::tuple_element<3, std::tuple<Args...>>::type EQUAL_TYPE;
+};
+
+template <typename T>
+struct is_unique_ptr : std::false_type {};
+
+template <typename T, typename D>
+struct is_unique_ptr<unique_ptr<T, D>> : std::true_type {
+	typedef T ELEMENT_TYPE;
+	typedef D DELETER_TYPE;
+};
+
+template <typename T>
+struct is_shared_ptr : std::false_type {};
+
+template <typename T>
+struct is_shared_ptr<shared_ptr<T>> : std::true_type {
+	typedef T ELEMENT_TYPE;
+};
+
+template <typename T>
+struct is_pair : std::false_type {};
+
+template <typename T, typename U>
+struct is_pair<std::pair<T, U>> : std::true_type {
+	typedef T FIRST_TYPE;
+	typedef U SECOND_TYPE;
+};
+
+template <typename T>
+struct is_unordered_set : std::false_type {};
+template <typename... Args>
+struct is_unordered_set<std::unordered_set<Args...>> : std::true_type {
+	typedef typename std::tuple_element<0, std::tuple<Args...>>::type ELEMENT_TYPE;
+	typedef typename std::tuple_element<1, std::tuple<Args...>>::type HASH_TYPE;
+	typedef typename std::tuple_element<2, std::tuple<Args...>>::type EQUAL_TYPE;
+};
+
+template <typename T>
+struct is_set : std::false_type {};
+template <typename... Args>
+struct is_set<std::set<Args...>> : std::true_type {
+	typedef typename std::tuple_element<0, std::tuple<Args...>>::type ELEMENT_TYPE;
+	typedef typename std::tuple_element<1, std::tuple<Args...>>::type HASH_TYPE;
+	typedef typename std::tuple_element<2, std::tuple<Args...>>::type EQUAL_TYPE;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/serializer.hpp

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "duckdb/catalog/catalog.hpp"
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector.hpp"
@@ -21,6 +22,8 @@ private:
 	uint64_t version = 0L;
 
 public:
+	bool is_query_plan = false;
+
 	virtual ~Serializer() {
 	}
 
@@ -111,6 +114,16 @@ public:
 	//! Reads [read_size] bytes into the buffer
 	virtual void ReadData(data_ptr_t buffer, idx_t read_size) = 0;
 
+	//! Gets the context for the deserializer
+	virtual ClientContext &GetContext() {
+		throw InternalException("This deserializer does not have a client-context");
+	};
+
+	//! Gets the catalog for the deserializer
+	virtual Catalog *GetCatalog() {
+		return nullptr;
+	};
+
 	template <class T>
 	T Read() {
 		T value;

package/src/duckdb/src/include/duckdb/common/string_util.hpp

@@ -21,6 +21,21 @@ namespace duckdb {
  */
 class StringUtil {
 public:
+	static string GenerateRandomName(idx_t length = 16);
+
+	static uint8_t GetHexValue(char c) {
+		if (c >= '0' && c <= '9') {
+			return c - '0';
+		}
+		if (c >= 'a' && c <= 'f') {
+			return c - 'a' + 10;
+		}
+		if (c >= 'A' && c <= 'F') {
+			return c - 'A' + 10;
+		}
+		throw InvalidInputException("Invalid input for hex digit: %s", string(c, 1));
+	}
+
 	DUCKDB_API static bool CharacterIsSpace(char c) {
 		return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
 	}
@@ -170,6 +185,18 @@ public:
 	//! Equivalent to calling TopNLevenshtein followed by CandidatesMessage
 	DUCKDB_API static string CandidatesErrorMessage(const vector<string> &strings, const string &target,
 	                                                const string &message_prefix, idx_t n = 5);
+
+	//! Returns true if two null-terminated strings are equal or point to the same address.
+	//! Returns false if only one of the strings is nullptr
+	DUCKDB_API static bool Equals(const char *s1, const char *s2) {
+		if (s1 == s2) {
+			return true;
+		}
+		if (s1 == nullptr || s2 == nullptr) {
+			return false;
+		}
+		return strcmp(s1, s2) == 0;
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/bit.hpp

@@ -25,7 +25,7 @@ public:
 	//! Extracts the nth bit from bit string; the first (leftmost) bit is indexed 0
 	DUCKDB_API static idx_t GetBit(string_t bit_string, idx_t n);
 	//! Sets the nth bit in bit string to newvalue; the first (leftmost) bit is indexed 0
-	DUCKDB_API static void SetBit(const string_t &bit_string, idx_t n, idx_t new_value, string_t &result);
+	DUCKDB_API static void SetBit(string_t &bit_string, idx_t n, idx_t new_value);
 	//! Returns first starting index of the specified substring within bits, or zero if it's not present.
 	DUCKDB_API static idx_t BitPosition(string_t substring, string_t bits);
 	//! Converts bits to a string, writing the output to the designated output string.
@@ -36,9 +36,13 @@ public:
 	DUCKDB_API static bool TryGetBitStringSize(string_t str, idx_t &result_size, string *error_message);
 	//! Convert a string to a bit. This function should ONLY be called after calling GetBitSize, since it does NOT
 	//! perform data validation.
-	DUCKDB_API static void ToBit(string_t str, data_ptr_t output);
+	DUCKDB_API static void ToBit(string_t str, string_t &output);
 	DUCKDB_API static string ToBit(string_t str);
+	//! Creates a new bitstring of determined length
+	DUCKDB_API static void BitString(const string_t &input, const idx_t &len, string_t &result);
 	DUCKDB_API static void SetEmptyBitString(string_t &target, string_t &input);
+	DUCKDB_API static void SetEmptyBitString(string_t &target, idx_t len);
+	DUCKDB_API static idx_t ComputeBitstringLen(idx_t len);
 
 	DUCKDB_API static void RightShift(const string_t &bit_string, const idx_t &shif, string_t &result);
 	DUCKDB_API static void LeftShift(const string_t &bit_string, const idx_t &shift, string_t &result);
@@ -47,11 +51,12 @@ public:
 	DUCKDB_API static void BitwiseXor(const string_t &rhs, const string_t &lhs, string_t &result);
 	DUCKDB_API static void BitwiseNot(const string_t &rhs, string_t &result);
 
+	DUCKDB_API static void Verify(const string_t &input);
+
 private:
-	//! Returns the amount of padded zeroes to fill up to a full byte. This information is stored in the first byte of
-	//! the bitstring.
-	DUCKDB_API static idx_t GetPadding(const string_t &bit_string);
-	DUCKDB_API static idx_t GetBitSize(string_t str);
-	DUCKDB_API static void SetBit(string_t &bit_string, idx_t n, idx_t new_value);
+	static void Finalize(string_t &str);
+	static idx_t GetBitInternal(string_t bit_string, idx_t n);
+	static void SetBitInternal(string_t &bit_string, idx_t n, idx_t new_value);
+	static idx_t GetBitIndex(idx_t n);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/interval.hpp

@@ -101,8 +101,44 @@ public:
 	static dtime_t Add(dtime_t left, interval_t right, date_t &date);
 
 	//! Comparison operators
-	static bool Equals(interval_t left, interval_t right);
-	static bool GreaterThan(interval_t left, interval_t right);
-	static bool GreaterThanEquals(interval_t left, interval_t right);
+	inline static bool Equals(const interval_t &left, const interval_t &right);
+	inline static bool GreaterThan(const interval_t &left, const interval_t &right);
 };
+static void NormalizeIntervalEntries(interval_t input, int64_t &months, int64_t &days, int64_t &micros) {
+	int64_t extra_months_d = input.days / Interval::DAYS_PER_MONTH;
+	int64_t extra_months_micros = input.micros / Interval::MICROS_PER_MONTH;
+	input.days -= extra_months_d * Interval::DAYS_PER_MONTH;
+	input.micros -= extra_months_micros * Interval::MICROS_PER_MONTH;
+
+	int64_t extra_days_micros = input.micros / Interval::MICROS_PER_DAY;
+	input.micros -= extra_days_micros * Interval::MICROS_PER_DAY;
+
+	months = input.months + extra_months_d + extra_months_micros;
+	days = input.days + extra_days_micros;
+	micros = input.micros;
+}
+
+bool Interval::Equals(const interval_t &left, const interval_t &right) {
+	return left.months == right.months && left.days == right.days && left.micros == right.micros;
+}
+
+bool Interval::GreaterThan(const interval_t &left, const interval_t &right) {
+	int64_t lmonths, ldays, lmicros;
+	int64_t rmonths, rdays, rmicros;
+	NormalizeIntervalEntries(left, lmonths, ldays, lmicros);
+	NormalizeIntervalEntries(right, rmonths, rdays, rmicros);
+
+	if (lmonths > rmonths) {
+		return true;
+	} else if (lmonths < rmonths) {
+		return false;
+	}
+	if (ldays > rdays) {
+		return true;
+	} else if (ldays < rdays) {
+		return false;
+	}
+	return lmicros > rmicros;
+}
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/list_segment.hpp

@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/list_segment.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#include "duckdb/common/allocator.hpp"
+#include "duckdb/common/constants.hpp"
+#include "duckdb/common/types/vector.hpp"
+
+#pragma once
+
+namespace duckdb {
+
+struct ListSegment {
+	uint16_t count;
+	uint16_t capacity;
+	ListSegment *next;
+};
+struct LinkedList {
+	LinkedList() {};
+	LinkedList(idx_t total_capacity_p, ListSegment *first_segment_p, ListSegment *last_segment_p)
+	    : total_capacity(total_capacity_p), first_segment(first_segment_p), last_segment(last_segment_p) {
+	}
+
+	idx_t total_capacity = 0;
+	ListSegment *first_segment = nullptr;
+	ListSegment *last_segment = nullptr;
+};
+
+// forward declarations
+struct WriteDataToSegment;
+struct ReadDataFromSegment;
+struct CopyDataFromSegment;
+typedef ListSegment *(*create_segment_t)(WriteDataToSegment &write_data_to_segment, Allocator &allocator,
+                                         vector<AllocatedData> &owning_vector, const uint16_t &capacity);
+typedef void (*write_data_to_segment_t)(WriteDataToSegment &write_data_to_segment, Allocator &allocator,
+                                        vector<AllocatedData> &owning_vector, ListSegment *segment, Vector &input,
+                                        idx_t &entry_idx, idx_t &count);
+typedef void (*read_data_from_segment_t)(ReadDataFromSegment &read_data_from_segment, const ListSegment *segment,
+                                         Vector &result, idx_t &total_count);
+typedef ListSegment *(*copy_data_from_segment_t)(CopyDataFromSegment &copy_data_from_segment, const ListSegment *source,
+                                                 Allocator &allocator, vector<AllocatedData> &owning_vector);
+
+struct WriteDataToSegment {
+	create_segment_t create_segment;
+	write_data_to_segment_t segment_function;
+	vector<WriteDataToSegment> child_functions;
+	void AppendRow(Allocator &allocator, vector<AllocatedData> &owning_vector, LinkedList *linked_list, Vector &input,
+	               idx_t &entry_idx, idx_t &count);
+};
+
+struct ReadDataFromSegment {
+	read_data_from_segment_t segment_function;
+	vector<ReadDataFromSegment> child_functions;
+	void BuildListVector(LinkedList *linked_list, Vector &result, idx_t &initial_total_count);
+};
+
+struct CopyDataFromSegment {
+	copy_data_from_segment_t segment_function;
+	vector<CopyDataFromSegment> child_functions;
+	void CopyLinkedList(const LinkedList *source_list, LinkedList &target_list, Allocator &allocator,
+	                    vector<AllocatedData> &owning_vector);
+};
+
+void GetSegmentDataFunctions(WriteDataToSegment &write_data_to_segment, ReadDataFromSegment &read_data_from_segment,
+                             CopyDataFromSegment &copy_data_from_segment, const LogicalType &type);
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/string_type.hpp

@@ -10,6 +10,7 @@
 
 #include "duckdb/common/assert.hpp"
 #include "duckdb/common/constants.hpp"
+#include "duckdb/common/helper.hpp"
 
 #include <cstring>
 
@@ -117,10 +118,79 @@ public:
 
 	void Verify() const;
 	void VerifyNull() const;
+
+	struct StringComparisonOperators {
+		static inline bool Equals(const string_t &a, const string_t &b) {
+#ifdef DUCKDB_DEBUG_NO_INLINE
+			if (a.GetSize() != b.GetSize())
+				return false;
+			return (memcmp(a.GetDataUnsafe(), b.GetDataUnsafe(), a.GetSize()) == 0);
+#endif
+			uint64_t A = Load<uint64_t>((const_data_ptr_t)&a);
+			uint64_t B = Load<uint64_t>((const_data_ptr_t)&b);
+			if (A != B) {
+				// Either length or prefix are different -> not equal
+				return false;
+			}
+			// they have the same length and same prefix!
+			A = Load<uint64_t>((const_data_ptr_t)&a + 8u);
+			B = Load<uint64_t>((const_data_ptr_t)&b + 8u);
+			if (A == B) {
+				// either they are both inlined (so compare equal) or point to the same string (so compare equal)
+				return true;
+			}
+			if (!a.IsInlined()) {
+				// 'long' strings of the same length -> compare pointed value
+				if (memcmp(a.value.pointer.ptr, b.value.pointer.ptr, a.GetSize()) == 0) {
+					return true;
+				}
+			}
+			// either they are short string of same length but different content
+			//     or they point to string with different content
+			//     either way, they can't represent the same underlying string
+			return false;
+		}
+		// compare up to shared length. if still the same, compare lengths
+		static bool GreaterThan(const string_t &left, const string_t &right) {
+			const uint32_t left_length = left.GetSize();
+			const uint32_t right_length = right.GetSize();
+			const uint32_t min_length = std::min<uint32_t>(left_length, right_length);
+
+#ifndef DUCKDB_DEBUG_NO_INLINE
+			uint32_t A = Load<uint32_t>((const_data_ptr_t)left.GetPrefix());
+			uint32_t B = Load<uint32_t>((const_data_ptr_t)right.GetPrefix());
+
+			// Utility to move 0xa1b2c3d4 into 0xd4c3b2a1, basically inverting the order byte-a-byte
+			auto bswap = [](uint32_t v) -> uint32_t {
+				uint32_t t1 = (v >> 16u) | (v << 16u);
+				uint32_t t2 = t1 & 0x00ff00ff;
+				uint32_t t3 = t1 & 0xff00ff00;
+				return (t2 << 8u) | (t3 >> 8u);
+			};
+
+			// Check on prefix -----
+			// We dont' need to mask since:
+			//	if the prefix is greater(after bswap), it will stay greater regardless of the extra bytes
+			// 	if the prefix is smaller(after bswap), it will stay smaller regardless of the extra bytes
+			//	if the prefix is equal, the extra bytes are guaranteed to be /0 for the shorter one
+
+			if (A != B)
+				return bswap(A) > bswap(B);
+#endif
+			auto memcmp_res = memcmp(left.GetDataUnsafe(), right.GetDataUnsafe(), min_length);
+			return memcmp_res > 0 || (memcmp_res == 0 && left_length > right_length);
+		}
+	};
+
+	bool operator==(const string_t &r) const {
+		return StringComparisonOperators::Equals(*this, r);
+	}
+
+	bool operator>(const string_t &r) const {
+		return StringComparisonOperators::GreaterThan(*this, r);
+	}
 	bool operator<(const string_t &r) const {
-		auto this_str = this->GetString();
-		auto r_str = r.GetString();
-		return this_str < r_str;
+		return r > *this;
 	}
 
 private:

package/src/duckdb/src/include/duckdb/common/types/time.hpp

@@ -39,6 +39,9 @@ public:
 	DUCKDB_API static string ConversionError(const string &str);
 	DUCKDB_API static string ConversionError(string_t str);
 
+	DUCKDB_API static dtime_t FromTimeMs(int64_t time_ms);
+	DUCKDB_API static dtime_t FromTimeNs(int64_t time_ns);
+
 private:
 	static bool TryConvertInternal(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict);
 };

package/src/duckdb/src/include/duckdb/common/types/validity_mask.hpp

@@ -323,9 +323,12 @@ public:
 public:
 	DUCKDB_API void Resize(idx_t old_size, idx_t new_size);
 
-	DUCKDB_API void Slice(const ValidityMask &other, idx_t offset, idx_t end);
+	DUCKDB_API void SliceInPlace(const ValidityMask &other, idx_t target_offset, idx_t source_offset, idx_t count);
+	DUCKDB_API void Slice(const ValidityMask &other, idx_t source_offset, idx_t count);
 	DUCKDB_API void Combine(const ValidityMask &other, idx_t count);
 	DUCKDB_API string ToString(idx_t count) const;
+
+	DUCKDB_API static bool IsAligned(idx_t count);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/value.hpp

@@ -23,6 +23,7 @@ class CastFunctionSet;
 class Deserializer;
 class Serializer;
 struct GetCastFunctionInput;
+struct ExtraValueInfo;
 
 //! The Value object holds a single arbitrary value of any type that can be
 //! stored in the database.
@@ -66,7 +67,7 @@ public:
 	inline LogicalType &GetTypeMutable() {
 		return type_;
 	}
-	inline const LogicalType &type() const {
+	inline const LogicalType &type() const { // NOLINT
 		return type_;
 	}
 	inline bool IsNull() const {
@@ -77,6 +78,10 @@ public:
 	DUCKDB_API static Value MinimumValue(const LogicalType &type);
 	//! Create the highest possible value of a given type (numeric only)
 	DUCKDB_API static Value MaximumValue(const LogicalType &type);
+	//! Create the negative infinite value of a given type (numeric only)
+	DUCKDB_API static Value NegativeInfinity(const LogicalType &type);
+	//! Create the positive infinite value of a given type (numeric only)
+	DUCKDB_API static Value Infinity(const LogicalType &type);
 	//! Create a Numeric value of the specified type with the specified value
 	DUCKDB_API static Value Numeric(const LogicalType &type, int64_t value);
 	DUCKDB_API static Value Numeric(const LogicalType &type, hugeint_t value);
@@ -150,17 +155,17 @@ public:
 	//! Cannot be called with an empty list, use either EMPTYLIST or LIST with a type instead
 	DUCKDB_API static Value LIST(vector<Value> values);
 	//! Create a list value with the given entries
-	DUCKDB_API static Value LIST(LogicalType child_type, vector<Value> values);
+	DUCKDB_API static Value LIST(const LogicalType &child_type, vector<Value> values);
 	//! Create an empty list with the specified child-type
-	DUCKDB_API static Value EMPTYLIST(LogicalType child_type);
+	DUCKDB_API static Value EMPTYLIST(const LogicalType &child_type);
 	//! Create a map value with the given entries
-	DUCKDB_API static Value MAP(LogicalType child_type, vector<Value> values);
+	DUCKDB_API static Value MAP(const LogicalType &child_type, vector<Value> values);
 	//! Create a union value from a selected value and a tag from a set of alternatives.
 	DUCKDB_API static Value UNION(child_list_t<LogicalType> members, uint8_t tag, Value value);
 
 	//! Create a blob Value from a data pointer and a length: no bytes are interpreted
 	DUCKDB_API static Value BLOB(const_data_ptr_t data, idx_t len);
-	DUCKDB_API static Value BLOB_RAW(const string &data) {
+	DUCKDB_API static Value BLOB_RAW(const string &data) { // NOLINT
 		return Value::BLOB((const_data_ptr_t)data.c_str(), data.size());
 	}
 	//! Creates a blob by casting a specified string to a blob (i.e. interpreting \x characters)
@@ -225,6 +230,8 @@ public:
 
 	//! Serializes a Value to a stand-alone binary blob
 	DUCKDB_API void Serialize(Serializer &serializer) const;
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const;
+	DUCKDB_API static Value FormatDeserialize(FormatDeserializer &deserializer);
 	//! Deserializes a Value from a blob
 	DUCKDB_API static Value Deserialize(Deserializer &source);
 
@@ -277,11 +284,8 @@ public:
 
 private:
 	//! The logical of the value
-	LogicalType type_;
+	LogicalType type_; // NOLINT
 
-#if DUCKDB_API_VERSION < DUCKDB_API_0_3_2
-public:
-#endif
 	//! Whether or not the value is NULL
 	bool is_null;
 
@@ -297,21 +301,17 @@ public:
 		uint32_t uinteger;
 		uint64_t ubigint;
 		hugeint_t hugeint;
-		float float_;
-		double double_;
+		float float_;   // NOLINT
+		double double_; // NOLINT
 		uintptr_t pointer;
 		uint64_t hash;
 		date_t date;
 		dtime_t time;
 		timestamp_t timestamp;
 		interval_t interval;
-	} value_;
-
-	//! The value of the object, if it is of a variable size type
-	string str_value;
+	} value_; // NOLINT
 
-	vector<Value> struct_value;
-	vector<Value> list_value;
+	shared_ptr<ExtraValueInfo> value_info_; // NOLINT
 
 private:
 	template <class T>
@@ -535,37 +535,6 @@ DUCKDB_API timestamp_t Value::GetValueUnsafe() const;
 template <>
 DUCKDB_API interval_t Value::GetValueUnsafe() const;
 
-template <>
-DUCKDB_API int8_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API int16_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API int32_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API int64_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API hugeint_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API uint8_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API uint16_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API uint32_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API uint64_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API float &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API double &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API date_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API dtime_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API timestamp_t &Value::GetReferenceUnsafe();
-template <>
-DUCKDB_API interval_t &Value::GetReferenceUnsafe();
-
 template <>
 DUCKDB_API bool Value::IsNan(float input);
 template <>

package/src/duckdb/src/include/duckdb/common/types/value_map.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/value_map.hpp
+// duckdb/common/types/value_map.hpp
 //
 //
 //===----------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/common/types/vector.hpp

@@ -162,6 +162,9 @@ public:
 	//! Deserializes a blob back into a Vector
 	DUCKDB_API void Deserialize(idx_t count, Deserializer &source);
 
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer, idx_t count);
+	DUCKDB_API void FormatDeserialize(FormatDeserializer &deserializer, idx_t count);
+
 	// Getters
 	inline VectorType GetVectorType() const {
 		return vector_type;
@@ -312,7 +315,6 @@ struct FlatVector {
 		return !vector.validity.RowIsValid(idx);
 	}
 	DUCKDB_API static const SelectionVector *IncrementalSelectionVector();
-	static Value GetValuesFromOffsets(Vector &values, vector<idx_t> &offsets);
 };
 
 struct ListVector {