duckdb 0.8.2-dev2673.0 → 0.8.2-dev2700.0

package/src/duckdb/src/include/duckdb/storage/meta_block_writer.hpp

@@ -1,50 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/meta_block_writer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/serializer.hpp"
-#include "duckdb/storage/block.hpp"
-#include "duckdb/storage/block_manager.hpp"
-#include "duckdb/common/set.hpp"
-
-namespace duckdb {
-class DatabaseInstance;
-
-//! This struct is responsible for writing data to disk in a stream of blocks.
-class MetaBlockWriter : public Serializer {
-public:
-	MetaBlockWriter(BlockManager &block_manager, block_id_t initial_block_id = INVALID_BLOCK);
-	~MetaBlockWriter() override;
-
-	BlockManager &block_manager;
-
-protected:
-	unique_ptr<Block> block;
-	set<block_id_t> written_blocks;
-	idx_t offset;
-
-public:
-	BlockPointer GetBlockPointer();
-	virtual void Flush();
-
-	void WriteData(const_data_ptr_t buffer, idx_t write_size) override;
-
-	void MarkWrittenBlocks() {
-		for (auto &block_id : written_blocks) {
-			block_manager.MarkBlockAsModified(block_id);
-		}
-	}
-
-protected:
-	virtual block_id_t GetNextBlockId();
-	void AdvanceBlock();
-};
-
-} // namespace duckdb

package/src/duckdb/src/storage/meta_block_reader.cpp

@@ -1,69 +0,0 @@
-#include "duckdb/storage/meta_block_reader.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/main/connection_manager.hpp"
-#include "duckdb/main/database.hpp"
-
-#include <cstring>
-
-namespace duckdb {
-
-MetaBlockReader::MetaBlockReader(BlockManager &block_manager, block_id_t block_id, bool free_blocks_on_read)
-    : block_manager(block_manager), offset(0), next_block(-1), free_blocks_on_read(free_blocks_on_read) {
-	ReadNewBlock(block_id);
-}
-
-MetaBlockReader::~MetaBlockReader() {
-}
-
-void MetaBlockReader::ReadData(data_ptr_t buffer, idx_t read_size) {
-	while (offset + read_size > handle.GetFileBuffer().size) {
-		// cannot read entire entry from block
-		// first read what we can from this block
-		idx_t to_read = handle.GetFileBuffer().size - offset;
-		if (to_read > 0) {
-			memcpy(buffer, handle.Ptr() + offset, to_read);
-			read_size -= to_read;
-			buffer += to_read;
-		}
-		// then move to the next block
-		if (next_block == INVALID_BLOCK) {
-			throw IOException("Cannot read from INVALID_BLOCK.");
-		}
-		ReadNewBlock(next_block);
-	}
-	// we have enough left in this block to read from the buffer
-	memcpy(buffer, handle.Ptr() + offset, read_size);
-	offset += read_size;
-}
-
-ClientContext &MetaBlockReader::GetContext() {
-	if (!context) {
-		throw InternalException("Meta Block Reader is missing context");
-	}
-	return *context;
-}
-
-void MetaBlockReader::ReadNewBlock(block_id_t id) {
-	auto &buffer_manager = block_manager.buffer_manager;
-
-	// Marking these blocks as modified will cause them to be moved to the free
-	// list upon the next successful checkpoint. Marking them modified here
-	// assumes MetaBlockReader is exclusively used for reading checkpoint data,
-	// and thus any blocks we're reading will be obviated by the next checkpoint.
-	if (free_blocks_on_read) {
-		block_manager.MarkBlockAsModified(id);
-	}
-	block = block_manager.RegisterBlock(id, true);
-	handle = buffer_manager.Pin(block);
-
-	next_block = Load<block_id_t>(handle.Ptr());
-	D_ASSERT(next_block >= -1);
-	offset = sizeof(block_id_t);
-}
-
-void MetaBlockReader::SetContext(ClientContext &context_p) {
-	D_ASSERT(!context);
-	context = &context_p;
-}
-
-} // namespace duckdb

package/src/duckdb/src/storage/meta_block_writer.cpp

@@ -1,80 +0,0 @@
-#include "duckdb/storage/meta_block_writer.hpp"
-
-#include <cstring>
-
-namespace duckdb {
-
-MetaBlockWriter::MetaBlockWriter(BlockManager &block_manager, block_id_t initial_block_id)
-    : block_manager(block_manager) {
-	if (initial_block_id == INVALID_BLOCK) {
-		initial_block_id = MetaBlockWriter::GetNextBlockId();
-	}
-	block = block_manager.CreateBlock(initial_block_id, nullptr);
-	Store<block_id_t>(-1, block->buffer);
-	offset = sizeof(block_id_t);
-}
-
-MetaBlockWriter::~MetaBlockWriter() {
-	// If there's an exception during checkpoint, this can get destroyed without
-	// flushing the data...which is fine, because none of the unwritten data
-	// will be referenced.
-	//
-	// Otherwise, we should have explicitly flushed (and thereby nulled the block).
-	D_ASSERT(!block || Exception::UncaughtException());
-}
-
-block_id_t MetaBlockWriter::GetNextBlockId() {
-	return block_manager.GetFreeBlockId();
-}
-
-BlockPointer MetaBlockWriter::GetBlockPointer() {
-	BlockPointer pointer;
-	pointer.block_id = block->id;
-	pointer.offset = offset;
-	return pointer;
-}
-
-void MetaBlockWriter::Flush() {
-	if (offset < block->size) {
-		// clear remaining bytes of block (if any)
-		memset(block->buffer + offset, 0, block->size - offset);
-	}
-	AdvanceBlock();
-	block = nullptr;
-}
-
-void MetaBlockWriter::AdvanceBlock() {
-	written_blocks.insert(block->id);
-	if (offset > sizeof(block_id_t)) {
-		block_manager.Write(*block);
-		offset = sizeof(block_id_t);
-	}
-}
-
-void MetaBlockWriter::WriteData(const_data_ptr_t buffer, idx_t write_size) {
-	while (offset + write_size > block->size) {
-		// we need to make a new block
-		// first copy what we can
-		D_ASSERT(offset <= block->size);
-		idx_t copy_amount = block->size - offset;
-		if (copy_amount > 0) {
-			memcpy(block->buffer + offset, buffer, copy_amount);
-			buffer += copy_amount;
-			offset += copy_amount;
-			write_size -= copy_amount;
-		}
-		// now we need to get a new block id
-		block_id_t new_block_id = GetNextBlockId();
-		// write the block id of the new block to the start of the current block
-		Store<block_id_t>(new_block_id, block->buffer);
-		// first flush the old block
-		AdvanceBlock();
-		// now update the block id of the block
-		block->id = new_block_id;
-		Store<block_id_t>(-1, block->buffer);
-	}
-	memcpy(block->buffer + offset, buffer, write_size);
-	offset += write_size;
-}
-
-} // namespace duckdb