duckdb 0.7.2-dev2552.0 → 0.7.2-dev2699.0

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

@@ -1,164 +1,219 @@
 #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/node16.hpp"
 #include "duckdb/storage/meta_block_reader.hpp"
+#include "duckdb/storage/meta_block_writer.hpp"
 
 namespace duckdb {
 
-Node4::Node4() : Node(NodeType::N4) {
-	memset(key, 0, sizeof(key));
-}
+Node4 &Node4::New(ART &art, Node &node) {
 
-idx_t Node4::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_4).New());
+	node.type = (uint8_t)NType::NODE_4;
+	auto &n4 = Node4::Get(art, node);
 
-idx_t Node4::GetChildPos(uint8_t k) {
-	for (idx_t pos = 0; pos < count; pos++) {
-		if (key[pos] == k) {
-			return pos;
-		}
-	}
-	return Node::GetChildPos(k);
+	n4.count = 0;
+	n4.prefix.Initialize();
+	return n4;
 }
 
-idx_t Node4::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;
-			}
-			return pos;
-		}
-	}
-	return DConstants::INVALID_INDEX;
-}
+void Node4::Free(ART &art, Node &node) {
 
-idx_t Node4::GetMin() {
-	return 0;
-}
+	D_ASSERT(node.IsSet());
+	D_ASSERT(!node.IsSwizzled());
+
+	auto &n4 = Node4::Get(art, node);
 
-idx_t Node4::GetNextPos(idx_t pos) {
-	if (pos == DConstants::INVALID_INDEX) {
-		return 0;
+	// free all children
+	for (idx_t i = 0; i < n4.count; i++) {
+		Node::Free(art, n4.children[i]);
 	}
-	pos++;
-	return pos < count ? pos : DConstants::INVALID_INDEX;
 }
 
-idx_t Node4::GetNextPosAndByte(idx_t pos, uint8_t &byte) {
-	if (pos == DConstants::INVALID_INDEX) {
-		byte = key[0];
-		return 0;
-	}
-	pos++;
-	if (pos < count) {
-		byte = key[pos];
-		return pos;
+Node4 &Node4::ShrinkNode16(ART &art, Node &node4, Node &node16) {
+
+	auto &n4 = Node4::New(art, node4);
+	auto &n16 = Node16::Get(art, node16);
+
+	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];
 	}
-	return DConstants::INVALID_INDEX;
-}
 
-Node *Node4::GetChild(ART &art, idx_t pos) {
-	D_ASSERT(pos < count);
-	return children[pos].Unswizzle(art);
+	n16.count = 0;
+	Node::Free(art, node16);
+	return n4;
 }
 
-void Node4::ReplaceChildPointer(idx_t pos, Node *node) {
-	children[pos] = node;
-}
+void Node4::InitializeMerge(ART &art, const ARTFlags &flags) {
 
-bool Node4::ChildIsInMemory(idx_t pos) {
-	return children[pos] && !children[pos].IsSwizzled();
+	for (idx_t i = 0; i < count; i++) {
+		children[i].InitializeMerge(art, flags);
+	}
 }
 
-void Node4::InsertChild(ART &art, Node *&node, uint8_t key_byte, Node *new_child) {
-	Node4 *n = (Node4 *)node;
+void Node4::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
+
+	D_ASSERT(node.IsSet());
+	D_ASSERT(!node.IsSwizzled());
+	auto &n4 = Node4::Get(art, node);
+
+	// ensure that there is no other child at the same byte
+	for (idx_t i = 0; i < n4.count; i++) {
+		D_ASSERT(n4.key[i] != byte);
+	}
 
 	// insert new child node into node
-	if (node->count < Node4::GetSize()) {
+	if (n4.count < Node::NODE_4_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 < n4.count && n4.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 = n4.count; i > child_pos; i--) {
+			n4.key[i] = n4.key[i - 1];
+			n4.children[i] = n4.children[i - 1];
 		}
-		n->key[pos] = key_byte;
-		n->children[pos] = new_child;
-		n->count++;
+
+		n4.key[child_pos] = byte;
+		n4.children[child_pos] = child;
+		n4.count++;
 
 	} else {
 		// node is full, grow to Node16
-		auto new_node = Node16::New();
-		art.IncreaseMemorySize(new_node->MemorySize(art, false));
-		new_node->count = n->count;
-		new_node->prefix = std::move(node->prefix);
-
-		for (idx_t i = 0; i < n->count; i++) {
-			new_node->key[i] = n->key[i];
-			new_node->children[i] = n->children[i];
-			n->children[i] = nullptr;
-		}
-		n->count = 0;
-
-		art.DecreaseMemorySize(node->MemorySize(art, false));
-		Node::Delete(node);
-		node = new_node;
-		Node16::InsertChild(art, node, key_byte, new_child);
+		auto node4 = node;
+		Node16::GrowNode4(art, node, node4);
+		Node16::InsertChild(art, node, byte, child);
 	}
 }
 
-void Node4::EraseChild(ART &art, Node *&node, idx_t pos) {
+void Node4::DeleteChild(ART &art, Node &node, const uint8_t byte) {
 
-	Node4 *n = (Node4 *)node;
-	D_ASSERT(pos < n->count);
-	D_ASSERT(n->count > 1);
+	D_ASSERT(node.IsSet());
+	D_ASSERT(!node.IsSwizzled());
+	auto &n4 = Node4::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 < n4.count; child_pos++) {
+		if (n4.key[child_pos] == byte) {
+			break;
+		}
 	}
 
-	// erase the child and decrease the count
-	n->children[pos].Reset();
-	n->count--;
-	D_ASSERT(n->count >= 1);
+	D_ASSERT(child_pos < n4.count);
+	D_ASSERT(n4.count > 1);
+
+	// free the child and decrease the count
+	Node::Free(art, n4.children[child_pos]);
+	n4.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];
-	}
-	// set any remaining nodes as nullptr
-	for (; pos < Node4::GetSize(); pos++) {
-		n->children[pos] = nullptr;
+	for (idx_t i = child_pos; i < n4.count; i++) {
+		n4.key[i] = n4.key[i + 1];
+		n4.children[i] = n4.children[i + 1];
 	}
 
 	// this is a one way node, compress
-	if (n->count == 1) {
+	if (n4.count == 1) {
 
 		// get only child and concatenate prefixes
-		auto child_ref = n->GetChild(art, 0);
-		// concatenate prefixes
-		child_ref->prefix.Concatenate(art, n->key[0], node->prefix);
-		// ensure that when deleting the node, we do not delete the child (because we move it)
-		n->children[0] = nullptr;
+		auto child = *n4.GetChild(n4.key[0]);
+		child.GetPrefix(art).Concatenate(art, n4.key[0], n4.prefix);
+		n4.count--;
+
+		Node::Free(art, node);
+		node = child;
+	}
+}
 
-		art.DecreaseMemorySize(n->MemorySize(art, false));
-		Node::Delete(node);
-		node = child_ref;
+void Node4::ReplaceChild(const uint8_t byte, const Node child) {
+	for (idx_t i = 0; i < count; i++) {
+		if (key[i] == byte) {
+			children[i] = child;
+			return;
+		}
 	}
 }
+
+optional_ptr<Node> Node4::GetChild(const uint8_t byte) {
+
+	for (idx_t i = 0; i < count; i++) {
+		if (key[i] == byte) {
+			return &children[i];
+		}
+	}
+	return nullptr;
+}
+
+optional_ptr<Node> Node4::GetNextChild(uint8_t &byte) {
+
+	for (idx_t i = 0; i < count; i++) {
+		if (key[i] >= byte) {
+			byte = key[i];
+			return &children[i];
+		}
+	}
+	return nullptr;
+}
+
+BlockPointer Node4::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_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);
+	prefix.Serialize(art, writer);
+
+	// 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);
+	}
+
+	return block_pointer;
+}
+
+void Node4::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_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);
+	}
+}
+
+void Node4::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/node48.cpp

@@ -1,160 +1,230 @@
 #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"
 
 namespace duckdb {
 
-Node48::Node48() : Node(NodeType::N48) {
-	for (idx_t i = 0; i < 256; i++) {
-		child_index[i] = Node::EMPTY_MARKER;
+Node48 &Node48::New(ART &art, Node &node) {
+
+	node.SetPtr(Node::GetAllocator(art, NType::NODE_48).New());
+	node.type = (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;
 	}
-}
 
-idx_t Node48::MemorySize(ART &art, const bool &recurse) {
-	if (recurse) {
-		return prefix.MemorySize() + sizeof(*this) + RecursiveMemorySize(art);
+	// necessary for faster child insertion/deletion
+	for (idx_t i = 0; i < Node::NODE_48_CAPACITY; i++) {
+		n48.children[i].Reset();
 	}
-	return prefix.MemorySize() + sizeof(*this);
+
+	return n48;
 }
 
-idx_t Node48::GetChildPos(uint8_t k) {
-	if (child_index[k] == Node::EMPTY_MARKER) {
-		return DConstants::INVALID_INDEX;
-	} else {
-		return k;
+void Node48::Free(ART &art, Node &node) {
+
+	D_ASSERT(node.IsSet());
+	D_ASSERT(!node.IsSwizzled());
+
+	auto &n48 = Node48::Get(art, node);
+
+	if (!n48.count) {
+		return;
 	}
-}
 
-idx_t Node48::GetChildGreaterEqual(uint8_t k, bool &equal) {
-	for (idx_t pos = k; pos < Node256::GetSize(); pos++) {
-		if (child_index[pos] != Node::EMPTY_MARKER) {
-			if (pos == k) {
-				equal = true;
-			} else {
-				equal = false;
-			}
-			return pos;
+	// free all children
+	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
+		if (n48.child_index[i] != Node::EMPTY_MARKER) {
+			Node::Free(art, n48.children[n48.child_index[i]]);
 		}
 	}
-	return DConstants::INVALID_INDEX;
 }
 
-idx_t Node48::GetMin() {
-	for (idx_t i = 0; i < Node256::GetSize(); i++) {
-		if (child_index[i] != Node::EMPTY_MARKER) {
-			return i;
-		}
+Node48 &Node48::GrowNode16(ART &art, Node &node48, Node &node16) {
+
+	auto &n16 = Node16::Get(art, 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;
 	}
-	return DConstants::INVALID_INDEX;
-}
 
-idx_t Node48::GetNextPos(idx_t pos) {
-	pos == DConstants::INVALID_INDEX ? pos = 0 : pos++;
-	for (; pos < Node256::GetSize(); pos++) {
-		if (child_index[pos] != Node::EMPTY_MARKER) {
-			return pos;
-		}
+	for (idx_t i = 0; i < n16.count; i++) {
+		n48.child_index[n16.key[i]] = i;
+		n48.children[i] = n16.children[i];
+	}
+
+	// necessary for faster child insertion/deletion
+	for (idx_t i = n16.count; i < Node::NODE_48_CAPACITY; i++) {
+		n48.children[i].Reset();
 	}
-	return Node::GetNextPos(pos);
+
+	n16.count = 0;
+	Node::Free(art, node16);
+	return n48;
 }
 
-idx_t Node48::GetNextPosAndByte(idx_t pos, uint8_t &byte) {
-	pos == DConstants::INVALID_INDEX ? pos = 0 : pos++;
-	for (; pos < Node256::GetSize(); pos++) {
-		if (child_index[pos] != Node::EMPTY_MARKER) {
-			byte = uint8_t(pos);
-			return pos;
+Node48 &Node48::ShrinkNode256(ART &art, Node &node48, Node &node256) {
+
+	auto &n48 = Node48::New(art, node48);
+	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++) {
+		if (n256.children[i].IsSet()) {
+			n48.child_index[i] = n48.count;
+			n48.children[n48.count] = n256.children[i];
+			n48.count++;
+		} else {
+			n48.child_index[i] = Node::EMPTY_MARKER;
 		}
 	}
-	return Node::GetNextPos(pos);
-}
 
-Node *Node48::GetChild(ART &art, idx_t pos) {
-	D_ASSERT(child_index[pos] != Node::EMPTY_MARKER);
-	return children[child_index[pos]].Unswizzle(art);
-}
+	// necessary for faster child insertion/deletion
+	for (idx_t i = n48.count; i < Node::NODE_48_CAPACITY; i++) {
+		n48.children[i].Reset();
+	}
 
-void Node48::ReplaceChildPointer(idx_t pos, Node *node) {
-	children[child_index[pos]] = node;
+	n256.count = 0;
+	Node::Free(art, node256);
+	return n48;
 }
 
-bool Node48::ChildIsInMemory(idx_t pos) {
-	return children[child_index[pos]] && !children[child_index[pos]].IsSwizzled();
+void Node48::InitializeMerge(ART &art, const ARTFlags &flags) {
+
+	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
+		if (child_index[i] != Node::EMPTY_MARKER) {
+			children[child_index[i]].InitializeMerge(art, flags);
+		}
+	}
 }
 
-void Node48::InsertChild(ART &art, Node *&node, uint8_t key_byte, Node *new_child) {
-	auto n = (Node48 *)node;
+void Node48::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
+
+	D_ASSERT(node.IsSet());
+	D_ASSERT(!node.IsSwizzled());
+	auto &n48 = Node48::Get(art, node);
+
+	// ensure that there is no other child at the same byte
+	D_ASSERT(n48.child_index[byte] == Node::EMPTY_MARKER);
 
 	// insert new child node into node
-	if (node->count < Node48::GetSize()) {
+	if (n48.count < Node::NODE_48_CAPACITY) {
 		// still space, just insert the child
-		idx_t pos = n->count;
-		if (n->children[pos]) {
+		idx_t child_pos = n48.count;
+		if (n48.children[child_pos].IsSet()) {
 			// find an empty position in the node list if the current position is occupied
-			pos = 0;
-			while (n->children[pos]) {
-				pos++;
+			child_pos = 0;
+			while (n48.children[child_pos].IsSet()) {
+				child_pos++;
 			}
 		}
-		n->children[pos] = new_child;
-		n->child_index[key_byte] = pos;
-		n->count++;
+		n48.children[child_pos] = child;
+		n48.child_index[byte] = child_pos;
+		n48.count++;
 
 	} else {
 		// node is full, grow to Node256
-		auto new_node = Node256::New();
-		art.IncreaseMemorySize(new_node->MemorySize(art, false));
-		new_node->count = n->count;
-		new_node->prefix = std::move(n->prefix);
-
-		for (idx_t i = 0; i < Node256::GetSize(); i++) {
-			if (n->child_index[i] != Node::EMPTY_MARKER) {
-				new_node->children[i] = n->children[n->child_index[i]];
-				n->children[n->child_index[i]] = nullptr;
-			}
-		}
-
-		art.DecreaseMemorySize(node->MemorySize(art, false));
-		Node::Delete(node);
-		node = new_node;
-		Node256::InsertChild(art, node, key_byte, new_child);
+		auto node48 = node;
+		Node256::GrowNode48(art, node, node48);
+		Node256::InsertChild(art, node, byte, child);
 	}
 }
 
-void Node48::EraseChild(ART &art, Node *&node, idx_t pos) {
-	auto n = (Node48 *)(node);
+void Node48::DeleteChild(ART &art, Node &node, const uint8_t byte) {
 
-	// adjust the ART size
-	if (n->ChildIsInMemory(pos)) {
-		auto child = n->GetChild(art, pos);
-		art.DecreaseMemorySize(child->MemorySize(art, true));
-	}
+	D_ASSERT(node.IsSet());
+	D_ASSERT(!node.IsSwizzled());
+	auto &n48 = Node48::Get(art, node);
 
-	// erase the child and decrease the count
-	n->children[n->child_index[pos]].Reset();
-	n->child_index[pos] = Node::EMPTY_MARKER;
-	n->count--;
+	// free the child and decrease the count
+	Node::Free(art, n48.children[n48.child_index[byte]]);
+	n48.child_index[byte] = Node::EMPTY_MARKER;
+	n48.count--;
 
 	// shrink node to Node16
-	if (node->count < NODE_48_SHRINK_THRESHOLD) {
+	if (n48.count < Node::NODE_48_SHRINK_THRESHOLD) {
+		auto node48 = node;
+		Node16::ShrinkNode48(art, node, node48);
+	}
+}
 
-		auto new_node = Node16::New();
-		art.IncreaseMemorySize(new_node->MemorySize(art, false));
-		new_node->prefix = std::move(n->prefix);
+optional_ptr<Node> Node48::GetNextChild(uint8_t &byte) {
 
-		for (idx_t i = 0; i < Node256::GetSize(); i++) {
-			if (n->child_index[i] != Node::EMPTY_MARKER) {
-				new_node->key[new_node->count] = i;
-				new_node->children[new_node->count++] = n->children[n->child_index[i]];
-				n->children[n->child_index[i]] = nullptr;
-			}
+	for (idx_t i = byte; i < Node::NODE_256_CAPACITY; i++) {
+		if (child_index[i] != Node::EMPTY_MARKER) {
+			byte = i;
+			return &children[child_index[i]];
 		}
+	}
+	return nullptr;
+}
+
+BlockPointer Node48::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_48_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_48);
+	writer.Write<uint8_t>(count);
+	prefix.Serialize(art, writer);
+
+	// write key values
+	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
+		writer.Write(child_index[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 Node48::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_256_CAPACITY; i++) {
+		child_index[i] = reader.Read<uint8_t>();
+	}
+
+	// read child block pointers
+	for (idx_t i = 0; i < Node::NODE_48_CAPACITY; i++) {
+		children[i] = Node(reader);
+	}
+}
 
-		art.DecreaseMemorySize(node->MemorySize(art, false));
-		Node::Delete(node);
-		node = new_node;
+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);
+		}
 	}
 }
+
 } // namespace duckdb