duckdb 0.8.2-dev33.0 → 0.8.2-dev3334.0

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

@@ -1,29 +1,26 @@
 #include "duckdb/execution/index/art/node16.hpp"
 
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
 #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 {
 
 Node16 &Node16::New(ART &art, Node &node) {
 
-	node.SetPtr(Node::GetAllocator(art, NType::NODE_16).New());
-	node.type = (uint8_t)NType::NODE_16;
+	node = Node::GetAllocator(art, NType::NODE_16).New();
+	node.SetType((uint8_t)NType::NODE_16);
 	auto &n16 = Node16::Get(art, node);
 
 	n16.count = 0;
-	n16.prefix.Initialize();
 	return n16;
 }
 
 void Node16::Free(ART &art, Node &node) {
 
 	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 
 	auto &n16 = Node16::Get(art, node);
 
@@ -39,8 +36,6 @@ Node16 &Node16::GrowNode4(ART &art, Node &node16, Node &node4) {
 	auto &n16 = Node16::New(art, node16);
 
 	n16.count = n4.count;
-	n16.prefix.Move(n4.prefix);
-
 	for (idx_t i = 0; i < n4.count; i++) {
 		n16.key[i] = n4.key[i];
 		n16.children[i] = n4.children[i];
@@ -57,8 +52,6 @@ Node16 &Node16::ShrinkNode48(ART &art, Node &node16, Node &node48) {
 	auto &n48 = Node48::Get(art, node48);
 
 	n16.count = 0;
-	n16.prefix.Move(n48.prefix);
-
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		D_ASSERT(n16.count <= Node::NODE_16_CAPACITY);
 		if (n48.child_index[i] != Node::EMPTY_MARKER) {
@@ -83,7 +76,7 @@ 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.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 	auto &n16 = Node16::Get(art, node);
 
 	// ensure that there is no other child at the same byte
@@ -119,7 +112,7 @@ 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.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 	auto &n16 = Node16::Get(art, node);
 
 	idx_t child_pos = 0;
@@ -180,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;
@@ -195,7 +188,6 @@ BlockPointer Node16::Serialize(ART &art, MetaBlockWriter &writer) {
 	auto block_pointer = writer.GetBlockPointer();
 	writer.Write(NType::NODE_16);
 	writer.Write<uint8_t>(count);
-	prefix.Serialize(art, writer);
 
 	// write key values
 	for (idx_t i = 0; i < Node::NODE_16_CAPACITY; i++) {
@@ -211,10 +203,9 @@ BlockPointer Node16::Serialize(ART &art, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Node16::Deserialize(ART &art, MetaBlockReader &reader) {
+void Node16::Deserialize(MetadataReader &reader) {
 
 	count = reader.Read<uint8_t>();
-	prefix.Deserialize(art, reader);
 
 	// read key values
 	for (idx_t i = 0; i < Node::NODE_16_CAPACITY; i++) {
@@ -230,7 +221,7 @@ void Node16::Deserialize(ART &art, MetaBlockReader &reader) {
 void Node16::Vacuum(ART &art, const ARTFlags &flags) {
 
 	for (idx_t i = 0; i < count; i++) {
-		Node::Vacuum(art, children[i], flags);
+		children[i].Vacuum(art, flags);
 	}
 }
 

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

@@ -1,22 +1,18 @@
 #include "duckdb/execution/index/art/node256.hpp"
 
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.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 {
 
 Node256 &Node256::New(ART &art, Node &node) {
 
-	node.SetPtr(Node::GetAllocator(art, NType::NODE_256).New());
-	node.type = (uint8_t)NType::NODE_256;
+	node = Node::GetAllocator(art, NType::NODE_256).New();
+	node.SetType((uint8_t)NType::NODE_256);
 	auto &n256 = Node256::Get(art, node);
 
 	n256.count = 0;
-	n256.prefix.Initialize();
-
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		n256.children[i].Reset();
 	}
@@ -27,7 +23,7 @@ Node256 &Node256::New(ART &art, Node &node) {
 void Node256::Free(ART &art, Node &node) {
 
 	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 
 	auto &n256 = Node256::Get(art, node);
 
@@ -49,8 +45,6 @@ Node256 &Node256::GrowNode48(ART &art, Node &node256, Node &node48) {
 	auto &n256 = Node256::New(art, node256);
 
 	n256.count = n48.count;
-	n256.prefix.Move(n48.prefix);
-
 	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]];
@@ -76,7 +70,7 @@ 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.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 	auto &n256 = Node256::Get(art, node);
 
 	// ensure that there is no other child at the same byte
@@ -90,7 +84,7 @@ 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.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 	auto &n256 = Node256::Get(art, node);
 
 	// free the child and decrease the count
@@ -115,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;
@@ -127,7 +121,6 @@ BlockPointer Node256::Serialize(ART &art, MetaBlockWriter &writer) {
 	auto block_pointer = writer.GetBlockPointer();
 	writer.Write(NType::NODE_256);
 	writer.Write<uint16_t>(count);
-	prefix.Serialize(art, writer);
 
 	// write child block pointers
 	for (auto &child_block_pointer : child_block_pointers) {
@@ -138,10 +131,9 @@ BlockPointer Node256::Serialize(ART &art, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Node256::Deserialize(ART &art, MetaBlockReader &reader) {
+void Node256::Deserialize(MetadataReader &reader) {
 
 	count = reader.Read<uint16_t>();
-	prefix.Deserialize(art, reader);
 
 	// read child block pointers
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
@@ -153,7 +145,7 @@ void Node256::Vacuum(ART &art, const ARTFlags &flags) {
 
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		if (children[i].IsSet()) {
-			Node::Vacuum(art, children[i], flags);
+			children[i].Vacuum(art, flags);
 		}
 	}
 }

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

@@ -1,28 +1,26 @@
 #include "duckdb/execution/index/art/node4.hpp"
 
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
+#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 {
 
 Node4 &Node4::New(ART &art, Node &node) {
 
-	node.SetPtr(Node::GetAllocator(art, NType::NODE_4).New());
-	node.type = (uint8_t)NType::NODE_4;
+	node = Node::GetAllocator(art, NType::NODE_4).New();
+	node.SetType((uint8_t)NType::NODE_4);
 	auto &n4 = Node4::Get(art, node);
 
 	n4.count = 0;
-	n4.prefix.Initialize();
 	return n4;
 }
 
 void Node4::Free(ART &art, Node &node) {
 
 	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 
 	auto &n4 = Node4::Get(art, node);
 
@@ -39,8 +37,6 @@ Node4 &Node4::ShrinkNode16(ART &art, Node &node4, Node &node16) {
 
 	D_ASSERT(n16.count <= Node::NODE_4_CAPACITY);
 	n4.count = n16.count;
-	n4.prefix.Move(n16.prefix);
-
 	for (idx_t i = 0; i < n16.count; i++) {
 		n4.key[i] = n16.key[i];
 		n4.children[i] = n16.children[i];
@@ -61,7 +57,7 @@ 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.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 	auto &n4 = Node4::Get(art, node);
 
 	// ensure that there is no other child at the same byte
@@ -94,10 +90,10 @@ void Node4::InsertChild(ART &art, Node &node, const uint8_t byte, const Node chi
 	}
 }
 
-void Node4::DeleteChild(ART &art, Node &node, const uint8_t byte) {
+void Node4::DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte) {
 
 	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 	auto &n4 = Node4::Get(art, node);
 
 	idx_t child_pos = 0;
@@ -123,13 +119,18 @@ void Node4::DeleteChild(ART &art, Node &node, const uint8_t byte) {
 	// this is a one way node, compress
 	if (n4.count == 1) {
 
+		// we need to keep track of the old node pointer
+		// because Concatenate() might overwrite that pointer while appending bytes to
+		// the prefix (and by doing so overwriting the subsequent node with
+		// new prefix nodes)
+		auto old_n4_node = node;
+
 		// get only child and concatenate prefixes
 		auto child = *n4.GetChild(n4.key[0]);
-		child.GetPrefix(art).Concatenate(art, n4.key[0], n4.prefix);
-		n4.count--;
+		Prefix::Concatenate(art, prefix, n4.key[0], child);
 
-		Node::Free(art, node);
-		node = child;
+		n4.count--;
+		Node::Free(art, old_n4_node);
 	}
 }
 
@@ -165,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;
@@ -180,7 +181,6 @@ BlockPointer Node4::Serialize(ART &art, MetaBlockWriter &writer) {
 	auto block_pointer = writer.GetBlockPointer();
 	writer.Write(NType::NODE_4);
 	writer.Write<uint8_t>(count);
-	prefix.Serialize(art, writer);
 
 	// write key values
 	for (idx_t i = 0; i < Node::NODE_4_CAPACITY; i++) {
@@ -196,10 +196,8 @@ BlockPointer Node4::Serialize(ART &art, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Node4::Deserialize(ART &art, MetaBlockReader &reader) {
-
+void Node4::Deserialize(MetadataReader &reader) {
 	count = reader.Read<uint8_t>();
-	prefix.Deserialize(art, reader);
 
 	// read key values
 	for (idx_t i = 0; i < Node::NODE_4_CAPACITY; i++) {
@@ -215,7 +213,7 @@ void Node4::Deserialize(ART &art, MetaBlockReader &reader) {
 void Node4::Vacuum(ART &art, const ARTFlags &flags) {
 
 	for (idx_t i = 0; i < count; i++) {
-		Node::Vacuum(art, children[i], flags);
+		children[i].Vacuum(art, flags);
 	}
 }
 

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

@@ -1,23 +1,19 @@
 #include "duckdb/execution/index/art/node48.hpp"
 
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/node.hpp"
 #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 {
 
 Node48 &Node48::New(ART &art, Node &node) {
 
-	node.SetPtr(Node::GetAllocator(art, NType::NODE_48).New());
-	node.type = (uint8_t)NType::NODE_48;
+	node = Node::GetAllocator(art, NType::NODE_48).New();
+	node.SetType((uint8_t)NType::NODE_48);
 	auto &n48 = Node48::Get(art, node);
 
 	n48.count = 0;
-	n48.prefix.Initialize();
-
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		n48.child_index[i] = Node::EMPTY_MARKER;
 	}
@@ -33,7 +29,7 @@ Node48 &Node48::New(ART &art, Node &node) {
 void Node48::Free(ART &art, Node &node) {
 
 	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 
 	auto &n48 = Node48::Get(art, node);
 
@@ -55,8 +51,6 @@ Node48 &Node48::GrowNode16(ART &art, Node &node48, Node &node16) {
 	auto &n48 = Node48::New(art, node48);
 
 	n48.count = n16.count;
-	n48.prefix.Move(n16.prefix);
-
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		n48.child_index[i] = Node::EMPTY_MARKER;
 	}
@@ -82,8 +76,6 @@ Node48 &Node48::ShrinkNode256(ART &art, Node &node48, Node &node256) {
 	auto &n256 = Node256::Get(art, node256);
 
 	n48.count = 0;
-	n48.prefix.Move(n256.prefix);
-
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		D_ASSERT(n48.count <= Node::NODE_48_CAPACITY);
 		if (n256.children[i].IsSet()) {
@@ -117,7 +109,7 @@ void Node48::InitializeMerge(ART &art, const ARTFlags &flags) {
 void Node48::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
 
 	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 	auto &n48 = Node48::Get(art, node);
 
 	// ensure that there is no other child at the same byte
@@ -149,7 +141,7 @@ void Node48::InsertChild(ART &art, Node &node, const uint8_t byte, const Node ch
 void Node48::DeleteChild(ART &art, Node &node, const uint8_t byte) {
 
 	D_ASSERT(node.IsSet());
-	D_ASSERT(!node.IsSwizzled());
+	D_ASSERT(!node.IsSerialized());
 	auto &n48 = Node48::Get(art, node);
 
 	// free the child and decrease the count
@@ -176,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;
@@ -188,7 +180,6 @@ BlockPointer Node48::Serialize(ART &art, MetaBlockWriter &writer) {
 	auto block_pointer = writer.GetBlockPointer();
 	writer.Write(NType::NODE_48);
 	writer.Write<uint8_t>(count);
-	prefix.Serialize(art, writer);
 
 	// write key values
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
@@ -204,10 +195,9 @@ BlockPointer Node48::Serialize(ART &art, MetaBlockWriter &writer) {
 	return block_pointer;
 }
 
-void Node48::Deserialize(ART &art, MetaBlockReader &reader) {
+void Node48::Deserialize(MetadataReader &reader) {
 
 	count = reader.Read<uint8_t>();
-	prefix.Deserialize(art, reader);
 
 	// read key values
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
@@ -224,7 +214,7 @@ void Node48::Vacuum(ART &art, const ARTFlags &flags) {
 
 	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
 		if (child_index[i] != Node::EMPTY_MARKER) {
-			Node::Vacuum(art, children[child_index[i]], flags);
+			children[child_index[i]].Vacuum(art, flags);
 		}
 	}
 }