duckdb 0.7.2-dev16.0 → 0.7.2-dev314.0

package/src/duckdb/src/planner/binder.cpp

@@ -3,8 +3,10 @@
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
 #include "duckdb/main/config.hpp"
+#include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/statement/list.hpp"
+#include "duckdb/parser/tableref/joinref.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/planner/bound_query_node.hpp"
 #include "duckdb/planner/bound_tableref.hpp"
@@ -13,7 +15,6 @@
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/operator/logical_sample.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
 
 #include <algorithm>
 
@@ -170,8 +171,12 @@ unique_ptr<BoundTableRef> Binder::Bind(TableRef &ref) {
 	case TableReferenceType::EXPRESSION_LIST:
 		result = Bind((ExpressionListRef &)ref);
 		break;
+	case TableReferenceType::PIVOT:
+		result = Bind((PivotRef &)ref);
+		break;
 	case TableReferenceType::CTE:
 	case TableReferenceType::INVALID:
+	default:
 		throw InternalException("Unknown table ref type");
 	}
 	result->sample = std::move(ref.sample);
@@ -203,6 +208,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableRef &ref) {
 		root = CreatePlan((BoundCTERef &)ref);
 		break;
 	case TableReferenceType::INVALID:
+	default:
 		throw InternalException("Unsupported bound table ref type");
 	}
 	// plan the sample clause

package/src/duckdb/src/planner/bound_result_modifier.cpp

@@ -19,7 +19,7 @@ BoundOrderByNode::BoundOrderByNode(OrderType type, OrderByNullType null_order, u
 
 BoundOrderByNode BoundOrderByNode::Copy() const {
 	if (stats) {
-		return BoundOrderByNode(type, null_order, expression->Copy(), stats->Copy());
+		return BoundOrderByNode(type, null_order, expression->Copy(), stats->ToUnique());
 	} else {
 		return BoundOrderByNode(type, null_order, expression->Copy());
 	}

package/src/duckdb/src/planner/expression/bound_window_expression.cpp

@@ -102,7 +102,7 @@ unique_ptr<Expression> BoundWindowExpression::Copy() {
 	}
 	for (auto &ps : partitions_stats) {
 		if (ps) {
-			new_window->partitions_stats.push_back(ps->Copy());
+			new_window->partitions_stats.push_back(ps->ToUnique());
 		} else {
 			new_window->partitions_stats.push_back(nullptr);
 		}

package/src/duckdb/src/planner/filter/constant_filter.cpp

@@ -1,8 +1,6 @@
 #include "duckdb/planner/filter/constant_filter.hpp"
-
+#include "duckdb/storage/statistics/base_statistics.hpp"
 #include "duckdb/common/field_writer.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
 
 namespace duckdb {
 
@@ -12,7 +10,7 @@ ConstantFilter::ConstantFilter(ExpressionType comparison_type_p, Value constant_
 }
 
 FilterPropagateResult ConstantFilter::CheckStatistics(BaseStatistics &stats) {
-	D_ASSERT(constant.type().id() == stats.type.id());
+	D_ASSERT(constant.type().id() == stats.GetType().id());
 	switch (constant.type().InternalType()) {
 	case PhysicalType::UINT8:
 	case PhysicalType::UINT16:
@@ -25,9 +23,9 @@ FilterPropagateResult ConstantFilter::CheckStatistics(BaseStatistics &stats) {
 	case PhysicalType::INT128:
 	case PhysicalType::FLOAT:
 	case PhysicalType::DOUBLE:
-		return ((NumericStatistics &)stats).CheckZonemap(comparison_type, constant);
+		return NumericStats::CheckZonemap(stats, comparison_type, constant);
 	case PhysicalType::VARCHAR:
-		return ((StringStatistics &)stats).CheckZonemap(comparison_type, StringValue::Get(constant));
+		return StringStats::CheckZonemap(stats, comparison_type, StringValue::Get(constant));
 	default:
 		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
 	}

package/src/duckdb/src/planner/pragma_handler.cpp

@@ -4,7 +4,7 @@
 
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp"
-
+#include "duckdb/parser/statement/multi_statement.hpp"
 #include "duckdb/parser/parsed_data/pragma_info.hpp"
 #include "duckdb/function/function.hpp"
 
@@ -22,6 +22,13 @@ PragmaHandler::PragmaHandler(ClientContext &context) : context(context) {
 void PragmaHandler::HandlePragmaStatementsInternal(vector<unique_ptr<SQLStatement>> &statements) {
 	vector<unique_ptr<SQLStatement>> new_statements;
 	for (idx_t i = 0; i < statements.size(); i++) {
+		if (statements[i]->type == StatementType::MULTI_STATEMENT) {
+			auto &multi_statement = (MultiStatement &)*statements[i];
+			for (auto &stmt : multi_statement.statements) {
+				statements.push_back(std::move(stmt));
+			}
+			continue;
+		}
 		if (statements[i]->type == StatementType::PRAGMA_STATEMENT) {
 			// PRAGMA statement: check if we need to replace it by a new set of statements
 			PragmaHandler handler(context);
@@ -47,7 +54,8 @@ void PragmaHandler::HandlePragmaStatements(ClientContextLock &lock, vector<uniqu
 	// first check if there are any pragma statements
 	bool found_pragma = false;
 	for (idx_t i = 0; i < statements.size(); i++) {
-		if (statements[i]->type == StatementType::PRAGMA_STATEMENT) {
+		if (statements[i]->type == StatementType::PRAGMA_STATEMENT ||
+		    statements[i]->type == StatementType::MULTI_STATEMENT) {
 			found_pragma = true;
 			break;
 		}

package/src/duckdb/src/storage/buffer_manager.cpp

@@ -7,6 +7,7 @@
 #include "duckdb/storage/in_memory_block_manager.hpp"
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/main/attached_database.hpp"
+#include "duckdb/main/database.hpp"
 
 namespace duckdb {
 
@@ -71,11 +72,11 @@ BlockHandle::~BlockHandle() { // NOLINT: allow internal exceptions
 		D_ASSERT(memory_charge.size > 0);
 		// the block is still loaded in memory: erase it
 		buffer.reset();
-		memory_charge.Resize(buffer_manager.current_memory, 0);
+		memory_charge.Resize(buffer_manager.buffer_pool.current_memory, 0);
 	} else {
 		D_ASSERT(memory_charge.size == 0);
 	}
-	buffer_manager.PurgeQueue();
+	buffer_manager.buffer_pool.PurgeQueue();
 	block_manager.UnregisterBlock(block_id, can_destroy);
 }
 
@@ -150,7 +151,7 @@ unique_ptr<FileBuffer> BlockHandle::UnloadAndTakeBlock() {
 		// temporary block that cannot be destroyed: write to temporary file
 		block_manager.buffer_manager.WriteTemporaryBuffer(block_id, *buffer);
 	}
-	memory_charge.Resize(block_manager.buffer_manager.current_memory, 0);
+	memory_charge.Resize(block_manager.buffer_manager.buffer_pool.current_memory, 0);
 	state = BlockState::BLOCK_UNLOADED;
 	return std::move(buffer);
 }
@@ -241,9 +242,14 @@ void BufferManager::SetTemporaryDirectory(string new_dir) {
 	this->temp_directory = std::move(new_dir);
 }
 
-BufferManager::BufferManager(DatabaseInstance &db, string tmp, idx_t maximum_memory)
-    : db(db), current_memory(0), maximum_memory(maximum_memory), temp_directory(std::move(tmp)),
-      queue(make_unique<EvictionQueue>()), temporary_id(MAXIMUM_BLOCK), queue_insertions(0),
+BufferPool::BufferPool(idx_t maximum_memory)
+    : current_memory(0), maximum_memory(maximum_memory), queue(make_unique<EvictionQueue>()), queue_insertions(0) {
+}
+BufferPool::~BufferPool() {
+}
+
+BufferManager::BufferManager(DatabaseInstance &db, string tmp)
+    : db(db), buffer_pool(db.GetBufferPool()), temp_directory(std::move(tmp)), temporary_id(MAXIMUM_BLOCK),
       buffer_allocator(BufferAllocatorAllocate, BufferAllocatorFree, BufferAllocatorRealloc,
                        make_unique<BufferAllocatorData>(*this)) {
 	temp_block_manager = make_unique<InMemoryBlockManager>(*this);
@@ -311,15 +317,15 @@ shared_ptr<BlockHandle> BlockManager::ConvertToPersistent(block_id_t block_id, s
 	// persist the new block to disk
 	Write(*new_block->buffer, block_id);
 
-	buffer_manager.AddToEvictionQueue(new_block);
+	buffer_manager.buffer_pool.AddToEvictionQueue(new_block);
 
 	return new_block;
 }
 
 template <typename... ARGS>
-TempBufferPoolReservation BufferManager::EvictBlocksOrThrow(idx_t memory_delta, idx_t limit,
-                                                            unique_ptr<FileBuffer> *buffer, ARGS... args) {
-	auto r = EvictBlocks(memory_delta, limit, buffer);
+TempBufferPoolReservation BufferManager::EvictBlocksOrThrow(idx_t memory_delta, unique_ptr<FileBuffer> *buffer,
+                                                            ARGS... args) {
+	auto r = buffer_pool.EvictBlocks(memory_delta, buffer_pool.maximum_memory, buffer);
 	if (!r.success) {
 		throw OutOfMemoryException(args..., InMemoryWarning());
 	}
@@ -328,9 +334,8 @@ TempBufferPoolReservation BufferManager::EvictBlocksOrThrow(idx_t memory_delta,
 
 shared_ptr<BlockHandle> BufferManager::RegisterSmallMemory(idx_t block_size) {
 	D_ASSERT(block_size < Storage::BLOCK_SIZE);
-	auto res = EvictBlocksOrThrow(block_size, maximum_memory, nullptr,
-	                              "could not allocate block of %lld bytes (%lld/%lld used) %s", block_size,
-	                              GetUsedMemory(), GetMaxMemory());
+	auto res = EvictBlocksOrThrow(block_size, nullptr, "could not allocate block of %lld bytes (%lld/%lld used) %s",
+	                              block_size, GetUsedMemory(), GetMaxMemory());
 
 	auto buffer = ConstructManagedBuffer(block_size, nullptr, FileBufferType::TINY_BUFFER);
 
@@ -344,9 +349,9 @@ shared_ptr<BlockHandle> BufferManager::RegisterMemory(idx_t block_size, bool can
 	auto alloc_size = GetAllocSize(block_size);
 	// first evict blocks until we have enough memory to store this buffer
 	unique_ptr<FileBuffer> reusable_buffer;
-	auto res = EvictBlocksOrThrow(alloc_size, maximum_memory, &reusable_buffer,
-	                              "could not allocate block of %lld bytes (%lld/%lld used) %s", alloc_size,
-	                              GetUsedMemory(), GetMaxMemory());
+	auto res =
+	    EvictBlocksOrThrow(alloc_size, &reusable_buffer, "could not allocate block of %lld bytes (%lld/%lld used) %s",
+	                       alloc_size, GetUsedMemory(), GetMaxMemory());
 
 	auto buffer = ConstructManagedBuffer(block_size, std::move(reusable_buffer));
 
@@ -376,14 +381,13 @@ void BufferManager::ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size
 		return;
 	} else if (memory_delta > 0) {
 		// evict blocks until we have space to resize this block
-		auto reservation =
-		    EvictBlocksOrThrow(memory_delta, maximum_memory, nullptr, "failed to resize block from %lld to %lld%s",
-		                       handle->memory_usage, req.alloc_size);
+		auto reservation = EvictBlocksOrThrow(memory_delta, nullptr, "failed to resize block from %lld to %lld%s",
+		                                      handle->memory_usage, req.alloc_size);
 		// EvictBlocks decrements 'current_memory' for us.
 		handle->memory_charge.Merge(std::move(reservation));
 	} else {
 		// no need to evict blocks, but we do need to decrement 'current_memory'.
-		handle->memory_charge.Resize(current_memory, req.alloc_size);
+		handle->memory_charge.Resize(buffer_pool.current_memory, req.alloc_size);
 	}
 
 	// resize and adjust current memory
@@ -407,15 +411,15 @@ BufferHandle BufferManager::Pin(shared_ptr<BlockHandle> &handle) {
 	}
 	// evict blocks until we have space for the current block
 	unique_ptr<FileBuffer> reusable_buffer;
-	auto reservation = EvictBlocksOrThrow(required_memory, maximum_memory, &reusable_buffer,
-	                                      "failed to pin block of size %lld%s", required_memory);
+	auto reservation =
+	    EvictBlocksOrThrow(required_memory, &reusable_buffer, "failed to pin block of size %lld%s", required_memory);
 	// lock the handle again and repeat the check (in case anybody loaded in the mean time)
 	lock_guard<mutex> lock(handle->lock);
 	// check if the block is already loaded
 	if (handle->state == BlockState::BLOCK_LOADED) {
 		// the block is loaded, increment the reader count and return a pointer to the handle
 		handle->readers++;
-		reservation.Resize(current_memory, 0);
+		reservation.Resize(buffer_pool.current_memory, 0);
 		return handle->Load(handle);
 	}
 	// now we can actually load the current block
@@ -428,13 +432,13 @@ BufferHandle BufferManager::Pin(shared_ptr<BlockHandle> &handle) {
 	if (delta) {
 		D_ASSERT(delta < 0);
 		handle->memory_usage += delta;
-		handle->memory_charge.Resize(current_memory, handle->memory_usage);
+		handle->memory_charge.Resize(buffer_pool.current_memory, handle->memory_usage);
 	}
 	D_ASSERT(handle->memory_usage == handle->buffer->AllocSize());
 	return buf;
 }
 
-void BufferManager::AddToEvictionQueue(shared_ptr<BlockHandle> &handle) {
+void BufferPool::AddToEvictionQueue(shared_ptr<BlockHandle> &handle) {
 	constexpr int INSERT_INTERVAL = 1024;
 
 	D_ASSERT(handle->readers == 0);
@@ -465,12 +469,12 @@ void BufferManager::Unpin(shared_ptr<BlockHandle> &handle) {
 	handle->readers--;
 	if (handle->readers == 0) {
 		VerifyZeroReaders(handle);
-		AddToEvictionQueue(handle);
+		buffer_pool.AddToEvictionQueue(handle);
 	}
 }
 
-BufferManager::EvictionResult BufferManager::EvictBlocks(idx_t extra_memory, idx_t memory_limit,
-                                                         unique_ptr<FileBuffer> *buffer) {
+BufferPool::EvictionResult BufferPool::EvictBlocks(idx_t extra_memory, idx_t memory_limit,
+                                                   unique_ptr<FileBuffer> *buffer) {
 	BufferEvictionNode node;
 	TempBufferPoolReservation r(current_memory, extra_memory);
 	while (current_memory > memory_limit) {
@@ -504,7 +508,7 @@ BufferManager::EvictionResult BufferManager::EvictBlocks(idx_t extra_memory, idx
 	return {true, std::move(r)};
 }
 
-void BufferManager::PurgeQueue() {
+void BufferPool::PurgeQueue() {
 	BufferEvictionNode node;
 	while (true) {
 		if (!queue->q.try_dequeue(node)) {
@@ -531,13 +535,13 @@ void BlockManager::UnregisterBlock(block_id_t block_id, bool can_destroy) {
 	}
 }
 
-void BufferManager::SetLimit(idx_t limit) {
+void BufferPool::SetLimit(idx_t limit, const char *exception_postscript) {
 	lock_guard<mutex> l_lock(limit_lock);
 	// try to evict until the limit is reached
 	if (!EvictBlocks(0, limit).success) {
 		throw OutOfMemoryException(
 		    "Failed to change memory limit to %lld: could not free up enough memory for the new limit%s", limit,
-		    InMemoryWarning());
+		    exception_postscript);
 	}
 	idx_t old_limit = maximum_memory;
 	// set the global maximum memory to the new limit if successful
@@ -548,20 +552,16 @@ void BufferManager::SetLimit(idx_t limit) {
 		maximum_memory = old_limit;
 		throw OutOfMemoryException(
 		    "Failed to change memory limit to %lld: could not free up enough memory for the new limit%s", limit,
-		    InMemoryWarning());
+		    exception_postscript);
 	}
 }
 
 void BufferManager::IncreaseUsedMemory(idx_t size) {
-	if (current_memory + size > maximum_memory) {
-		throw OutOfMemoryException("Failed to allocate data of size %lld%s", size, InMemoryWarning());
-	}
-	current_memory += size;
+	ReserveMemory(size);
 }
 
 void BufferManager::DecreaseUsedMemory(idx_t size) {
-	D_ASSERT(current_memory >= size);
-	current_memory -= size;
+	FreeReservedMemory(size);
 }
 
 //===--------------------------------------------------------------------===//
@@ -1044,7 +1044,7 @@ vector<TemporaryFileInformation> BufferManager::GetTemporaryFiles() {
 	return result;
 }
 
-string BufferManager::InMemoryWarning() {
+const char *BufferManager::InMemoryWarning() {
 	if (!temp_directory.empty()) {
 		return "";
 	}
@@ -1058,8 +1058,7 @@ void BufferManager::ReserveMemory(idx_t size) {
 	if (size == 0) {
 		return;
 	}
-	auto reservation =
-	    EvictBlocksOrThrow(size, maximum_memory, nullptr, "failed to reserve memory data of size %lld%s", size);
+	auto reservation = EvictBlocksOrThrow(size, nullptr, "failed to reserve memory data of size %lld%s", size);
 	reservation.size = 0;
 }
 
@@ -1067,7 +1066,7 @@ void BufferManager::FreeReservedMemory(idx_t size) {
 	if (size == 0) {
 		return;
 	}
-	current_memory -= size;
+	buffer_pool.current_memory -= size;
 }
 
 //===--------------------------------------------------------------------===//
@@ -1075,8 +1074,7 @@ void BufferManager::FreeReservedMemory(idx_t size) {
 //===--------------------------------------------------------------------===//
 data_ptr_t BufferManager::BufferAllocatorAllocate(PrivateAllocatorData *private_data, idx_t size) {
 	auto &data = (BufferAllocatorData &)*private_data;
-	auto reservation = data.manager.EvictBlocksOrThrow(size, data.manager.maximum_memory, nullptr,
-	                                                   "failed to allocate data of size %lld%s", size);
+	auto reservation = data.manager.EvictBlocksOrThrow(size, nullptr, "failed to allocate data of size %lld%s", size);
 	// We rely on manual tracking of this one. :(
 	reservation.size = 0;
 	return Allocator::Get(data.manager.db).AllocateData(size);
@@ -1086,7 +1084,7 @@ void BufferManager::BufferAllocatorFree(PrivateAllocatorData *private_data, data
 	auto &data = (BufferAllocatorData &)*private_data;
 	BufferPoolReservation r;
 	r.size = size;
-	r.Resize(data.manager.current_memory, 0);
+	r.Resize(data.manager.buffer_pool.current_memory, 0);
 	return Allocator::Get(data.manager.db).FreeData(pointer, size);
 }
 
@@ -1098,7 +1096,7 @@ data_ptr_t BufferManager::BufferAllocatorRealloc(PrivateAllocatorData *private_d
 	auto &data = (BufferAllocatorData &)*private_data;
 	BufferPoolReservation r;
 	r.size = old_size;
-	r.Resize(data.manager.current_memory, size);
+	r.Resize(data.manager.buffer_pool.current_memory, size);
 	r.size = 0;
 	return Allocator::Get(data.manager.db).ReallocateData(pointer, old_size, size);
 }

package/src/duckdb/src/storage/checkpoint/row_group_writer.cpp

@@ -32,7 +32,7 @@ void SingleFileRowGroupWriter::WriteColumnDataPointers(ColumnCheckpointState &co
 		meta_writer.Write<block_id_t>(data_pointer.block_pointer.block_id);
 		meta_writer.Write<uint32_t>(data_pointer.block_pointer.offset);
 		meta_writer.Write<CompressionType>(data_pointer.compression_type);
-		data_pointer.statistics->Serialize(meta_writer);
+		data_pointer.statistics.Serialize(meta_writer);
 	}
 }
 

package/src/duckdb/src/storage/checkpoint/table_data_reader.cpp

@@ -24,10 +24,7 @@ void TableDataReader::ReadTableData() {
 	D_ASSERT(!columns.empty());
 
 	// deserialize the total table statistics
-	info.data->column_stats.reserve(columns.PhysicalColumnCount());
-	for (auto &col : columns.Physical()) {
-		info.data->column_stats.push_back(BaseStatistics::Deserialize(reader, col.Type()));
-	}
+	info.data->table_stats.Deserialize(reader, columns);
 
 	// deserialize each of the individual row groups
 	auto row_group_count = reader.Read<uint64_t>();

package/src/duckdb/src/storage/checkpoint/table_data_writer.cpp

@@ -5,6 +5,7 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/serializer/buffered_serializer.hpp"
 #include "duckdb/storage/table/column_checkpoint_state.hpp"
+#include "duckdb/storage/table/table_statistics.hpp"
 
 namespace duckdb {
 
@@ -40,14 +41,13 @@ unique_ptr<RowGroupWriter> SingleFileTableDataWriter::GetRowGroupWriter(RowGroup
 	return make_unique<SingleFileRowGroupWriter>(table, checkpoint_manager.partial_block_manager, table_data_writer);
 }
 
-void SingleFileTableDataWriter::FinalizeTable(vector<unique_ptr<BaseStatistics>> &&global_stats, DataTableInfo *info) {
+void SingleFileTableDataWriter::FinalizeTable(TableStatistics &&global_stats, DataTableInfo *info) {
 	// store the current position in the metadata writer
 	// this is where the row groups for this table start
 	auto pointer = table_data_writer.GetBlockPointer();
 
-	for (auto &stats : global_stats) {
-		stats->Serialize(table_data_writer);
-	}
+	global_stats.Serialize(table_data_writer);
+
 	// now start writing the row group pointers to disk
 	table_data_writer.Write<uint64_t>(row_group_pointers.size());
 	for (auto &row_group_pointer : row_group_pointers) {

package/src/duckdb/src/storage/compression/bitpacking.cpp

@@ -6,7 +6,7 @@
 #include "duckdb/function/compression_function.hpp"
 #include "duckdb/main/config.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
+
 #include "duckdb/storage/table/column_data_checkpointer.hpp"
 #include "duckdb/storage/table/column_segment.hpp"
 #include "duckdb/common/operator/subtract.hpp"
@@ -347,7 +347,7 @@ idx_t BitpackingFinalAnalyze(AnalyzeState &state) {
 //===--------------------------------------------------------------------===//
 // Compress
 //===--------------------------------------------------------------------===//
-template <class T, class T_S = typename std::make_signed<T>::type>
+template <class T, bool WRITE_STATISTICS, class T_S = typename std::make_signed<T>::type>
 struct BitpackingCompressState : public CompressionState {
 public:
 	explicit BitpackingCompressState(ColumnDataCheckpointer &checkpointer) : checkpointer(checkpointer) {
@@ -377,7 +377,7 @@ public:
 public:
 	struct BitpackingWriter {
 		static void WriteConstant(T constant, idx_t count, void *data_ptr, bool all_invalid) {
-			auto state = (BitpackingCompressState<T> *)data_ptr;
+			auto state = (BitpackingCompressState<T, WRITE_STATISTICS> *)data_ptr;
 
 			ReserveSpace(state, sizeof(T));
 			WriteMetaData(state, BitpackingMode::CONSTANT);
@@ -388,7 +388,7 @@ public:
 
 		static void WriteConstantDelta(T_S constant, T frame_of_reference, idx_t count, T *values, bool *validity,
 		                               void *data_ptr) {
-			auto state = (BitpackingCompressState<T> *)data_ptr;
+			auto state = (BitpackingCompressState<T, WRITE_STATISTICS> *)data_ptr;
 
 			ReserveSpace(state, 2 * sizeof(T));
 			WriteMetaData(state, BitpackingMode::CONSTANT_DELTA);
@@ -400,7 +400,7 @@ public:
 
 		static void WriteDeltaFor(T *values, bool *validity, bitpacking_width_t width, T frame_of_reference,
 		                          T_S delta_offset, T *original_values, idx_t count, void *data_ptr) {
-			auto state = (BitpackingCompressState<T> *)data_ptr;
+			auto state = (BitpackingCompressState<T, WRITE_STATISTICS> *)data_ptr;
 
 			auto bp_size = BitpackingPrimitives::GetRequiredSize(count, width);
 			ReserveSpace(state, bp_size + 3 * sizeof(T));
@@ -418,7 +418,7 @@ public:
 
 		static void WriteFor(T *values, bool *validity, bitpacking_width_t width, T frame_of_reference, idx_t count,
 		                     void *data_ptr) {
-			auto state = (BitpackingCompressState<T> *)data_ptr;
+			auto state = (BitpackingCompressState<T, WRITE_STATISTICS> *)data_ptr;
 
 			auto bp_size = BitpackingPrimitives::GetRequiredSize(count, width);
 			ReserveSpace(state, bp_size + 2 * sizeof(T));
@@ -439,24 +439,24 @@ public:
 			ptr += sizeof(T_OUT);
 		}
 
-		static void WriteMetaData(BitpackingCompressState<T> *state, BitpackingMode mode) {
+		static void WriteMetaData(BitpackingCompressState<T, WRITE_STATISTICS> *state, BitpackingMode mode) {
 			bitpacking_metadata_t metadata {mode, (uint32_t)(state->data_ptr - state->handle.Ptr())};
 			state->metadata_ptr -= sizeof(bitpacking_metadata_encoded_t);
 			Store<bitpacking_metadata_encoded_t>(EncodeMeta(metadata), state->metadata_ptr);
 		}
 
-		static void ReserveSpace(BitpackingCompressState<T> *state, idx_t data_bytes) {
+		static void ReserveSpace(BitpackingCompressState<T, WRITE_STATISTICS> *state, idx_t data_bytes) {
 			idx_t meta_bytes = sizeof(bitpacking_metadata_encoded_t);
 			state->FlushAndCreateSegmentIfFull(data_bytes, meta_bytes);
 			D_ASSERT(state->CanStore(data_bytes, meta_bytes));
 		}
 
-		static void UpdateStats(BitpackingCompressState<T> *state, idx_t count) {
+		static void UpdateStats(BitpackingCompressState<T, WRITE_STATISTICS> *state, idx_t count) {
 			state->current_segment->count += count;
 
-			if (!state->state.all_invalid) {
-				NumericStatistics::Update<T>(state->current_segment->stats, state->state.minimum);
-				NumericStatistics::Update<T>(state->current_segment->stats, state->state.maximum);
+			if (WRITE_STATISTICS && !state->state.all_invalid) {
+				NumericStats::Update<T>(state->current_segment->stats.statistics, state->state.minimum);
+				NumericStats::Update<T>(state->current_segment->stats.statistics, state->state.maximum);
 			}
 		}
 	};
@@ -487,8 +487,8 @@ public:
 
 		for (idx_t i = 0; i < count; i++) {
 			auto idx = vdata.sel->get_index(i);
-			state.template Update<BitpackingCompressState<T, T_S>::BitpackingWriter>(data[idx],
-			                                                                         vdata.validity.RowIsValid(idx));
+			state.template Update<BitpackingCompressState<T, WRITE_STATISTICS, T_S>::BitpackingWriter>(
+			    data[idx], vdata.validity.RowIsValid(idx));
 		}
 	}
 
@@ -524,29 +524,29 @@ public:
 	}
 
 	void Finalize() {
-		state.template Flush<BitpackingCompressState<T, T_S>::BitpackingWriter>();
+		state.template Flush<BitpackingCompressState<T, WRITE_STATISTICS, T_S>::BitpackingWriter>();
 		FlushSegment();
 		current_segment.reset();
 	}
 };
 
-template <class T>
+template <class T, bool WRITE_STATISTICS>
 unique_ptr<CompressionState> BitpackingInitCompression(ColumnDataCheckpointer &checkpointer,
                                                        unique_ptr<AnalyzeState> state) {
-	return make_unique<BitpackingCompressState<T>>(checkpointer);
+	return make_unique<BitpackingCompressState<T, WRITE_STATISTICS>>(checkpointer);
 }
 
-template <class T>
+template <class T, bool WRITE_STATISTICS>
 void BitpackingCompress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
-	auto &state = (BitpackingCompressState<T> &)state_p;
+	auto &state = (BitpackingCompressState<T, WRITE_STATISTICS> &)state_p;
 	UnifiedVectorFormat vdata;
 	scan_vector.ToUnifiedFormat(count, vdata);
 	state.Append(vdata, count);
 }
 
-template <class T>
+template <class T, bool WRITE_STATISTICS>
 void BitpackingFinalizeCompress(CompressionState &state_p) {
-	auto &state = (BitpackingCompressState<T> &)state_p;
+	auto &state = (BitpackingCompressState<T, WRITE_STATISTICS> &)state_p;
 	state.Finalize();
 }
 
@@ -880,11 +880,12 @@ void BitpackingSkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_c
 //===--------------------------------------------------------------------===//
 // Get Function
 //===--------------------------------------------------------------------===//
-template <class T>
+template <class T, bool WRITE_STATISTICS = true>
 CompressionFunction GetBitpackingFunction(PhysicalType data_type) {
 	return CompressionFunction(CompressionType::COMPRESSION_BITPACKING, data_type, BitpackingInitAnalyze<T>,
-	                           BitpackingAnalyze<T>, BitpackingFinalAnalyze<T>, BitpackingInitCompression<T>,
-	                           BitpackingCompress<T>, BitpackingFinalizeCompress<T>, BitpackingInitScan<T>,
+	                           BitpackingAnalyze<T>, BitpackingFinalAnalyze<T>,
+	                           BitpackingInitCompression<T, WRITE_STATISTICS>, BitpackingCompress<T, WRITE_STATISTICS>,
+	                           BitpackingFinalizeCompress<T, WRITE_STATISTICS>, BitpackingInitScan<T>,
 	                           BitpackingScan<T>, BitpackingScanPartial<T>, BitpackingFetchRow<T>, BitpackingSkip<T>);
 }
 
@@ -907,6 +908,8 @@ CompressionFunction BitpackingFun::GetFunction(PhysicalType type) {
 		return GetBitpackingFunction<uint32_t>(type);
 	case PhysicalType::UINT64:
 		return GetBitpackingFunction<uint64_t>(type);
+	case PhysicalType::LIST:
+		return GetBitpackingFunction<uint64_t, false>(type);
 	default:
 		throw InternalException("Unsupported type for Bitpacking");
 	}
@@ -923,6 +926,7 @@ bool BitpackingFun::TypeIsSupported(PhysicalType type) {
 	case PhysicalType::UINT16:
 	case PhysicalType::UINT32:
 	case PhysicalType::UINT64:
+	case PhysicalType::LIST:
 		return true;
 	default:
 		return false;