duckdb 0.3.5-dev411.0 → 0.3.5-dev449.0

package/src/duckdb.cpp

@@ -1094,6 +1094,7 @@ private:
 	Serializer &serializer;
 	unique_ptr<BufferedSerializer> buffer;
 	idx_t field_count;
+	bool finalized;
 };
 
 template <>
@@ -1179,6 +1180,17 @@ public:
 		return T::Deserialize(source);
 	}
 
+	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
+	RETURN_TYPE ReadSerializable(RETURN_TYPE default_value, ARGS &&...args) {
+		if (field_count >= max_field_count) {
+			// field is not there, read the default value
+			return default_value;
+		}
+		// field is there, read the actual value
+		AddField();
+		return T::Deserialize(source, std::forward<ARGS>(args)...);
+	}
+
 	template <class T, class RETURN_TYPE = unique_ptr<T>>
 	RETURN_TYPE ReadRequiredSerializable() {
 		if (field_count >= max_field_count) {
@@ -1190,6 +1202,17 @@ public:
 		return T::Deserialize(source);
 	}
 
+	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
+	RETURN_TYPE ReadRequiredSerializable(ARGS &&...args) {
+		if (field_count >= max_field_count) {
+			// field is not there, read the default value
+			throw SerializationException("Attempting to read mandatory field, but field is missing");
+		}
+		// field is there, read the actual value
+		AddField();
+		return T::Deserialize(source, std::forward<ARGS>(args)...);
+	}
+
 	template <class T, class RETURN_TYPE = unique_ptr<T>>
 	vector<RETURN_TYPE> ReadRequiredSerializableList() {
 		if (field_count >= max_field_count) {
@@ -1233,6 +1256,7 @@ private:
 	idx_t field_count;
 	idx_t max_field_count;
 	idx_t total_size;
+	bool finalized;
 };
 
 } // namespace duckdb
@@ -2473,6 +2497,11 @@ private:
 
 
 
+
+#include <cfloat>
+#include <cstring> // strlen() on Solaris
+#include <limits.h>
+
 namespace duckdb {
 
 #define BSWAP16(x) ((uint16_t)((((uint16_t)(x)&0xff00) >> 8) | (((uint16_t)(x)&0x00ff) << 8)))
@@ -2487,44 +2516,170 @@ namespace duckdb {
 	            (((uint64_t)(x)&0x00000000ff000000ull) << 8) | (((uint64_t)(x)&0x0000000000ff0000ull) << 24) |         \
 	            (((uint64_t)(x)&0x000000000000ff00ull) << 40) | (((uint64_t)(x)&0x00000000000000ffull) << 56)))
 
-bool IsLittleEndian();
-uint8_t FlipSign(uint8_t key_byte);
-uint32_t EncodeFloat(float x);
-uint64_t EncodeDouble(double x);
+struct Radix {
+public:
+	static inline bool IsLittleEndian() {
+		int n = 1;
+		if (*(char *)&n == 1) {
+			return true;
+		} else {
+			return false;
+		}
+	}
 
-template <class T>
-void EncodeData(data_ptr_t dataptr, T value, bool is_little_endian) {
-	throw NotImplementedException("Cannot create data from this type");
-}
+	template <class T>
+	static inline void EncodeData(data_ptr_t dataptr, T value, bool is_little_endian) {
+		throw NotImplementedException("Cannot create data from this type");
+	}
+
+	static inline void EncodeStringDataPrefix(data_ptr_t dataptr, string_t value, idx_t prefix_len) {
+		auto len = value.GetSize();
+		memcpy(dataptr, value.GetDataUnsafe(), MinValue(len, prefix_len));
+		if (len < prefix_len) {
+			memset(dataptr + len, '\0', prefix_len - len);
+		}
+	}
+
+	static inline uint8_t FlipSign(uint8_t key_byte) {
+		return key_byte ^ 128;
+	}
+
+	static inline uint32_t EncodeFloat(float x) {
+		uint64_t buff;
+
+		//! zero
+		if (x == 0) {
+			buff = 0;
+			buff |= (1u << 31);
+			return buff;
+		}
+		// nan
+		if (Value::IsNan(x)) {
+			return UINT_MAX;
+		}
+		//! infinity
+		if (x > FLT_MAX) {
+			return UINT_MAX - 1;
+		}
+		//! -infinity
+		if (x < -FLT_MAX) {
+			return 0;
+		}
+		buff = Load<uint32_t>((const_data_ptr_t)&x);
+		if ((buff & (1u << 31)) == 0) { //! +0 and positive numbers
+			buff |= (1u << 31);
+		} else {          //! negative numbers
+			buff = ~buff; //! complement 1
+		}
+
+		return buff;
+	}
+
+	static inline uint64_t EncodeDouble(double x) {
+		uint64_t buff;
+		//! zero
+		if (x == 0) {
+			buff = 0;
+			buff += (1ull << 63);
+			return buff;
+		}
+		// nan
+		if (Value::IsNan(x)) {
+			return ULLONG_MAX;
+		}
+		//! infinity
+		if (x > DBL_MAX) {
+			return ULLONG_MAX - 1;
+		}
+		//! -infinity
+		if (x < -DBL_MAX) {
+			return 0;
+		}
+		buff = Load<uint64_t>((const_data_ptr_t)&x);
+		if (buff < (1ull << 63)) { //! +0 and positive numbers
+			buff += (1ull << 63);
+		} else {          //! negative numbers
+			buff = ~buff; //! complement 1
+		}
+		return buff;
+	}
+};
 
 template <>
-void EncodeData(data_ptr_t dataptr, bool value, bool is_little_endian);
-template <>
-void EncodeData(data_ptr_t dataptr, int8_t value, bool is_little_endian);
+inline void Radix::EncodeData(data_ptr_t dataptr, bool value, bool is_little_endian) {
+	Store<uint8_t>(value ? 1 : 0, dataptr);
+}
+
 template <>
-void EncodeData(data_ptr_t dataptr, int16_t value, bool is_little_endian);
+inline void Radix::EncodeData(data_ptr_t dataptr, int8_t value, bool is_little_endian) {
+	Store<uint8_t>(value, dataptr);
+	dataptr[0] = FlipSign(dataptr[0]);
+}
+
 template <>
-void EncodeData(data_ptr_t dataptr, int32_t value, bool is_little_endian);
+inline void Radix::EncodeData(data_ptr_t dataptr, int16_t value, bool is_little_endian) {
+	Store<uint16_t>(is_little_endian ? BSWAP16(value) : value, dataptr);
+	dataptr[0] = FlipSign(dataptr[0]);
+}
+
 template <>
-void EncodeData(data_ptr_t dataptr, int64_t value, bool is_little_endian);
+inline void Radix::EncodeData(data_ptr_t dataptr, int32_t value, bool is_little_endian) {
+	Store<uint32_t>(is_little_endian ? BSWAP32(value) : value, dataptr);
+	dataptr[0] = FlipSign(dataptr[0]);
+}
+
 template <>
-void EncodeData(data_ptr_t dataptr, uint8_t value, bool is_little_endian);
+inline void Radix::EncodeData(data_ptr_t dataptr, int64_t value, bool is_little_endian) {
+	Store<uint64_t>(is_little_endian ? BSWAP64(value) : value, dataptr);
+	dataptr[0] = FlipSign(dataptr[0]);
+}
+
 template <>
-void EncodeData(data_ptr_t dataptr, uint16_t value, bool is_little_endian);
+inline void Radix::EncodeData(data_ptr_t dataptr, uint8_t value, bool is_little_endian) {
+	Store<uint8_t>(value, dataptr);
+}
+
 template <>
-void EncodeData(data_ptr_t dataptr, uint32_t value, bool is_little_endian);
+inline void Radix::EncodeData(data_ptr_t dataptr, uint16_t value, bool is_little_endian) {
+	Store<uint16_t>(is_little_endian ? BSWAP16(value) : value, dataptr);
+}
+
 template <>
-void EncodeData(data_ptr_t dataptr, uint64_t value, bool is_little_endian);
+inline void Radix::EncodeData(data_ptr_t dataptr, uint32_t value, bool is_little_endian) {
+	Store<uint32_t>(is_little_endian ? BSWAP32(value) : value, dataptr);
+}
+
 template <>
-void EncodeData(data_ptr_t dataptr, hugeint_t value, bool is_little_endian);
+inline void Radix::EncodeData(data_ptr_t dataptr, uint64_t value, bool is_little_endian) {
+	Store<uint64_t>(is_little_endian ? BSWAP64(value) : value, dataptr);
+}
+
 template <>
-void EncodeData(data_ptr_t dataptr, double value, bool is_little_endian);
+inline void Radix::EncodeData(data_ptr_t dataptr, hugeint_t value, bool is_little_endian) {
+	EncodeData<int64_t>(dataptr, value.upper, is_little_endian);
+	EncodeData<uint64_t>(dataptr + sizeof(value.upper), value.lower, is_little_endian);
+}
+
 template <>
-void EncodeData(data_ptr_t dataptr, float value, bool is_little_endian);
+inline void Radix::EncodeData(data_ptr_t dataptr, float value, bool is_little_endian) {
+	uint32_t converted_value = EncodeFloat(value);
+	Store<uint32_t>(is_little_endian ? BSWAP32(converted_value) : converted_value, dataptr);
+}
+
 template <>
-void EncodeData(data_ptr_t dataptr, interval_t value, bool is_little_endian);
+inline void Radix::EncodeData(data_ptr_t dataptr, double value, bool is_little_endian) {
+	uint64_t converted_value = EncodeDouble(value);
+	Store<uint64_t>(is_little_endian ? BSWAP64(converted_value) : converted_value, dataptr);
+}
 
-void EncodeStringDataPrefix(data_ptr_t dataptr, string_t value, idx_t prefix_len);
+template <>
+inline void Radix::EncodeData(data_ptr_t dataptr, interval_t value, bool is_little_endian) {
+	EncodeData<int32_t>(dataptr, value.months, is_little_endian);
+	dataptr += sizeof(value.months);
+	EncodeData<int32_t>(dataptr, value.days, is_little_endian);
+	dataptr += sizeof(value.days);
+	EncodeData<int64_t>(dataptr, value.micros, is_little_endian);
+}
 
 } // namespace duckdb
 
@@ -2542,13 +2697,13 @@ public:
 
 public:
 	template <class T>
-	static unique_ptr<Key> CreateKey(T element, bool is_little_endian) {
+	static inline unique_ptr<Key> CreateKey(T element, bool is_little_endian) {
 		auto data = Key::CreateData<T>(element, is_little_endian);
 		return make_unique<Key>(move(data), sizeof(element));
 	}
 
 	template <class T>
-	static unique_ptr<Key> CreateKey(const Value &element, bool is_little_endian) {
+	static inline unique_ptr<Key> CreateKey(const Value &element, bool is_little_endian) {
 		return CreateKey(element.GetValueUnsafe<T>(), is_little_endian);
 	}
 
@@ -2566,9 +2721,9 @@ public:
 
 private:
 	template <class T>
-	static unique_ptr<data_t[]> CreateData(T value, bool is_little_endian) {
+	static inline unique_ptr<data_t[]> CreateData(T value, bool is_little_endian) {
 		auto data = unique_ptr<data_t[]>(new data_t[sizeof(value)]);
-		EncodeData<T>(data.get(), value, is_little_endian);
+		Radix::EncodeData<T>(data.get(), value, is_little_endian);
 		return data;
 	}
 };
@@ -12934,13 +13089,14 @@ namespace duckdb {
 // Field Writer
 //===--------------------------------------------------------------------===//
 FieldWriter::FieldWriter(Serializer &serializer_p)
-    : serializer(serializer_p), buffer(make_unique<BufferedSerializer>()), field_count(0) {
+    : serializer(serializer_p), buffer(make_unique<BufferedSerializer>()), field_count(0), finalized(false) {
 }
 
 FieldWriter::~FieldWriter() {
 	if (Exception::UncaughtException()) {
 		return;
 	}
+	D_ASSERT(finalized);
 	// finalize should always have been called, unless this is destroyed as part of stack unwinding
 	D_ASSERT(!buffer);
 }
@@ -12960,7 +13116,8 @@ void FieldWriter::Write(const string &val) {
 
 void FieldWriter::Finalize() {
 	D_ASSERT(buffer);
-
+	D_ASSERT(!finalized);
+	finalized = true;
 	serializer.Write<uint32_t>(field_count);
 	serializer.Write<uint64_t>(buffer->blob.size);
 	serializer.WriteData(buffer->blob.data.get(), buffer->blob.size);
@@ -12992,7 +13149,7 @@ void FieldDeserializer::SetRemainingData(idx_t remaining_data) {
 //===--------------------------------------------------------------------===//
 // Field Reader
 //===--------------------------------------------------------------------===//
-FieldReader::FieldReader(Deserializer &source_p) : source(source_p), field_count(0) {
+FieldReader::FieldReader(Deserializer &source_p) : source(source_p), field_count(0), finalized(false) {
 	max_field_count = source_p.Read<uint32_t>();
 	total_size = source_p.Read<uint64_t>();
 	D_ASSERT(max_field_count > 0);
@@ -13000,9 +13157,15 @@ FieldReader::FieldReader(Deserializer &source_p) : source(source_p), field_count
 }
 
 FieldReader::~FieldReader() {
+	if (Exception::UncaughtException()) {
+		return;
+	}
+	D_ASSERT(finalized);
 }
 
 void FieldReader::Finalize() {
+	D_ASSERT(!finalized);
+	finalized = true;
 	if (field_count < max_field_count) {
 		// we can handle this case by calling source.ReadData(buffer, source.RemainingData())
 		throw SerializationException("Not all fields were read. This file might have been written with a newer version "
@@ -24874,174 +25037,6 @@ void ProgressBar::Update(bool final) {
 }
 
 } // namespace duckdb
-
-
-
-
-#include <cfloat>
-#include <cstring> // strlen() on Solaris
-#include <limits.h>
-
-namespace duckdb {
-
-bool IsLittleEndian() {
-	int n = 1;
-	if (*(char *)&n == 1) {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-uint8_t FlipSign(uint8_t key_byte) {
-	return key_byte ^ 128;
-}
-
-uint32_t EncodeFloat(float x) {
-	uint64_t buff;
-
-	//! zero
-	if (x == 0) {
-		buff = 0;
-		buff |= (1u << 31);
-		return buff;
-	}
-	// nan
-	if (Value::IsNan(x)) {
-		return UINT_MAX;
-	}
-	//! infinity
-	if (x > FLT_MAX) {
-		return UINT_MAX - 1;
-	}
-	//! -infinity
-	if (x < -FLT_MAX) {
-		return 0;
-	}
-	buff = Load<uint32_t>((const_data_ptr_t)&x);
-	if ((buff & (1u << 31)) == 0) { //! +0 and positive numbers
-		buff |= (1u << 31);
-	} else {          //! negative numbers
-		buff = ~buff; //! complement 1
-	}
-
-	return buff;
-}
-
-uint64_t EncodeDouble(double x) {
-	uint64_t buff;
-	//! zero
-	if (x == 0) {
-		buff = 0;
-		buff += (1ull << 63);
-		return buff;
-	}
-	// nan
-	if (Value::IsNan(x)) {
-		return ULLONG_MAX;
-	}
-	//! infinity
-	if (x > DBL_MAX) {
-		return ULLONG_MAX - 1;
-	}
-	//! -infinity
-	if (x < -DBL_MAX) {
-		return 0;
-	}
-	buff = Load<uint64_t>((const_data_ptr_t)&x);
-	if (buff < (1ull << 63)) { //! +0 and positive numbers
-		buff += (1ull << 63);
-	} else {          //! negative numbers
-		buff = ~buff; //! complement 1
-	}
-	return buff;
-}
-
-template <>
-void EncodeData(data_ptr_t dataptr, bool value, bool is_little_endian) {
-	Store<uint8_t>(value ? 1 : 0, dataptr);
-}
-
-template <>
-void EncodeData(data_ptr_t dataptr, int8_t value, bool is_little_endian) {
-	Store<uint8_t>(value, dataptr);
-	dataptr[0] = FlipSign(dataptr[0]);
-}
-
-template <>
-void EncodeData(data_ptr_t dataptr, int16_t value, bool is_little_endian) {
-	Store<uint16_t>(is_little_endian ? BSWAP16(value) : value, dataptr);
-	dataptr[0] = FlipSign(dataptr[0]);
-}
-
-template <>
-void EncodeData(data_ptr_t dataptr, int32_t value, bool is_little_endian) {
-	Store<uint32_t>(is_little_endian ? BSWAP32(value) : value, dataptr);
-	dataptr[0] = FlipSign(dataptr[0]);
-}
-
-template <>
-void EncodeData(data_ptr_t dataptr, int64_t value, bool is_little_endian) {
-	Store<uint64_t>(is_little_endian ? BSWAP64(value) : value, dataptr);
-	dataptr[0] = FlipSign(dataptr[0]);
-}
-
-template <>
-void EncodeData(data_ptr_t dataptr, uint8_t value, bool is_little_endian) {
-	Store<uint8_t>(value, dataptr);
-}
-
-template <>
-void EncodeData(data_ptr_t dataptr, uint16_t value, bool is_little_endian) {
-	Store<uint16_t>(is_little_endian ? BSWAP16(value) : value, dataptr);
-}
-
-template <>
-void EncodeData(data_ptr_t dataptr, uint32_t value, bool is_little_endian) {
-	Store<uint32_t>(is_little_endian ? BSWAP32(value) : value, dataptr);
-}
-
-template <>
-void EncodeData(data_ptr_t dataptr, uint64_t value, bool is_little_endian) {
-	Store<uint64_t>(is_little_endian ? BSWAP64(value) : value, dataptr);
-}
-
-template <>
-void EncodeData(data_ptr_t dataptr, hugeint_t value, bool is_little_endian) {
-	EncodeData<int64_t>(dataptr, value.upper, is_little_endian);
-	EncodeData<uint64_t>(dataptr + sizeof(value.upper), value.lower, is_little_endian);
-}
-
-template <>
-void EncodeData(data_ptr_t dataptr, float value, bool is_little_endian) {
-	uint32_t converted_value = EncodeFloat(value);
-	Store<uint32_t>(is_little_endian ? BSWAP32(converted_value) : converted_value, dataptr);
-}
-
-template <>
-void EncodeData(data_ptr_t dataptr, double value, bool is_little_endian) {
-	uint64_t converted_value = EncodeDouble(value);
-	Store<uint64_t>(is_little_endian ? BSWAP64(converted_value) : converted_value, dataptr);
-}
-
-template <>
-void EncodeData(data_ptr_t dataptr, interval_t value, bool is_little_endian) {
-	EncodeData<int32_t>(dataptr, value.months, is_little_endian);
-	dataptr += sizeof(value.months);
-	EncodeData<int32_t>(dataptr, value.days, is_little_endian);
-	dataptr += sizeof(value.days);
-	EncodeData<int64_t>(dataptr, value.micros, is_little_endian);
-}
-
-void EncodeStringDataPrefix(data_ptr_t dataptr, string_t value, idx_t prefix_len) {
-	auto len = value.GetSize();
-	memcpy(dataptr, value.GetDataUnsafe(), MinValue(len, prefix_len));
-	if (len < prefix_len) {
-		memset(dataptr + len, '\0', prefix_len - len);
-	}
-}
-
-} // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -31664,7 +31659,7 @@ void TemplatedRadixScatter(VectorData &vdata, const SelectionVector &sel, idx_t
 			// write validity and according value
 			if (validity.RowIsValid(source_idx)) {
 				key_locations[i][0] = valid;
-				EncodeData<T>(key_locations[i] + 1, source[source_idx], is_little_endian);
+				Radix::EncodeData<T>(key_locations[i] + 1, source[source_idx], is_little_endian);
 				// invert bits if desc
 				if (desc) {
 					for (idx_t s = 1; s < sizeof(T) + 1; s++) {
@@ -31682,7 +31677,7 @@ void TemplatedRadixScatter(VectorData &vdata, const SelectionVector &sel, idx_t
 			auto idx = sel.get_index(i);
 			auto source_idx = vdata.sel->get_index(idx) + offset;
 			// write value
-			EncodeData<T>(key_locations[i], source[source_idx], is_little_endian);
+			Radix::EncodeData<T>(key_locations[i], source[source_idx], is_little_endian);
 			// invert bits if desc
 			if (desc) {
 				for (idx_t s = 0; s < sizeof(T); s++) {
@@ -31709,7 +31704,7 @@ void RadixScatterStringVector(VectorData &vdata, const SelectionVector &sel, idx
 			// write validity and according value
 			if (validity.RowIsValid(source_idx)) {
 				key_locations[i][0] = valid;
-				EncodeStringDataPrefix(key_locations[i] + 1, source[source_idx], prefix_len);
+				Radix::EncodeStringDataPrefix(key_locations[i] + 1, source[source_idx], prefix_len);
 				// invert bits if desc
 				if (desc) {
 					for (idx_t s = 1; s < prefix_len + 1; s++) {
@@ -31727,7 +31722,7 @@ void RadixScatterStringVector(VectorData &vdata, const SelectionVector &sel, idx
 			auto idx = sel.get_index(i);
 			auto source_idx = vdata.sel->get_index(idx) + offset;
 			// write value
-			EncodeStringDataPrefix(key_locations[i], source[source_idx], prefix_len);
+			Radix::EncodeStringDataPrefix(key_locations[i], source[source_idx], prefix_len);
 			// invert bits if desc
 			if (desc) {
 				for (idx_t s = 0; s < prefix_len; s++) {
@@ -31854,7 +31849,7 @@ void RadixScatterStructVector(Vector &v, VectorData &vdata, idx_t vcount, const
 void RowOperations::RadixScatter(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count,
                                  data_ptr_t *key_locations, bool desc, bool has_null, bool nulls_first,
                                  idx_t prefix_len, idx_t width, idx_t offset) {
-	auto is_little_endian = IsLittleEndian();
+	auto is_little_endian = Radix::IsLittleEndian();
 
 	VectorData vdata;
 	v.Orrify(vcount, vdata);
@@ -40595,34 +40590,6 @@ string hugeint_t::ToString() const {
 
 
 
-namespace duckdb {
-
-//! The HyperLogLog class holds a HyperLogLog counter for approximate cardinality counting
-class HyperLogLog {
-public:
-	HyperLogLog();
-	~HyperLogLog();
-	// implicit copying of HyperLogLog is not allowed
-	HyperLogLog(const HyperLogLog &) = delete;
-
-	//! Adds an element of the specified size to the HyperLogLog counter
-	void Add(data_ptr_t element, idx_t size);
-	//! Return the count of this HyperLogLog counter
-	idx_t Count();
-	//! Merge this HyperLogLog counter with another counter to create a new one
-	unique_ptr<HyperLogLog> Merge(HyperLogLog &other);
-	HyperLogLog *MergePointer(HyperLogLog &other);
-	//! Merge a set of HyperLogLogs to create one big one
-	static unique_ptr<HyperLogLog> Merge(HyperLogLog logs[], idx_t count);
-
-private:
-	HyperLogLog(void *hll);
-
-	void *hll;
-};
-} // namespace duckdb
-
-
 
 
 // LICENSE_CHANGE_BEGIN
@@ -40639,41 +40606,116 @@ private:
 
 
 
-#include <string.h>
 #include <stdint.h>
+#include <string.h>
 
 namespace duckdb_hll {
 
 /* Error codes */
-#define HLL_C_OK                    0
-#define HLL_C_ERR                   -1
+#define HLL_C_OK  0
+#define HLL_C_ERR -1
 
 typedef struct {
-    void *ptr;
+	void *ptr;
 } robj;
 
 //! Create a new empty HyperLogLog object
 robj *hll_create(void);
+//! Convert hll from sparse to dense
+int hllSparseToDense(robj *o);
 //! Destroy the specified HyperLogLog object
 void hll_destroy(robj *obj);
-//! Add an element with the specified amount of bytes to the HyperLogLog. Returns C_ERR on failure, otherwise returns 0 if the cardinality did not change, and 1 otherwise.
+//! Add an element with the specified amount of bytes to the HyperLogLog. Returns C_ERR on failure, otherwise returns 0
+//! if the cardinality did not change, and 1 otherwise.
 int hll_add(robj *o, unsigned char *ele, size_t elesize);
-//! Returns the estimated amount of unique elements seen by the HyperLogLog. Returns C_OK on success, or C_ERR on failure.
+//! Returns the estimated amount of unique elements seen by the HyperLogLog. Returns C_OK on success, or C_ERR on
+//! failure.
 int hll_count(robj *o, size_t *result);
 //! Merge hll_count HyperLogLog objects into a single one. Returns NULL on failure, or the new HLL object on success.
 robj *hll_merge(robj **hlls, size_t hll_count);
+//! Get size (in bytes) of the HLL
+uint64_t get_size();
 
-uint64_t MurmurHash64A (const void * key, int len, unsigned int seed);
+uint64_t MurmurHash64A(const void *key, int len, unsigned int seed);
+
+} // namespace duckdb_hll
+
+namespace duckdb {
+
+void AddToLogsInternal(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void ***logs[],
+                       const SelectionVector *log_sel);
+
+void AddToSingleLogInternal(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void *log);
+
+} // namespace duckdb
 
-}
 
 // LICENSE_CHANGE_END
 
 
+namespace duckdb {
+
+enum class HLLStorageType { UNCOMPRESSED = 1 };
+
+class FieldWriter;
+class FieldReader;
+
+//! The HyperLogLog class holds a HyperLogLog counter for approximate cardinality counting
+class HyperLogLog {
+public:
+	HyperLogLog();
+	~HyperLogLog();
+	// implicit copying of HyperLogLog is not allowed
+	HyperLogLog(const HyperLogLog &) = delete;
+
+	//! Adds an element of the specified size to the HyperLogLog counter
+	void Add(data_ptr_t element, idx_t size);
+	//! Return the count of this HyperLogLog counter
+	idx_t Count() const;
+	//! Merge this HyperLogLog counter with another counter to create a new one
+	unique_ptr<HyperLogLog> Merge(HyperLogLog &other);
+	HyperLogLog *MergePointer(HyperLogLog &other);
+	//! Merge a set of HyperLogLogs to create one big one
+	static unique_ptr<HyperLogLog> Merge(HyperLogLog logs[], idx_t count);
+	//! Get the size (in bytes) of a HLL
+	static idx_t GetSize();
+	//! Get pointer to the HLL
+	data_ptr_t GetPtr() const;
+	//! Get copy of the HLL
+	unique_ptr<HyperLogLog> Copy();
+	//! (De)Serialize the HLL
+	void Serialize(FieldWriter &writer) const;
+	static unique_ptr<HyperLogLog> Deserialize(FieldReader &reader);
+
+public:
+	//! Compute HLL hashes over vdata, and store them in 'hashes'
+	//! Then, compute register indices and prefix lengths, and also store them in 'hashes' as a pair of uint32_t
+	static void ProcessEntries(VectorData &vdata, const LogicalType &type, uint64_t hashes[], uint8_t counts[],
+	                           idx_t count);
+	//! Add the indices and counts to the logs
+	static void AddToLogs(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[], HyperLogLog **logs[],
+	                      const SelectionVector *log_sel);
+	//! Add the indices and counts to THIS log
+	void AddToLog(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[]);
+
+private:
+	explicit HyperLogLog(void *hll);
+
+	void *hll;
+	mutex lock;
+};
+} // namespace duckdb
+
+
+
+
+
 namespace duckdb {
 
 HyperLogLog::HyperLogLog() : hll(nullptr) {
 	hll = duckdb_hll::hll_create();
+	// Insert into a dense hll can be vectorized, sparse cannot, so we immediately convert
+	duckdb_hll::hllSparseToDense((duckdb_hll::robj *)hll);
 }
 
 HyperLogLog::HyperLogLog(void *hll) : hll(hll) {
@@ -40689,7 +40731,7 @@ void HyperLogLog::Add(data_ptr_t element, idx_t size) {
 	}
 }
 
-idx_t HyperLogLog::Count() {
+idx_t HyperLogLog::Count() const {
 	// exception from size_t ban
 	size_t result;
 
@@ -40736,9 +40778,206 @@ unique_ptr<HyperLogLog> HyperLogLog::Merge(HyperLogLog logs[], idx_t count) {
 	return unique_ptr<HyperLogLog>(new HyperLogLog((void *)new_hll));
 }
 
+idx_t HyperLogLog::GetSize() {
+	return duckdb_hll::get_size();
+}
+
+data_ptr_t HyperLogLog::GetPtr() const {
+	return (data_ptr_t)((duckdb_hll::robj *)hll)->ptr;
+}
+
+unique_ptr<HyperLogLog> HyperLogLog::Copy() {
+	auto result = make_unique<HyperLogLog>();
+	lock_guard<mutex> guard(lock);
+	memcpy(result->GetPtr(), GetPtr(), GetSize());
+	D_ASSERT(result->Count() == Count());
+	return result;
+}
+
+void HyperLogLog::Serialize(FieldWriter &writer) const {
+	writer.WriteField<HLLStorageType>(HLLStorageType::UNCOMPRESSED);
+	writer.WriteBlob(GetPtr(), GetSize());
+}
+
+unique_ptr<HyperLogLog> HyperLogLog::Deserialize(FieldReader &reader) {
+	auto result = make_unique<HyperLogLog>();
+	auto storage_type = reader.ReadRequired<HLLStorageType>();
+	switch (storage_type) {
+	case HLLStorageType::UNCOMPRESSED:
+		reader.ReadBlob(result->GetPtr(), GetSize());
+		break;
+	default:
+		throw SerializationException("Unknown HyperLogLog storage type!");
+	}
+	return result;
+}
+
+//===--------------------------------------------------------------------===//
+// Vectorized HLL implementation
+//===--------------------------------------------------------------------===//
+//! Taken from https://nullprogram.com/blog/2018/07/31/
+template <class T>
+inline uint64_t TemplatedHash(const T &elem) {
+	uint64_t x = elem;
+	x ^= x >> 30;
+	x *= UINT64_C(0xbf58476d1ce4e5b9);
+	x ^= x >> 27;
+	x *= UINT64_C(0x94d049bb133111eb);
+	x ^= x >> 31;
+	return x;
+}
+
+template <>
+inline uint64_t TemplatedHash(const hugeint_t &elem) {
+	return TemplatedHash<uint64_t>(Load<uint64_t>((data_ptr_t)&elem.upper)) ^ TemplatedHash<uint64_t>(elem.lower);
+}
+
+template <idx_t rest>
+inline void CreateIntegerRecursive(const data_ptr_t &data, uint64_t &x) {
+	x ^= (uint64_t)data[rest - 1] << ((rest - 1) * 8);
+	return CreateIntegerRecursive<rest - 1>(data, x);
+}
+
+template <>
+inline void CreateIntegerRecursive<1>(const data_ptr_t &data, uint64_t &x) {
+	x ^= (uint64_t)data[0];
+}
+
+inline uint64_t HashOtherSize(const data_ptr_t &data, const idx_t &len) {
+	uint64_t x = 0;
+	switch (len & 7) {
+	case 7:
+		CreateIntegerRecursive<7>(data, x);
+		break;
+	case 6:
+		CreateIntegerRecursive<6>(data, x);
+		break;
+	case 5:
+		CreateIntegerRecursive<5>(data, x);
+		break;
+	case 4:
+		CreateIntegerRecursive<4>(data, x);
+		break;
+	case 3:
+		CreateIntegerRecursive<3>(data, x);
+		break;
+	case 2:
+		CreateIntegerRecursive<2>(data, x);
+		break;
+	case 1:
+		CreateIntegerRecursive<1>(data, x);
+		break;
+	case 0:
+		break;
+	}
+	return TemplatedHash<uint64_t>(x);
+}
+
+template <>
+inline uint64_t TemplatedHash(const string_t &elem) {
+	data_ptr_t data = (data_ptr_t)elem.GetDataUnsafe();
+	const auto &len = elem.GetSize();
+	uint64_t h = 0;
+	for (idx_t i = 0; i < len / 8; i += 8) {
+		h ^= TemplatedHash<uint64_t>(Load<uint64_t>(data));
+		data += 8;
+	}
+	switch (len & 7) {
+	case 4:
+		h ^= TemplatedHash<uint32_t>(Load<uint32_t>(data));
+		break;
+	case 2:
+		h ^= TemplatedHash<uint16_t>(Load<uint16_t>(data));
+		break;
+	case 1:
+		h ^= TemplatedHash<uint8_t>(Load<uint8_t>(data));
+		break;
+	default:
+		h ^= HashOtherSize(data, len);
+	}
+	return h;
+}
+
+template <class T>
+void TemplatedComputeHashes(VectorData &vdata, const idx_t &count, uint64_t hashes[]) {
+	T *data = (T *)vdata.data;
+	for (idx_t i = 0; i < count; i++) {
+		auto idx = vdata.sel->get_index(i);
+		if (vdata.validity.RowIsValid(idx)) {
+			hashes[i] = TemplatedHash<T>(data[idx]);
+		}
+	}
+}
+
+static void ComputeHashes(VectorData &vdata, const LogicalType &type, uint64_t hashes[], idx_t count) {
+	switch (type.InternalType()) {
+	case PhysicalType::BOOL:
+	case PhysicalType::INT8:
+	case PhysicalType::UINT8:
+		return TemplatedComputeHashes<uint8_t>(vdata, count, hashes);
+	case PhysicalType::INT16:
+	case PhysicalType::UINT16:
+		return TemplatedComputeHashes<uint16_t>(vdata, count, hashes);
+	case PhysicalType::INT32:
+	case PhysicalType::UINT32:
+	case PhysicalType::FLOAT:
+		return TemplatedComputeHashes<uint32_t>(vdata, count, hashes);
+	case PhysicalType::INT64:
+	case PhysicalType::UINT64:
+	case PhysicalType::DOUBLE:
+		return TemplatedComputeHashes<uint64_t>(vdata, count, hashes);
+	case PhysicalType::INT128:
+	case PhysicalType::INTERVAL:
+		static_assert(sizeof(hugeint_t) == sizeof(interval_t), "ComputeHashes assumes these are the same size!");
+		return TemplatedComputeHashes<hugeint_t>(vdata, count, hashes);
+	case PhysicalType::VARCHAR:
+		return TemplatedComputeHashes<string_t>(vdata, count, hashes);
+	default:
+		throw InternalException("Unimplemented type for HyperLogLog::ComputeHashes");
+	}
+}
+
+//! Taken from https://stackoverflow.com/a/72088344
+static inline uint8_t CountTrailingZeros(uint64_t &x) {
+	static constexpr const uint64_t DEBRUIJN = 0x03f79d71b4cb0a89;
+	static constexpr const uint8_t LOOKUP[] = {0,  47, 1,  56, 48, 27, 2,  60, 57, 49, 41, 37, 28, 16, 3,  61,
+	                                           54, 58, 35, 52, 50, 42, 21, 44, 38, 32, 29, 23, 17, 11, 4,  62,
+	                                           46, 55, 26, 59, 40, 36, 15, 53, 34, 51, 20, 43, 31, 22, 10, 45,
+	                                           25, 39, 14, 33, 19, 30, 9,  24, 13, 18, 8,  12, 7,  6,  5,  63};
+	return LOOKUP[(DEBRUIJN * (x ^ (x - 1))) >> 58];
+}
+
+static inline void ComputeIndexAndCount(uint64_t &hash, uint8_t &prefix) {
+	uint64_t index = hash & ((1 << 12) - 1); /* Register index. */
+	hash >>= 12;                             /* Remove bits used to address the register. */
+	hash |= ((uint64_t)1 << (64 - 12));      /* Make sure the count will be <= Q+1. */
+
+	prefix = CountTrailingZeros(hash) + 1; /* Add 1 since we count the "00000...1" pattern. */
+	hash = index;
+}
+
+void HyperLogLog::ProcessEntries(VectorData &vdata, const LogicalType &type, uint64_t hashes[], uint8_t counts[],
+                                 idx_t count) {
+	ComputeHashes(vdata, type, hashes, count);
+	for (idx_t i = 0; i < count; i++) {
+		ComputeIndexAndCount(hashes[i], counts[i]);
+	}
+}
+
+void HyperLogLog::AddToLogs(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[], HyperLogLog **logs[],
+                            const SelectionVector *log_sel) {
+	AddToLogsInternal(vdata, count, indices, counts, (void ****)logs, log_sel);
+}
+
+void HyperLogLog::AddToLog(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[]) {
+	lock_guard<mutex> guard(lock);
+	AddToSingleLogInternal(vdata, count, indices, counts, hll);
+}
+
 } // namespace duckdb
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -44318,6 +44557,7 @@ Value Value::Deserialize(Deserializer &main_source) {
 	auto is_null = reader.ReadRequired<bool>();
 	Value new_value = Value(type);
 	if (is_null) {
+		reader.Finalize();
 		return new_value;
 	}
 	new_value.is_null = false;
@@ -54344,7 +54584,7 @@ ART::ART(const vector<column_t> &column_ids, const vector<unique_ptr<Expression>
     : Index(IndexType::ART, column_ids, unbound_expressions, constraint_type) {
 	tree = nullptr;
 	expression_result.Initialize(logical_types);
-	is_little_endian = IsLittleEndian();
+	is_little_endian = Radix::IsLittleEndian();
 	for (idx_t i = 0; i < types.size(); i++) {
 		switch (types[i]) {
 		case PhysicalType::BOOL:
@@ -72978,11 +73218,11 @@ static bool CanUsePerfectHashAggregate(ClientContext &context, LogicalAggregate
 			switch (group_type.InternalType()) {
 			case PhysicalType::INT8:
 				stats = make_unique<NumericStatistics>(group_type, Value::MinimumValue(group_type),
-				                                       Value::MaximumValue(group_type));
+				                                       Value::MaximumValue(group_type), StatisticsType::LOCAL_STATS);
 				break;
 			case PhysicalType::INT16:
 				stats = make_unique<NumericStatistics>(group_type, Value::MinimumValue(group_type),
-				                                       Value::MaximumValue(group_type));
+				                                       Value::MaximumValue(group_type), StatisticsType::LOCAL_STATS);
 				break;
 			default:
 				// type is too large and there are no stats: skip perfect hashing
@@ -78255,7 +78495,7 @@ struct ApproxDistinctCountState {
 	HyperLogLog *log;
 };
 
-struct ApproxCountDistinctFunctionBase {
+struct ApproxCountDistinctFunction {
 	template <class STATE>
 	static void Initialize(STATE *state) {
 		state->log = nullptr;
@@ -78296,109 +78536,76 @@ struct ApproxCountDistinctFunctionBase {
 	}
 };
 
-struct ApproxCountDistinctFunction : ApproxCountDistinctFunctionBase {
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (!state->log) {
-			state->log = new HyperLogLog();
-		}
-		INPUT_TYPE value = input[idx];
-		state->log->Add((uint8_t *)&value, sizeof(value));
-	}
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input, mask, 0);
-		}
-	}
-};
+static void ApproxCountDistinctSimpleUpdateFunction(Vector inputs[], FunctionData *bind_data, idx_t input_count,
+                                                    data_ptr_t state, idx_t count) {
+	D_ASSERT(input_count == 1);
 
-struct ApproxCountDistinctFunctionString : ApproxCountDistinctFunctionBase {
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		if (!state->log) {
-			state->log = new HyperLogLog();
-		}
-		auto str = input[idx].GetDataUnsafe();
-		auto str_len = input[idx].GetSize();
-		auto str_hash = Hash(str, str_len);
-		state->log->Add((uint8_t *)&str_hash, sizeof(str_hash));
-	}
-	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, FunctionData *bind_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
-		for (idx_t i = 0; i < count; i++) {
-			Operation<INPUT_TYPE, STATE, OP>(state, bind_data, input, mask, 0);
-		}
+	auto agg_state = (ApproxDistinctCountState *)state;
+	if (!agg_state->log) {
+		agg_state->log = new HyperLogLog();
 	}
-};
 
-template <typename INPUT_TYPE, typename RESULT_TYPE>
-AggregateFunction GetApproxCountDistinctFunction(const LogicalType &input_type, const LogicalType &result_type) {
-	return AggregateFunction::UnaryAggregateDestructor<ApproxDistinctCountState, INPUT_TYPE, RESULT_TYPE,
-	                                                   ApproxCountDistinctFunction>(input_type, result_type);
+	VectorData vdata;
+	inputs[0].Orrify(count, vdata);
+
+	uint64_t indices[STANDARD_VECTOR_SIZE];
+	uint8_t counts[STANDARD_VECTOR_SIZE];
+
+	HyperLogLog::ProcessEntries(vdata, inputs[0].GetType(), indices, counts, count);
+	agg_state->log->AddToLog(vdata, count, indices, counts);
 }
 
-AggregateFunction GetApproxCountDistinctFunction(PhysicalType type) {
-	switch (type) {
-	case PhysicalType::UINT16:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxDistinctCountState, uint16_t, int64_t,
-		                                                   ApproxCountDistinctFunction>(LogicalType::UTINYINT,
-		                                                                                LogicalType::BIGINT);
-	case PhysicalType::UINT32:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxDistinctCountState, uint32_t, int64_t,
-		                                                   ApproxCountDistinctFunction>(LogicalType::UINTEGER,
-		                                                                                LogicalType::BIGINT);
-	case PhysicalType::UINT64:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxDistinctCountState, uint64_t, int64_t,
-		                                                   ApproxCountDistinctFunction>(LogicalType::UBIGINT,
-		                                                                                LogicalType::BIGINT);
-	case PhysicalType::INT16:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxDistinctCountState, int16_t, int64_t,
-		                                                   ApproxCountDistinctFunction>(LogicalType::TINYINT,
-		                                                                                LogicalType::BIGINT);
-	case PhysicalType::INT32:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxDistinctCountState, int32_t, int64_t,
-		                                                   ApproxCountDistinctFunction>(LogicalType::INTEGER,
-		                                                                                LogicalType::BIGINT);
-	case PhysicalType::INT64:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxDistinctCountState, int64_t, int64_t,
-		                                                   ApproxCountDistinctFunction>(LogicalType::BIGINT,
-		                                                                                LogicalType::BIGINT);
-	case PhysicalType::FLOAT:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxDistinctCountState, float, int64_t,
-		                                                   ApproxCountDistinctFunction>(LogicalType::FLOAT,
-		                                                                                LogicalType::BIGINT);
-	case PhysicalType::DOUBLE:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxDistinctCountState, double, int64_t,
-		                                                   ApproxCountDistinctFunction>(LogicalType::DOUBLE,
-		                                                                                LogicalType::BIGINT);
-	case PhysicalType::VARCHAR:
-		return AggregateFunction::UnaryAggregateDestructor<ApproxDistinctCountState, string_t, int64_t,
-		                                                   ApproxCountDistinctFunctionString>(LogicalType::VARCHAR,
-		                                                                                      LogicalType::BIGINT);
+static void ApproxCountDistinctUpdateFunction(Vector inputs[], FunctionData *bind_data, idx_t input_count,
+                                              Vector &state_vector, idx_t count) {
+	D_ASSERT(input_count == 1);
 
-	default:
-		throw InternalException("Unimplemented approximate_count aggregate");
+	VectorData sdata;
+	state_vector.Orrify(count, sdata);
+	auto states = (ApproxDistinctCountState **)sdata.data;
+
+	for (idx_t i = 0; i < count; i++) {
+		auto agg_state = states[sdata.sel->get_index(i)];
+		if (!agg_state->log) {
+			agg_state->log = new HyperLogLog();
+		}
 	}
+
+	VectorData vdata;
+	inputs[0].Orrify(count, vdata);
+
+	uint64_t indices[STANDARD_VECTOR_SIZE];
+	uint8_t counts[STANDARD_VECTOR_SIZE];
+
+	HyperLogLog::ProcessEntries(vdata, inputs[0].GetType(), indices, counts, count);
+	HyperLogLog::AddToLogs(vdata, count, indices, counts, (HyperLogLog ***)states, sdata.sel);
+}
+
+AggregateFunction GetApproxCountDistinctFunction(const LogicalType &input_type) {
+	return AggregateFunction(
+	    {input_type}, LogicalTypeId::BIGINT, AggregateFunction::StateSize<ApproxDistinctCountState>,
+	    AggregateFunction::StateInitialize<ApproxDistinctCountState, ApproxCountDistinctFunction>,
+	    ApproxCountDistinctUpdateFunction,
+	    AggregateFunction::StateCombine<ApproxDistinctCountState, ApproxCountDistinctFunction>,
+	    AggregateFunction::StateFinalize<ApproxDistinctCountState, int64_t, ApproxCountDistinctFunction>,
+	    ApproxCountDistinctSimpleUpdateFunction, nullptr,
+	    AggregateFunction::StateDestroy<ApproxDistinctCountState, ApproxCountDistinctFunction>);
 }
 
 void ApproxCountDistinctFun::RegisterFunction(BuiltinFunctions &set) {
 	AggregateFunctionSet approx_count("approx_count_distinct");
-	approx_count.AddFunction(GetApproxCountDistinctFunction(PhysicalType::UINT16));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(PhysicalType::UINT32));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(PhysicalType::UINT64));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(PhysicalType::FLOAT));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(PhysicalType::INT16));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(PhysicalType::INT32));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(PhysicalType::INT64));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(PhysicalType::DOUBLE));
-	approx_count.AddFunction(GetApproxCountDistinctFunction(PhysicalType::VARCHAR));
-	approx_count.AddFunction(
-	    GetApproxCountDistinctFunction<int64_t, int64_t>(LogicalType::TIMESTAMP, LogicalType::BIGINT));
-	approx_count.AddFunction(
-	    GetApproxCountDistinctFunction<int64_t, int64_t>(LogicalType::TIMESTAMP_TZ, LogicalType::BIGINT));
+	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::UTINYINT));
+	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::USMALLINT));
+	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::UINTEGER));
+	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::UBIGINT));
+	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::TINYINT));
+	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::SMALLINT));
+	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::BIGINT));
+	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::HUGEINT));
+	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::FLOAT));
+	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::DOUBLE));
+	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::VARCHAR));
+	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::TIMESTAMP));
+	approx_count.AddFunction(GetApproxCountDistinctFunction(LogicalType::TIMESTAMP_TZ));
 	set.AddFunction(approx_count);
 }
 
@@ -87498,7 +87705,8 @@ static unique_ptr<BaseStatistics> PropagateDatePartStatistics(vector<unique_ptr<
 	}
 	auto min_part = OP::template Operation<T, int64_t>(min);
 	auto max_part = OP::template Operation<T, int64_t>(max);
-	auto result = make_unique<NumericStatistics>(LogicalType::BIGINT, Value::BIGINT(min_part), Value::BIGINT(max_part));
+	auto result = make_unique<NumericStatistics>(LogicalType::BIGINT, Value::BIGINT(min_part), Value::BIGINT(max_part),
+	                                             StatisticsType::LOCAL_STATS);
 	if (child_stats[0]->validity_stats) {
 		result->validity_stats = child_stats[0]->validity_stats->Copy();
 	}
@@ -87509,7 +87717,8 @@ template <int64_t MIN, int64_t MAX>
 static unique_ptr<BaseStatistics> PropagateSimpleDatePartStatistics(vector<unique_ptr<BaseStatistics>> &child_stats) {
 	// we can always propagate simple date part statistics
 	// since the min and max can never exceed these bounds
-	auto result = make_unique<NumericStatistics>(LogicalType::BIGINT, Value::BIGINT(MIN), Value::BIGINT(MAX));
+	auto result = make_unique<NumericStatistics>(LogicalType::BIGINT, Value::BIGINT(MIN), Value::BIGINT(MAX),
+	                                             StatisticsType::LOCAL_STATS);
 	if (!child_stats[0]) {
 		// if there are no child stats, we don't know
 		result->validity_stats = make_unique<ValidityStatistics>(true);
@@ -96367,7 +96576,8 @@ static unique_ptr<BaseStatistics> PropagateNumericStats(ClientContext &context,
 		// no potential overflow: replace with non-overflowing operator
 		expr.function.function = GetScalarIntegerFunction<BASEOP>(expr.return_type.InternalType());
 	}
-	auto stats = make_unique<NumericStatistics>(expr.return_type, move(new_min), move(new_max));
+	auto stats =
+	    make_unique<NumericStatistics>(expr.return_type, move(new_min), move(new_max), StatisticsType::LOCAL_STATS);
 	stats->validity_stats = ValidityStatistics::Combine(lstats.validity_stats, rstats.validity_stats);
 	return move(stats);
 }
@@ -96672,7 +96882,8 @@ static unique_ptr<BaseStatistics> NegateBindStatistics(ClientContext &context, B
 		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));
+	auto stats =
+	    make_unique<NumericStatistics>(expr.return_type, move(new_min), move(new_max), StatisticsType::LOCAL_STATS);
 	if (istats.validity_stats) {
 		stats->validity_stats = istats.validity_stats->Copy();
 	}
@@ -135403,10 +135614,8 @@ static unique_ptr<BaseStatistics> StatisticsOperationsNumericNumericCast(const B
 		// overflow in cast: bailout
 		return nullptr;
 	}
-	auto stats = make_unique<NumericStatistics>(target, move(min), move(max));
-	if (input.validity_stats) {
-		stats->validity_stats = input.validity_stats->Copy();
-	}
+	auto stats = make_unique<NumericStatistics>(target, move(min), move(max), input.stats_type);
+	stats->CopyBase(*input_p);
 	return move(stats);
 }
 
@@ -135601,12 +135810,73 @@ unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundCompar
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/distinct_statistics.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
 
 
 
 
 
 namespace duckdb {
+class Serializer;
+class Deserializer;
+class Vector;
+
+class DistinctStatistics : public BaseStatistics {
+public:
+	DistinctStatistics();
+	explicit DistinctStatistics(unique_ptr<HyperLogLog> log, idx_t sample_count, idx_t total_count);
+
+	//! The HLL of the table
+	unique_ptr<HyperLogLog> log;
+	//! How many values have been sampled into the HLL
+	atomic<idx_t> sample_count;
+	//! How many values have been inserted (before sampling)
+	atomic<idx_t> total_count;
+
+public:
+	void Merge(const BaseStatistics &other) override;
+
+	unique_ptr<BaseStatistics> Copy() const override;
+
+	void Serialize(Serializer &serializer) const override;
+	void Serialize(FieldWriter &writer) const override;
+
+	static unique_ptr<DistinctStatistics> Deserialize(Deserializer &source);
+	static unique_ptr<DistinctStatistics> Deserialize(FieldReader &reader);
+
+	void Update(Vector &update, idx_t count);
+	void Update(VectorData &update_data, const LogicalType &ptype, idx_t count);
+
+	string ToString() const override;
+	idx_t GetCount() const;
+
+private:
+	//! For distinct statistics we sample the input to speed up insertions
+	static constexpr const double SAMPLE_RATE = 0.1;
+};
+
+} // namespace duckdb
+
+
+
+
+
+
+namespace duckdb {
+
+void UpdateDistinctStats(BaseStatistics &distinct_stats, const Value &input) {
+	Vector v(input);
+	auto &d_stats = (DistinctStatistics &)distinct_stats;
+	d_stats.Update(v, 1);
+}
 
 unique_ptr<BaseStatistics> StatisticsPropagator::StatisticsFromValue(const Value &input) {
 	switch (input.type().InternalType()) {
@@ -135622,13 +135892,15 @@ unique_ptr<BaseStatistics> StatisticsPropagator::StatisticsFromValue(const Value
 	case PhysicalType::INT128:
 	case PhysicalType::FLOAT:
 	case PhysicalType::DOUBLE: {
-		auto result = make_unique<NumericStatistics>(input.type(), input, input);
+		auto result = make_unique<NumericStatistics>(input.type(), input, input, StatisticsType::GLOBAL_STATS);
 		result->validity_stats = make_unique<ValidityStatistics>(input.IsNull(), !input.IsNull());
+		UpdateDistinctStats(*result->distinct_stats, input);
 		return move(result);
 	}
 	case PhysicalType::VARCHAR: {
-		auto result = make_unique<StringStatistics>(input.type());
+		auto result = make_unique<StringStatistics>(input.type(), StatisticsType::GLOBAL_STATS);
 		result->validity_stats = make_unique<ValidityStatistics>(input.IsNull(), !input.IsNull());
+		UpdateDistinctStats(*result->distinct_stats, input);
 		if (!input.IsNull()) {
 			auto &string_value = StringValue::Get(input);
 			result->Update(string_t(string_value));
@@ -151469,6 +151741,7 @@ unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &main_source) {
 	}
 	result->modifiers = move(modifiers);
 	result->cte_map = move(cte_map);
+	reader.Finalize();
 	return result;
 }
 
@@ -151514,6 +151787,7 @@ unique_ptr<ResultModifier> ResultModifier::Deserialize(Deserializer &source) {
 	default:
 		throw InternalException("Unrecognized ResultModifierType for Deserialization");
 	}
+	reader.Finalize();
 	return result;
 }
 
@@ -151649,6 +151923,7 @@ OrderByNode OrderByNode::Deserialize(Deserializer &source) {
 	auto type = reader.ReadRequired<OrderType>();
 	auto null_order = reader.ReadRequired<OrderByNullType>();
 	auto expression = reader.ReadRequiredSerializable<ParsedExpression>();
+	reader.Finalize();
 	return OrderByNode(type, null_order, move(expression));
 }
 
@@ -176309,7 +176584,7 @@ DataTable::DataTable(DatabaseInstance &db, const string &schema, const string &t
 
 		AppendRowGroup(0);
 		for (auto &type : types) {
-			column_stats.push_back(BaseStatistics::CreateEmpty(type));
+			column_stats.push_back(BaseStatistics::CreateEmpty(type, StatisticsType::GLOBAL_STATS));
 		}
 	} else {
 		D_ASSERT(column_stats.size() == types.size());
@@ -176339,7 +176614,7 @@ DataTable::DataTable(ClientContext &context, DataTable &parent, ColumnDefinition
 	for (idx_t i = 0; i < parent.column_stats.size(); i++) {
 		column_stats.push_back(parent.column_stats[i]->Copy());
 	}
-	column_stats.push_back(BaseStatistics::CreateEmpty(new_column_type));
+	column_stats.push_back(BaseStatistics::CreateEmpty(new_column_type, StatisticsType::GLOBAL_STATS));
 
 	// add the column definitions from this DataTable
 	column_definitions.emplace_back(new_column.Copy());
@@ -176448,7 +176723,8 @@ DataTable::DataTable(ClientContext &context, DataTable &parent, idx_t changed_id
 	// the column that had its type changed will have the new statistics computed during conversion
 	for (idx_t i = 0; i < column_definitions.size(); i++) {
 		if (i == changed_idx) {
-			column_stats.push_back(BaseStatistics::CreateEmpty(column_definitions[i].type));
+			column_stats.push_back(
+			    BaseStatistics::CreateEmpty(column_definitions[i].type, StatisticsType::GLOBAL_STATS));
 		} else {
 			column_stats.push_back(parent.column_stats[i]->Copy());
 		}
@@ -176965,6 +177241,13 @@ void DataTable::Append(Transaction &transaction, DataChunk &chunk, TableAppendSt
 		}
 	}
 	state.current_row += append_count;
+	for (idx_t col_idx = 0; col_idx < column_stats.size(); col_idx++) {
+		auto type = chunk.data[col_idx].GetType().InternalType();
+		if (type == PhysicalType::LIST || type == PhysicalType::STRUCT) {
+			continue;
+		}
+		column_stats[col_idx]->UpdateDistinctStatistics(chunk.data[col_idx], chunk.size());
+	}
 }
 
 void DataTable::ScanTableSegment(idx_t row_start, idx_t count, const std::function<void(DataChunk &chunk)> &function) {
@@ -177535,7 +177818,7 @@ BlockPointer DataTable::Checkpoint(TableDataWriter &writer) {
 	// FIXME: we might want to combine adjacent row groups in case they have had deletions...
 	vector<unique_ptr<BaseStatistics>> global_stats;
 	for (idx_t i = 0; i < column_definitions.size(); i++) {
-		global_stats.push_back(BaseStatistics::CreateEmpty(column_definitions[i].type));
+		global_stats.push_back(column_stats[i]->Copy());
 	}
 
 	auto row_group = (RowGroup *)row_groups->GetRootSegment();
@@ -178803,14 +179086,22 @@ void SingleFileBlockManager::WriteHeader(DatabaseHeader header) {
 
 
 
+
 namespace duckdb {
 
-BaseStatistics::BaseStatistics(LogicalType type) : type(move(type)) {
+BaseStatistics::BaseStatistics(LogicalType type, StatisticsType stats_type) : type(move(type)), stats_type(stats_type) {
 }
 
 BaseStatistics::~BaseStatistics() {
 }
 
+void BaseStatistics::InitializeBase() {
+	validity_stats = make_unique<ValidityStatistics>(false);
+	if (stats_type == GLOBAL_STATS) {
+		distinct_stats = make_unique<DistinctStatistics>();
+	}
+}
+
 bool BaseStatistics::CanHaveNull() const {
 	if (!validity_stats) {
 		// we don't know
@@ -178829,18 +179120,34 @@ bool BaseStatistics::CanHaveNoNull() const {
 	return ((ValidityStatistics &)*validity_stats).has_no_null;
 }
 
-void BaseStatistics::Merge(const BaseStatistics &other) {
-	D_ASSERT(type == other.type);
-	if (other.validity_stats) {
-		if (validity_stats) {
-			validity_stats->Merge(*other.validity_stats);
+void BaseStatistics::UpdateDistinctStatistics(Vector &v, idx_t count) {
+	if (!distinct_stats) {
+		return;
+	}
+	auto &d_stats = (DistinctStatistics &)*distinct_stats;
+	d_stats.Update(v, count);
+}
+
+void MergeInternal(unique_ptr<BaseStatistics> &orig, const unique_ptr<BaseStatistics> &other) {
+	if (other) {
+		if (orig) {
+			orig->Merge(*other);
 		} else {
-			validity_stats = other.validity_stats->Copy();
+			orig = other->Copy();
 		}
 	}
 }
 
-unique_ptr<BaseStatistics> BaseStatistics::CreateEmpty(LogicalType type) {
+void BaseStatistics::Merge(const BaseStatistics &other) {
+	D_ASSERT(type == other.type);
+	MergeInternal(validity_stats, other.validity_stats);
+	if (stats_type == GLOBAL_STATS) {
+		MergeInternal(distinct_stats, other.distinct_stats);
+	}
+}
+
+unique_ptr<BaseStatistics> BaseStatistics::CreateEmpty(LogicalType type, StatisticsType stats_type) {
+	unique_ptr<BaseStatistics> result;
 	switch (type.InternalType()) {
 	case PhysicalType::BIT:
 		return make_unique<ValidityStatistics>(false, false);
@@ -178856,34 +179163,49 @@ unique_ptr<BaseStatistics> BaseStatistics::CreateEmpty(LogicalType type) {
 	case PhysicalType::INT128:
 	case PhysicalType::FLOAT:
 	case PhysicalType::DOUBLE:
-		return make_unique<NumericStatistics>(move(type));
+		result = make_unique<NumericStatistics>(move(type), stats_type);
+		break;
 	case PhysicalType::VARCHAR:
-		return make_unique<StringStatistics>(move(type));
+		result = make_unique<StringStatistics>(move(type), stats_type);
+		break;
 	case PhysicalType::STRUCT:
-		return make_unique<StructStatistics>(move(type));
+		result = make_unique<StructStatistics>(move(type));
+		break;
 	case PhysicalType::LIST:
-		return make_unique<ListStatistics>(move(type));
+		result = make_unique<ListStatistics>(move(type));
+		break;
 	case PhysicalType::INTERVAL:
 	default:
-		auto base_stats = make_unique<BaseStatistics>(move(type));
-		base_stats->validity_stats = make_unique<ValidityStatistics>(false);
-		return base_stats;
+		result = make_unique<BaseStatistics>(move(type), stats_type);
 	}
+	result->InitializeBase();
+	return result;
 }
 
 unique_ptr<BaseStatistics> BaseStatistics::Copy() const {
-	auto statistics = make_unique<BaseStatistics>(type);
-	if (validity_stats) {
-		statistics->validity_stats = validity_stats->Copy();
+	auto result = make_unique<BaseStatistics>(type, stats_type);
+	result->CopyBase(*this);
+	return result;
+}
+
+void BaseStatistics::CopyBase(const BaseStatistics &orig) {
+	if (orig.validity_stats) {
+		validity_stats = orig.validity_stats->Copy();
+	}
+	if (orig.distinct_stats) {
+		distinct_stats = orig.distinct_stats->Copy();
 	}
-	return statistics;
 }
 
 void BaseStatistics::Serialize(Serializer &serializer) const {
 	FieldWriter writer(serializer);
-	writer.WriteField<bool>(CanHaveNull());
-	writer.WriteField<bool>(CanHaveNoNull());
+	ValidityStatistics(CanHaveNull(), CanHaveNoNull()).Serialize(writer);
 	Serialize(writer);
+	auto ptype = type.InternalType();
+	if (ptype != PhysicalType::BIT) {
+		writer.WriteField<StatisticsType>(stats_type);
+		writer.WriteOptional<BaseStatistics>(distinct_stats);
+	}
 	writer.Finalize();
 }
 
@@ -178892,12 +179214,13 @@ void BaseStatistics::Serialize(FieldWriter &writer) const {
 
 unique_ptr<BaseStatistics> BaseStatistics::Deserialize(Deserializer &source, LogicalType type) {
 	FieldReader reader(source);
-	bool can_have_null = reader.ReadRequired<bool>();
-	bool can_have_no_null = reader.ReadRequired<bool>();
+	auto validity_stats = ValidityStatistics::Deserialize(reader);
 	unique_ptr<BaseStatistics> result;
-	switch (type.InternalType()) {
+	auto ptype = type.InternalType();
+	switch (ptype) {
 	case PhysicalType::BIT:
-		return ValidityStatistics::Deserialize(reader);
+		result = ValidityStatistics::Deserialize(reader);
+		break;
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
 	case PhysicalType::INT16:
@@ -178922,17 +179245,25 @@ unique_ptr<BaseStatistics> BaseStatistics::Deserialize(Deserializer &source, Log
 		result = ListStatistics::Deserialize(reader, move(type));
 		break;
 	case PhysicalType::INTERVAL:
-		result = make_unique<BaseStatistics>(move(type));
+		result = make_unique<BaseStatistics>(move(type), StatisticsType::LOCAL_STATS);
 		break;
 	default:
 		throw InternalException("Unimplemented type for statistics deserialization");
 	}
-	result->validity_stats = make_unique<ValidityStatistics>(can_have_null, can_have_no_null);
+
+	if (ptype != PhysicalType::BIT) {
+		result->validity_stats = move(validity_stats);
+		result->stats_type = reader.ReadField<StatisticsType>(StatisticsType::LOCAL_STATS);
+		result->distinct_stats = reader.ReadOptional<DistinctStatistics>(nullptr);
+	}
+
+	reader.Finalize();
 	return result;
 }
 
 string BaseStatistics::ToString() const {
-	return StringUtil::Format("Base Statistics %s", validity_stats ? validity_stats->ToString() : "[]");
+	return StringUtil::Format("%s%s", validity_stats ? validity_stats->ToString() : "",
+	                          distinct_stats ? distinct_stats->ToString() : "");
 }
 
 void BaseStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
@@ -178953,14 +179284,104 @@ void BaseStatistics::Verify(Vector &vector, idx_t count) const {
 
 
 
+
 namespace duckdb {
 
-ListStatistics::ListStatistics(LogicalType type_p) : BaseStatistics(move(type_p)) {
-	D_ASSERT(type.InternalType() == PhysicalType::LIST);
+DistinctStatistics::DistinctStatistics()
+    : BaseStatistics(LogicalType::INVALID, StatisticsType::LOCAL_STATS), log(make_unique<HyperLogLog>()),
+      sample_count(0), total_count(0) {
+}
+
+DistinctStatistics::DistinctStatistics(unique_ptr<HyperLogLog> log, idx_t sample_count, idx_t total_count)
+    : BaseStatistics(LogicalType::INVALID, StatisticsType::LOCAL_STATS), log(move(log)), sample_count(sample_count),
+      total_count(total_count) {
+}
+
+unique_ptr<BaseStatistics> DistinctStatistics::Copy() const {
+	return make_unique<DistinctStatistics>(log->Copy(), sample_count, total_count);
+}
+
+void DistinctStatistics::Merge(const BaseStatistics &other_p) {
+	BaseStatistics::Merge(other_p);
+	auto &other = (const DistinctStatistics &)other_p;
+	log->Merge(*other.log);
+	sample_count += other.sample_count;
+	total_count += other.total_count;
+}
+
+void DistinctStatistics::Serialize(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	Serialize(writer);
+	writer.Finalize();
+}
+
+void DistinctStatistics::Serialize(FieldWriter &writer) const {
+	writer.WriteField<idx_t>(sample_count);
+	writer.WriteField<idx_t>(total_count);
+	log->Serialize(writer);
+}
+
+unique_ptr<DistinctStatistics> DistinctStatistics::Deserialize(Deserializer &source) {
+	FieldReader reader(source);
+	auto result = Deserialize(reader);
+	reader.Finalize();
+	return result;
+}
+
+unique_ptr<DistinctStatistics> DistinctStatistics::Deserialize(FieldReader &reader) {
+	auto sample_count = reader.ReadRequired<idx_t>();
+	auto total_count = reader.ReadRequired<idx_t>();
+	return make_unique<DistinctStatistics>(HyperLogLog::Deserialize(reader), sample_count, total_count);
+}
+
+void DistinctStatistics::Update(Vector &v, idx_t count) {
+	VectorData vdata;
+	v.Orrify(count, vdata);
+	Update(vdata, v.GetType(), count);
+}
+
+void DistinctStatistics::Update(VectorData &vdata, const LogicalType &type, idx_t count) {
+	if (count == 0) {
+		return;
+	}
+	total_count += count;
+	count = MaxValue<idx_t>(idx_t(SAMPLE_RATE * double(count)), 1);
+	sample_count += count;
+
+	uint64_t indices[STANDARD_VECTOR_SIZE];
+	uint8_t counts[STANDARD_VECTOR_SIZE];
+
+	HyperLogLog::ProcessEntries(vdata, type, indices, counts, count);
+	log->AddToLog(vdata, count, indices, counts);
+}
+
+string DistinctStatistics::ToString() const {
+	return StringUtil::Format("[Approx Unique: %s]", to_string(GetCount()));
+}
+
+idx_t DistinctStatistics::GetCount() const {
+	// Estimate HLL count because we use sampling
+	double hll_count = log->Count();
+	double unique_proportion = hll_count / double(sample_count);
+	double actual_sample_rate = double(sample_count) / double(total_count);
+	double multiplier = double(1) + unique_proportion * (double(1) / actual_sample_rate - double(1));
+	return idx_t(multiplier * hll_count);
+}
 
+} // namespace duckdb
+
+
+
+
+
+
+namespace duckdb {
+
+ListStatistics::ListStatistics(LogicalType type_p) : BaseStatistics(move(type_p), StatisticsType::LOCAL_STATS) {
+	D_ASSERT(type.InternalType() == PhysicalType::LIST);
+	InitializeBase();
 	auto &child_type = ListType::GetChildType(type);
-	child_stats = BaseStatistics::CreateEmpty(child_type);
-	validity_stats = make_unique<ValidityStatistics>(false);
+	child_stats = BaseStatistics::CreateEmpty(child_type, StatisticsType::LOCAL_STATS);
 }
 
 void ListStatistics::Merge(const BaseStatistics &other_p) {
@@ -178981,10 +179402,11 @@ FilterPropagateResult ListStatistics::CheckZonemap(ExpressionType comparison_typ
 // LCOV_EXCL_STOP
 
 unique_ptr<BaseStatistics> ListStatistics::Copy() const {
-	auto copy = make_unique<ListStatistics>(type);
-	copy->validity_stats = validity_stats ? validity_stats->Copy() : nullptr;
-	copy->child_stats = child_stats ? child_stats->Copy() : nullptr;
-	return move(copy);
+	auto result = make_unique<ListStatistics>(type);
+	result->CopyBase(*this);
+
+	result->child_stats = child_stats ? child_stats->Copy() : nullptr;
+	return move(result);
 }
 
 void ListStatistics::Serialize(FieldWriter &writer) const {
@@ -178995,18 +179417,12 @@ unique_ptr<BaseStatistics> ListStatistics::Deserialize(FieldReader &reader, Logi
 	D_ASSERT(type.InternalType() == PhysicalType::LIST);
 	auto result = make_unique<ListStatistics>(move(type));
 	auto &child_type = ListType::GetChildType(result->type);
-	auto &source = reader.GetSource();
-	result->child_stats = BaseStatistics::Deserialize(source, child_type);
+	result->child_stats = reader.ReadRequiredSerializable<BaseStatistics>(child_type);
 	return move(result);
 }
 
 string ListStatistics::ToString() const {
-	string result;
-	result += " [";
-	result += child_stats ? child_stats->ToString() : "No Stats";
-	result += "]";
-	result += validity_stats ? validity_stats->ToString() : "";
-	return result;
+	return StringUtil::Format("[%s]%s", child_stats ? child_stats->ToString() : "No Stats", BaseStatistics::ToString());
 }
 
 void ListStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
@@ -179052,6 +179468,7 @@ void ListStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t co
 
 
 
+
 namespace duckdb {
 
 template <>
@@ -179062,14 +179479,16 @@ template <>
 void NumericStatistics::Update<list_entry_t>(SegmentStatistics &stats, list_entry_t new_value) {
 }
 
-NumericStatistics::NumericStatistics(LogicalType type_p) : BaseStatistics(move(type_p)) {
+NumericStatistics::NumericStatistics(LogicalType type_p, StatisticsType stats_type)
+    : BaseStatistics(move(type_p), stats_type) {
+	InitializeBase();
 	min = Value::MaximumValue(type);
 	max = Value::MinimumValue(type);
-	validity_stats = make_unique<ValidityStatistics>(false);
 }
 
-NumericStatistics::NumericStatistics(LogicalType type_p, Value min_p, Value max_p)
-    : BaseStatistics(move(type_p)), min(move(min_p)), max(move(max_p)) {
+NumericStatistics::NumericStatistics(LogicalType type_p, Value min_p, Value max_p, StatisticsType stats_type)
+    : BaseStatistics(move(type_p), stats_type), min(move(min_p)), max(move(max_p)) {
+	InitializeBase();
 }
 
 void NumericStatistics::Merge(const BaseStatistics &other_p) {
@@ -179161,11 +179580,9 @@ FilterPropagateResult NumericStatistics::CheckZonemap(ExpressionType comparison_
 }
 
 unique_ptr<BaseStatistics> NumericStatistics::Copy() const {
-	auto stats = make_unique<NumericStatistics>(type, min, max);
-	if (validity_stats) {
-		stats->validity_stats = validity_stats->Copy();
-	}
-	return move(stats);
+	auto result = make_unique<NumericStatistics>(type, min, max, stats_type);
+	result->CopyBase(*this);
+	return move(result);
 }
 
 bool NumericStatistics::IsConstant() const {
@@ -179180,12 +179597,11 @@ void NumericStatistics::Serialize(FieldWriter &writer) const {
 unique_ptr<BaseStatistics> NumericStatistics::Deserialize(FieldReader &reader, LogicalType type) {
 	auto min = reader.ReadRequiredSerializable<Value, Value>();
 	auto max = reader.ReadRequiredSerializable<Value, Value>();
-	return make_unique_base<BaseStatistics, NumericStatistics>(move(type), min, max);
+	return make_unique_base<BaseStatistics, NumericStatistics>(move(type), min, max, StatisticsType::LOCAL_STATS);
 }
 
 string NumericStatistics::ToString() const {
-	return StringUtil::Format("[Min: %s, Max: %s]%s", min.ToString(), max.ToString(),
-	                          validity_stats ? validity_stats->ToString() : "");
+	return StringUtil::Format("[Min: %s, Max: %s]%s", min.ToString(), max.ToString(), BaseStatistics::ToString());
 }
 
 template <class T>
@@ -179260,8 +179676,6 @@ void NumericStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t
 
 
 
-
-
 namespace duckdb {
 
 SegmentStatistics::SegmentStatistics(LogicalType type) : type(move(type)) {
@@ -179276,8 +179690,7 @@ SegmentStatistics::SegmentStatistics(LogicalType type, unique_ptr<BaseStatistics
 }
 
 void SegmentStatistics::Reset() {
-	statistics = BaseStatistics::CreateEmpty(type);
-	statistics->validity_stats = make_unique<ValidityStatistics>(false);
+	statistics = BaseStatistics::CreateEmpty(type, StatisticsType::LOCAL_STATS);
 }
 
 } // namespace duckdb
@@ -179289,7 +179702,9 @@ void SegmentStatistics::Reset() {
 
 namespace duckdb {
 
-StringStatistics::StringStatistics(LogicalType type_p) : BaseStatistics(move(type_p)) {
+StringStatistics::StringStatistics(LogicalType type_p, StatisticsType stats_type)
+    : BaseStatistics(move(type_p), stats_type) {
+	InitializeBase();
 	for (idx_t i = 0; i < MAX_STRING_MINMAX_SIZE; i++) {
 		min[i] = 0xFF;
 		max[i] = 0;
@@ -179297,19 +179712,17 @@ StringStatistics::StringStatistics(LogicalType type_p) : BaseStatistics(move(typ
 	max_string_length = 0;
 	has_unicode = false;
 	has_overflow_strings = false;
-	validity_stats = make_unique<ValidityStatistics>(false);
 }
 
 unique_ptr<BaseStatistics> StringStatistics::Copy() const {
-	auto stats = make_unique<StringStatistics>(type);
-	memcpy(stats->min, min, MAX_STRING_MINMAX_SIZE);
-	memcpy(stats->max, max, MAX_STRING_MINMAX_SIZE);
-	stats->has_unicode = has_unicode;
-	stats->max_string_length = max_string_length;
-	if (validity_stats) {
-		stats->validity_stats = validity_stats->Copy();
-	}
-	return move(stats);
+	auto result = make_unique<StringStatistics>(type, stats_type);
+	result->CopyBase(*this);
+
+	memcpy(result->min, min, MAX_STRING_MINMAX_SIZE);
+	memcpy(result->max, max, MAX_STRING_MINMAX_SIZE);
+	result->has_unicode = has_unicode;
+	result->max_string_length = max_string_length;
+	return move(result);
 }
 
 void StringStatistics::Serialize(FieldWriter &writer) const {
@@ -179321,7 +179734,7 @@ void StringStatistics::Serialize(FieldWriter &writer) const {
 }
 
 unique_ptr<BaseStatistics> StringStatistics::Deserialize(FieldReader &reader, LogicalType type) {
-	auto stats = make_unique<StringStatistics>(move(type));
+	auto stats = make_unique<StringStatistics>(move(type), StatisticsType::LOCAL_STATS);
 	reader.ReadBlob(stats->min, MAX_STRING_MINMAX_SIZE);
 	reader.ReadBlob(stats->max, MAX_STRING_MINMAX_SIZE);
 	stats->has_unicode = reader.ReadRequired<bool>();
@@ -179449,8 +179862,7 @@ string StringStatistics::ToString() const {
 	idx_t max_len = GetValidMinMaxSubstring(max);
 	return StringUtil::Format("[Min: %s, Max: %s, Has Unicode: %s, Max String Length: %lld]%s",
 	                          string((const char *)min, min_len), string((const char *)max, max_len),
-	                          has_unicode ? "true" : "false", max_string_length,
-	                          validity_stats ? validity_stats->ToString() : "");
+	                          has_unicode ? "true" : "false", max_string_length, BaseStatistics::ToString());
 }
 
 void StringStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
@@ -179504,17 +179916,18 @@ void StringStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t
 
 
 
+
 namespace duckdb {
 
-StructStatistics::StructStatistics(LogicalType type_p) : BaseStatistics(move(type_p)) {
+StructStatistics::StructStatistics(LogicalType type_p) : BaseStatistics(move(type_p), StatisticsType::LOCAL_STATS) {
 	D_ASSERT(type.InternalType() == PhysicalType::STRUCT);
+	InitializeBase();
 
 	auto &child_types = StructType::GetChildTypes(type);
 	child_stats.resize(child_types.size());
 	for (idx_t i = 0; i < child_types.size(); i++) {
-		child_stats[i] = BaseStatistics::CreateEmpty(child_types[i].second);
+		child_stats[i] = BaseStatistics::CreateEmpty(child_types[i].second, StatisticsType::LOCAL_STATS);
 	}
-	validity_stats = make_unique<ValidityStatistics>(false);
 }
 
 void StructStatistics::Merge(const BaseStatistics &other_p) {
@@ -179538,14 +179951,13 @@ FilterPropagateResult StructStatistics::CheckZonemap(ExpressionType comparison_t
 // LCOV_EXCL_STOP
 
 unique_ptr<BaseStatistics> StructStatistics::Copy() const {
-	auto copy = make_unique<StructStatistics>(type);
-	if (validity_stats) {
-		copy->validity_stats = validity_stats->Copy();
-	}
+	auto result = make_unique<StructStatistics>(type);
+	result->CopyBase(*this);
+
 	for (idx_t i = 0; i < child_stats.size(); i++) {
-		copy->child_stats[i] = child_stats[i] ? child_stats[i]->Copy() : nullptr;
+		result->child_stats[i] = child_stats[i] ? child_stats[i]->Copy() : nullptr;
 	}
-	return move(copy);
+	return move(result);
 }
 
 void StructStatistics::Serialize(FieldWriter &writer) const {
@@ -179591,7 +180003,7 @@ string StructStatistics::ToString() const {
 		result += child_types[i].first + ": " + (child_stats[i] ? child_stats[i]->ToString() : "No Stats");
 	}
 	result += "}";
-	result += validity_stats ? validity_stats->ToString() : "";
+	result += BaseStatistics::ToString();
 	return result;
 }
 
@@ -179612,10 +180024,13 @@ void StructStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t
 
 
 
+
+
 namespace duckdb {
 
 ValidityStatistics::ValidityStatistics(bool has_null, bool has_no_null)
-    : BaseStatistics(LogicalType(LogicalTypeId::VALIDITY)), has_null(has_null), has_no_null(has_no_null) {
+    : BaseStatistics(LogicalType(LogicalTypeId::VALIDITY), StatisticsType::LOCAL_STATS), has_null(has_null),
+      has_no_null(has_no_null) {
 }
 
 unique_ptr<BaseStatistics> ValidityStatistics::Combine(const unique_ptr<BaseStatistics> &lstats,
@@ -179658,7 +180073,7 @@ void ValidityStatistics::Serialize(FieldWriter &writer) const {
 	writer.WriteField<bool>(has_no_null);
 }
 
-unique_ptr<BaseStatistics> ValidityStatistics::Deserialize(FieldReader &reader) {
+unique_ptr<ValidityStatistics> ValidityStatistics::Deserialize(FieldReader &reader) {
 	bool has_null = reader.ReadRequired<bool>();
 	bool has_no_null = reader.ReadRequired<bool>();
 	return make_unique<ValidityStatistics>(has_null, has_no_null);
@@ -179689,7 +180104,9 @@ void ValidityStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_
 }
 
 string ValidityStatistics::ToString() const {
-	return has_null ? "[Has Null: true]" : "[Has Null: false]";
+	auto has_n = has_null ? "true" : "false";
+	auto has_n_n = has_no_null ? "true" : "false";
+	return StringUtil::Format("[Has Null: %s, Has No Null: %s]", has_n, has_n_n);
 }
 
 } // namespace duckdb
@@ -180411,6 +180828,78 @@ void ColumnCheckpointState::FlushToDisk() {
 
 
 
+
+
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/table/struct_column_data.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+//! Struct column data represents a struct
+class StructColumnData : public ColumnData {
+public:
+	StructColumnData(DataTableInfo &info, idx_t column_index, idx_t start_row, LogicalType type,
+	                 ColumnData *parent = nullptr);
+
+	//! The sub-columns of the struct
+	vector<unique_ptr<ColumnData>> sub_columns;
+	//! The validity column data of the struct
+	ValidityColumnData validity;
+
+public:
+	bool CheckZonemap(ColumnScanState &state, TableFilter &filter) override;
+	idx_t GetMaxEntry() override;
+
+	void InitializeScan(ColumnScanState &state) override;
+	void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) override;
+
+	idx_t Scan(Transaction &transaction, idx_t vector_index, ColumnScanState &state, Vector &result) override;
+	idx_t ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates) override;
+	idx_t ScanCount(ColumnScanState &state, Vector &result, idx_t count) override;
+
+	void InitializeAppend(ColumnAppendState &state) override;
+	void Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count) override;
+	void RevertAppend(row_t start_row) override;
+	idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result) override;
+	void FetchRow(Transaction &transaction, ColumnFetchState &state, row_t row_id, Vector &result,
+	              idx_t result_idx) override;
+	void Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
+	            idx_t update_count) override;
+	void UpdateColumn(Transaction &transaction, const vector<column_t> &column_path, Vector &update_vector,
+	                  row_t *row_ids, idx_t update_count, idx_t depth) override;
+	unique_ptr<BaseStatistics> GetUpdateStatistics() override;
+
+	void CommitDropColumn() override;
+
+	unique_ptr<ColumnCheckpointState> CreateCheckpointState(RowGroup &row_group, TableDataWriter &writer) override;
+	unique_ptr<ColumnCheckpointState> Checkpoint(RowGroup &row_group, TableDataWriter &writer,
+	                                             ColumnCheckpointInfo &checkpoint_info) override;
+
+	void DeserializeColumn(Deserializer &source) override;
+
+	void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, vector<vector<Value>> &result) override;
+
+	void Verify(RowGroup &parent) override;
+};
+
+} // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -180521,77 +181010,6 @@ struct UpdateNode {
 } // namespace duckdb
 
 
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/table/struct_column_data.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! Struct column data represents a struct
-class StructColumnData : public ColumnData {
-public:
-	StructColumnData(DataTableInfo &info, idx_t column_index, idx_t start_row, LogicalType type,
-	                 ColumnData *parent = nullptr);
-
-	//! The sub-columns of the struct
-	vector<unique_ptr<ColumnData>> sub_columns;
-	//! The validity column data of the struct
-	ValidityColumnData validity;
-
-public:
-	bool CheckZonemap(ColumnScanState &state, TableFilter &filter) override;
-	idx_t GetMaxEntry() override;
-
-	void InitializeScan(ColumnScanState &state) override;
-	void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) override;
-
-	idx_t Scan(Transaction &transaction, idx_t vector_index, ColumnScanState &state, Vector &result) override;
-	idx_t ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates) override;
-	idx_t ScanCount(ColumnScanState &state, Vector &result, idx_t count) override;
-
-	void InitializeAppend(ColumnAppendState &state) override;
-	void Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count) override;
-	void RevertAppend(row_t start_row) override;
-	idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result) override;
-	void FetchRow(Transaction &transaction, ColumnFetchState &state, row_t row_id, Vector &result,
-	              idx_t result_idx) override;
-	void Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	            idx_t update_count) override;
-	void UpdateColumn(Transaction &transaction, const vector<column_t> &column_path, Vector &update_vector,
-	                  row_t *row_ids, idx_t update_count, idx_t depth) override;
-	unique_ptr<BaseStatistics> GetUpdateStatistics() override;
-
-	void CommitDropColumn() override;
-
-	unique_ptr<ColumnCheckpointState> CreateCheckpointState(RowGroup &row_group, TableDataWriter &writer) override;
-	unique_ptr<ColumnCheckpointState> Checkpoint(RowGroup &row_group, TableDataWriter &writer,
-	                                             ColumnCheckpointInfo &checkpoint_info) override;
-
-	void DeserializeColumn(Deserializer &source) override;
-
-	void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, vector<vector<Value>> &result) override;
-
-	void Verify(RowGroup &parent) override;
-};
-
-} // namespace duckdb
-
-
-
-
-
-
-
 namespace duckdb {
 
 ColumnData::ColumnData(DataTableInfo &info, idx_t column_index, idx_t start_row, LogicalType type, ColumnData *parent)
@@ -180940,7 +181358,7 @@ unique_ptr<ColumnCheckpointState> ColumnData::Checkpoint(RowGroup &row_group, Ta
 	// scan the segments of the column data
 	// set up the checkpoint state
 	auto checkpoint_state = CreateCheckpointState(row_group, writer);
-	checkpoint_state->global_stats = BaseStatistics::CreateEmpty(type);
+	checkpoint_state->global_stats = BaseStatistics::CreateEmpty(type, StatisticsType::LOCAL_STATS);
 
 	if (!data.root_node) {
 		// empty table: flush the empty list
@@ -182295,8 +182713,9 @@ unique_ptr<RowGroup> RowGroup::AddColumn(ClientContext &context, ColumnDefinitio
 
 	// construct a new column data for the new column
 	auto added_column = ColumnData::CreateColumn(GetTableInfo(), columns.size(), start, new_column.type);
+	auto added_col_stats = make_shared<SegmentStatistics>(
+	    new_column.type, BaseStatistics::CreateEmpty(new_column.type, StatisticsType::LOCAL_STATS));
 
-	auto added_col_stats = make_shared<SegmentStatistics>(new_column.type);
 	idx_t rows_to_write = this->count;
 	if (rows_to_write > 0) {
 		DataChunk dummy_chunk;
@@ -183204,7 +183623,7 @@ unique_ptr<BaseStatistics> StandardColumnData::GetUpdateStatistics() {
 		return nullptr;
 	}
 	if (!stats) {
-		stats = BaseStatistics::CreateEmpty(type);
+		stats = BaseStatistics::CreateEmpty(type, StatisticsType::GLOBAL_STATS);
 	}
 	stats->validity_stats = move(validity_stats);
 	return stats;
@@ -183470,7 +183889,7 @@ void StructColumnData::UpdateColumn(Transaction &transaction, const vector<colum
 
 unique_ptr<BaseStatistics> StructColumnData::GetUpdateStatistics() {
 	// check if any child column has updates
-	auto stats = BaseStatistics::CreateEmpty(type);
+	auto stats = BaseStatistics::CreateEmpty(type, StatisticsType::GLOBAL_STATS);
 	auto &struct_stats = (StructStatistics &)*stats;
 	stats->validity_stats = validity.GetUpdateStatistics();
 	for (idx_t i = 0; i < sub_columns.size(); i++) {
@@ -183578,6 +183997,13 @@ void StructColumnData::Verify(RowGroup &parent) {
 
 } // namespace duckdb
 
+
+
+
+
+
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -183642,11 +184068,6 @@ struct UpdateInfo {
 
 } // namespace duckdb
 
-
-
-
-
-
 namespace duckdb {
 
 static UpdateSegment::initialize_update_function_t GetInitializeUpdateFunction(PhysicalType type);
@@ -219918,6 +220339,9 @@ void StringAppendF(std::string* dst, const char* format, ...) {
 
 
 
+
+
+
 // LICENSE_CHANGE_BEGIN
 // The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #7
 // See the end of this file for a list
@@ -220380,7 +220804,7 @@ struct hllhdr {
 #define HLL_INVALIDATE_CACHE(hdr) (hdr)->card[7] |= (1<<7)
 #define HLL_VALID_CACHE(hdr) (((hdr)->card[7] & (1<<7)) == 0)
 
-#define HLL_P 14 /* The greater is P, the smaller the error. */
+#define HLL_P 12 /* The greater is P, the smaller the error. */
 #define HLL_Q (64-HLL_P) /* The number of bits of the hash value used for
                             determining the number of leading zeros. */
 #define HLL_REGISTERS (1<<HLL_P) /* With P=14, 16384 registers. */
@@ -220677,7 +221101,7 @@ int hllPatLen(unsigned char *ele, size_t elesize, long *regp) {
  * The function always succeed, however if as a result of the operation
  * the approximated cardinality changed, 1 is returned. Otherwise 0
  * is returned. */
-int hllDenseSet(uint8_t *registers, long index, uint8_t count) {
+static inline int hllDenseSet(uint8_t *registers, long index, uint8_t count) {
     uint8_t oldcount;
 
     HLL_DENSE_GET_REGISTER(oldcount,registers,index);
@@ -221417,8 +221841,51 @@ robj *hll_merge(robj **hlls, size_t hll_count) {
     }
 	return result;
 }
+
+uint64_t get_size() {
+	return HLL_DENSE_SIZE;
+}
+
+}
+
+namespace duckdb {
+
+static inline int AddToLog(void *log, const uint64_t &index, const uint8_t &count) {
+	auto o = (duckdb_hll::robj *)log;
+	duckdb_hll::hllhdr *hdr = (duckdb_hll::hllhdr *)o->ptr;
+	D_ASSERT(hdr->encoding == HLL_DENSE);
+	return duckdb_hll::hllDenseSet(hdr->registers + 1, index, count);
+}
+
+void AddToLogsInternal(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void ***logs[],
+                       const SelectionVector *log_sel) {
+	// 'logs' is an array of pointers to AggregateStates
+	// AggregateStates have a pointer to a HyperLogLog object
+	// HyperLogLog objects have a pointer to a 'robj', which we need
+	for (idx_t i = 0; i < count; i++) {
+		auto log = logs[log_sel->get_index(i)];
+		if (log && vdata.validity.RowIsValid(vdata.sel->get_index(i))) {
+			AddToLog(**log, indices[i], counts[i]);
+		}
+	}
+}
+
+void AddToSingleLogInternal(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void *log) {
+	const auto o = (duckdb_hll::robj *)log;
+	duckdb_hll::hllhdr *hdr = (duckdb_hll::hllhdr *)o->ptr;
+	D_ASSERT(hdr->encoding == HLL_DENSE);
+
+	const auto registers = hdr->registers + 1;
+	for (idx_t i = 0; i < count; i++) {
+		if (vdata.validity.RowIsValid(vdata.sel->get_index(i))) {
+			duckdb_hll::hllDenseSet(registers, indices[i], counts[i]);
+		}
+	}
 }
 
+} // namespace duckdb
+
+
 // LICENSE_CHANGE_END