duckdb 0.8.2-dev4025.0 → 0.8.2-dev4142.0

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

@@ -2,16 +2,14 @@
 
 #include "duckdb/execution/index/art/node4.hpp"
 #include "duckdb/execution/index/art/node48.hpp"
-#include "duckdb/storage/metadata/metadata_reader.hpp"
-#include "duckdb/storage/metadata/metadata_writer.hpp"
 
 namespace duckdb {
 
 Node16 &Node16::New(ART &art, Node &node) {
 
 	node = Node::GetAllocator(art, NType::NODE_16).New();
-	node.SetType((uint8_t)NType::NODE_16);
-	auto &n16 = Node16::Get(art, node);
+	node.SetMetadata(static_cast<uint8_t>(NType::NODE_16));
+	auto &n16 = Node::RefMutable<Node16>(art, node, NType::NODE_16);
 
 	n16.count = 0;
 	return n16;
@@ -19,10 +17,8 @@ Node16 &Node16::New(ART &art, Node &node) {
 
 void Node16::Free(ART &art, Node &node) {
 
-	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSerialized());
-
-	auto &n16 = Node16::Get(art, node);
+	D_ASSERT(node.HasMetadata());
+	auto &n16 = Node::RefMutable<Node16>(art, node, NType::NODE_16);
 
 	// free all children
 	for (idx_t i = 0; i < n16.count; i++) {
@@ -32,8 +28,8 @@ void Node16::Free(ART &art, Node &node) {
 
 Node16 &Node16::GrowNode4(ART &art, Node &node16, Node &node4) {
 
-	auto &n4 = Node4::Get(art, node4);
-	auto &n16 = Node16::New(art, node16);
+	auto &n4 = Node::RefMutable<Node4>(art, node4, NType::NODE_4);
+	auto &n16 = New(art, node16);
 
 	n16.count = n4.count;
 	for (idx_t i = 0; i < n4.count; i++) {
@@ -48,8 +44,8 @@ Node16 &Node16::GrowNode4(ART &art, Node &node16, Node &node4) {
 
 Node16 &Node16::ShrinkNode48(ART &art, Node &node16, Node &node48) {
 
-	auto &n16 = Node16::New(art, node16);
-	auto &n48 = Node48::Get(art, node48);
+	auto &n16 = New(art, node16);
+	auto &n48 = Node::RefMutable<Node48>(art, node48, NType::NODE_48);
 
 	n16.count = 0;
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
@@ -75,9 +71,8 @@ void Node16::InitializeMerge(ART &art, const ARTFlags &flags) {
 
 void Node16::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
 
-	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSerialized());
-	auto &n16 = Node16::Get(art, node);
+	D_ASSERT(node.HasMetadata());
+	auto &n16 = Node::RefMutable<Node16>(art, node, NType::NODE_16);
 
 	// ensure that there is no other child at the same byte
 	for (idx_t i = 0; i < n16.count; i++) {
@@ -111,9 +106,8 @@ void Node16::InsertChild(ART &art, Node &node, const uint8_t byte, const Node ch
 
 void Node16::DeleteChild(ART &art, Node &node, const uint8_t byte) {
 
-	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSerialized());
-	auto &n16 = Node16::Get(art, node);
+	D_ASSERT(node.HasMetadata());
+	auto &n16 = Node::RefMutable<Node16>(art, node, NType::NODE_16);
 
 	idx_t child_pos = 0;
 	for (; child_pos < n16.count; child_pos++) {
@@ -150,72 +144,46 @@ void Node16::ReplaceChild(const uint8_t byte, const Node child) {
 	}
 }
 
-optional_ptr<Node> Node16::GetChild(const uint8_t byte) {
-
+optional_ptr<const Node> Node16::GetChild(const uint8_t byte) const {
 	for (idx_t i = 0; i < count; i++) {
 		if (key[i] == byte) {
-			D_ASSERT(children[i].IsSet());
+			D_ASSERT(children[i].HasMetadata());
 			return &children[i];
 		}
 	}
 	return nullptr;
 }
 
-optional_ptr<Node> Node16::GetNextChild(uint8_t &byte) {
-
+optional_ptr<Node> Node16::GetChildMutable(const uint8_t byte) {
 	for (idx_t i = 0; i < count; i++) {
-		if (key[i] >= byte) {
-			byte = key[i];
-			D_ASSERT(children[i].IsSet());
+		if (key[i] == byte) {
+			D_ASSERT(children[i].HasMetadata());
 			return &children[i];
 		}
 	}
 	return nullptr;
 }
 
-BlockPointer Node16::Serialize(ART &art, MetadataWriter &writer) {
-
-	// recurse into children and retrieve child block pointers
-	vector<BlockPointer> child_block_pointers;
+optional_ptr<const Node> Node16::GetNextChild(uint8_t &byte) const {
 	for (idx_t i = 0; i < count; i++) {
-		child_block_pointers.push_back(children[i].Serialize(art, writer));
-	}
-	for (idx_t i = count; i < Node::NODE_16_CAPACITY; i++) {
-		child_block_pointers.emplace_back((block_id_t)DConstants::INVALID_INDEX, 0);
-	}
-
-	// get pointer and write fields
-	auto block_pointer = writer.GetBlockPointer();
-	writer.Write(NType::NODE_16);
-	writer.Write<uint8_t>(count);
-
-	// write key values
-	for (idx_t i = 0; i < Node::NODE_16_CAPACITY; i++) {
-		writer.Write(key[i]);
-	}
-
-	// write child block pointers
-	for (auto &child_block_pointer : child_block_pointers) {
-		writer.Write(child_block_pointer.block_id);
-		writer.Write(child_block_pointer.offset);
+		if (key[i] >= byte) {
+			byte = key[i];
+			D_ASSERT(children[i].HasMetadata());
+			return &children[i];
+		}
 	}
-
-	return block_pointer;
+	return nullptr;
 }
 
-void Node16::Deserialize(MetadataReader &reader) {
-
-	count = reader.Read<uint8_t>();
-
-	// read key values
-	for (idx_t i = 0; i < Node::NODE_16_CAPACITY; i++) {
-		key[i] = reader.Read<uint8_t>();
-	}
-
-	// read child block pointers
-	for (idx_t i = 0; i < Node::NODE_16_CAPACITY; i++) {
-		children[i] = Node(reader);
+optional_ptr<Node> Node16::GetNextChildMutable(uint8_t &byte) {
+	for (idx_t i = 0; i < count; i++) {
+		if (key[i] >= byte) {
+			byte = key[i];
+			D_ASSERT(children[i].HasMetadata());
+			return &children[i];
+		}
 	}
+	return nullptr;
 }
 
 void Node16::Vacuum(ART &art, const ARTFlags &flags) {

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

@@ -1,20 +1,18 @@
 #include "duckdb/execution/index/art/node256.hpp"
 
 #include "duckdb/execution/index/art/node48.hpp"
-#include "duckdb/storage/metadata/metadata_reader.hpp"
-#include "duckdb/storage/metadata/metadata_writer.hpp"
 
 namespace duckdb {
 
 Node256 &Node256::New(ART &art, Node &node) {
 
 	node = Node::GetAllocator(art, NType::NODE_256).New();
-	node.SetType((uint8_t)NType::NODE_256);
-	auto &n256 = Node256::Get(art, node);
+	node.SetMetadata(static_cast<uint8_t>(NType::NODE_256));
+	auto &n256 = Node::RefMutable<Node256>(art, node, NType::NODE_256);
 
 	n256.count = 0;
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
-		n256.children[i].Reset();
+		n256.children[i].Clear();
 	}
 
 	return n256;
@@ -22,10 +20,8 @@ Node256 &Node256::New(ART &art, Node &node) {
 
 void Node256::Free(ART &art, Node &node) {
 
-	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSerialized());
-
-	auto &n256 = Node256::Get(art, node);
+	D_ASSERT(node.HasMetadata());
+	auto &n256 = Node::RefMutable<Node256>(art, node, NType::NODE_256);
 
 	if (!n256.count) {
 		return;
@@ -33,7 +29,7 @@ void Node256::Free(ART &art, Node &node) {
 
 	// free all children
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
-		if (n256.children[i].IsSet()) {
+		if (n256.children[i].HasMetadata()) {
 			Node::Free(art, n256.children[i]);
 		}
 	}
@@ -41,15 +37,15 @@ void Node256::Free(ART &art, Node &node) {
 
 Node256 &Node256::GrowNode48(ART &art, Node &node256, Node &node48) {
 
-	auto &n48 = Node48::Get(art, node48);
-	auto &n256 = Node256::New(art, node256);
+	auto &n48 = Node::RefMutable<Node48>(art, node48, NType::NODE_48);
+	auto &n256 = New(art, node256);
 
 	n256.count = n48.count;
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		if (n48.child_index[i] != Node::EMPTY_MARKER) {
 			n256.children[i] = n48.children[n48.child_index[i]];
 		} else {
-			n256.children[i].Reset();
+			n256.children[i].Clear();
 		}
 	}
 
@@ -61,7 +57,7 @@ Node256 &Node256::GrowNode48(ART &art, Node &node256, Node &node48) {
 void Node256::InitializeMerge(ART &art, const ARTFlags &flags) {
 
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
-		if (children[i].IsSet()) {
+		if (children[i].HasMetadata()) {
 			children[i].InitializeMerge(art, flags);
 		}
 	}
@@ -69,12 +65,11 @@ void Node256::InitializeMerge(ART &art, const ARTFlags &flags) {
 
 void Node256::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
 
-	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSerialized());
-	auto &n256 = Node256::Get(art, node);
+	D_ASSERT(node.HasMetadata());
+	auto &n256 = Node::RefMutable<Node256>(art, node, NType::NODE_256);
 
 	// ensure that there is no other child at the same byte
-	D_ASSERT(!n256.children[byte].IsSet());
+	D_ASSERT(!n256.children[byte].HasMetadata());
 
 	n256.count++;
 	D_ASSERT(n256.count <= Node::NODE_256_CAPACITY);
@@ -83,9 +78,8 @@ void Node256::InsertChild(ART &art, Node &node, const uint8_t byte, const Node c
 
 void Node256::DeleteChild(ART &art, Node &node, const uint8_t byte) {
 
-	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSerialized());
-	auto &n256 = Node256::Get(art, node);
+	D_ASSERT(node.HasMetadata());
+	auto &n256 = Node::RefMutable<Node256>(art, node, NType::NODE_256);
 
 	// free the child and decrease the count
 	Node::Free(art, n256.children[byte]);
@@ -98,53 +92,44 @@ void Node256::DeleteChild(ART &art, Node &node, const uint8_t byte) {
 	}
 }
 
-optional_ptr<Node> Node256::GetNextChild(uint8_t &byte) {
-
-	for (idx_t i = byte; i < Node::NODE_256_CAPACITY; i++) {
-		if (children[i].IsSet()) {
-			byte = i;
-			return &children[i];
-		}
+optional_ptr<const Node> Node256::GetChild(const uint8_t byte) const {
+	if (children[byte].HasMetadata()) {
+		return &children[byte];
 	}
 	return nullptr;
 }
 
-BlockPointer Node256::Serialize(ART &art, MetadataWriter &writer) {
-
-	// recurse into children and retrieve child block pointers
-	vector<BlockPointer> child_block_pointers;
-	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
-		child_block_pointers.push_back(children[i].Serialize(art, writer));
+optional_ptr<Node> Node256::GetChildMutable(const uint8_t byte) {
+	if (children[byte].HasMetadata()) {
+		return &children[byte];
 	}
+	return nullptr;
+}
 
-	// get pointer and write fields
-	auto block_pointer = writer.GetBlockPointer();
-	writer.Write(NType::NODE_256);
-	writer.Write<uint16_t>(count);
-
-	// write child block pointers
-	for (auto &child_block_pointer : child_block_pointers) {
-		writer.Write(child_block_pointer.block_id);
-		writer.Write(child_block_pointer.offset);
+optional_ptr<const Node> Node256::GetNextChild(uint8_t &byte) const {
+	for (idx_t i = byte; i < Node::NODE_256_CAPACITY; i++) {
+		if (children[i].HasMetadata()) {
+			byte = i;
+			return &children[i];
+		}
 	}
-
-	return block_pointer;
+	return nullptr;
 }
 
-void Node256::Deserialize(MetadataReader &reader) {
-
-	count = reader.Read<uint16_t>();
-
-	// read child block pointers
-	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
-		children[i] = Node(reader);
+optional_ptr<Node> Node256::GetNextChildMutable(uint8_t &byte) {
+	for (idx_t i = byte; i < Node::NODE_256_CAPACITY; i++) {
+		if (children[i].HasMetadata()) {
+			byte = i;
+			return &children[i];
+		}
 	}
+	return nullptr;
 }
 
 void Node256::Vacuum(ART &art, const ARTFlags &flags) {
 
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
-		if (children[i].IsSet()) {
+		if (children[i].HasMetadata()) {
 			children[i].Vacuum(art, flags);
 		}
 	}

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

@@ -2,16 +2,14 @@
 
 #include "duckdb/execution/index/art/prefix.hpp"
 #include "duckdb/execution/index/art/node16.hpp"
-#include "duckdb/storage/metadata/metadata_reader.hpp"
-#include "duckdb/storage/metadata/metadata_writer.hpp"
 
 namespace duckdb {
 
 Node4 &Node4::New(ART &art, Node &node) {
 
 	node = Node::GetAllocator(art, NType::NODE_4).New();
-	node.SetType((uint8_t)NType::NODE_4);
-	auto &n4 = Node4::Get(art, node);
+	node.SetMetadata(static_cast<uint8_t>(NType::NODE_4));
+	auto &n4 = Node::RefMutable<Node4>(art, node, NType::NODE_4);
 
 	n4.count = 0;
 	return n4;
@@ -19,10 +17,8 @@ Node4 &Node4::New(ART &art, Node &node) {
 
 void Node4::Free(ART &art, Node &node) {
 
-	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSerialized());
-
-	auto &n4 = Node4::Get(art, node);
+	D_ASSERT(node.HasMetadata());
+	auto &n4 = Node::RefMutable<Node4>(art, node, NType::NODE_4);
 
 	// free all children
 	for (idx_t i = 0; i < n4.count; i++) {
@@ -32,8 +28,8 @@ void Node4::Free(ART &art, Node &node) {
 
 Node4 &Node4::ShrinkNode16(ART &art, Node &node4, Node &node16) {
 
-	auto &n4 = Node4::New(art, node4);
-	auto &n16 = Node16::Get(art, node16);
+	auto &n4 = New(art, node4);
+	auto &n16 = Node::RefMutable<Node16>(art, node16, NType::NODE_16);
 
 	D_ASSERT(n16.count <= Node::NODE_4_CAPACITY);
 	n4.count = n16.count;
@@ -56,9 +52,8 @@ void Node4::InitializeMerge(ART &art, const ARTFlags &flags) {
 
 void Node4::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
 
-	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSerialized());
-	auto &n4 = Node4::Get(art, node);
+	D_ASSERT(node.HasMetadata());
+	auto &n4 = Node::RefMutable<Node4>(art, node, NType::NODE_4);
 
 	// ensure that there is no other child at the same byte
 	for (idx_t i = 0; i < n4.count; i++) {
@@ -92,9 +87,8 @@ void Node4::InsertChild(ART &art, Node &node, const uint8_t byte, const Node chi
 
 void Node4::DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte) {
 
-	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSerialized());
-	auto &n4 = Node4::Get(art, node);
+	D_ASSERT(node.HasMetadata());
+	auto &n4 = Node::RefMutable<Node4>(art, node, NType::NODE_4);
 
 	idx_t child_pos = 0;
 	for (; child_pos < n4.count; child_pos++) {
@@ -126,7 +120,7 @@ void Node4::DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte)
 		auto old_n4_node = node;
 
 		// get only child and concatenate prefixes
-		auto child = *n4.GetChild(n4.key[0]);
+		auto child = *n4.GetChildMutable(n4.key[0]);
 		Prefix::Concatenate(art, prefix, n4.key[0], child);
 
 		n4.count--;
@@ -143,71 +137,46 @@ void Node4::ReplaceChild(const uint8_t byte, const Node child) {
 	}
 }
 
-optional_ptr<Node> Node4::GetChild(const uint8_t byte) {
-
+optional_ptr<const Node> Node4::GetChild(const uint8_t byte) const {
 	for (idx_t i = 0; i < count; i++) {
 		if (key[i] == byte) {
-			D_ASSERT(children[i].IsSet());
+			D_ASSERT(children[i].HasMetadata());
 			return &children[i];
 		}
 	}
 	return nullptr;
 }
 
-optional_ptr<Node> Node4::GetNextChild(uint8_t &byte) {
-
+optional_ptr<Node> Node4::GetChildMutable(const uint8_t byte) {
 	for (idx_t i = 0; i < count; i++) {
-		if (key[i] >= byte) {
-			byte = key[i];
-			D_ASSERT(children[i].IsSet());
+		if (key[i] == byte) {
+			D_ASSERT(children[i].HasMetadata());
 			return &children[i];
 		}
 	}
 	return nullptr;
 }
 
-BlockPointer Node4::Serialize(ART &art, MetadataWriter &writer) {
-
-	// recurse into children and retrieve child block pointers
-	vector<BlockPointer> child_block_pointers;
+optional_ptr<const Node> Node4::GetNextChild(uint8_t &byte) const {
 	for (idx_t i = 0; i < count; i++) {
-		child_block_pointers.push_back(children[i].Serialize(art, writer));
-	}
-	for (idx_t i = count; i < Node::NODE_4_CAPACITY; i++) {
-		child_block_pointers.emplace_back((block_id_t)DConstants::INVALID_INDEX, 0);
-	}
-
-	// get pointer and write fields
-	auto block_pointer = writer.GetBlockPointer();
-	writer.Write(NType::NODE_4);
-	writer.Write<uint8_t>(count);
-
-	// write key values
-	for (idx_t i = 0; i < Node::NODE_4_CAPACITY; i++) {
-		writer.Write(key[i]);
-	}
-
-	// write child block pointers
-	for (auto &child_block_pointer : child_block_pointers) {
-		writer.Write(child_block_pointer.block_id);
-		writer.Write(child_block_pointer.offset);
+		if (key[i] >= byte) {
+			byte = key[i];
+			D_ASSERT(children[i].HasMetadata());
+			return &children[i];
+		}
 	}
-
-	return block_pointer;
+	return nullptr;
 }
 
-void Node4::Deserialize(MetadataReader &reader) {
-	count = reader.Read<uint8_t>();
-
-	// read key values
-	for (idx_t i = 0; i < Node::NODE_4_CAPACITY; i++) {
-		key[i] = reader.Read<uint8_t>();
-	}
-
-	// read child block pointers
-	for (idx_t i = 0; i < Node::NODE_4_CAPACITY; i++) {
-		children[i] = Node(reader);
+optional_ptr<Node> Node4::GetNextChildMutable(uint8_t &byte) {
+	for (idx_t i = 0; i < count; i++) {
+		if (key[i] >= byte) {
+			byte = key[i];
+			D_ASSERT(children[i].HasMetadata());
+			return &children[i];
+		}
 	}
+	return nullptr;
 }
 
 void Node4::Vacuum(ART &art, const ARTFlags &flags) {