duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

package/src/duckdb/src/storage/arena_allocator.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/storage/arena_allocator.hpp"
+
 #include "duckdb/common/assert.hpp"
 
 namespace duckdb {
@@ -9,9 +10,9 @@ ArenaChunk::ArenaChunk(Allocator &allocator, idx_t size) : current_position(0),
 }
 ArenaChunk::~ArenaChunk() {
 	if (next) {
-		auto current_next = move(next);
+		auto current_next = std::move(next);
 		while (current_next) {
-			current_next = move(current_next->next);
+			current_next = std::move(current_next->next);
 		}
 	}
 }
@@ -34,11 +35,11 @@ data_ptr_t ArenaAllocator::Allocate(idx_t len) {
 		auto new_chunk = make_unique<ArenaChunk>(allocator, current_capacity);
 		if (head) {
 			head->prev = new_chunk.get();
-			new_chunk->next = move(head);
+			new_chunk->next = std::move(head);
 		} else {
 			tail = new_chunk.get();
 		}
-		head = move(new_chunk);
+		head = std::move(new_chunk);
 	}
 	D_ASSERT(head->current_position + len <= head->maximum_size);
 	auto result = head->data.get() + head->current_position;
@@ -46,14 +47,43 @@ data_ptr_t ArenaAllocator::Allocate(idx_t len) {
 	return result;
 }
 
+data_ptr_t ArenaAllocator::Reallocate(data_ptr_t pointer, idx_t old_size, idx_t size) {
+	D_ASSERT(head);
+	if (old_size == size) {
+		// nothing to do
+		return pointer;
+	}
+
+	auto head_ptr = head->data.get() + head->current_position;
+	int64_t diff = size - old_size;
+	if (pointer == head_ptr && (size < old_size || head->current_position + diff <= head->maximum_size)) {
+		// passed pointer is the head pointer, and the diff fits on the current chunk
+		head->current_position += diff;
+		return pointer;
+	} else {
+		// allocate new memory
+		auto result = Allocate(size);
+		memcpy(result, pointer, old_size);
+		return result;
+	}
+}
+
+data_ptr_t ArenaAllocator::AllocateAligned(idx_t size) {
+	return Allocate(AlignValue<idx_t>(size));
+}
+
+data_ptr_t ArenaAllocator::ReallocateAligned(data_ptr_t pointer, idx_t old_size, idx_t size) {
+	return Reallocate(pointer, old_size, AlignValue<idx_t>(size));
+}
+
 void ArenaAllocator::Reset() {
 
 	if (head) {
 		// destroy all chunks except the current one
 		if (head->next) {
-			auto current_next = move(head->next);
+			auto current_next = std::move(head->next);
 			while (current_next) {
-				current_next = move(current_next->next);
+				current_next = std::move(current_next->next);
 			}
 		}
 		tail = head.get();
@@ -73,7 +103,7 @@ void ArenaAllocator::Destroy() {
 void ArenaAllocator::Move(ArenaAllocator &other) {
 	D_ASSERT(!other.head);
 	other.tail = tail;
-	other.head = move(head);
+	other.head = std::move(head);
 	other.current_capacity = current_capacity;
 	Destroy();
 }

package/src/duckdb/src/storage/block.cpp

@@ -9,11 +9,11 @@ Block::Block(Allocator &allocator, block_id_t id)
 
 Block::Block(Allocator &allocator, block_id_t id, uint32_t internal_size)
     : FileBuffer(allocator, FileBufferType::BLOCK, internal_size), id(id) {
-	D_ASSERT((GetMallocedSize() & (Storage::SECTOR_SIZE - 1)) == 0);
+	D_ASSERT((AllocSize() & (Storage::SECTOR_SIZE - 1)) == 0);
 }
 
 Block::Block(FileBuffer &source, block_id_t id) : FileBuffer(source, FileBufferType::BLOCK), id(id) {
-	D_ASSERT((GetMallocedSize() & (Storage::SECTOR_SIZE - 1)) == 0);
+	D_ASSERT((AllocSize() & (Storage::SECTOR_SIZE - 1)) == 0);
 }
 
 } // namespace duckdb

package/src/duckdb/src/storage/buffer/buffer_handle.cpp

@@ -6,7 +6,7 @@ namespace duckdb {
 BufferHandle::BufferHandle() : handle(nullptr), node(nullptr) {
 }
 
-BufferHandle::BufferHandle(shared_ptr<BlockHandle> handle, FileBuffer *node) : handle(move(handle)), node(node) {
+BufferHandle::BufferHandle(shared_ptr<BlockHandle> handle, FileBuffer *node) : handle(std::move(handle)), node(node) {
 }
 
 BufferHandle::BufferHandle(BufferHandle &&other) noexcept {

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

@@ -56,10 +56,10 @@ BlockHandle::BlockHandle(BlockManager &block_manager, block_id_t block_id_p, uni
                          bool can_destroy_p, idx_t block_size, BufferPoolReservation &&reservation)
     : block_manager(block_manager), readers(0), block_id(block_id_p), eviction_timestamp(0), can_destroy(can_destroy_p),
       unswizzled(nullptr) {
-	buffer = move(buffer_p);
+	buffer = std::move(buffer_p);
 	state = BlockState::BLOCK_LOADED;
 	memory_usage = block_size;
-	memory_charge = move(reservation);
+	memory_charge = std::move(reservation);
 }
 
 BlockHandle::~BlockHandle() {
@@ -87,7 +87,7 @@ unique_ptr<Block> AllocateBlock(BlockManager &block_manager, unique_ptr<FileBuff
 			// we can reuse the buffer entirely
 			auto &block = (Block &)*reusable_buffer;
 			block.id = block_id;
-			return unique_ptr_cast<FileBuffer, Block>(move(reusable_buffer));
+			return unique_ptr_cast<FileBuffer, Block>(std::move(reusable_buffer));
 		}
 		auto block = block_manager.CreateBlock(block_id, reusable_buffer.get());
 		reusable_buffer.reset();
@@ -105,7 +105,7 @@ idx_t GetAllocSize(idx_t size) {
 unique_ptr<FileBuffer> BufferManager::ConstructManagedBuffer(idx_t size, unique_ptr<FileBuffer> &&source,
                                                              FileBufferType type) {
 	if (source) {
-		auto tmp = move(source);
+		auto tmp = std::move(source);
 		D_ASSERT(tmp->AllocSize() == BufferManager::GetAllocSize(size));
 		return make_unique<FileBuffer>(*tmp, type);
 	} else {
@@ -123,14 +123,15 @@ BufferHandle BlockHandle::Load(shared_ptr<BlockHandle> &handle, unique_ptr<FileB
 
 	auto &block_manager = handle->block_manager;
 	if (handle->block_id < MAXIMUM_BLOCK) {
-		auto block = AllocateBlock(block_manager, move(reusable_buffer), handle->block_id);
+		auto block = AllocateBlock(block_manager, std::move(reusable_buffer), handle->block_id);
 		block_manager.Read(*block);
-		handle->buffer = move(block);
+		handle->buffer = std::move(block);
 	} else {
 		if (handle->can_destroy) {
 			return BufferHandle();
 		} else {
-			handle->buffer = block_manager.buffer_manager.ReadTemporaryBuffer(handle->block_id, move(reusable_buffer));
+			handle->buffer =
+			    block_manager.buffer_manager.ReadTemporaryBuffer(handle->block_id, std::move(reusable_buffer));
 		}
 	}
 	handle->state = BlockState::BLOCK_LOADED;
@@ -151,7 +152,7 @@ unique_ptr<FileBuffer> BlockHandle::UnloadAndTakeBlock() {
 	}
 	memory_charge.Resize(block_manager.buffer_manager.current_memory, 0);
 	state = BlockState::BLOCK_UNLOADED;
-	return move(buffer);
+	return std::move(buffer);
 }
 
 void BlockHandle::Unload() {
@@ -181,7 +182,7 @@ struct BufferEvictionNode {
 	BufferEvictionNode() {
 	}
 	BufferEvictionNode(weak_ptr<BlockHandle> handle_p, idx_t timestamp_p)
-	    : handle(move(handle_p)), timestamp(timestamp_p) {
+	    : handle(std::move(handle_p)), timestamp(timestamp_p) {
 		D_ASSERT(!handle.expired());
 	}
 
@@ -236,11 +237,11 @@ void BufferManager::SetTemporaryDirectory(string new_dir) {
 	if (temp_directory_handle) {
 		throw NotImplementedException("Cannot switch temporary directory after the current one has been used");
 	}
-	this->temp_directory = move(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(move(tmp)),
+    : 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),
       buffer_allocator(BufferAllocatorAllocate, BufferAllocatorFree, BufferAllocatorRealloc,
                        make_unique<BufferAllocatorData>(*this)) {
@@ -297,7 +298,7 @@ shared_ptr<BlockHandle> BlockManager::ConvertToPersistent(block_id_t block_id, s
 	new_block->state = BlockState::BLOCK_LOADED;
 	new_block->buffer = CreateBlock(block_id, old_block->buffer.get());
 	new_block->memory_usage = old_block->memory_usage;
-	new_block->memory_charge = move(old_block->memory_charge);
+	new_block->memory_charge = std::move(old_block->memory_charge);
 
 	// clear the old buffer and unload it
 	old_block->buffer.reset();
@@ -321,7 +322,7 @@ TempBufferPoolReservation BufferManager::EvictBlocksOrThrow(idx_t memory_delta,
 	if (!r.success) {
 		throw OutOfMemoryException(args..., InMemoryWarning());
 	}
-	return move(r.reservation);
+	return std::move(r.reservation);
 }
 
 shared_ptr<BlockHandle> BufferManager::RegisterSmallMemory(idx_t block_size) {
@@ -333,7 +334,8 @@ shared_ptr<BlockHandle> BufferManager::RegisterSmallMemory(idx_t block_size) {
 	auto buffer = ConstructManagedBuffer(block_size, nullptr, FileBufferType::TINY_BUFFER);
 
 	// create a new block pointer for this block
-	return make_shared<BlockHandle>(*temp_block_manager, ++temporary_id, move(buffer), false, block_size, move(res));
+	return make_shared<BlockHandle>(*temp_block_manager, ++temporary_id, std::move(buffer), false, block_size,
+	                                std::move(res));
 }
 
 shared_ptr<BlockHandle> BufferManager::RegisterMemory(idx_t block_size, bool can_destroy) {
@@ -345,11 +347,11 @@ shared_ptr<BlockHandle> BufferManager::RegisterMemory(idx_t block_size, bool can
 	                              "could not allocate block of %lld bytes (%lld/%lld used) %s", alloc_size,
 	                              GetUsedMemory(), GetMaxMemory());
 
-	auto buffer = ConstructManagedBuffer(block_size, move(reusable_buffer));
+	auto buffer = ConstructManagedBuffer(block_size, std::move(reusable_buffer));
 
 	// create a new block pointer for this block
-	return make_shared<BlockHandle>(*temp_block_manager, ++temporary_id, move(buffer), can_destroy, alloc_size,
-	                                move(res));
+	return make_shared<BlockHandle>(*temp_block_manager, ++temporary_id, std::move(buffer), can_destroy, alloc_size,
+	                                std::move(res));
 }
 
 BufferHandle BufferManager::Allocate(idx_t block_size, bool can_destroy, shared_ptr<BlockHandle> *block) {
@@ -377,7 +379,7 @@ void BufferManager::ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size
 		    EvictBlocksOrThrow(memory_delta, maximum_memory, 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(move(reservation));
+		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);
@@ -418,8 +420,8 @@ BufferHandle BufferManager::Pin(shared_ptr<BlockHandle> &handle) {
 	// now we can actually load the current block
 	D_ASSERT(handle->readers == 0);
 	handle->readers = 1;
-	auto buf = handle->Load(handle, move(reusable_buffer));
-	handle->memory_charge = move(reservation);
+	auto buf = handle->Load(handle, std::move(reusable_buffer));
+	handle->memory_charge = std::move(reservation);
 	// In the case of a variable sized block, the buffer may be smaller than a full block.
 	int64_t delta = handle->buffer->AllocSize() - handle->memory_usage;
 	if (delta) {
@@ -449,7 +451,7 @@ void BufferManager::VerifyZeroReaders(shared_ptr<BlockHandle> &handle) {
 	                                                  handle->memory_usage - Storage::BLOCK_HEADER_SIZE);
 	memcpy(replacement_buffer->buffer, handle->buffer->buffer, handle->buffer->size);
 	memset(handle->buffer->buffer, 165, handle->buffer->size); // 165 is default memory in debug mode
-	handle->buffer = move(replacement_buffer);
+	handle->buffer = std::move(replacement_buffer);
 #endif
 }
 
@@ -475,7 +477,7 @@ BufferManager::EvictionResult BufferManager::EvictBlocks(idx_t extra_memory, idx
 		if (!queue->q.try_dequeue(node)) {
 			// Failed to reserve. Adjust size of temp reservation to 0.
 			r.Resize(current_memory, 0);
-			return {false, move(r)};
+			return {false, std::move(r)};
 		}
 		// get a reference to the underlying block pointer
 		auto handle = node.TryGetBlockHandle();
@@ -492,13 +494,13 @@ BufferManager::EvictionResult BufferManager::EvictBlocks(idx_t extra_memory, idx
 		if (buffer && handle->buffer->AllocSize() == extra_memory) {
 			// we can actually re-use the memory directly!
 			*buffer = handle->UnloadAndTakeBlock();
-			return {true, move(r)};
+			return {true, std::move(r)};
 		} else {
 			// release the memory and mark the block as unloaded
 			handle->Unload();
 		}
 	}
-	return {true, move(r)};
+	return {true, std::move(r)};
 }
 
 void BufferManager::PurgeQueue() {
@@ -511,7 +513,7 @@ void BufferManager::PurgeQueue() {
 		if (!handle) {
 			continue;
 		} else {
-			queue->q.enqueue(move(node));
+			queue->q.enqueue(std::move(node));
 			break;
 		}
 	}
@@ -552,12 +554,24 @@ void BufferManager::SetLimit(idx_t limit) {
 	}
 }
 
+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;
+}
+
+void BufferManager::DecreaseUsedMemory(idx_t size) {
+	D_ASSERT(current_memory >= size);
+	current_memory -= size;
+}
+
 //===--------------------------------------------------------------------===//
 // Temporary File Management
 //===--------------------------------------------------------------------===//
 unique_ptr<FileBuffer> ReadTemporaryBufferInternal(BufferManager &buffer_manager, FileHandle &handle, idx_t position,
                                                    idx_t size, block_id_t id, unique_ptr<FileBuffer> reusable_buffer) {
-	auto buffer = buffer_manager.ConstructManagedBuffer(size, move(reusable_buffer));
+	auto buffer = buffer_manager.ConstructManagedBuffer(size, std::move(reusable_buffer));
 	buffer->Read(handle, position);
 	return buffer;
 }
@@ -680,7 +694,7 @@ public:
 	                                           unique_ptr<FileBuffer> reusable_buffer) {
 		auto buffer =
 		    ReadTemporaryBufferInternal(BufferManager::GetBufferManager(db), *handle, GetPositionInFile(block_index),
-		                                Storage::BLOCK_SIZE, id, move(reusable_buffer));
+		                                Storage::BLOCK_SIZE, id, std::move(reusable_buffer));
 		{
 			// remove the block (and potentially truncate the temp file)
 			TemporaryFileLock lock(file_lock);
@@ -718,9 +732,9 @@ private:
 		if (index_manager.RemoveIndex(index)) {
 			// the max_index that is currently in use has decreased
 			// as a result we can truncate the file
+#ifndef WIN32 // this ended up causing issues when sorting
 			auto max_index = index_manager.GetMaxIndex();
 			auto &fs = FileSystem::GetFileSystem(db);
-#ifndef WIN32 // this ended up causing issues when sorting
 			fs.Truncate(*handle, GetPositionInFile(max_index + 1));
 #endif
 		}
@@ -774,7 +788,7 @@ public:
 				auto new_file_index = index_manager.GetNewBlockIndex();
 				auto new_file = make_unique<TemporaryFileHandle>(db, temp_directory, new_file_index);
 				handle = new_file.get();
-				files[new_file_index] = move(new_file);
+				files[new_file_index] = std::move(new_file);
 
 				index = handle->TryGetBlockIndex();
 			}
@@ -799,7 +813,7 @@ public:
 			index = GetTempBlockIndex(lock, id);
 			handle = GetFileHandle(lock, index.file_index);
 		}
-		auto buffer = handle->ReadTemporaryBuffer(id, index.block_index, move(reusable_buffer));
+		auto buffer = handle->ReadTemporaryBuffer(id, index.block_index, std::move(reusable_buffer));
 		{
 			// remove the block (and potentially erase the temp file)
 			TemporaryManagerLock lock(manager_lock);
@@ -851,7 +865,7 @@ private:
 };
 
 TemporaryDirectoryHandle::TemporaryDirectoryHandle(DatabaseInstance &db, string path_p)
-    : db(db), temp_directory(move(path_p)), temp_file(make_unique<TemporaryFileManager>(db, temp_directory)) {
+    : db(db), temp_directory(std::move(path_p)), temp_file(make_unique<TemporaryFileManager>(db, temp_directory)) {
 	auto &fs = FileSystem::GetFileSystem(db);
 	if (!temp_directory.empty()) {
 		fs.CreateDirectory(temp_directory);
@@ -909,7 +923,7 @@ unique_ptr<FileBuffer> BufferManager::ReadTemporaryBuffer(block_id_t id, unique_
 	D_ASSERT(!temp_directory.empty());
 	D_ASSERT(temp_directory_handle.get());
 	if (temp_directory_handle->GetTempFile().HasTemporaryBuffer(id)) {
-		return temp_directory_handle->GetTempFile().ReadTemporaryBuffer(id, move(reusable_buffer));
+		return temp_directory_handle->GetTempFile().ReadTemporaryBuffer(id, std::move(reusable_buffer));
 	}
 	idx_t block_size;
 	// open the temporary file and read the size
@@ -919,7 +933,8 @@ unique_ptr<FileBuffer> BufferManager::ReadTemporaryBuffer(block_id_t id, unique_
 	handle->Read(&block_size, sizeof(idx_t), 0);
 
 	// now allocate a buffer of this size and read the data into that buffer
-	auto buffer = ReadTemporaryBufferInternal(*this, *handle, sizeof(idx_t), block_size, id, move(reusable_buffer));
+	auto buffer =
+	    ReadTemporaryBufferInternal(*this, *handle, sizeof(idx_t), block_size, id, std::move(reusable_buffer));
 
 	handle.reset();
 	DeleteTemporaryFile(id);

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

@@ -8,11 +8,11 @@
 namespace duckdb {
 
 CompressionType RowGroupWriter::GetColumnCompressionType(idx_t i) {
-	return table.columns.GetColumn(LogicalIndex(i)).CompressionType();
+	return table.GetColumn(LogicalIndex(i)).CompressionType();
 }
 
 void RowGroupWriter::RegisterPartialBlock(PartialBlockAllocation &&allocation) {
-	partial_block_manager.RegisterPartialBlock(move(allocation));
+	partial_block_manager.RegisterPartialBlock(std::move(allocation));
 }
 
 PartialBlockAllocation RowGroupWriter::GetBlockAllocation(uint32_t segment_size) {

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

@@ -34,7 +34,7 @@ void TableDataReader::ReadTableData() {
 	info.data->row_groups.reserve(row_group_count);
 	for (idx_t i = 0; i < row_group_count; i++) {
 		auto row_group_pointer = RowGroup::Deserialize(reader, columns);
-		info.data->row_groups.push_back(move(row_group_pointer));
+		info.data->row_groups.push_back(std::move(row_group_pointer));
 	}
 }
 

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

@@ -1,5 +1,6 @@
 #include "duckdb/storage/checkpoint/table_data_writer.hpp"
 
+#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/serializer/buffered_serializer.hpp"
@@ -7,7 +8,8 @@
 
 namespace duckdb {
 
-TableDataWriter::TableDataWriter(TableCatalogEntry &table) : table(table) {
+TableDataWriter::TableDataWriter(TableCatalogEntry &table_p) : table((DuckTableEntry &)table_p) {
+	D_ASSERT(table_p.IsDuckTable());
 }
 
 TableDataWriter::~TableDataWriter() {
@@ -15,15 +17,15 @@ TableDataWriter::~TableDataWriter() {
 
 void TableDataWriter::WriteTableData() {
 	// start scanning the table and append the data to the uncompressed segments
-	table.storage->Checkpoint(*this);
+	table.GetStorage().Checkpoint(*this);
 }
 
 CompressionType TableDataWriter::GetColumnCompressionType(idx_t i) {
-	return table.columns.GetColumn(LogicalIndex(i)).CompressionType();
+	return table.GetColumn(LogicalIndex(i)).CompressionType();
 }
 
 void TableDataWriter::AddRowGroup(RowGroupPointer &&row_group_pointer, unique_ptr<RowGroupWriter> &&writer) {
-	row_group_pointers.push_back(move(row_group_pointer));
+	row_group_pointers.push_back(std::move(row_group_pointer));
 	writer.reset();
 }
 

package/src/duckdb/src/storage/checkpoint_manager.cpp

@@ -1,11 +1,11 @@
 #include "duckdb/storage/checkpoint_manager.hpp"
 
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/index_catalog_entry.hpp"
+#include "duckdb/catalog/duck_catalog.hpp"
+#include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
 #include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
 #include "duckdb/common/field_writer.hpp"
@@ -73,7 +73,8 @@ void SingleFileCheckpointWriter::CreateCheckpoint() {
 
 	vector<SchemaCatalogEntry *> schemas;
 	// we scan the set of committed schemas
-	catalog.schemas->Scan([&](CatalogEntry *entry) { schemas.push_back((SchemaCatalogEntry *)entry); });
+	auto &catalog = (DuckCatalog &)Catalog::GetCatalog(db);
+	catalog.ScanSchemas([&](CatalogEntry *entry) { schemas.push_back((SchemaCatalogEntry *)entry); });
 	// write the actual data into the database
 	// write the amount of schemas
 	metadata_writer->Write<uint32_t>(schemas.size());
@@ -341,9 +342,9 @@ void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader
 	// Create index in the catalog
 	auto schema_catalog = catalog.GetSchema(context, info->schema);
 	auto table_catalog =
-	    (TableCatalogEntry *)catalog.GetEntry(context, CatalogType::TABLE_ENTRY, info->schema, info->table->table_name);
-	auto index_catalog = (IndexCatalogEntry *)schema_catalog->CreateIndex(context, info.get(), table_catalog);
-	index_catalog->info = table_catalog->storage->info;
+	    (DuckTableEntry *)catalog.GetEntry(context, CatalogType::TABLE_ENTRY, info->schema, info->table->table_name);
+	auto index_catalog = (DuckIndexEntry *)schema_catalog->CreateIndex(context, info.get(), table_catalog);
+	index_catalog->info = table_catalog->GetStorage().info;
 	// Here we just gotta read the root node
 	auto root_block_id = reader.Read<block_id_t>();
 	auto root_offset = reader.Read<uint32_t>();
@@ -371,7 +372,7 @@ void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader
 		// column refs
 		unbound_expressions.reserve(info->column_ids.size());
 		for (idx_t key_nr = 0; key_nr < info->column_ids.size(); key_nr++) {
-			auto &col = table_catalog->columns.GetColumn(LogicalIndex(info->column_ids[key_nr]));
+			auto &col = table_catalog->GetColumn(LogicalIndex(info->column_ids[key_nr]));
 			unbound_expressions.push_back(
 			    make_unique<BoundColumnRefExpression>(col.GetName(), col.GetType(), ColumnBinding(0, key_nr)));
 		}
@@ -379,11 +380,11 @@ void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader
 
 	switch (info->index_type) {
 	case IndexType::ART: {
-		auto art =
-		    make_unique<ART>(info->column_ids, TableIOManager::Get(*table_catalog->storage), move(unbound_expressions),
-		                     info->constraint_type, table_catalog->storage->db, root_block_id, root_offset);
+		auto &storage = table_catalog->GetStorage();
+		auto art = make_unique<ART>(info->column_ids, TableIOManager::Get(storage), std::move(unbound_expressions),
+		                            info->constraint_type, storage.db, true, root_block_id, root_offset);
 		index_catalog->index = art.get();
-		table_catalog->storage->info->indexes.AddIndex(move(art));
+		storage.info->indexes.AddIndex(std::move(art));
 		break;
 	}
 	default:
@@ -442,7 +443,7 @@ void CheckpointReader::ReadTable(ClientContext &context, MetaBlockReader &reader
 	// bind the info
 	auto binder = Binder::CreateBinder(context);
 	auto schema = catalog.GetSchema(context, info->schema);
-	auto bound_info = binder->BindCreateTableInfo(move(info), schema);
+	auto bound_info = binder->BindCreateTableInfo(std::move(info), schema);
 
 	// now read the actual table data and place it into the create table info
 	ReadTableData(context, reader, *bound_info);

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

@@ -211,8 +211,9 @@ public:
 
 	template <class T_INNER>
 	void SubtractFrameOfReference(T_INNER *buffer, T_INNER frame_of_reference) {
+		static_assert(std::is_integral<T_INNER>::value, "Integral type required.");
 		for (idx_t i = 0; i < compression_buffer_idx; i++) {
-			buffer[i] -= frame_of_reference;
+			buffer[i] -= uint64_t(frame_of_reference);
 		}
 	}
 
@@ -470,7 +471,7 @@ public:
 		auto &type = checkpointer.GetType();
 		auto compressed_segment = ColumnSegment::CreateTransientSegment(db, type, row_start);
 		compressed_segment->function = function;
-		current_segment = move(compressed_segment);
+		current_segment = std::move(compressed_segment);
 		auto &buffer_manager = BufferManager::GetBufferManager(db);
 		handle = buffer_manager.Pin(current_segment->block);
 
@@ -510,7 +511,7 @@ public:
 		Store<idx_t>(metadata_offset + metadata_size, base_ptr);
 		handle.Destroy();
 
-		state.FlushSegment(move(current_segment), total_segment_size);
+		state.FlushSegment(std::move(current_segment), total_segment_size);
 	}
 
 	void Finalize() {
@@ -719,7 +720,7 @@ public:
 template <class T>
 unique_ptr<SegmentScanState> BitpackingInitScan(ColumnSegment &segment) {
 	auto result = make_unique<BitpackingScanState<T>>(segment);
-	return move(result);
+	return std::move(result);
 }
 
 //===--------------------------------------------------------------------===//

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

@@ -164,7 +164,7 @@ public:
 		auto &db = checkpointer.GetDatabase();
 		auto &type = checkpointer.GetType();
 		auto compressed_segment = ColumnSegment::CreateTransientSegment(db, type, row_start);
-		current_segment = move(compressed_segment);
+		current_segment = std::move(compressed_segment);
 
 		current_segment->function = function;
 
@@ -254,7 +254,7 @@ public:
 
 		auto segment_size = Finalize();
 		auto &state = checkpointer.GetCheckpointState();
-		state.FlushSegment(move(current_segment), segment_size);
+		state.FlushSegment(std::move(current_segment), segment_size);
 
 		if (!final) {
 			CreateEmptySegment(next_start);
@@ -461,7 +461,7 @@ unique_ptr<SegmentScanState> DictionaryCompressionStorage::StringInitScan(Column
 		dict_child_data[i] = FetchStringFromDict(segment, dict, baseptr, index_buffer_ptr[i], str_len);
 	}
 
-	return move(state);
+	return std::move(state);
 }
 
 //===--------------------------------------------------------------------===//

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

@@ -55,7 +55,7 @@ struct UncompressedCompressState : public CompressionState {
 
 UncompressedCompressState::UncompressedCompressState(ColumnDataCheckpointer &checkpointer)
     : checkpointer(checkpointer) {
-	CreateEmptySegment(checkpointer.GetRowGroup().start);
+	UncompressedCompressState::CreateEmptySegment(checkpointer.GetRowGroup().start);
 }
 
 void UncompressedCompressState::CreateEmptySegment(idx_t row_start) {
@@ -66,13 +66,13 @@ void UncompressedCompressState::CreateEmptySegment(idx_t row_start) {
 		auto &state = (UncompressedStringSegmentState &)*compressed_segment->GetSegmentState();
 		state.overflow_writer = make_unique<WriteOverflowStringsToDisk>(checkpointer.GetColumnData().block_manager);
 	}
-	current_segment = move(compressed_segment);
+	current_segment = std::move(compressed_segment);
 	current_segment->InitializeAppend(append_state);
 }
 
 void UncompressedCompressState::FlushSegment(idx_t segment_size) {
 	auto &state = checkpointer.GetCheckpointState();
-	state.FlushSegment(move(current_segment), segment_size);
+	state.FlushSegment(std::move(current_segment), segment_size);
 }
 
 void UncompressedCompressState::Finalize(idx_t segment_size) {
@@ -124,7 +124,7 @@ unique_ptr<SegmentScanState> FixedSizeInitScan(ColumnSegment &segment) {
 	auto result = make_unique<FixedSizeScanState>();
 	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
 	result->handle = buffer_manager.Pin(segment.block);
-	return move(result);
+	return std::move(result);
 }
 
 //===--------------------------------------------------------------------===//
@@ -183,7 +183,7 @@ void FixedSizeFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t ro
 static unique_ptr<CompressionAppendState> FixedSizeInitAppend(ColumnSegment &segment) {
 	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
 	auto handle = buffer_manager.Pin(segment.block);
-	return make_unique<CompressionAppendState>(move(handle));
+	return make_unique<CompressionAppendState>(std::move(handle));
 }
 
 template <class T>