duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

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

@@ -1,5 +1,6 @@
 #include "duckdb/execution/index/art/node16.hpp"
 
+#include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node4.hpp"
 #include "duckdb/execution/index/art/node48.hpp"
 
@@ -11,6 +12,13 @@ Node16::Node16() : Node(NodeType::N16) {
 	memset(key, 16, sizeof(key));
 }
 
+idx_t Node16::MemorySize(ART &art, const bool &recurse) {
+	if (recurse) {
+		return prefix.MemorySize() + sizeof(*this) + RecursiveMemorySize(art);
+	}
+	return prefix.MemorySize() + sizeof(*this);
+}
+
 idx_t Node16::GetChildPos(uint8_t k) {
 	for (idx_t pos = 0; pos < count; pos++) {
 		if (key[pos] == k) {
@@ -47,6 +55,19 @@ idx_t Node16::GetNextPos(idx_t pos) {
 	return pos < count ? pos : DConstants::INVALID_INDEX;
 }
 
+idx_t Node16::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;
+	}
+	return DConstants::INVALID_INDEX;
+}
+
 Node *Node16::GetChild(ART &art, idx_t pos) {
 	D_ASSERT(pos < count);
 	return children[pos].Unswizzle(art);
@@ -56,12 +77,16 @@ void Node16::ReplaceChildPointer(idx_t pos, Node *node) {
 	children[pos] = node;
 }
 
-void Node16::InsertChild(Node *&node, uint8_t key_byte, Node *new_child) {
+bool Node16::ChildIsInMemory(idx_t pos) {
+	return children[pos] && !children[pos].IsSwizzled();
+}
+
+void Node16::InsertChild(ART &art, Node *&node, uint8_t key_byte, Node *new_child) {
 	Node16 *n = (Node16 *)node;
 
-	// Insert new child node into node
-	if (n->count < 16) {
-		// Insert element
+	// insert new child node into node
+	if (n->count < Node16::GetSize()) {
+		// still space, just insert the child
 		idx_t pos = 0;
 		while (pos < node->count && n->key[pos] < key_byte) {
 			pos++;
@@ -75,71 +100,74 @@ void Node16::InsertChild(Node *&node, uint8_t key_byte, Node *new_child) {
 		n->key[pos] = key_byte;
 		n->children[pos] = new_child;
 		n->count++;
+
 	} else {
-		// Grow to Node48
+		// node is full, grow to Node48
 		auto new_node = Node48::New();
+		art.memory_size += 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;
 		}
-		new_node->prefix = move(n->prefix);
-		new_node->count = node->count;
+
+		D_ASSERT(art.memory_size >= node->MemorySize(art, false));
+		art.memory_size -= node->MemorySize(art, false);
 		Node::Delete(node);
 		node = new_node;
-
-		Node48::InsertChild(node, key_byte, new_child);
+		Node48::InsertChild(art, node, key_byte, new_child);
 	}
 }
 
-void Node16::EraseChild(Node *&node, int pos, ART &art) {
+void Node16::EraseChild(ART &art, Node *&node, idx_t pos) {
+
 	auto n = (Node16 *)node;
+	D_ASSERT(pos < n->count);
+
+	// adjust the ART size
+	if (n->ChildIsInMemory(pos)) {
+		auto child = n->GetChild(art, pos);
+		D_ASSERT(art.memory_size >= child->MemorySize(art, true));
+		art.memory_size -= child->MemorySize(art, true);
+	}
+
 	// erase the child and decrease the count
 	n->children[pos].Reset();
 	n->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 < 16; pos++) {
+	for (; pos < Node16::GetSize(); pos++) {
 		if (!n->children[pos]) {
 			break;
 		}
 		n->children[pos] = nullptr;
 	}
 
-	if (node->count <= 3) {
-		// Shrink node
+	// shrink node to Node4
+	if (node->count < Node4::GetSize()) {
+
 		auto new_node = Node4::New();
-		for (unsigned i = 0; i < n->count; i++) {
+		art.memory_size += new_node->MemorySize(art, false);
+		new_node->prefix = std::move(n->prefix);
+
+		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;
 		}
-		new_node->prefix = move(n->prefix);
+
+		D_ASSERT(art.memory_size >= node->MemorySize(art, false));
+		art.memory_size -= node->MemorySize(art, false);
 		Node::Delete(node);
 		node = new_node;
 	}
 }
-
-bool Node16::Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos) {
-
-	Node16 *r_n = (Node16 *)info.r_node;
-
-	for (idx_t i = 0; i < info.r_node->count; i++) {
-
-		auto l_child_pos = info.l_node->GetChildPos(r_n->key[i]);
-		if (!Node::MergeAtByte(info, depth, l_child_pos, i, r_n->key[i], l_parent, l_pos)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-idx_t Node16::GetSize() {
-	return 16;
-}
-
 } // namespace duckdb

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

@@ -1,5 +1,6 @@
 #include "duckdb/execution/index/art/node256.hpp"
 
+#include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node48.hpp"
 
 namespace duckdb {
@@ -7,6 +8,13 @@ namespace duckdb {
 Node256::Node256() : Node(NodeType::N256) {
 }
 
+idx_t Node256::MemorySize(ART &art, const bool &recurse) {
+	if (recurse) {
+		return prefix.MemorySize() + sizeof(*this) + RecursiveMemorySize(art);
+	}
+	return prefix.MemorySize() + sizeof(*this);
+}
+
 idx_t Node256::GetChildPos(uint8_t k) {
 	if (children[k]) {
 		return k;
@@ -16,7 +24,7 @@ idx_t Node256::GetChildPos(uint8_t k) {
 }
 
 idx_t Node256::GetChildGreaterEqual(uint8_t k, bool &equal) {
-	for (idx_t pos = k; pos < 256; pos++) {
+	for (idx_t pos = k; pos < Node256::GetSize(); pos++) {
 		if (children[pos]) {
 			if (pos == k) {
 				equal = true;
@@ -30,7 +38,7 @@ idx_t Node256::GetChildGreaterEqual(uint8_t k, bool &equal) {
 }
 
 idx_t Node256::GetMin() {
-	for (idx_t i = 0; i < 256; i++) {
+	for (idx_t i = 0; i < Node256::GetSize(); i++) {
 		if (children[i]) {
 			return i;
 		}
@@ -39,7 +47,8 @@ idx_t Node256::GetMin() {
 }
 
 idx_t Node256::GetNextPos(idx_t pos) {
-	for (pos == DConstants::INVALID_INDEX ? pos = 0 : pos++; pos < 256; pos++) {
+	pos == DConstants::INVALID_INDEX ? pos = 0 : pos++;
+	for (; pos < Node256::GetSize(); pos++) {
 		if (children[pos]) {
 			return pos;
 		}
@@ -47,6 +56,17 @@ idx_t Node256::GetNextPos(idx_t pos) {
 	return Node::GetNextPos(pos);
 }
 
+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;
+		}
+	}
+	return Node::GetNextPos(pos);
+}
+
 Node *Node256::GetChild(ART &art, idx_t pos) {
 	return children[pos].Unswizzle(art);
 }
@@ -55,50 +75,50 @@ void Node256::ReplaceChildPointer(idx_t pos, Node *node) {
 	children[pos] = node;
 }
 
-void Node256::InsertChild(Node *&node, uint8_t key_byte, Node *new_child) {
+bool Node256::ChildIsInMemory(idx_t pos) {
+	return children[pos] && !children[pos].IsSwizzled();
+}
+
+void Node256::InsertChild(ART &, Node *&node, uint8_t key_byte, Node *new_child) {
 	auto n = (Node256 *)(node);
 
 	n->count++;
 	n->children[key_byte] = new_child;
 }
 
-void Node256::EraseChild(Node *&node, int pos, ART &art) {
+void Node256::EraseChild(ART &art, Node *&node, idx_t pos) {
 	auto n = (Node256 *)(node);
+
+	// adjust the ART size
+	if (n->ChildIsInMemory(pos)) {
+		auto child = n->GetChild(art, pos);
+		D_ASSERT(art.memory_size >= child->MemorySize(art, true));
+		art.memory_size -= child->MemorySize(art, true);
+	}
+
+	// erase the child and decrease the count
 	n->children[pos].Reset();
 	n->count--;
-	if (node->count <= 36) {
+
+	// shrink node to Node48
+	if (node->count <= NODE_256_SHRINK_THRESHOLD) {
+
 		auto new_node = Node48::New();
-		new_node->prefix = move(n->prefix);
-		for (idx_t i = 0; i < 256; i++) {
+		art.memory_size += 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];
+				new_node->children[new_node->count++] = n->children[i];
 				n->children[i] = nullptr;
-				new_node->count++;
 			}
 		}
+
+		D_ASSERT(art.memory_size >= node->MemorySize(art, false));
+		art.memory_size -= node->MemorySize(art, false);
 		Node::Delete(node);
 		node = new_node;
 	}
 }
-
-bool Node256::Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos) {
-
-	for (idx_t i = 0; i < 256; i++) {
-		if (info.r_node->GetChildPos(i) != DConstants::INVALID_INDEX) {
-
-			auto l_child_pos = info.l_node->GetChildPos(i);
-			auto key_byte = (uint8_t)i;
-			if (!Node::MergeAtByte(info, depth, l_child_pos, i, key_byte, l_parent, l_pos)) {
-				return false;
-			}
-		}
-	}
-	return true;
-}
-
-idx_t Node256::GetSize() {
-	return 256;
-}
-
 } // namespace duckdb

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

@@ -1,7 +1,7 @@
 #include "duckdb/execution/index/art/node4.hpp"
 
-#include "duckdb/execution/index/art/node16.hpp"
 #include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/execution/index/art/node16.hpp"
 #include "duckdb/storage/meta_block_reader.hpp"
 
 namespace duckdb {
@@ -10,6 +10,13 @@ Node4::Node4() : Node(NodeType::N4) {
 	memset(key, 0, sizeof(key));
 }
 
+idx_t Node4::MemorySize(ART &art, const bool &recurse) {
+	if (recurse) {
+		return prefix.MemorySize() + sizeof(*this) + RecursiveMemorySize(art);
+	}
+	return prefix.MemorySize() + sizeof(*this);
+}
+
 idx_t Node4::GetChildPos(uint8_t k) {
 	for (idx_t pos = 0; pos < count; pos++) {
 		if (key[pos] == k) {
@@ -45,6 +52,19 @@ idx_t Node4::GetNextPos(idx_t 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;
+	}
+	return DConstants::INVALID_INDEX;
+}
+
 Node *Node4::GetChild(ART &art, idx_t pos) {
 	D_ASSERT(pos < count);
 	return children[pos].Unswizzle(art);
@@ -54,12 +74,16 @@ void Node4::ReplaceChildPointer(idx_t pos, Node *node) {
 	children[pos] = node;
 }
 
-void Node4::InsertChild(Node *&node, uint8_t key_byte, Node *new_child) {
+bool Node4::ChildIsInMemory(idx_t pos) {
+	return children[pos] && !children[pos].IsSwizzled();
+}
+
+void Node4::InsertChild(ART &art, Node *&node, uint8_t key_byte, Node *new_child) {
 	Node4 *n = (Node4 *)node;
 
-	// Insert new child node into node
-	if (node->count < 4) {
-		// Insert element
+	// insert new child node into node
+	if (node->count < Node4::GetSize()) {
+		// still space, just insert the child
 		idx_t pos = 0;
 		while ((pos < node->count) && (n->key[pos] < key_byte)) {
 			pos++;
@@ -73,66 +97,71 @@ void Node4::InsertChild(Node *&node, uint8_t key_byte, Node *new_child) {
 		n->key[pos] = key_byte;
 		n->children[pos] = new_child;
 		n->count++;
+
 	} else {
-		// Grow to Node16
+		// node is full, grow to Node16
 		auto new_node = Node16::New();
-		new_node->count = 4;
-		new_node->prefix = move(node->prefix);
-		for (idx_t i = 0; i < 4; i++) {
+		art.memory_size += 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;
 		}
-		// Delete old node and replace it with new Node16
+		n->count = 0;
+
+		D_ASSERT(art.memory_size >= node->MemorySize(art, false));
+		art.memory_size -= node->MemorySize(art, false);
 		Node::Delete(node);
 		node = new_node;
-		Node16::InsertChild(node, key_byte, new_child);
+		Node16::InsertChild(art, node, key_byte, new_child);
 	}
 }
 
-void Node4::EraseChild(Node *&node, int pos, ART &art) {
+void Node4::EraseChild(ART &art, Node *&node, idx_t pos) {
+
 	Node4 *n = (Node4 *)node;
 	D_ASSERT(pos < n->count);
+	D_ASSERT(n->count > 1);
+
+	// adjust the ART size
+	if (n->ChildIsInMemory(pos)) {
+		auto child = n->GetChild(art, pos);
+		D_ASSERT(art.memory_size >= child->MemorySize(art, true));
+		art.memory_size -= child->MemorySize(art, true);
+	}
+
 	// erase the child and decrease the count
 	n->children[pos].Reset();
 	n->count--;
+	D_ASSERT(n->count >= 1);
+
 	// 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 < 4; pos++) {
+	for (; pos < Node4::GetSize(); pos++) {
 		n->children[pos] = nullptr;
 	}
 
-	// This is a one way node
+	// this is a one way node, compress
 	if (n->count == 1) {
+
+		// get only child and concatenate prefixes
 		auto child_ref = n->GetChild(art, 0);
 		// concatenate prefixes
-		child_ref->prefix.Concatenate(n->key[0], node->prefix);
+		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;
+
+		D_ASSERT(art.memory_size >= n->MemorySize(art, false));
+		art.memory_size -= n->MemorySize(art, false);
 		Node::Delete(node);
 		node = child_ref;
 	}
 }
-
-bool Node4::Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos) {
-
-	Node4 *r_n = (Node4 *)info.r_node;
-
-	for (idx_t i = 0; i < info.r_node->count; i++) {
-
-		auto l_child_pos = info.l_node->GetChildPos(r_n->key[i]);
-		if (!Node::MergeAtByte(info, depth, l_child_pos, i, r_n->key[i], l_parent, l_pos)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-idx_t Node4::GetSize() {
-	return 4;
-}
-
 } // namespace duckdb

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

@@ -1,5 +1,6 @@
 #include "duckdb/execution/index/art/node48.hpp"
 
+#include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node16.hpp"
 #include "duckdb/execution/index/art/node256.hpp"
 
@@ -11,6 +12,13 @@ Node48::Node48() : Node(NodeType::N48) {
 	}
 }
 
+idx_t Node48::MemorySize(ART &art, const bool &recurse) {
+	if (recurse) {
+		return prefix.MemorySize() + sizeof(*this) + RecursiveMemorySize(art);
+	}
+	return prefix.MemorySize() + sizeof(*this);
+}
+
 idx_t Node48::GetChildPos(uint8_t k) {
 	if (child_index[k] == Node::EMPTY_MARKER) {
 		return DConstants::INVALID_INDEX;
@@ -20,7 +28,7 @@ idx_t Node48::GetChildPos(uint8_t k) {
 }
 
 idx_t Node48::GetChildGreaterEqual(uint8_t k, bool &equal) {
-	for (idx_t pos = k; pos < 256; pos++) {
+	for (idx_t pos = k; pos < Node256::GetSize(); pos++) {
 		if (child_index[pos] != Node::EMPTY_MARKER) {
 			if (pos == k) {
 				equal = true;
@@ -34,7 +42,7 @@ idx_t Node48::GetChildGreaterEqual(uint8_t k, bool &equal) {
 }
 
 idx_t Node48::GetMin() {
-	for (idx_t i = 0; i < 256; i++) {
+	for (idx_t i = 0; i < Node256::GetSize(); i++) {
 		if (child_index[i] != Node::EMPTY_MARKER) {
 			return i;
 		}
@@ -43,7 +51,8 @@ idx_t Node48::GetMin() {
 }
 
 idx_t Node48::GetNextPos(idx_t pos) {
-	for (pos == DConstants::INVALID_INDEX ? pos = 0 : pos++; pos < 256; pos++) {
+	pos == DConstants::INVALID_INDEX ? pos = 0 : pos++;
+	for (; pos < Node256::GetSize(); pos++) {
 		if (child_index[pos] != Node::EMPTY_MARKER) {
 			return pos;
 		}
@@ -51,6 +60,17 @@ idx_t Node48::GetNextPos(idx_t pos) {
 	return Node::GetNextPos(pos);
 }
 
+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;
+		}
+	}
+	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);
@@ -60,12 +80,16 @@ void Node48::ReplaceChildPointer(idx_t pos, Node *node) {
 	children[child_index[pos]] = node;
 }
 
-void Node48::InsertChild(Node *&node, uint8_t key_byte, Node *new_child) {
+bool Node48::ChildIsInMemory(idx_t pos) {
+	return children[child_index[pos]] && !children[child_index[pos]].IsSwizzled();
+}
+
+void Node48::InsertChild(ART &art, Node *&node, uint8_t key_byte, Node *new_child) {
 	auto n = (Node48 *)node;
 
-	// Insert new child node into node
-	if (node->count < 48) {
-		// Insert element
+	// insert new child node into node
+	if (node->count < Node48::GetSize()) {
+		// still space, just insert the child
 		idx_t pos = n->count;
 		if (n->children[pos]) {
 			// find an empty position in the node list if the current position is occupied
@@ -77,62 +101,63 @@ void Node48::InsertChild(Node *&node, uint8_t key_byte, Node *new_child) {
 		n->children[pos] = new_child;
 		n->child_index[key_byte] = pos;
 		n->count++;
+
 	} else {
-		// Grow to Node256
+		// node is full, grow to Node256
 		auto new_node = Node256::New();
-		for (idx_t i = 0; i < 256; i++) {
+		art.memory_size += 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;
 			}
 		}
-		new_node->count = n->count;
-		new_node->prefix = move(n->prefix);
+
+		D_ASSERT(art.memory_size >= node->MemorySize(art, false));
+		art.memory_size -= node->MemorySize(art, false);
 		Node::Delete(node);
 		node = new_node;
-		Node256::InsertChild(node, key_byte, new_child);
+		Node256::InsertChild(art, node, key_byte, new_child);
 	}
 }
 
-void Node48::EraseChild(Node *&node, int pos, ART &art) {
+void Node48::EraseChild(ART &art, Node *&node, idx_t pos) {
 	auto n = (Node48 *)(node);
+
+	// adjust the ART size
+	if (n->ChildIsInMemory(pos)) {
+		auto child = n->GetChild(art, pos);
+		D_ASSERT(art.memory_size >= child->MemorySize(art, true));
+		art.memory_size -= child->MemorySize(art, true);
+	}
+
+	// erase the child and decrease the count
 	n->children[n->child_index[pos]].Reset();
 	n->child_index[pos] = Node::EMPTY_MARKER;
 	n->count--;
-	if (node->count <= 12) {
+
+	// shrink node to Node16
+	if (node->count < NODE_48_SHRINK_THRESHOLD) {
+
 		auto new_node = Node16::New();
-		new_node->prefix = move(n->prefix);
-		for (idx_t i = 0; i < 256; i++) {
+		art.memory_size += new_node->MemorySize(art, false);
+		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->key[new_node->count] = i;
 				new_node->children[new_node->count++] = n->children[n->child_index[i]];
 				n->children[n->child_index[i]] = nullptr;
 			}
 		}
+
+		D_ASSERT(art.memory_size >= node->MemorySize(art, false));
+		art.memory_size -= node->MemorySize(art, false);
 		Node::Delete(node);
 		node = new_node;
 	}
 }
-
-bool Node48::Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos) {
-
-	Node48 *r_n = (Node48 *)info.r_node;
-
-	for (idx_t i = 0; i < 256; i++) {
-		if (r_n->child_index[i] != Node::EMPTY_MARKER) {
-
-			auto l_child_pos = info.l_node->GetChildPos(i);
-			auto key_byte = (uint8_t)i;
-			if (!Node::MergeAtByte(info, depth, l_child_pos, i, key_byte, l_parent, l_pos)) {
-				return false;
-			}
-		}
-	}
-	return true;
-}
-
-idx_t Node48::GetSize() {
-	return 48;
-}
-
 } // namespace duckdb