duckdb 0.7.2-dev2552.0 → 0.7.2-dev2675.0

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

@@ -1,170 +1,234 @@
 #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 <cstring>
+#include "duckdb/storage/meta_block_reader.hpp"
+#include "duckdb/storage/meta_block_writer.hpp"
 
 namespace duckdb {
 
-Node16::Node16() : Node(NodeType::N16) {
-	memset(key, 16, sizeof(key));
+Node16 &Node16::New(ART &art, Node &node) {
+
+	node.SetPtr(Node::GetAllocator(art, NType::NODE_16).New());
+	node.type = (uint8_t)NType::NODE_16;
+	auto &n16 = Node16::Get(art, node);
+
+	n16.count = 0;
+	n16.prefix.Initialize();
+	return n16;
 }
 
-idx_t Node16::MemorySize(ART &art, const bool &recurse) {
-	if (recurse) {
-		return prefix.MemorySize() + sizeof(*this) + RecursiveMemorySize(art);
+void Node16::Free(ART &art, Node &node) {
+
+	D_ASSERT(node.IsSet());
+	D_ASSERT(!node.IsSwizzled());
+
+	auto &n16 = Node16::Get(art, node);
+
+	// free all children
+	for (idx_t i = 0; i < n16.count; i++) {
+		Node::Free(art, n16.children[i]);
 	}
-	return prefix.MemorySize() + sizeof(*this);
 }
 
-idx_t Node16::GetChildPos(uint8_t k) {
-	for (idx_t pos = 0; pos < count; pos++) {
-		if (key[pos] == k) {
-			return pos;
-		}
+Node16 &Node16::GrowNode4(ART &art, Node &node16, Node &node4) {
+
+	auto &n4 = Node4::Get(art, 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];
 	}
-	return Node::GetChildPos(k);
+
+	n4.count = 0;
+	Node::Free(art, node4);
+	return n16;
 }
 
-idx_t Node16::GetChildGreaterEqual(uint8_t k, bool &equal) {
-	for (idx_t pos = 0; pos < count; pos++) {
-		if (key[pos] >= k) {
-			if (key[pos] == k) {
-				equal = true;
-			} else {
-				equal = false;
-			}
+Node16 &Node16::ShrinkNode48(ART &art, Node &node16, Node &node48) {
+
+	auto &n16 = Node16::New(art, node16);
+	auto &n48 = Node48::Get(art, node48);
 
-			return pos;
+	n16.count = 0;
+	n16.prefix.Move(n48.prefix);
+
+	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
+		if (n48.child_index[i] != Node::EMPTY_MARKER) {
+			n16.key[n16.count] = i;
+			n16.children[n16.count] = n48.children[n48.child_index[i]];
+			n16.count++;
 		}
 	}
-	return DConstants::INVALID_INDEX;
-}
 
-idx_t Node16::GetMin() {
-	return 0;
+	n48.count = 0;
+	Node::Free(art, node48);
+	return n16;
 }
 
-idx_t Node16::GetNextPos(idx_t pos) {
-	if (pos == DConstants::INVALID_INDEX) {
-		return 0;
-	}
-	pos++;
-	return pos < count ? pos : DConstants::INVALID_INDEX;
-}
+void Node16::InitializeMerge(ART &art, const ARTFlags &flags) {
 
-idx_t Node16::GetNextPosAndByte(idx_t pos, uint8_t &byte) {
-	if (pos == DConstants::INVALID_INDEX) {
-		byte = key[0];
-		return 0;
+	for (idx_t i = 0; i < count; i++) {
+		children[i].InitializeMerge(art, flags);
 	}
-	pos++;
-	if (pos < count) {
-		byte = key[pos];
-		return pos;
-	}
-	return DConstants::INVALID_INDEX;
-}
-
-Node *Node16::GetChild(ART &art, idx_t pos) {
-	D_ASSERT(pos < count);
-	return children[pos].Unswizzle(art);
 }
 
-void Node16::ReplaceChildPointer(idx_t pos, Node *node) {
-	children[pos] = node;
-}
+void Node16::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
 
-bool Node16::ChildIsInMemory(idx_t pos) {
-	return children[pos] && !children[pos].IsSwizzled();
-}
+	D_ASSERT(node.IsSet());
+	D_ASSERT(!node.IsSwizzled());
+	auto &n16 = Node16::Get(art, node);
 
-void Node16::InsertChild(ART &art, Node *&node, uint8_t key_byte, Node *new_child) {
-	Node16 *n = (Node16 *)node;
+	// ensure that there is no other child at the same byte
+	for (idx_t i = 0; i < n16.count; i++) {
+		D_ASSERT(n16.key[i] != byte);
+	}
 
 	// insert new child node into node
-	if (n->count < Node16::GetSize()) {
+	if (n16.count < Node::NODE_16_CAPACITY) {
 		// still space, just insert the child
-		idx_t pos = 0;
-		while (pos < node->count && n->key[pos] < key_byte) {
-			pos++;
+		idx_t child_pos = 0;
+		while (child_pos < n16.count && n16.key[child_pos] < byte) {
+			child_pos++;
 		}
-		if (n->children[pos]) {
-			for (idx_t i = n->count; i > pos; i--) {
-				n->key[i] = n->key[i - 1];
-				n->children[i] = n->children[i - 1];
-			}
+		// move children backwards to make space
+		for (idx_t i = n16.count; i > child_pos; i--) {
+			n16.key[i] = n16.key[i - 1];
+			n16.children[i] = n16.children[i - 1];
 		}
-		n->key[pos] = key_byte;
-		n->children[pos] = new_child;
-		n->count++;
+
+		n16.key[child_pos] = byte;
+		n16.children[child_pos] = child;
+		n16.count++;
 
 	} else {
 		// node is full, grow to Node48
-		auto new_node = Node48::New();
-		art.IncreaseMemorySize(new_node->MemorySize(art, false));
-		new_node->count = node->count;
-		new_node->prefix = std::move(n->prefix);
-
-		for (idx_t i = 0; i < node->count; i++) {
-			new_node->child_index[n->key[i]] = i;
-			new_node->children[i] = n->children[i];
-			n->children[i] = nullptr;
-		}
-
-		art.DecreaseMemorySize(node->MemorySize(art, false));
-		Node::Delete(node);
-		node = new_node;
-		Node48::InsertChild(art, node, key_byte, new_child);
+		auto node16 = node;
+		Node48::GrowNode16(art, node, node16);
+		Node48::InsertChild(art, node, byte, child);
 	}
 }
 
-void Node16::EraseChild(ART &art, Node *&node, idx_t pos) {
+void Node16::DeleteChild(ART &art, Node &node, const uint8_t byte) {
 
-	auto n = (Node16 *)node;
-	D_ASSERT(pos < n->count);
+	D_ASSERT(node.IsSet());
+	D_ASSERT(!node.IsSwizzled());
+	auto &n16 = Node16::Get(art, node);
 
-	// adjust the ART size
-	if (n->ChildIsInMemory(pos)) {
-		auto child = n->GetChild(art, pos);
-		art.DecreaseMemorySize(child->MemorySize(art, true));
+	idx_t child_pos = 0;
+	for (; child_pos < n16.count; child_pos++) {
+		if (n16.key[child_pos] == byte) {
+			break;
+		}
 	}
 
-	// erase the child and decrease the count
-	n->children[pos].Reset();
-	n->count--;
+	D_ASSERT(child_pos < n16.count);
+
+	// free the child and decrease the count
+	Node::Free(art, n16.children[child_pos]);
+	n16.count--;
 
 	// potentially move any children backwards
-	for (; pos < n->count; pos++) {
-		n->key[pos] = n->key[pos + 1];
-		n->children[pos] = n->children[pos + 1];
+	for (idx_t i = child_pos; i < n16.count; i++) {
+		n16.key[i] = n16.key[i + 1];
+		n16.children[i] = n16.children[i + 1];
 	}
-	// set any remaining nodes as nullptr
-	for (; pos < Node16::GetSize(); pos++) {
-		if (!n->children[pos]) {
-			break;
+
+	// shrink node to Node4
+	if (n16.count < Node::NODE_4_CAPACITY) {
+		auto node16 = node;
+		Node4::ShrinkNode16(art, node, node16);
+	}
+}
+
+void Node16::ReplaceChild(const uint8_t byte, const Node child) {
+	for (idx_t i = 0; i < count; i++) {
+		if (key[i] == byte) {
+			children[i] = child;
+			return;
 		}
-		n->children[pos] = nullptr;
 	}
+}
 
-	// shrink node to Node4
-	if (node->count < Node4::GetSize()) {
+optional_ptr<Node> Node16::GetChild(const uint8_t byte) {
+
+	for (idx_t i = 0; i < count; i++) {
+		if (key[i] == byte) {
+			return &children[i];
+		}
+	}
+	return nullptr;
+}
 
-		auto new_node = Node4::New();
-		art.IncreaseMemorySize(new_node->MemorySize(art, false));
-		new_node->prefix = std::move(n->prefix);
+optional_ptr<Node> Node16::GetNextChild(uint8_t &byte) {
 
-		for (idx_t i = 0; i < n->count; i++) {
-			new_node->key[new_node->count] = n->key[i];
-			new_node->children[new_node->count++] = n->children[i];
-			n->children[i] = nullptr;
+	for (idx_t i = 0; i < count; i++) {
+		if (key[i] >= byte) {
+			byte = key[i];
+			return &children[i];
 		}
+	}
+	return nullptr;
+}
+
+BlockPointer Node16::Serialize(ART &art, MetaBlockWriter &writer) {
+
+	// recurse into children and retrieve child block pointers
+	vector<BlockPointer> child_block_pointers;
+	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);
+	prefix.Serialize(art, writer);
 
-		art.DecreaseMemorySize(node->MemorySize(art, false));
-		Node::Delete(node);
-		node = new_node;
+	// 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);
+	}
+
+	return block_pointer;
 }
+
+void Node16::Deserialize(ART &art, MetaBlockReader &reader) {
+
+	count = reader.Read<uint8_t>();
+	prefix.Deserialize(art, reader);
+
+	// 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);
+	}
+}
+
+void Node16::Vacuum(ART &art, const ARTFlags &flags) {
+
+	for (idx_t i = 0; i < count; i++) {
+		Node::Vacuum(art, children[i], flags);
+	}
+}
+
 } // namespace duckdb

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

@@ -1,122 +1,160 @@
 #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"
 
 namespace duckdb {
 
-Node256::Node256() : Node(NodeType::N256) {
-}
+Node256 &Node256::New(ART &art, Node &node) {
 
-idx_t Node256::MemorySize(ART &art, const bool &recurse) {
-	if (recurse) {
-		return prefix.MemorySize() + sizeof(*this) + RecursiveMemorySize(art);
-	}
-	return prefix.MemorySize() + sizeof(*this);
-}
+	node.SetPtr(Node::GetAllocator(art, NType::NODE_256).New());
+	node.type = (uint8_t)NType::NODE_256;
+	auto &n256 = Node256::Get(art, node);
 
-idx_t Node256::GetChildPos(uint8_t k) {
-	if (children[k]) {
-		return k;
-	} else {
-		return DConstants::INVALID_INDEX;
+	n256.count = 0;
+	n256.prefix.Initialize();
+
+	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
+		n256.children[i].Reset();
 	}
+
+	return n256;
 }
 
-idx_t Node256::GetChildGreaterEqual(uint8_t k, bool &equal) {
-	for (idx_t pos = k; pos < Node256::GetSize(); pos++) {
-		if (children[pos]) {
-			if (pos == k) {
-				equal = true;
-			} else {
-				equal = false;
-			}
-			return pos;
-		}
+void Node256::Free(ART &art, Node &node) {
+
+	D_ASSERT(node.IsSet());
+	D_ASSERT(!node.IsSwizzled());
+
+	auto &n256 = Node256::Get(art, node);
+
+	if (!n256.count) {
+		return;
 	}
-	return DConstants::INVALID_INDEX;
-}
 
-idx_t Node256::GetMin() {
-	for (idx_t i = 0; i < Node256::GetSize(); i++) {
-		if (children[i]) {
-			return i;
+	// free all children
+	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
+		if (n256.children[i].IsSet()) {
+			Node::Free(art, n256.children[i]);
 		}
 	}
-	return DConstants::INVALID_INDEX;
 }
 
-idx_t Node256::GetNextPos(idx_t pos) {
-	pos == DConstants::INVALID_INDEX ? pos = 0 : pos++;
-	for (; pos < Node256::GetSize(); pos++) {
-		if (children[pos]) {
-			return pos;
+Node256 &Node256::GrowNode48(ART &art, Node &node256, Node &node48) {
+
+	auto &n48 = Node48::Get(art, 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]];
+		} else {
+			n256.children[i].Reset();
 		}
 	}
-	return Node::GetNextPos(pos);
+
+	n48.count = 0;
+	Node::Free(art, node48);
+	return n256;
 }
 
-idx_t Node256::GetNextPosAndByte(idx_t pos, uint8_t &byte) {
-	pos == DConstants::INVALID_INDEX ? pos = 0 : pos++;
-	for (; pos < Node256::GetSize(); pos++) {
-		if (children[pos]) {
-			byte = uint8_t(pos);
-			return pos;
+void Node256::InitializeMerge(ART &art, const ARTFlags &flags) {
+
+	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
+		if (children[i].IsSet()) {
+			children[i].InitializeMerge(art, flags);
 		}
 	}
-	return Node::GetNextPos(pos);
 }
 
-Node *Node256::GetChild(ART &art, idx_t pos) {
-	return children[pos].Unswizzle(art);
+void Node256::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
+
+	D_ASSERT(node.IsSet());
+	D_ASSERT(!node.IsSwizzled());
+	auto &n256 = Node256::Get(art, node);
+
+	// ensure that there is no other child at the same byte
+	D_ASSERT(!n256.children[byte].IsSet());
+
+	n256.count++;
+	n256.children[byte] = child;
 }
 
-void Node256::ReplaceChildPointer(idx_t pos, Node *node) {
-	children[pos] = node;
+void Node256::DeleteChild(ART &art, Node &node, const uint8_t byte) {
+
+	D_ASSERT(node.IsSet());
+	D_ASSERT(!node.IsSwizzled());
+	auto &n256 = Node256::Get(art, node);
+
+	// free the child and decrease the count
+	Node::Free(art, n256.children[byte]);
+	n256.count--;
+
+	// shrink node to Node48
+	if (n256.count <= Node::NODE_256_SHRINK_THRESHOLD) {
+		auto node256 = node;
+		Node48::ShrinkNode256(art, node, node256);
+	}
 }
 
-bool Node256::ChildIsInMemory(idx_t pos) {
-	return children[pos] && !children[pos].IsSwizzled();
+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];
+		}
+	}
+	return nullptr;
 }
 
-void Node256::InsertChild(ART &, Node *&node, uint8_t key_byte, Node *new_child) {
-	auto n = (Node256 *)(node);
+BlockPointer Node256::Serialize(ART &art, MetaBlockWriter &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));
+	}
+
+	// get pointer and write fields
+	auto block_pointer = writer.GetBlockPointer();
+	writer.Write(NType::NODE_256);
+	writer.Write<uint16_t>(count);
+	prefix.Serialize(art, writer);
 
-	n->count++;
-	n->children[key_byte] = new_child;
+	// 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);
+	}
+
+	return block_pointer;
 }
 
-void Node256::EraseChild(ART &art, Node *&node, idx_t pos) {
-	auto n = (Node256 *)(node);
+void Node256::Deserialize(ART &art, MetaBlockReader &reader) {
+
+	count = reader.Read<uint16_t>();
+	prefix.Deserialize(art, reader);
 
-	// adjust the ART size
-	if (n->ChildIsInMemory(pos)) {
-		auto child = n->GetChild(art, pos);
-		art.DecreaseMemorySize(child->MemorySize(art, true));
+	// read child block pointers
+	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
+		children[i] = Node(reader);
 	}
+}
 
-	// erase the child and decrease the count
-	n->children[pos].Reset();
-	n->count--;
+void Node256::Vacuum(ART &art, const ARTFlags &flags) {
 
-	// shrink node to Node48
-	if (node->count <= NODE_256_SHRINK_THRESHOLD) {
-
-		auto new_node = Node48::New();
-		art.IncreaseMemorySize(new_node->MemorySize(art, false));
-		new_node->prefix = std::move(n->prefix);
-
-		for (idx_t i = 0; i < Node256::GetSize(); i++) {
-			if (n->children[i]) {
-				new_node->child_index[i] = new_node->count;
-				new_node->children[new_node->count++] = n->children[i];
-				n->children[i] = nullptr;
-			}
+	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
+		if (children[i].IsSet()) {
+			Node::Vacuum(art, children[i], flags);
 		}
-
-		art.DecreaseMemorySize(node->MemorySize(art, false));
-		Node::Delete(node);
-		node = new_node;
 	}
 }
+
 } // namespace duckdb