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

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

@@ -1,528 +1,593 @@
-#include "duckdb/execution/index/art/node.hpp"
-
-#include "duckdb/common/exception.hpp"
+#include "duckdb/common/limits.hpp"
 #include "duckdb/common/swap.hpp"
 #include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/execution/index/art/swizzleable_pointer.hpp"
-#include "duckdb/storage/storage_manager.hpp"
+#include "duckdb/execution/index/art/leaf.hpp"
+#include "duckdb/execution/index/art/leaf_segment.hpp"
+#include "duckdb/execution/index/art/node.hpp"
+#include "duckdb/execution/index/art/node16.hpp"
+#include "duckdb/execution/index/art/node256.hpp"
+#include "duckdb/execution/index/art/node4.hpp"
+#include "duckdb/execution/index/art/node48.hpp"
+#include "duckdb/execution/index/art/prefix.hpp"
+#include "duckdb/execution/index/art/prefix_segment.hpp"
+#include "duckdb/storage/meta_block_reader.hpp"
+#include "duckdb/storage/meta_block_writer.hpp"
+#include "duckdb/storage/table_io_manager.hpp"
 
 namespace duckdb {
 
-InternalType::InternalType(Node *n) {
-	switch (n->type) {
-	case NodeType::N4: {
-		auto n4 = (Node4 *)n;
-		Set(n4->key, 4, n4->children, 4);
-		break;
-	}
-	case NodeType::N16: {
-		auto n16 = (Node16 *)n;
-		Set(n16->key, 16, n16->children, 16);
-		break;
-	}
-	case NodeType::N48: {
-		auto n48 = (Node48 *)n;
-		Set(n48->child_index, 256, n48->children, 48);
-		break;
-	}
-	case NodeType::N256: {
-		auto n256 = (Node256 *)n;
-		Set(nullptr, 0, n256->children, 256);
-		break;
-	}
-	default:
-		throw InternalException("This is not an Internal ART Node Type");
-	}
-}
-
-void InternalType::Set(uint8_t *key_p, uint16_t key_size_p, ARTPointer *children_p, uint16_t children_size_p) {
-	key = key_p;
-	key_size = key_size_p;
-	children = children_p;
-	children_size = children_size_p;
-}
-
-Node::Node(NodeType type) : count(0), type(type) {
-}
-
-// LCOV_EXCL_START
-idx_t Node::MemorySize(ART &, const bool &) {
-	throw InternalException("MemorySize not implemented for the specific node type.");
-}
-
-idx_t Node::GetMin() {
-	throw InternalException("GetMin not implemented for the specific node type.");
-}
+//===--------------------------------------------------------------------===//
+// Constructors / Destructors
+//===--------------------------------------------------------------------===//
 
-Node *Node::GetChild(ART &art, idx_t pos) {
-	throw InternalException("GetChild not implemented for the specific node type.");
+Node::Node() : SwizzleablePointer() {
 }
 
-void Node::ReplaceChildPointer(idx_t pos, Node *node) {
-	throw InternalException("ReplaceChildPointer not implemented for the specific node type.");
+Node::Node(MetaBlockReader &reader) : SwizzleablePointer(reader) {
 }
 
-bool Node::ChildIsInMemory(idx_t) {
-	throw InternalException("ChildIsInMemory not implemented for the specific node type.");
-}
-// LCOV_EXCL_STOP
+void Node::New(ART &art, Node &node, const NType type) {
 
-void Node::InsertChild(ART &art, Node *&node, uint8_t key_byte, Node *new_child) {
-	switch (node->type) {
-	case NodeType::N4:
-		Node4::InsertChild(art, node, key_byte, new_child);
-		break;
-	case NodeType::N16:
-		Node16::InsertChild(art, node, key_byte, new_child);
-		break;
-	case NodeType::N48:
-		Node48::InsertChild(art, node, key_byte, new_child);
+	switch (type) {
+	case NType::PREFIX_SEGMENT:
+		PrefixSegment::New(art, node);
 		break;
-	case NodeType::N256:
-		Node256::InsertChild(art, node, key_byte, new_child);
+	case NType::LEAF_SEGMENT:
+		LeafSegment::New(art, node);
 		break;
-	default:
-		throw InternalException("Unrecognized node type for insert.");
-	}
-}
-
-void Node::EraseChild(ART &art, Node *&node, idx_t pos) {
-	switch (node->type) {
-	case NodeType::N4: {
-		Node4::EraseChild(art, node, pos);
+	case NType::NODE_4:
+		Node4::New(art, node);
 		break;
-	}
-	case NodeType::N16: {
-		Node16::EraseChild(art, node, pos);
+	case NType::NODE_16:
+		Node16::New(art, node);
 		break;
-	}
-	case NodeType::N48: {
-		Node48::EraseChild(art, node, pos);
+	case NType::NODE_48:
+		Node48::New(art, node);
 		break;
-	}
-	case NodeType::N256:
-		Node256::EraseChild(art, node, pos);
+	case NType::NODE_256:
+		Node256::New(art, node);
 		break;
 	default:
-		throw InternalException("Unrecognized node type for erase.");
+		throw InternalException("Invalid node type for New.");
 	}
 }
 
-NodeType Node::GetTypeBySize(idx_t size) {
+void Node::Free(ART &art, Node &node) {
 
-	if (size <= Node4::GetSize()) {
-		return NodeType::N4;
-	} else if (size <= Node16::GetSize()) {
-		return NodeType::N16;
-	} else if (size <= Node48::GetSize()) {
-		return NodeType::N48;
-	}
-	D_ASSERT(size <= Node256::GetSize());
-	return NodeType::N256;
-}
+	// recursively free all nodes that are in-memory, and skip swizzled and empty nodes
 
-void Node::New(const NodeType &type, Node *&node) {
-	switch (type) {
-	case NodeType::N4:
-		node = (Node *)Node4::New();
+	if (!node.IsSet()) {
 		return;
-	case NodeType::N16:
-		node = (Node *)Node16::New();
-		return;
-	case NodeType::N48:
-		node = (Node *)Node48::New();
-		return;
-	case NodeType::N256:
-		node = (Node *)Node256::New();
-		return;
-	default:
-		throw InternalException("Unrecognized node type for new node creation.");
 	}
-}
 
-Node4 *Node4::New() {
-	return AllocateObject<Node4>();
-}
+	if (!node.IsSwizzled()) {
 
-Node16 *Node16::New() {
-	return AllocateObject<Node16>();
-}
+		auto type = node.DecodeARTNodeType();
+		if (type != NType::PREFIX_SEGMENT && type != NType::LEAF_SEGMENT) {
+			node.GetPrefix(art).Free(art);
+		}
 
-Node48 *Node48::New() {
-	return AllocateObject<Node48>();
-}
+		// free the prefixes and children of the nodes
+		switch (type) {
+		case NType::LEAF:
+			Leaf::Free(art, node);
+			break;
+		case NType::NODE_4:
+			Node4::Free(art, node);
+			break;
+		case NType::NODE_16:
+			Node16::Free(art, node);
+			break;
+		case NType::NODE_48:
+			Node48::Free(art, node);
+			break;
+		case NType::NODE_256:
+			Node256::Free(art, node);
+			break;
+		default:
+			break;
+		}
 
-Node256 *Node256::New() {
-	return AllocateObject<Node256>();
-}
+		Node::GetAllocator(art, type).Free(node);
+	}
 
-Leaf *Leaf::New() {
-	return AllocateObject<Leaf>();
+	// overwrite with an empty ART node
+	node.Reset();
 }
 
-Leaf *Leaf::New(Key &value, uint32_t depth, row_t row_id) {
-	return AllocateObject<Leaf>(value, depth, row_id);
-}
+//===--------------------------------------------------------------------===//
+// Inserts
+//===--------------------------------------------------------------------===//
+
+void Node::ReplaceChild(const ART &art, const uint8_t byte, const Node child) {
 
-Leaf *Leaf::New(Key &value, uint32_t depth, row_t *row_ids, idx_t num_elements) {
-	return AllocateObject<Leaf>(value, depth, row_ids, num_elements);
+	D_ASSERT(!IsSwizzled());
+
+	switch (DecodeARTNodeType()) {
+	case NType::NODE_4:
+		return Node4::Get(art, *this).ReplaceChild(byte, child);
+	case NType::NODE_16:
+		return Node16::Get(art, *this).ReplaceChild(byte, child);
+	case NType::NODE_48:
+		return Node48::Get(art, *this).ReplaceChild(byte, child);
+	case NType::NODE_256:
+		return Node256::Get(art, *this).ReplaceChild(byte, child);
+	default:
+		throw InternalException("Invalid node type for ReplaceChild.");
+	}
 }
 
-Leaf *Leaf::New(row_t *row_ids, idx_t num_elements, Prefix &prefix) {
-	return AllocateObject<Leaf>(row_ids, num_elements, prefix);
+void Node::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
+
+	switch (node.DecodeARTNodeType()) {
+	case NType::NODE_4:
+		return Node4::InsertChild(art, node, byte, child);
+	case NType::NODE_16:
+		return Node16::InsertChild(art, node, byte, child);
+	case NType::NODE_48:
+		return Node48::InsertChild(art, node, byte, child);
+	case NType::NODE_256:
+		return Node256::InsertChild(art, node, byte, child);
+	default:
+		throw InternalException("Invalid node type for InsertChild.");
+	}
 }
 
-Leaf *Leaf::New(row_t row_id, Prefix &prefix) {
-	return AllocateObject<Leaf>(row_id, prefix);
+//===--------------------------------------------------------------------===//
+// Deletes
+//===--------------------------------------------------------------------===//
+
+void Node::DeleteChild(ART &art, Node &node, const uint8_t byte) {
+
+	switch (node.DecodeARTNodeType()) {
+	case NType::NODE_4:
+		return Node4::DeleteChild(art, node, byte);
+	case NType::NODE_16:
+		return Node16::DeleteChild(art, node, byte);
+	case NType::NODE_48:
+		return Node48::DeleteChild(art, node, byte);
+	case NType::NODE_256:
+		return Node256::DeleteChild(art, node, byte);
+	default:
+		throw InternalException("Invalid node type for DeleteChild.");
+	}
 }
 
-void Node::Delete(Node *ptr) {
-	switch (ptr->type) {
-	case NodeType::NLeaf:
-		DestroyObject((Leaf *)ptr);
-		break;
-	case NodeType::N4:
-		DestroyObject((Node4 *)ptr);
+//===--------------------------------------------------------------------===//
+// Get functions
+//===--------------------------------------------------------------------===//
+
+optional_ptr<Node> Node::GetChild(ART &art, const uint8_t byte) const {
+
+	D_ASSERT(!IsSwizzled());
+
+	optional_ptr<Node> child;
+	switch (DecodeARTNodeType()) {
+	case NType::NODE_4: {
+		child = Node4::Get(art, *this).GetChild(byte);
 		break;
-	case NodeType::N16:
-		DestroyObject((Node16 *)ptr);
+	}
+	case NType::NODE_16: {
+		child = Node16::Get(art, *this).GetChild(byte);
 		break;
-	case NodeType::N48:
-		DestroyObject((Node48 *)ptr);
+	}
+	case NType::NODE_48: {
+		child = Node48::Get(art, *this).GetChild(byte);
 		break;
-	case NodeType::N256:
-		DestroyObject((Node256 *)ptr);
+	}
+	case NType::NODE_256: {
+		child = Node256::Get(art, *this).GetChild(byte);
 		break;
+	}
 	default:
-		throw InternalException("Invalid node type for delete.");
+		throw InternalException("Invalid node type for GetChild.");
+	}
+
+	// unswizzle the ART node before returning it
+	if (child && child->IsSwizzled()) {
+		child->Deserialize(art);
 	}
+	return child;
 }
 
-string Node::ToString(ART &art) {
+optional_ptr<Node> Node::GetNextChild(ART &art, uint8_t &byte) const {
 
-	string str = "Node";
-	switch (this->type) {
-	case NodeType::NLeaf:
-		return Leaf::ToString(this);
-	case NodeType::N4:
-		str += to_string(Node4::GetSize());
+	D_ASSERT(!IsSwizzled());
+
+	optional_ptr<Node> child;
+	switch (DecodeARTNodeType()) {
+	case NType::NODE_4: {
+		child = Node4::Get(art, *this).GetNextChild(byte);
 		break;
-	case NodeType::N16:
-		str += to_string(Node16::GetSize());
+	}
+	case NType::NODE_16: {
+		child = Node16::Get(art, *this).GetNextChild(byte);
 		break;
-	case NodeType::N48:
-		str += to_string(Node48::GetSize());
+	}
+	case NType::NODE_48: {
+		child = Node48::Get(art, *this).GetNextChild(byte);
 		break;
-	case NodeType::N256:
-		str += to_string(Node256::GetSize());
+	}
+	case NType::NODE_256: {
+		child = Node256::Get(art, *this).GetNextChild(byte);
 		break;
 	}
+	default:
+		throw InternalException("Invalid node type for GetNextChild.");
+	}
 
-	str += ": [";
-	auto next_pos = GetNextPos(DConstants::INVALID_INDEX);
-	while (next_pos != DConstants::INVALID_INDEX) {
-		auto child = GetChild(art, next_pos);
-		str += "(" + to_string(next_pos) + ", " + child->ToString(art) + ")";
-		next_pos = GetNextPos(next_pos);
+	// unswizzle the ART node before returning it
+	if (child && child->IsSwizzled()) {
+		child->Deserialize(art);
 	}
-	return str + "]";
+	return child;
 }
 
-BlockPointer Node::SerializeInternal(ART &art, duckdb::MetaBlockWriter &writer, InternalType &internal_type) {
+//===--------------------------------------------------------------------===//
+// (De)serialization
+//===--------------------------------------------------------------------===//
 
-	// iterate through children and annotate their offsets
-	vector<BlockPointer> child_offsets;
-	for (idx_t i = 0; i < internal_type.children_size; i++) {
-		child_offsets.emplace_back(internal_type.children[i].Serialize(art, writer));
-	}
-	auto ptr = writer.GetBlockPointer();
+BlockPointer Node::Serialize(ART &art, MetaBlockWriter &writer) {
 
-	writer.Write(type);
-	writer.Write<uint16_t>(count);
-	prefix.Serialize(writer);
+	if (!IsSet()) {
+		return {(block_id_t)DConstants::INVALID_INDEX, 0};
+	}
 
-	// write key values
-	for (idx_t i = 0; i < internal_type.key_size; i++) {
-		writer.Write(internal_type.key[i]);
+	if (IsSwizzled()) {
+		Deserialize(art);
 	}
 
-	// write child offsets
-	for (auto &offsets : child_offsets) {
-		writer.Write(offsets.block_id);
-		writer.Write(offsets.offset);
+	switch (DecodeARTNodeType()) {
+	case NType::LEAF:
+		return Leaf::Get(art, *this).Serialize(art, writer);
+	case NType::NODE_4:
+		return Node4::Get(art, *this).Serialize(art, writer);
+	case NType::NODE_16:
+		return Node16::Get(art, *this).Serialize(art, writer);
+	case NType::NODE_48:
+		return Node48::Get(art, *this).Serialize(art, writer);
+	case NType::NODE_256:
+		return Node256::Get(art, *this).Serialize(art, writer);
+	default:
+		throw InternalException("Invalid node type for Serialize.");
 	}
-	return ptr;
 }
 
-BlockPointer Node::Serialize(ART &art, duckdb::MetaBlockWriter &writer) {
+void Node::Deserialize(ART &art) {
+
+	MetaBlockReader reader(art.table_io_manager.GetIndexBlockManager(), buffer_id);
+	reader.offset = offset;
+	type = reader.Read<uint8_t>();
+	swizzle_flag = 0;
+
+	auto type = DecodeARTNodeType();
+	SetPtr(Node::GetAllocator(art, type).New());
 
 	switch (type) {
-	case NodeType::N4:
-	case NodeType::N16:
-	case NodeType::N48:
-	case NodeType::N256: {
-		InternalType internal_type(this);
-		return SerializeInternal(art, writer, internal_type);
-	}
-	case NodeType::NLeaf: {
-		auto leaf = (Leaf *)this;
-		return leaf->Serialize(writer);
-	}
+	case NType::LEAF:
+		return Leaf::Get(art, *this).Deserialize(art, reader);
+	case NType::NODE_4:
+		return Node4::Get(art, *this).Deserialize(art, reader);
+	case NType::NODE_16:
+		return Node16::Get(art, *this).Deserialize(art, reader);
+	case NType::NODE_48:
+		return Node48::Get(art, *this).Deserialize(art, reader);
+	case NType::NODE_256:
+		return Node256::Get(art, *this).Deserialize(art, reader);
 	default:
-		throw InternalException("Invalid ART node for serialize.");
+		throw InternalException("Invalid node type for Deserialize.");
 	}
 }
 
-void Node::DeserializeInternal(ART &art, duckdb::MetaBlockReader &reader) {
+//===--------------------------------------------------------------------===//
+// Utility
+//===--------------------------------------------------------------------===//
 
-	InternalType internal_type(this);
-	count = reader.Read<uint16_t>();
-	prefix.Deserialize(reader);
+string Node::ToString(ART &art) const {
 
-	// read key values
-	for (idx_t i = 0; i < internal_type.key_size; i++) {
-		internal_type.key[i] = reader.Read<uint8_t>();
+	D_ASSERT(!IsSwizzled());
+
+	if (DecodeARTNodeType() == NType::LEAF) {
+		return Leaf::Get(art, *this).ToString(art);
 	}
 
-	// read child offsets
-	for (idx_t i = 0; i < internal_type.children_size; i++) {
-		internal_type.children[i] = ARTPointer(reader);
+	string str = "Node" + to_string(GetCapacity()) + ": [";
+
+	uint8_t byte = 0;
+	auto child = GetNextChild(art, byte);
+	while (child) {
+		str += "(" + to_string(byte) + ", " + child->ToString(art) + ")";
+		if (byte == NumericLimits<uint8_t>::Maximum()) {
+			break;
+		}
+		byte++;
+		child = GetNextChild(art, byte);
 	}
-}
 
-Node *Node::Deserialize(ART &art, idx_t block_id, idx_t offset) {
+	return str + "]";
+}
 
-	MetaBlockReader reader(art.table_io_manager.GetIndexBlockManager(), block_id);
-	reader.offset = offset;
+idx_t Node::GetCapacity() const {
 
-	auto n = reader.Read<uint8_t>();
-	NodeType node_type((NodeType)(n));
+	D_ASSERT(!IsSwizzled());
 
-	Node *deserialized_node = nullptr;
-	switch (node_type) {
-	case NodeType::NLeaf: {
-		auto leaf = Leaf::New();
-		leaf->Deserialize(art, reader);
-		art.IncreaseMemorySize(leaf->MemorySize(art, false));
-		return leaf;
-	}
-	case NodeType::N4: {
-		deserialized_node = (Node *)Node4::New();
-		break;
-	}
-	case NodeType::N16: {
-		deserialized_node = (Node *)Node16::New();
-		break;
-	}
-	case NodeType::N48: {
-		deserialized_node = (Node *)Node48::New();
-		break;
-	}
-	case NodeType::N256: {
-		deserialized_node = (Node *)Node256::New();
-		break;
-	}
+	switch (DecodeARTNodeType()) {
+	case NType::NODE_4:
+		return Node::NODE_4_CAPACITY;
+	case NType::NODE_16:
+		return Node::NODE_16_CAPACITY;
+	case NType::NODE_48:
+		return Node::NODE_48_CAPACITY;
+	case NType::NODE_256:
+		return Node::NODE_256_CAPACITY;
 	default:
-		throw InternalException("Unrecognized node type");
+		throw InternalException("Invalid node type for GetCapacity.");
 	}
-	deserialized_node->DeserializeInternal(art, reader);
-	art.IncreaseMemorySize(deserialized_node->MemorySize(art, false));
-	return deserialized_node;
 }
 
-void UpdateParentsOfNodes(Node *&l_node, Node *&r_node, ParentsOfNodes &parents) {
-	if (parents.l_parent) {
-		parents.l_parent->ReplaceChildPointer(parents.l_pos, l_node);
+Prefix &Node::GetPrefix(ART &art) {
+
+	if (IsSwizzled()) {
+		Deserialize(art);
 	}
-	if (parents.r_parent) {
-		parents.r_parent->ReplaceChildPointer(parents.r_pos, r_node);
+
+	switch (DecodeARTNodeType()) {
+	case NType::LEAF:
+		return Leaf::Get(art, *this).prefix;
+	case NType::NODE_4:
+		return Node4::Get(art, *this).prefix;
+	case NType::NODE_16:
+		return Node16::Get(art, *this).prefix;
+	case NType::NODE_48:
+		return Node48::Get(art, *this).prefix;
+	case NType::NODE_256:
+		return Node256::Get(art, *this).prefix;
+	default:
+		throw InternalException("Invalid node type for GetPrefix.");
 	}
 }
 
-// forward declaration
-bool ResolvePrefixesAndMerge(MergeInfo &info, ParentsOfNodes &parents);
+NType Node::GetARTNodeTypeByCount(const idx_t count) {
 
-void SwapNodes(MergeInfo &info, ParentsOfNodes &parents) {
-	// adjust the memory sizes
-	auto l_node_memory_size = info.l_node->MemorySize(*info.l_art, true);
-	auto r_node_memory_size = info.r_node->MemorySize(*info.r_art, true);
-
-	info.root_l_art->DecreaseMemorySize(l_node_memory_size);
-	info.root_r_art->DecreaseMemorySize(r_node_memory_size);
-	info.root_l_art->IncreaseMemorySize(r_node_memory_size);
-	info.root_r_art->IncreaseMemorySize(l_node_memory_size);
+	if (count <= NODE_4_CAPACITY) {
+		return NType::NODE_4;
+	} else if (count <= NODE_16_CAPACITY) {
+		return NType::NODE_16;
+	} else if (count <= NODE_48_CAPACITY) {
+		return NType::NODE_48;
+	}
+	return NType::NODE_256;
+}
 
-	// actual swap
-	swap(info.l_art, info.r_art);
-	swap(info.l_node, info.r_node);
-	UpdateParentsOfNodes(info.l_node, info.r_node, parents);
+FixedSizeAllocator &Node::GetAllocator(const ART &art, NType type) {
+	return *art.allocators[(uint8_t)type - 1];
 }
 
-bool Merge(MergeInfo &info, ParentsOfNodes &parents) {
+//===--------------------------------------------------------------------===//
+// Merging
+//===--------------------------------------------------------------------===//
 
-	D_ASSERT(info.l_node);
-	D_ASSERT(info.r_node);
+void Node::InitializeMerge(ART &art, const ARTFlags &flags) {
 
-	// always try to merge the smaller node into the bigger node
-	// because maybe there is enough free space in the bigger node to fit the smaller one
-	// without too much recursion
+	if (!IsSet()) {
+		return;
+	}
 
-	if (info.l_node->type < info.r_node->type) {
-		// swap subtrees to ensure that l_node has the bigger node type
-		SwapNodes(info, parents);
+	if (IsSwizzled()) {
+		Deserialize(art);
 	}
 
-	if (info.r_node->type == NodeType::NLeaf) {
-		D_ASSERT(info.l_node->type == NodeType::NLeaf);
-		D_ASSERT(info.r_node->type == NodeType::NLeaf);
-		if (info.l_art->IsUnique()) {
-			return false;
+	// if not all prefixes are inlined
+	if (flags.merge_buffer_counts[(uint8_t)NType::PREFIX_SEGMENT - 1] != 0) {
+		// initialize prefix segments
+		GetPrefix(art).InitializeMerge(art, flags.merge_buffer_counts[(uint8_t)NType::PREFIX_SEGMENT - 1]);
+	}
+
+	auto type = DecodeARTNodeType();
+	switch (type) {
+	case NType::LEAF:
+		// if not all leaves are inlined
+		if (flags.merge_buffer_counts[(uint8_t)NType::LEAF_SEGMENT - 1] != 0) {
+			// initialize leaf segments
+			Leaf::Get(art, *this).InitializeMerge(art, flags.merge_buffer_counts[(uint8_t)NType::LEAF_SEGMENT - 1]);
 		}
-		Leaf::Merge(*info.root_l_art, info.l_node, info.r_node);
-		return true;
+		break;
+	case NType::NODE_4:
+		Node4::Get(art, *this).InitializeMerge(art, flags);
+		break;
+	case NType::NODE_16:
+		Node16::Get(art, *this).InitializeMerge(art, flags);
+		break;
+	case NType::NODE_48:
+		Node48::Get(art, *this).InitializeMerge(art, flags);
+		break;
+	case NType::NODE_256:
+		Node256::Get(art, *this).InitializeMerge(art, flags);
+		break;
+	default:
+		throw InternalException("Invalid node type for InitializeMerge.");
 	}
 
-	uint8_t key_byte;
-	idx_t r_child_pos = DConstants::INVALID_INDEX;
+	buffer_id += flags.merge_buffer_counts[(uint8_t)type - 1];
+}
 
-	while (true) {
-		r_child_pos = info.r_node->GetNextPosAndByte(r_child_pos, key_byte);
-		if (r_child_pos == DConstants::INVALID_INDEX) {
-			break;
-		}
-		auto r_child = info.r_node->GetChild(*info.r_art, r_child_pos);
-		auto l_child_pos = info.l_node->GetChildPos(key_byte);
-
-		if (l_child_pos == DConstants::INVALID_INDEX) {
-			// insert child at empty position
-			auto r_memory_size = r_child->MemorySize(*info.r_art, true);
-			Node::InsertChild(*info.root_l_art, info.l_node, key_byte, r_child);
-
-			info.root_l_art->IncreaseMemorySize(r_memory_size);
-			info.root_r_art->DecreaseMemorySize(r_memory_size);
-			if (parents.l_parent) {
-				parents.l_parent->ReplaceChildPointer(parents.l_pos, info.l_node);
-			}
-			info.r_node->ReplaceChildPointer(r_child_pos, nullptr);
+bool Node::Merge(ART &art, Node &other) {
 
-		} else {
-			// recurse
-			auto l_child = info.l_node->GetChild(*info.l_art, l_child_pos);
-			MergeInfo child_info(info.l_art, info.r_art, info.root_l_art, info.root_r_art, l_child, r_child);
-			ParentsOfNodes child_parents(info.l_node, l_child_pos, info.r_node, r_child_pos);
-			if (!ResolvePrefixesAndMerge(child_info, child_parents)) {
-				return false;
-			}
-		}
+	if (!IsSet()) {
+		*this = other;
+		other = Node();
+		return true;
 	}
-	return true;
+
+	return ResolvePrefixes(art, other);
 }
 
-bool ResolvePrefixesAndMerge(MergeInfo &info, ParentsOfNodes &parents) {
+bool Node::ResolvePrefixes(ART &art, Node &other) {
+
 	// NOTE: we always merge into the left ART
 
-	D_ASSERT(info.l_node);
-	D_ASSERT(info.r_node);
+	D_ASSERT(IsSet());
+	D_ASSERT(other.IsSet());
 
 	// make sure that r_node has the longer (or equally long) prefix
-	if (info.l_node->prefix.Size() > info.r_node->prefix.Size()) {
-		SwapNodes(info, parents);
+	if (GetPrefix(art).count > other.GetPrefix(art).count) {
+		swap(*this, other);
 	}
 
-	Node *null_parent = nullptr;
-	auto &l_node = info.l_node;
-	auto &r_node = info.r_node;
-	auto l_prefix_size = l_node->prefix.Size();
-	auto r_prefix_size = r_node->prefix.Size();
+	auto &l_node = *this;
+	auto &r_node = other;
+	auto &l_prefix = l_node.GetPrefix(art);
+	auto &r_prefix = r_node.GetPrefix(art);
 
-	auto mismatch_pos = l_node->prefix.MismatchPosition(r_node->prefix);
+	auto mismatch_position = l_prefix.MismatchPosition(art, r_prefix);
 
 	// both nodes have no prefix or the same prefix
-	if (mismatch_pos == l_prefix_size && l_prefix_size == r_prefix_size) {
-		return Merge(info, parents);
+	if (mismatch_position == l_prefix.count && l_prefix.count == r_prefix.count) {
+		return MergeInternal(art, r_node);
 	}
 
-	if (mismatch_pos == l_prefix_size) {
+	if (mismatch_position == l_prefix.count) {
 		// r_node's prefix contains l_node's prefix
 		// l_node cannot be a leaf, otherwise the key represented by l_node would be a subset of another key
 		// which is not possible by our construction
-		D_ASSERT(l_node->type != NodeType::NLeaf);
+		D_ASSERT(l_node.DecodeARTNodeType() != NType::LEAF);
 
-		// test if the next byte (mismatch_pos) in r_node (longer prefix) exists in l_node
-		auto mismatch_byte = r_node->prefix[mismatch_pos];
-		auto child_pos = l_node->GetChildPos(mismatch_byte);
+		// test if the next byte (mismatch_position) in r_node (longer prefix) exists in l_node
+		auto mismatch_byte = r_prefix.GetByte(art, mismatch_position);
+		auto child_node = l_node.GetChild(art, mismatch_byte);
 
-		// update the prefix of r_node to only consist of the bytes after mismatch_pos
-		r_node->prefix.Reduce(*info.root_r_art, mismatch_pos);
+		// update the prefix of r_node to only consist of the bytes after mismatch_position
+		r_prefix.Reduce(art, mismatch_position);
 
 		// insert r_node as a child of l_node at empty position
-		if (child_pos == DConstants::INVALID_INDEX) {
-
-			auto r_memory_size = r_node->MemorySize(*info.r_art, true);
-			Node::InsertChild(*info.root_l_art, l_node, mismatch_byte, r_node);
-
-			info.root_l_art->IncreaseMemorySize(r_memory_size);
-			info.root_r_art->DecreaseMemorySize(r_memory_size);
-			UpdateParentsOfNodes(l_node, null_parent, parents);
-			r_node = nullptr;
+		if (!child_node) {
+			Node::InsertChild(art, l_node, mismatch_byte, r_node);
+			r_node.Reset();
 			return true;
 		}
 
 		// recurse
-		auto child_node = l_node->GetChild(*info.l_art, child_pos);
-		MergeInfo child_info(info.l_art, info.r_art, info.root_l_art, info.root_r_art, child_node, r_node);
-		ParentsOfNodes child_parents(l_node, child_pos, parents.r_parent, parents.r_pos);
-		return ResolvePrefixesAndMerge(child_info, child_parents);
+		return child_node->ResolvePrefixes(art, r_node);
 	}
 
 	// prefixes differ, create new node and insert both nodes as children
 
 	// create new node
-	Node *new_node = Node4::New();
-	new_node->prefix = Prefix(l_node->prefix, mismatch_pos);
-	info.root_l_art->IncreaseMemorySize(new_node->MemorySize(*info.l_art, false));
+	auto old_l_node = l_node;
+	auto &new_n4 = Node4::New(art, l_node);
+	new_n4.prefix.Initialize(art, l_prefix, mismatch_position);
 
-	// insert l_node, break up prefix of l_node
-	auto key_byte = l_node->prefix.Reduce(*info.root_l_art, mismatch_pos);
-	Node4::InsertChild(*info.root_l_art, new_node, key_byte, l_node);
+	// insert old l_node, break up prefix of old l_node
+	auto key_byte = l_prefix.Reduce(art, mismatch_position);
+	Node4::InsertChild(art, l_node, key_byte, old_l_node);
 
 	// insert r_node, break up prefix of r_node
-	key_byte = r_node->prefix.Reduce(*info.root_r_art, mismatch_pos);
-	auto r_memory_size = r_node->MemorySize(*info.r_art, true);
-	Node4::InsertChild(*info.root_l_art, new_node, key_byte, r_node);
+	key_byte = r_prefix.Reduce(art, mismatch_position);
+	Node4::InsertChild(art, l_node, key_byte, r_node);
 
-	info.root_l_art->IncreaseMemorySize(r_memory_size);
-	info.root_r_art->DecreaseMemorySize(r_memory_size);
-
-	l_node = new_node;
-	UpdateParentsOfNodes(l_node, null_parent, parents);
-	r_node = nullptr;
+	r_node.Reset();
 	return true;
 }
 
-bool Node::MergeARTs(ART *l_art, ART *r_art) {
+bool Node::MergeInternal(ART &art, Node &other) {
 
-	Node *null_parent = nullptr;
-	MergeInfo info(l_art, r_art, l_art, r_art, l_art->tree, r_art->tree);
-	ParentsOfNodes parents(null_parent, 0, null_parent, 0);
-	return ResolvePrefixesAndMerge(info, parents);
-}
+	D_ASSERT(IsSet());
+	D_ASSERT(other.IsSet());
 
-idx_t Node::RecursiveMemorySize(ART &art) {
+	// always try to merge the smaller node into the bigger node
+	// because maybe there is enough free space in the bigger node to fit the smaller one
+	// without too much recursion
+	if (this->DecodeARTNodeType() < other.DecodeARTNodeType()) {
+		swap(*this, other);
+	}
 
-	// get the size of all children
-	auto memory_size_children = 0;
+	Node empty_node;
+	auto &l_node = *this;
+	auto &r_node = other;
+
+	if (r_node.DecodeARTNodeType() == NType::LEAF) {
+		D_ASSERT(l_node.DecodeARTNodeType() == NType::LEAF);
+
+		if (art.IsUnique()) {
+			return false;
+		}
+
+		Leaf::Get(art, *this).Merge(art, r_node);
+		return true;
+	}
+
+	uint8_t byte = 0;
+	auto r_child = r_node.GetNextChild(art, byte);
+
+	// while r_node still has children to merge
+	while (r_child) {
+		auto l_child = l_node.GetChild(art, byte);
+		if (!l_child) {
+			// insert child at empty byte
+			Node::InsertChild(art, l_node, byte, *r_child);
+			r_node.ReplaceChild(art, byte, empty_node);
+
+		} else {
+			// recurse
+			if (!l_child->ResolvePrefixes(art, *r_child)) {
+				return false;
+			}
+		}
 
-	auto next_pos = GetNextPos(DConstants::INVALID_INDEX);
-	while (next_pos != DConstants::INVALID_INDEX) {
-		if (ChildIsInMemory(next_pos)) {
-			auto child = GetChild(art, next_pos);
-			memory_size_children += child->MemorySize(art, true);
+		if (byte == NumericLimits<uint8_t>::Maximum()) {
+			break;
 		}
-		next_pos = GetNextPos(next_pos);
+		byte++;
+		r_child = r_node.GetNextChild(art, byte);
 	}
 
-	return memory_size_children;
+	Node::Free(art, r_node);
+	return true;
+}
+
+//===--------------------------------------------------------------------===//
+// Vacuum
+//===--------------------------------------------------------------------===//
+
+void Node::Vacuum(ART &art, Node &node, const ARTFlags &flags) {
+
+	if (node.IsSwizzled()) {
+		return;
+	}
+
+	// possibly vacuum prefix segments, if not all prefixes are inlined
+	bool needs_vacuum = flags.vacuum_flags[(uint8_t)NType::PREFIX_SEGMENT - 1];
+	if (needs_vacuum) {
+		// vacuum prefix segments
+		node.GetPrefix(art).Vacuum(art);
+	}
+
+	auto type = node.DecodeARTNodeType();
+	auto &allocator = Node::GetAllocator(art, type);
+	needs_vacuum = flags.vacuum_flags[node.type - 1] && allocator.NeedsVacuum(node);
+	if (needs_vacuum) {
+		node.SetPtr(allocator.VacuumPointer(node));
+	}
+
+	switch (type) {
+	case NType::LEAF: {
+		// possibly vacuum leaf segments, if not all leaves are inlined
+		if (flags.vacuum_flags[(uint8_t)NType::LEAF_SEGMENT - 1]) {
+			Leaf::Get(art, node).Vacuum(art);
+		}
+		return;
+	}
+	case NType::NODE_4:
+		return Node4::Get(art, node).Vacuum(art, flags);
+	case NType::NODE_16:
+		return Node16::Get(art, node).Vacuum(art, flags);
+	case NType::NODE_48:
+		return Node48::Get(art, node).Vacuum(art, flags);
+	case NType::NODE_256:
+		return Node256::Get(art, node).Vacuum(art, flags);
+	default:
+		throw InternalException("Invalid node type for Vacuum.");
+	}
 }
 
 } // namespace duckdb