duckdb 0.8.2-dev2673.0 → 0.8.2-dev2809.0

package/binding.gyp

@@ -136,6 +136,7 @@
                 "src/duckdb/ub_src_storage_checkpoint.cpp", 
                 "src/duckdb/ub_src_storage_compression.cpp", 
                 "src/duckdb/ub_src_storage_compression_chimp.cpp", 
+                "src/duckdb/ub_src_storage_metadata.cpp", 
                 "src/duckdb/ub_src_storage_serialization.cpp", 
                 "src/duckdb/ub_src_storage_statistics.cpp", 
                 "src/duckdb/ub_src_storage_table.cpp", 

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev2673.0",
+  "version": "0.8.2-dev2809.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/icu/icu-makedate.cpp

@@ -1,4 +1,6 @@
+#include "duckdb/common/operator/add.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/operator/subtract.hpp"
 #include "duckdb/common/types/date.hpp"
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
@@ -66,7 +68,11 @@ struct ICUMakeDate : public ICUDateFunc {
 struct ICUMakeTimestampTZFunc : public ICUDateFunc {
 	template <typename T>
 	static inline timestamp_t Operation(icu::Calendar *calendar, T yyyy, T mm, T dd, T hr, T mn, double ss) {
-		const auto year = yyyy + (yyyy < 0);
+		const auto year = Cast::Operation<T, int32_t>(AddOperator::Operation<T, T, T>(yyyy, (yyyy < 0)));
+		const auto month = Cast::Operation<T, int32_t>(SubtractOperatorOverflowCheck::Operation<T, T, T>(mm, 1));
+		const auto day = Cast::Operation<T, int32_t>(dd);
+		const auto hour = Cast::Operation<T, int32_t>(hr);
+		const auto min = Cast::Operation<T, int32_t>(mn);
 
 		const auto secs = Cast::Operation<double, int32_t>(ss);
 		ss -= secs;
@@ -74,11 +80,11 @@ struct ICUMakeTimestampTZFunc : public ICUDateFunc {
 		const auto millis = int32_t(ss);
 		int64_t micros = std::round((ss - millis) * Interval::MICROS_PER_MSEC);
 
-		calendar->set(UCAL_YEAR, int32_t(year));
-		calendar->set(UCAL_MONTH, int32_t(mm - 1));
-		calendar->set(UCAL_DATE, int32_t(dd));
-		calendar->set(UCAL_HOUR_OF_DAY, int32_t(hr));
-		calendar->set(UCAL_MINUTE, int32_t(mn));
+		calendar->set(UCAL_YEAR, year);
+		calendar->set(UCAL_MONTH, month);
+		calendar->set(UCAL_DATE, day);
+		calendar->set(UCAL_HOUR_OF_DAY, hour);
+		calendar->set(UCAL_MINUTE, min);
 		calendar->set(UCAL_SECOND, secs);
 		calendar->set(UCAL_MILLISECOND, millis);
 

package/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp

@@ -23,7 +23,7 @@
 namespace duckdb {
 
 void AddDataTableIndex(DataTable &storage, const ColumnList &columns, const vector<PhysicalIndex> &keys,
-                       IndexConstraintType constraint_type, BlockPointer *index_block = nullptr) {
+                       IndexConstraintType constraint_type, BlockPointer index_block = BlockPointer()) {
 	// fetch types and create expressions for the index from the columns
 	vector<column_t> column_ids;
 	vector<unique_ptr<Expression>> unbound_expressions;
@@ -41,9 +41,9 @@ void AddDataTableIndex(DataTable &storage, const ColumnList &columns, const vect
 	}
 	unique_ptr<ART> art;
 	// create an adaptive radix tree around the expressions
-	if (index_block) {
+	if (index_block.IsValid()) {
 		art = make_uniq<ART>(column_ids, TableIOManager::Get(storage), std::move(unbound_expressions), constraint_type,
-		                     storage.db, nullptr, index_block->block_id, index_block->offset);
+		                     storage.db, nullptr, index_block);
 	} else {
 		art = make_uniq<ART>(column_ids, TableIOManager::Get(storage), std::move(unbound_expressions), constraint_type,
 		                     storage.db);
@@ -55,7 +55,7 @@ void AddDataTableIndex(DataTable &storage, const ColumnList &columns, const vect
 }
 
 void AddDataTableIndex(DataTable &storage, const ColumnList &columns, vector<LogicalIndex> &keys,
-                       IndexConstraintType constraint_type, BlockPointer *index_block = nullptr) {
+                       IndexConstraintType constraint_type, BlockPointer index_block = BlockPointer()) {
 	vector<PhysicalIndex> new_keys;
 	new_keys.reserve(keys.size());
 	for (auto &logical_key : keys) {
@@ -92,7 +92,7 @@ DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, Bou
 				if (info.indexes.empty()) {
 					AddDataTableIndex(*storage, columns, unique.keys, constraint_type);
 				} else {
-					AddDataTableIndex(*storage, columns, unique.keys, constraint_type, &info.indexes[indexes_idx++]);
+					AddDataTableIndex(*storage, columns, unique.keys, constraint_type, info.indexes[indexes_idx++]);
 				}
 			} else if (constraint->type == ConstraintType::FOREIGN_KEY) {
 				// foreign key constraint: create a foreign key index
@@ -103,7 +103,7 @@ DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, Bou
 						AddDataTableIndex(*storage, columns, bfk.info.fk_keys, IndexConstraintType::FOREIGN);
 					} else {
 						AddDataTableIndex(*storage, columns, bfk.info.fk_keys, IndexConstraintType::FOREIGN,
-						                  &info.indexes[indexes_idx++]);
+						                  info.indexes[indexes_idx++]);
 					}
 				}
 			}

package/src/duckdb/src/common/adbc/adbc.cpp

@@ -586,16 +586,14 @@ AdbcStatusCode StatementExecuteQuery(struct AdbcStatement *statement, struct Arr
 
 // this is a nop for us
 AdbcStatusCode StatementPrepare(struct AdbcStatement *statement, struct AdbcError *error) {
-	auto status = SetErrorMaybe(statement, error, "Missing statement object");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!statement) {
+		SetError(error, "Missing statement object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-
-	status = SetErrorMaybe(statement->private_data, error, "Invalid statement object");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!error) {
+		SetError(error, "Missing error object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-
 	return ADBC_STATUS_OK;
 }
 
@@ -687,10 +685,6 @@ AdbcStatusCode QueryInternal(struct AdbcConnection *connection, struct ArrowArra
 AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth, const char *catalog,
                                     const char *db_schema, const char *table_name, const char **table_type,
                                     const char *column_name, struct ArrowArrayStream *out, struct AdbcError *error) {
-	if (depth != 0) {
-		SetError(error, "Depth parameter not yet supported");
-		return ADBC_STATUS_NOT_IMPLEMENTED;
-	}
 	if (catalog != nullptr) {
 		if (strcmp(catalog, "duckdb") == 0) {
 			SetError(error, "catalog must be NULL or 'duckdb'");
@@ -702,16 +696,53 @@ AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth
 		SetError(error, "Table types parameter not yet supported");
 		return ADBC_STATUS_NOT_IMPLEMENTED;
 	}
+	std::string query;
+	switch (depth) {
+	case ADBC_OBJECT_DEPTH_CATALOGS:
+		SetError(error, "ADBC_OBJECT_DEPTH_CATALOGS not yet supported");
+		return ADBC_STATUS_NOT_IMPLEMENTED;
+	case ADBC_OBJECT_DEPTH_DB_SCHEMAS:
+		// Return metadata on catalogs and schemas.
+		query = duckdb::StringUtil::Format(R"(
+				SELECT table_schema db_schema_name
+				FROM information_schema.columns
+				WHERE table_schema LIKE '%s' AND table_name LIKE '%s' AND column_name LIKE '%s' ;
+				)",
+		                                   db_schema ? db_schema : "%", table_name ? table_name : "%",
+		                                   column_name ? column_name : "%");
+		break;
+	case ADBC_OBJECT_DEPTH_TABLES:
+		// Return metadata on catalogs, schemas, and tables.
+		query = duckdb::StringUtil::Format(R"(
+				SELECT table_schema db_schema_name, LIST(table_schema_list) db_schema_tables
+				FROM (
+					SELECT table_schema, { table_name : table_name} table_schema_list
+					FROM information_schema.columns
+					WHERE table_schema LIKE '%s' AND table_name LIKE '%s' AND column_name LIKE '%s'  GROUP BY table_schema, table_name
+					) GROUP BY table_schema;
+				)",
+		                                   db_schema ? db_schema : "%", table_name ? table_name : "%",
+		                                   column_name ? column_name : "%");
+		break;
+	case ADBC_OBJECT_DEPTH_COLUMNS:
+		// Return metadata on catalogs, schemas, tables, and columns.
+		query = duckdb::StringUtil::Format(R"(
+				SELECT table_schema db_schema_name, LIST(table_schema_list) db_schema_tables
+				FROM (
+					SELECT table_schema, { table_name : table_name, table_columns : LIST({column_name : column_name, ordinal_position : ordinal_position + 1, remarks : ''})} table_schema_list
+					FROM information_schema.columns
+					WHERE table_schema LIKE '%s' AND table_name LIKE '%s' AND column_name LIKE '%s' GROUP BY table_schema, table_name
+					) GROUP BY table_schema;
+				)",
+		                                   db_schema ? db_schema : "%", table_name ? table_name : "%",
+		                                   column_name ? column_name : "%");
+		break;
+	default:
+		SetError(error, "Invalid value of Depth");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
 
-	auto q = duckdb::StringUtil::Format(R"(
-SELECT table_schema db_schema_name, LIST(table_schema_list) db_schema_tables FROM (
-	SELECT table_schema, { table_name : table_name, table_columns : LIST({column_name : column_name, ordinal_position : ordinal_position + 1, remarks : ''})} table_schema_list FROM information_schema.columns WHERE table_schema LIKE '%s' AND table_name LIKE '%s' AND column_name LIKE '%s' GROUP BY table_schema, table_name
-	) GROUP BY table_schema;
-)",
-	                                    db_schema ? db_schema : "%", table_name ? table_name : "%",
-	                                    column_name ? column_name : "%");
-
-	return QueryInternal(connection, out, q.c_str(), error);
+	return QueryInternal(connection, out, query.c_str(), error);
 }
 
 AdbcStatusCode ConnectionGetTableTypes(struct AdbcConnection *connection, struct ArrowArrayStream *out,

package/src/duckdb/src/common/adbc/driver_manager.cpp

@@ -304,7 +304,12 @@ AdbcStatusCode AdbcConnectionGetObjects(struct AdbcConnection *connection, int d
                                         const char *db_schema, const char *table_name, const char **table_types,
                                         const char *column_name, struct ArrowArrayStream *stream,
                                         struct AdbcError *error) {
-	if (!connection->private_driver) {
+	if (!connection) {
+		SetError(error, "connection can't be null");
+		return ADBC_STATUS_INVALID_STATE;
+	}
+	if (!connection->private_data) {
+		SetError(error, "connection must be initialized");
 		return ADBC_STATUS_INVALID_STATE;
 	}
 	return connection->private_driver->ConnectionGetObjects(connection, depth, catalog, db_schema, table_name,
@@ -474,7 +479,12 @@ AdbcStatusCode AdbcStatementNew(struct AdbcConnection *connection, struct AdbcSt
 }
 
 AdbcStatusCode AdbcStatementPrepare(struct AdbcStatement *statement, struct AdbcError *error) {
-	if (!statement->private_driver) {
+	auto status = SetErrorMaybe(statement, error, "Missing statement object");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
+	status = SetErrorMaybe(statement->private_data, error, "Invalid statement object");
+	if (status != ADBC_STATUS_OK) {
 		return ADBC_STATUS_INVALID_STATE;
 	}
 	return statement->private_driver->StatementPrepare(statement, error);

package/src/duckdb/src/common/enum_util.cpp

@@ -3872,6 +3872,8 @@ const char* EnumUtil::ToChars<PendingExecutionResult>(PendingExecutionResult val
 		return "RESULT_NOT_READY";
 	case PendingExecutionResult::EXECUTION_ERROR:
 		return "EXECUTION_ERROR";
+	case PendingExecutionResult::NO_TASKS_AVAILABLE:
+		return "NO_TASKS_AVAILABLE";
 	default:
 		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
 	}
@@ -3888,6 +3890,9 @@ PendingExecutionResult EnumUtil::FromString<PendingExecutionResult>(const char *
 	if (StringUtil::Equals(value, "EXECUTION_ERROR")) {
 		return PendingExecutionResult::EXECUTION_ERROR;
 	}
+	if (StringUtil::Equals(value, "NO_TASKS_AVAILABLE")) {
+		return PendingExecutionResult::NO_TASKS_AVAILABLE;
+	}
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 

package/src/duckdb/src/common/field_writer.cpp

@@ -72,6 +72,7 @@ FieldReader::FieldReader(Deserializer &source_p) : source(source_p), field_count
 	max_field_count = source_p.Read<uint32_t>();
 	total_size = source_p.Read<uint64_t>();
 	D_ASSERT(max_field_count > 0);
+	D_ASSERT(total_size > 0);
 	source.SetRemainingData(total_size);
 }
 

package/src/duckdb/src/common/local_file_system.cpp

@@ -267,6 +267,11 @@ void LocalFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes, i
 		if (bytes_read == -1) {
 			throw IOException("Could not read from file \"%s\": %s", handle.path, strerror(errno));
 		}
+		if (bytes_read == 0) {
+			throw IOException(
+			    "Could not read enough bytes from file \"%s\": attempted to read %llu bytes from location %llu",
+			    handle.path, nr_bytes, location);
+		}
 		read_buffer += bytes_read;
 		nr_bytes -= bytes_read;
 	}

package/src/duckdb/src/common/types/interval.cpp

@@ -116,6 +116,9 @@ interval_parse_time : {
 	}
 	result.micros += time.micros;
 	found_any = true;
+	if (negative) {
+		result.micros = -result.micros;
+	}
 	goto end_of_string;
 }
 interval_parse_identifier:

package/src/duckdb/src/common/types/row/row_data_collection_scanner.cpp

@@ -4,6 +4,8 @@
 #include "duckdb/common/types/row/row_data_collection.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
 
+#include <numeric>
+
 namespace duckdb {
 
 void RowDataCollectionScanner::AlignHeapBlocks(RowDataCollection &swizzled_block_collection,
@@ -155,6 +157,31 @@ RowDataCollectionScanner::RowDataCollectionScanner(RowDataCollection &rows_p, Ro
 	ValidateUnscannedBlock();
 }
 
+RowDataCollectionScanner::RowDataCollectionScanner(RowDataCollection &rows_p, RowDataCollection &heap_p,
+                                                   const RowLayout &layout_p, bool external_p, idx_t block_idx,
+                                                   bool flush_p)
+    : rows(rows_p), heap(heap_p), layout(layout_p), read_state(*this), total_count(rows.count), total_scanned(0),
+      external(external_p), flush(flush_p), unswizzling(!layout.AllConstant() && external && !heap.keep_pinned) {
+
+	if (unswizzling) {
+		D_ASSERT(rows.blocks.size() == heap.blocks.size());
+	}
+
+	D_ASSERT(block_idx < rows.blocks.size());
+	read_state.block_idx = block_idx;
+	read_state.entry_idx = 0;
+
+	//	Pretend that we have scanned up to the start block
+	//	and will stop at the end
+	auto begin = rows.blocks.begin();
+	auto end = begin + block_idx;
+	total_scanned =
+	    std::accumulate(begin, end, idx_t(0), [&](idx_t c, const unique_ptr<RowDataBlock> &b) { return c + b->count; });
+	total_count = total_scanned + (*end)->count;
+
+	ValidateUnscannedBlock();
+}
+
 void RowDataCollectionScanner::SwizzleBlock(RowDataBlock &data_block, RowDataBlock &heap_block) {
 	// Pin the data block and swizzle the pointers within the rows
 	D_ASSERT(!data_block.block->IsSwizzled());
@@ -190,7 +217,7 @@ void RowDataCollectionScanner::ReSwizzle() {
 }
 
 void RowDataCollectionScanner::ValidateUnscannedBlock() const {
-	if (unswizzling && read_state.block_idx < rows.blocks.size()) {
+	if (unswizzling && read_state.block_idx < rows.blocks.size() && Remaining()) {
 		D_ASSERT(rows.blocks[read_state.block_idx]->block->IsSwizzled());
 	}
 }
@@ -202,6 +229,9 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
 		return;
 	}
 
+	//	Only flush blocks we processed.
+	const auto flush_block_idx = read_state.block_idx;
+
 	const idx_t &row_width = layout.GetRowWidth();
 	// Set up a batch of pointers to scan data from
 	idx_t scanned = 0;
@@ -227,6 +257,8 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
 		}
 		// Update state indices
 		read_state.entry_idx += next;
+		scanned += next;
+		total_scanned += next;
 		if (read_state.entry_idx == data_block->count) {
 			// Pin completed blocks so we don't lose them
 			pinned_blocks.emplace_back(rows.buffer_manager.Pin(data_block->block));
@@ -238,7 +270,6 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
 			read_state.entry_idx = 0;
 			ValidateUnscannedBlock();
 		}
-		scanned += next;
 	}
 	D_ASSERT(scanned == count);
 	// Deserialize the payload data
@@ -248,14 +279,13 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
 	}
 	chunk.SetCardinality(count);
 	chunk.Verify();
-	total_scanned += scanned;
 
 	//	Switch to a new set of pinned blocks
 	read_state.pinned_blocks.swap(pinned_blocks);
 
 	if (flush) {
 		// Release blocks we have passed.
-		for (idx_t i = 0; i < read_state.block_idx; ++i) {
+		for (idx_t i = flush_block_idx; i < read_state.block_idx; ++i) {
 			rows.blocks[i]->block = nullptr;
 			if (unswizzling) {
 				heap.blocks[i]->block = nullptr;
@@ -263,7 +293,7 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
 		}
 	} else if (unswizzling) {
 		// Reswizzle blocks we have passed so they can be flushed safely.
-		for (idx_t i = 0; i < read_state.block_idx; ++i) {
+		for (idx_t i = flush_block_idx; i < read_state.block_idx; ++i) {
 			auto &data_block = rows.blocks[i];
 			if (data_block->block && !data_block->block->IsSwizzled()) {
 				SwizzleBlock(*data_block, *heap.blocks[i]);

package/src/duckdb/src/execution/index/art/art.cpp

@@ -33,12 +33,9 @@ struct ARTIndexScanState : public IndexScanState {
 
 ART::ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
          const vector<unique_ptr<Expression>> &unbound_expressions, const IndexConstraintType constraint_type,
-         AttachedDatabase &db, const shared_ptr<vector<FixedSizeAllocator>> &allocators_ptr, const idx_t block_id,
-         const idx_t block_offset)
-
+         AttachedDatabase &db, const shared_ptr<vector<FixedSizeAllocator>> &allocators_ptr, BlockPointer pointer)
     : Index(db, IndexType::ART, table_io_manager, column_ids, unbound_expressions, constraint_type),
       allocators(allocators_ptr), owns_data(false) {
-
 	if (!Radix::IsLittleEndian()) {
 		throw NotImplementedException("ART indexes are not supported on big endian architectures");
 	}
@@ -57,12 +54,12 @@ ART::ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
 
 	// set the root node of the tree
 	tree = make_uniq<Node>();
-	if (block_id != DConstants::INVALID_INDEX) {
+	serialized_data_pointer = pointer;
+	if (pointer.IsValid()) {
 		tree->SetSerialized();
-		tree->SetPtr(block_id, block_offset);
+		tree->SetPtr(pointer.block_id, pointer.offset);
 		tree->Deserialize(*this);
 	}
-	serialized_data_pointer = BlockPointer(block_id, block_offset);
 
 	// validate the types of the key columns
 	for (idx_t i = 0; i < types.size(); i++) {
@@ -974,13 +971,13 @@ void ART::CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_m
 // Serialization
 //===--------------------------------------------------------------------===//
 
-BlockPointer ART::Serialize(MetaBlockWriter &writer) {
+BlockPointer ART::Serialize(MetadataWriter &writer) {
 
 	lock_guard<mutex> l(lock);
 	if (tree->IsSet()) {
 		serialized_data_pointer = tree->Serialize(*this, writer);
 	} else {
-		serialized_data_pointer = {(block_id_t)DConstants::INVALID_INDEX, (uint32_t)DConstants::INVALID_INDEX};
+		serialized_data_pointer = BlockPointer();
 	}
 
 	return serialized_data_pointer;

package/src/duckdb/src/execution/index/art/leaf.cpp

@@ -2,8 +2,8 @@
 
 #include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/storage/meta_block_reader.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
+#include "duckdb/storage/metadata/metadata_reader.hpp"
+#include "duckdb/storage/metadata/metadata_writer.hpp"
 
 namespace duckdb {
 
@@ -323,7 +323,7 @@ string Leaf::VerifyAndToString(ART &art, Node &node) {
 	return str;
 }
 
-BlockPointer Leaf::Serialize(ART &art, Node &node, MetaBlockWriter &writer) {
+BlockPointer Leaf::Serialize(ART &art, Node &node, MetadataWriter &writer) {
 
 	if (node.GetType() == NType::LEAF_INLINED) {
 		auto block_pointer = writer.GetBlockPointer();
@@ -353,7 +353,7 @@ BlockPointer Leaf::Serialize(ART &art, Node &node, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Leaf::Deserialize(ART &art, Node &node, MetaBlockReader &reader) {
+void Leaf::Deserialize(ART &art, Node &node, MetadataReader &reader) {
 
 	auto total_count = reader.Read<idx_t>();
 	reference<Node> ref_node(node);

package/src/duckdb/src/execution/index/art/node.cpp

@@ -9,8 +9,8 @@
 #include "duckdb/execution/index/art/node4.hpp"
 #include "duckdb/execution/index/art/leaf.hpp"
 #include "duckdb/execution/index/art/prefix.hpp"
-#include "duckdb/storage/meta_block_reader.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
+#include "duckdb/storage/metadata/metadata_reader.hpp"
+#include "duckdb/storage/metadata/metadata_writer.hpp"
 #include "duckdb/storage/table_io_manager.hpp"
 
 namespace duckdb {
@@ -19,13 +19,12 @@ namespace duckdb {
 // Constructors / Destructors
 //===--------------------------------------------------------------------===//
 
-Node::Node(MetaBlockReader &reader) {
-
-	idx_t block_id = reader.Read<block_id_t>();
+Node::Node(MetadataReader &reader) {
+	block_id_t block_id = reader.Read<block_id_t>();
 	auto offset = reader.Read<uint32_t>();
 	Reset();
 
-	if (block_id == DConstants::INVALID_INDEX) {
+	if (block_id == INVALID_BLOCK) {
 		return;
 	}
 
@@ -223,10 +222,9 @@ optional_ptr<Node> Node::GetNextChild(ART &art, uint8_t &byte, const bool deseri
 // (De)serialization
 //===--------------------------------------------------------------------===//
 
-BlockPointer Node::Serialize(ART &art, MetaBlockWriter &writer) {
-
+BlockPointer Node::Serialize(ART &art, MetadataWriter &writer) {
 	if (!IsSet()) {
-		return {(block_id_t)DConstants::INVALID_INDEX, 0};
+		return BlockPointer();
 	}
 	if (IsSerialized()) {
 		Deserialize(art);
@@ -254,11 +252,10 @@ BlockPointer Node::Serialize(ART &art, MetaBlockWriter &writer) {
 }
 
 void Node::Deserialize(ART &art) {
-
 	D_ASSERT(IsSet() && IsSerialized());
 
-	MetaBlockReader reader(art.table_io_manager.GetIndexBlockManager(), GetBufferId());
-	reader.offset = GetOffset();
+	BlockPointer pointer(GetBufferId(), GetOffset());
+	MetadataReader reader(art.table_io_manager.GetMetadataManager(), pointer);
 	Reset();
 	SetType(reader.Read<uint8_t>());
 

package/src/duckdb/src/execution/index/art/node16.cpp

@@ -2,8 +2,8 @@
 
 #include "duckdb/execution/index/art/node4.hpp"
 #include "duckdb/execution/index/art/node48.hpp"
-#include "duckdb/storage/meta_block_reader.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
+#include "duckdb/storage/metadata/metadata_reader.hpp"
+#include "duckdb/storage/metadata/metadata_writer.hpp"
 
 namespace duckdb {
 
@@ -173,7 +173,7 @@ optional_ptr<Node> Node16::GetNextChild(uint8_t &byte) {
 	return nullptr;
 }
 
-BlockPointer Node16::Serialize(ART &art, MetaBlockWriter &writer) {
+BlockPointer Node16::Serialize(ART &art, MetadataWriter &writer) {
 
 	// recurse into children and retrieve child block pointers
 	vector<BlockPointer> child_block_pointers;
@@ -203,7 +203,7 @@ BlockPointer Node16::Serialize(ART &art, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Node16::Deserialize(MetaBlockReader &reader) {
+void Node16::Deserialize(MetadataReader &reader) {
 
 	count = reader.Read<uint8_t>();
 

package/src/duckdb/src/execution/index/art/node256.cpp

@@ -1,8 +1,8 @@
 #include "duckdb/execution/index/art/node256.hpp"
 
 #include "duckdb/execution/index/art/node48.hpp"
-#include "duckdb/storage/meta_block_reader.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
+#include "duckdb/storage/metadata/metadata_reader.hpp"
+#include "duckdb/storage/metadata/metadata_writer.hpp"
 
 namespace duckdb {
 
@@ -109,7 +109,7 @@ optional_ptr<Node> Node256::GetNextChild(uint8_t &byte) {
 	return nullptr;
 }
 
-BlockPointer Node256::Serialize(ART &art, MetaBlockWriter &writer) {
+BlockPointer Node256::Serialize(ART &art, MetadataWriter &writer) {
 
 	// recurse into children and retrieve child block pointers
 	vector<BlockPointer> child_block_pointers;
@@ -131,7 +131,7 @@ BlockPointer Node256::Serialize(ART &art, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Node256::Deserialize(MetaBlockReader &reader) {
+void Node256::Deserialize(MetadataReader &reader) {
 
 	count = reader.Read<uint16_t>();
 

package/src/duckdb/src/execution/index/art/node4.cpp

@@ -2,8 +2,8 @@
 
 #include "duckdb/execution/index/art/prefix.hpp"
 #include "duckdb/execution/index/art/node16.hpp"
-#include "duckdb/storage/meta_block_reader.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
+#include "duckdb/storage/metadata/metadata_reader.hpp"
+#include "duckdb/storage/metadata/metadata_writer.hpp"
 
 namespace duckdb {
 
@@ -166,7 +166,7 @@ optional_ptr<Node> Node4::GetNextChild(uint8_t &byte) {
 	return nullptr;
 }
 
-BlockPointer Node4::Serialize(ART &art, MetaBlockWriter &writer) {
+BlockPointer Node4::Serialize(ART &art, MetadataWriter &writer) {
 
 	// recurse into children and retrieve child block pointers
 	vector<BlockPointer> child_block_pointers;
@@ -196,8 +196,7 @@ BlockPointer Node4::Serialize(ART &art, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Node4::Deserialize(MetaBlockReader &reader) {
-
+void Node4::Deserialize(MetadataReader &reader) {
 	count = reader.Read<uint8_t>();
 
 	// read key values

package/src/duckdb/src/execution/index/art/node48.cpp

@@ -2,8 +2,8 @@
 
 #include "duckdb/execution/index/art/node16.hpp"
 #include "duckdb/execution/index/art/node256.hpp"
-#include "duckdb/storage/meta_block_reader.hpp"
-#include "duckdb/storage/meta_block_writer.hpp"
+#include "duckdb/storage/metadata/metadata_reader.hpp"
+#include "duckdb/storage/metadata/metadata_writer.hpp"
 
 namespace duckdb {
 
@@ -168,7 +168,7 @@ optional_ptr<Node> Node48::GetNextChild(uint8_t &byte) {
 	return nullptr;
 }
 
-BlockPointer Node48::Serialize(ART &art, MetaBlockWriter &writer) {
+BlockPointer Node48::Serialize(ART &art, MetadataWriter &writer) {
 
 	// recurse into children and retrieve child block pointers
 	vector<BlockPointer> child_block_pointers;
@@ -195,7 +195,7 @@ BlockPointer Node48::Serialize(ART &art, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Node48::Deserialize(MetaBlockReader &reader) {
+void Node48::Deserialize(MetadataReader &reader) {
 
 	count = reader.Read<uint8_t>();