duckdb 0.8.2-dev1791.0 → 0.8.2-dev1859.0

package/binding.gyp

@@ -45,6 +45,7 @@
                 "src/duckdb/ub_src_core_functions_scalar_bit.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_blob.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_date.cpp", 
+                "src/duckdb/ub_src_core_functions_scalar_debug.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_enum.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_generic.cpp", 
                 "src/duckdb/ub_src_core_functions_scalar_list.cpp", 

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev1791.0",
+  "version": "0.8.2-dev1859.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/src/common/constants.cpp

@@ -7,7 +7,8 @@
 namespace duckdb {
 
 constexpr const idx_t DConstants::INVALID_INDEX;
-const row_t MAX_ROW_ID = 4611686018427388000ULL; // 2^62
+const row_t MAX_ROW_ID = 36028797018960000ULL;       // 2^55
+const row_t MAX_ROW_ID_LOCAL = 72057594037920000ULL; // 2^56
 const column_t COLUMN_IDENTIFIER_ROW_ID = (column_t)-1;
 const sel_t ZERO_VECTOR[STANDARD_VECTOR_SIZE] = {0};
 const double PI = 3.141592653589793;

package/src/duckdb/src/common/enum_util.cpp

@@ -3112,8 +3112,6 @@ const char* EnumUtil::ToChars<NType>(NType value) {
 	switch(value) {
 	case NType::PREFIX:
 		return "PREFIX";
-	case NType::LEAF_SEGMENT:
-		return "LEAF_SEGMENT";
 	case NType::LEAF:
 		return "LEAF";
 	case NType::NODE_4:
@@ -3124,6 +3122,8 @@ const char* EnumUtil::ToChars<NType>(NType value) {
 		return "NODE_48";
 	case NType::NODE_256:
 		return "NODE_256";
+	case NType::LEAF_INLINED:
+		return "LEAF_INLINED";
 	default:
 		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
 	}
@@ -3134,9 +3134,6 @@ NType EnumUtil::FromString<NType>(const char *value) {
 	if (StringUtil::Equals(value, "PREFIX")) {
 		return NType::PREFIX;
 	}
-	if (StringUtil::Equals(value, "LEAF_SEGMENT")) {
-		return NType::LEAF_SEGMENT;
-	}
 	if (StringUtil::Equals(value, "LEAF")) {
 		return NType::LEAF;
 	}
@@ -3152,6 +3149,9 @@ NType EnumUtil::FromString<NType>(const char *value) {
 	if (StringUtil::Equals(value, "NODE_256")) {
 		return NType::NODE_256;
 	}
+	if (StringUtil::Equals(value, "LEAF_INLINED")) {
+		return NType::LEAF_INLINED;
+	}
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 

package/src/duckdb/src/core_functions/function_list.cpp

@@ -17,6 +17,7 @@
 #include "duckdb/core_functions/scalar/string_functions.hpp"
 #include "duckdb/core_functions/scalar/struct_functions.hpp"
 #include "duckdb/core_functions/scalar/union_functions.hpp"
+#include "duckdb/core_functions/scalar/debug_functions.hpp"
 
 namespace duckdb {
 
@@ -339,6 +340,7 @@ static StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_AGGREGATE_FUNCTION(VarPopFun),
 	DUCKDB_AGGREGATE_FUNCTION(VarSampFun),
 	DUCKDB_AGGREGATE_FUNCTION_ALIAS(VarianceFun),
+	DUCKDB_SCALAR_FUNCTION(VectorTypeFun),
 	DUCKDB_SCALAR_FUNCTION(VersionFun),
 	DUCKDB_SCALAR_FUNCTION_SET(WeekFun),
 	DUCKDB_SCALAR_FUNCTION_SET(WeekDayFun),

package/src/duckdb/src/core_functions/scalar/debug/vector_type.cpp

@@ -0,0 +1,23 @@
+#include "duckdb/core_functions/scalar/debug_functions.hpp"
+
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/common/enum_util.hpp"
+
+namespace duckdb {
+
+static void VectorTypeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	auto data = ConstantVector::GetData<string_t>(result);
+	data[0] = StringVector::AddString(result, EnumUtil::ToString(input.data[0].GetVectorType()));
+}
+
+ScalarFunction VectorTypeFun::GetFunction() {
+	return ScalarFunction("vector_type",        // name of the function
+	                      {LogicalType::ANY},   // argument list
+	                      LogicalType::VARCHAR, // return type
+	                      VectorTypeFunction);
+}
+
+} // namespace duckdb

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

@@ -5,7 +5,6 @@
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/storage/arena_allocator.hpp"
 #include "duckdb/execution/index/art/art_key.hpp"
-#include "duckdb/execution/index/art/leaf_segment.hpp"
 #include "duckdb/execution/index/art/prefix.hpp"
 #include "duckdb/execution/index/art/leaf.hpp"
 #include "duckdb/execution/index/art/node4.hpp"
@@ -44,7 +43,6 @@ ART::ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
 
 	// initialize all allocators
 	allocators.emplace_back(make_uniq<FixedSizeAllocator>(sizeof(Prefix), buffer_manager.GetBufferAllocator()));
-	allocators.emplace_back(make_uniq<FixedSizeAllocator>(sizeof(LeafSegment), buffer_manager.GetBufferAllocator()));
 	allocators.emplace_back(make_uniq<FixedSizeAllocator>(sizeof(Leaf), buffer_manager.GetBufferAllocator()));
 	allocators.emplace_back(make_uniq<FixedSizeAllocator>(sizeof(Node4), buffer_manager.GetBufferAllocator()));
 	allocators.emplace_back(make_uniq<FixedSizeAllocator>(sizeof(Node16), buffer_manager.GetBufferAllocator()));
@@ -54,8 +52,8 @@ ART::ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
 	// set the root node of the tree
 	tree = make_uniq<Node>();
 	if (block_id != DConstants::INVALID_INDEX) {
-		tree->buffer_id = block_id;
-		tree->offset = block_offset;
+		tree->SetSerialized();
+		tree->SetPtr(block_id, block_offset);
 		tree->Deserialize(*this);
 	}
 	serialized_data_pointer = BlockPointer(block_id, block_offset);
@@ -308,7 +306,7 @@ bool Construct(ART &art, vector<ARTKey> &keys, row_t *row_ids, Node &node, KeySe
 		reference<Node> ref_node(node);
 		Prefix::New(art, ref_node, start_key, prefix_start, start_key.len - prefix_start);
 		if (single_row_id) {
-			Leaf::New(art, ref_node, row_ids[key_section.start]);
+			Leaf::New(ref_node, row_ids[key_section.start]);
 		} else {
 			Leaf::New(art, ref_node, row_ids + key_section.start, num_row_ids);
 		}
@@ -358,19 +356,9 @@ bool ART::ConstructFromSorted(idx_t count, vector<ARTKey> &keys, Vector &row_ide
 	D_ASSERT(!VerifyAndToStringInternal(true).empty());
 	for (idx_t i = 0; i < count; i++) {
 		D_ASSERT(!keys[i].Empty());
-		auto leaf_node = Lookup(*tree, keys[i], 0);
-		D_ASSERT(leaf_node.IsSet());
-		auto &leaf = Leaf::Get(*this, leaf_node);
-
-		if (leaf.IsInlined()) {
-			D_ASSERT(row_ids[i] == leaf.row_ids.inlined);
-			continue;
-		}
-
-		D_ASSERT(leaf.row_ids.ptr.IsSet());
-		Node leaf_segment = leaf.row_ids.ptr;
-		auto position = leaf.FindRowId(*this, leaf_segment, row_ids[i]);
-		D_ASSERT(position != (uint32_t)DConstants::INVALID_INDEX);
+		auto leaf = Lookup(*tree, keys[i], 0);
+		D_ASSERT(leaf.IsSet());
+		D_ASSERT(Leaf::ContainsRowId(*this, leaf, row_ids[i]));
 	}
 #endif
 
@@ -431,19 +419,9 @@ PreservedError ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
 			continue;
 		}
 
-		auto leaf_node = Lookup(*tree, keys[i], 0);
-		D_ASSERT(leaf_node.IsSet());
-		auto &leaf = Leaf::Get(*this, leaf_node);
-
-		if (leaf.IsInlined()) {
-			D_ASSERT(row_identifiers[i] == leaf.row_ids.inlined);
-			continue;
-		}
-
-		D_ASSERT(leaf.row_ids.ptr.IsSet());
-		Node leaf_segment = leaf.row_ids.ptr;
-		auto position = leaf.FindRowId(*this, leaf_segment, row_identifiers[i]);
-		D_ASSERT(position != (uint32_t)DConstants::INVALID_INDEX);
+		auto leaf = Lookup(*tree, keys[i], 0);
+		D_ASSERT(leaf.IsSet());
+		D_ASSERT(Leaf::ContainsRowId(*this, leaf, row_identifiers[i]));
 	}
 #endif
 
@@ -471,19 +449,13 @@ void ART::VerifyAppend(DataChunk &chunk, ConflictManager &conflict_manager) {
 	CheckConstraintsForChunk(chunk, conflict_manager);
 }
 
-bool ART::InsertToLeaf(Node &leaf_node, const row_t &row_id) {
+bool ART::InsertToLeaf(Node &leaf, const row_t &row_id) {
 
-	auto &leaf = Leaf::Get(*this, leaf_node);
-
-#ifdef DEBUG
-	for (idx_t k = 0; k < leaf.count; k++) {
-		D_ASSERT(leaf.GetRowId(*this, k) != row_id);
-	}
-#endif
-	if (IsUnique() && leaf.count != 0) {
+	if (IsUnique()) {
 		return false;
 	}
-	leaf.Insert(*this, row_id);
+
+	Leaf::Insert(*this, leaf, row_id);
 	return true;
 }
 
@@ -494,14 +466,14 @@ bool ART::Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id
 		D_ASSERT(depth <= key.len);
 		reference<Node> ref_node(node);
 		Prefix::New(*this, ref_node, key, depth, key.len - depth);
-		Leaf::New(*this, ref_node, row_id);
+		Leaf::New(ref_node, row_id);
 		return true;
 	}
 
-	auto node_type = node.DecodeARTNodeType();
+	auto node_type = node.GetType();
 
 	// insert the row ID into this leaf
-	if (node_type == NType::LEAF) {
+	if (node_type == NType::LEAF || node_type == NType::LEAF_INLINED) {
 		return InsertToLeaf(node, row_id);
 	}
 
@@ -518,13 +490,11 @@ bool ART::Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id
 
 		// insert a new leaf node at key[depth]
 		Node leaf_node;
+		reference<Node> ref_node(leaf_node);
 		if (depth + 1 < key.len) {
-			reference<Node> ref_node(leaf_node);
 			Prefix::New(*this, ref_node, key, depth + 1, key.len - depth - 1);
-			Leaf::New(*this, ref_node, row_id);
-		} else {
-			Leaf::New(*this, leaf_node, row_id);
 		}
+		Leaf::New(ref_node, row_id);
 		Node::InsertChild(*this, node, key[depth], leaf_node);
 		return true;
 	}
@@ -534,7 +504,7 @@ bool ART::Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id
 	auto mismatch_position = Prefix::Traverse(*this, next_node, key, depth);
 
 	// prefix matches key
-	if (next_node.get().DecodeARTNodeType() != NType::PREFIX) {
+	if (next_node.get().GetType() != NType::PREFIX) {
 		return Insert(next_node, key, depth, row_id);
 	}
 
@@ -550,13 +520,11 @@ bool ART::Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id
 
 	// insert new leaf
 	Node leaf_node;
+	reference<Node> ref_node(leaf_node);
 	if (depth + 1 < key.len) {
-		reference<Node> ref_node(leaf_node);
 		Prefix::New(*this, ref_node, key, depth + 1, key.len - depth - 1);
-		Leaf::New(*this, ref_node, row_id);
-	} else {
-		Leaf::New(*this, leaf_node, row_id);
 	}
+	Leaf::New(ref_node, row_id);
 	Node4::InsertChild(*this, next_node, key[depth], leaf_node);
 	return true;
 }
@@ -596,19 +564,9 @@ void ART::Delete(IndexLock &state, DataChunk &input, Vector &row_ids) {
 			continue;
 		}
 
-		auto node = Lookup(*tree, keys[i], 0);
-		if (node.IsSet()) {
-			auto &leaf = Leaf::Get(*this, node);
-
-			if (leaf.IsInlined()) {
-				D_ASSERT(row_identifiers[i] != leaf.row_ids.inlined);
-				continue;
-			}
-
-			D_ASSERT(leaf.row_ids.ptr.IsSet());
-			Node leaf_segment = leaf.row_ids.ptr;
-			auto position = leaf.FindRowId(*this, leaf_segment, row_identifiers[i]);
-			D_ASSERT(position == (uint32_t)DConstants::INVALID_INDEX);
+		auto leaf = Lookup(*tree, keys[i], 0);
+		if (leaf.IsSet()) {
+			D_ASSERT(!Leaf::ContainsRowId(*this, leaf, row_identifiers[i]));
 		}
 	}
 #endif
@@ -622,21 +580,17 @@ void ART::Erase(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id)
 
 	// handle prefix
 	reference<Node> next_node(node);
-	if (next_node.get().DecodeARTNodeType() == NType::PREFIX) {
+	if (next_node.get().GetType() == NType::PREFIX) {
 		Prefix::Traverse(*this, next_node, key, depth);
-		if (next_node.get().DecodeARTNodeType() == NType::PREFIX) {
+		if (next_node.get().GetType() == NType::PREFIX) {
 			return;
 		}
 	}
 
 	// delete a row ID from a leaf (root is leaf with possible prefix nodes)
-	if (next_node.get().DecodeARTNodeType() == NType::LEAF) {
-		auto &leaf = Leaf::Get(*this, next_node.get());
-		leaf.Remove(*this, row_id);
-
-		if (leaf.count == 0) {
+	if (next_node.get().GetType() == NType::LEAF || next_node.get().GetType() == NType::LEAF_INLINED) {
+		if (Leaf::Remove(*this, next_node, row_id)) {
 			Node::Free(*this, node);
-			node.Reset();
 		}
 		return;
 	}
@@ -648,20 +602,16 @@ void ART::Erase(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id)
 
 		auto temp_depth = depth + 1;
 		reference<Node> child_node(*child);
-		if (child_node.get().DecodeARTNodeType() == NType::PREFIX) {
+		if (child_node.get().GetType() == NType::PREFIX) {
 			Prefix::Traverse(*this, child_node, key, temp_depth);
-			if (child_node.get().DecodeARTNodeType() == NType::PREFIX) {
+			if (child_node.get().GetType() == NType::PREFIX) {
 				return;
 			}
 		}
 
-		if (child_node.get().DecodeARTNodeType() == NType::LEAF) {
+		if (child_node.get().GetType() == NType::LEAF || child_node.get().GetType() == NType::LEAF_INLINED) {
 			// leaf found, remove entry
-			auto &leaf = Leaf::Get(*this, child_node.get());
-			leaf.Remove(*this, row_id);
-
-			if (leaf.count == 0) {
-				// leaf is empty, delete leaf, decrement node counter and maybe shrink node
+			if (Leaf::Remove(*this, child_node, row_id)) {
 				Node::DeleteChild(*this, next_node, node, key[depth]);
 			}
 			return;
@@ -713,20 +663,11 @@ static ARTKey CreateKey(ArenaAllocator &allocator, PhysicalType type, Value &val
 
 bool ART::SearchEqual(ARTKey &key, idx_t max_count, vector<row_t> &result_ids) {
 
-	auto leaf_node = Lookup(*tree, key, 0);
-	if (!leaf_node.IsSet()) {
+	auto leaf = Lookup(*tree, key, 0);
+	if (!leaf.IsSet()) {
 		return true;
 	}
-
-	auto &leaf = Leaf::Get(*this, leaf_node);
-	if (leaf.count > max_count) {
-		return false;
-	}
-	for (idx_t i = 0; i < leaf.count; i++) {
-		row_t row_id = leaf.GetRowId(*this, i);
-		result_ids.push_back(row_id);
-	}
-	return true;
+	return Leaf::GetRowIds(*this, leaf, result_ids, max_count);
 }
 
 void ART::SearchEqualJoinNoFetch(ARTKey &key, idx_t &result_size) {
@@ -738,8 +679,10 @@ void ART::SearchEqualJoinNoFetch(ARTKey &key, idx_t &result_size) {
 		return;
 	}
 
-	auto &leaf = Leaf::Get(*this, leaf_node);
-	result_size = leaf.count;
+	// we only perform index joins on PK/FK columns
+	D_ASSERT(leaf_node.GetType() == NType::LEAF_INLINED);
+	result_size = 1;
+	return;
 }
 
 //===--------------------------------------------------------------------===//
@@ -752,14 +695,14 @@ Node ART::Lookup(Node node, const ARTKey &key, idx_t depth) {
 
 		// traverse prefix, if exists
 		reference<Node> next_node(node);
-		if (next_node.get().DecodeARTNodeType() == NType::PREFIX) {
+		if (next_node.get().GetType() == NType::PREFIX) {
 			Prefix::Traverse(*this, next_node, key, depth);
-			if (next_node.get().DecodeARTNodeType() == NType::PREFIX) {
+			if (next_node.get().GetType() == NType::PREFIX) {
 				return Node();
 			}
 		}
 
-		if (next_node.get().DecodeARTNodeType() == NType::LEAF) {
+		if (next_node.get().GetType() == NType::LEAF || next_node.get().GetType() == NType::LEAF_INLINED) {
 			return next_node.get();
 		}
 
@@ -994,20 +937,18 @@ void ART::CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_m
 			continue;
 		}
 
-		auto leaf_node = Lookup(*tree, keys[i], 0);
-		if (!leaf_node.IsSet()) {
+		auto leaf = Lookup(*tree, keys[i], 0);
+		if (!leaf.IsSet()) {
 			if (conflict_manager.AddMiss(i)) {
 				found_conflict = i;
 			}
 			continue;
 		}
 
-		// When we find a node, we need to update the 'matches' and 'row_ids'
-		// NOTE: Leafs can have more than one row_id, but for UNIQUE/PRIMARY KEY they will only have one
-		Leaf &leaf = Leaf::Get(*this, leaf_node);
-		D_ASSERT(leaf.count == 1);
-		auto row_id = leaf.GetRowId(*this, 0);
-		if (conflict_manager.AddHit(i, row_id)) {
+		// when we find a node, we need to update the 'matches' and 'row_ids'
+		// NOTE: leaves can have more than one row_id, but for UNIQUE/PRIMARY KEY they will only have one
+		D_ASSERT(leaf.GetType() == NType::LEAF_INLINED);
+		if (conflict_manager.AddHit(i, leaf.GetRowId())) {
 			found_conflict = i;
 		}
 	}
@@ -1086,7 +1027,7 @@ void ART::Vacuum(IndexLock &state) {
 	}
 
 	// traverse the allocated memory of the tree to perform a vacuum
-	Node::Vacuum(*this, *tree, flags);
+	tree->Vacuum(*this, flags);
 
 	// finalize the vacuum operation
 	FinalizeVacuum(flags);

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

@@ -72,17 +72,6 @@ bool ARTKey::operator>(const ARTKey &k) const {
 	return len > k.len;
 }
 
-bool ARTKey::operator<(const ARTKey &k) const {
-	for (uint32_t i = 0; i < MinValue<uint32_t>(len, k.len); i++) {
-		if (data[i] < k.data[i]) {
-			return true;
-		} else if (data[i] > k.data[i]) {
-			return false;
-		}
-	}
-	return len < k.len;
-}
-
 bool ARTKey::operator>=(const ARTKey &k) const {
 	for (uint32_t i = 0; i < MinValue<uint32_t>(len, k.len); i++) {
 		if (data[i] > k.data[i]) {

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

@@ -1,9 +1,5 @@
 #include "duckdb/execution/index/art/fixed_size_allocator.hpp"
 
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/helper.hpp"
-
 namespace duckdb {
 
 constexpr idx_t FixedSizeAllocator::BASE[];
@@ -46,7 +42,7 @@ FixedSizeAllocator::~FixedSizeAllocator() {
 	}
 }
 
-SwizzleablePointer FixedSizeAllocator::New() {
+Node FixedSizeAllocator::New() {
 
 	// no more free pointers
 	if (buffers_with_free_space.empty()) {
@@ -77,19 +73,19 @@ SwizzleablePointer FixedSizeAllocator::New() {
 		buffers_with_free_space.erase(buffer_id);
 	}
 
-	return SwizzleablePointer(offset, buffer_id);
+	return Node(buffer_id, offset);
 }
 
-void FixedSizeAllocator::Free(const SwizzleablePointer ptr) {
-	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffers[ptr.buffer_id].ptr);
+void FixedSizeAllocator::Free(const Node ptr) {
+	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffers[ptr.GetBufferId()].ptr);
 	ValidityMask mask(bitmask_ptr);
-	D_ASSERT(!mask.RowIsValid(ptr.offset));
-	mask.SetValid(ptr.offset);
-	buffers_with_free_space.insert(ptr.buffer_id);
+	D_ASSERT(!mask.RowIsValid(ptr.GetOffset()));
+	mask.SetValid(ptr.GetOffset());
+	buffers_with_free_space.insert(ptr.GetBufferId());
 
 	D_ASSERT(total_allocations > 0);
-	D_ASSERT(buffers[ptr.buffer_id].allocation_count > 0);
-	buffers[ptr.buffer_id].allocation_count--;
+	D_ASSERT(buffers[ptr.GetBufferId()].allocation_count > 0);
+	buffers[ptr.GetBufferId()].allocation_count--;
 	total_allocations--;
 }
 
@@ -172,7 +168,7 @@ void FixedSizeAllocator::FinalizeVacuum() {
 	}
 }
 
-SwizzleablePointer FixedSizeAllocator::VacuumPointer(const SwizzleablePointer ptr) {
+Node FixedSizeAllocator::VacuumPointer(const Node ptr) {
 
 	// we do not need to adjust the bitmask of the old buffer, because we will free the entire
 	// buffer after the vacuum operation

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

@@ -58,17 +58,11 @@ bool Iterator::Scan(const ARTKey &upper_bound, const idx_t max_count, vector<row
 			}
 		}
 
-		// adding more elements would exceed the maximum count
-		if (result_ids.size() + last_leaf->count > max_count) {
+		// copy all row IDs of this leaf into the result IDs (if they don't exceed max_count)
+		if (!Leaf::GetRowIds(*art, last_leaf, result_ids, max_count)) {
 			return false;
 		}
 
-		// FIXME: copy all at once to improve performance
-		for (idx_t i = 0; i < last_leaf->count; i++) {
-			row_t row_id = last_leaf->GetRowId(*art, i);
-			result_ids.push_back(row_id);
-		}
-
 		// get the next leaf
 		has_next = Next();
 
@@ -80,18 +74,18 @@ bool Iterator::Scan(const ARTKey &upper_bound, const idx_t max_count, vector<row
 void Iterator::FindMinimum(Node &node) {
 
 	D_ASSERT(node.IsSet());
-	if (node.IsSwizzled()) {
+	if (node.IsSerialized()) {
 		node.Deserialize(*art);
 	}
 
 	// found the minimum
-	if (node.DecodeARTNodeType() == NType::LEAF) {
-		last_leaf = Node::GetAllocator(*art, NType::LEAF).Get<Leaf>(node);
+	if (node.GetType() == NType::LEAF || node.GetType() == NType::LEAF_INLINED) {
+		last_leaf = node;
 		return;
 	}
 
 	// traverse the prefix
-	if (node.DecodeARTNodeType() == NType::PREFIX) {
+	if (node.GetType() == NType::PREFIX) {
 		auto &prefix = Prefix::Get(*art, node);
 		for (idx_t i = 0; i < prefix.data[Node::PREFIX_SIZE]; i++) {
 			current_key.Push(prefix.data[i]);
@@ -115,20 +109,20 @@ bool Iterator::LowerBound(Node &node, const ARTKey &key, const bool equal, idx_t
 		return false;
 	}
 
-	if (node.IsSwizzled()) {
+	if (node.IsSerialized()) {
 		node.Deserialize(*art);
 	}
 
 	// we found the lower bound
-	if (node.DecodeARTNodeType() == NType::LEAF) {
+	if (node.GetType() == NType::LEAF || node.GetType() == NType::LEAF_INLINED) {
 		if (!equal && current_key == key) {
 			return Next();
 		}
-		last_leaf = Node::GetAllocator(*art, NType::LEAF).Get<Leaf>(node);
+		last_leaf = node;
 		return true;
 	}
 
-	if (node.DecodeARTNodeType() != NType::PREFIX) {
+	if (node.GetType() != NType::PREFIX) {
 		auto next_byte = key[depth];
 		auto child = node.GetNextChild(*art, next_byte);
 		if (!child) {
@@ -181,9 +175,9 @@ bool Iterator::Next() {
 	while (!nodes.empty()) {
 
 		auto &top = nodes.top();
-		D_ASSERT(top.node.DecodeARTNodeType() != NType::LEAF);
+		D_ASSERT(top.node.GetType() != NType::LEAF && top.node.GetType() != NType::LEAF_INLINED);
 
-		if (top.node.DecodeARTNodeType() == NType::PREFIX) {
+		if (top.node.GetType() == NType::PREFIX) {
 			PopNode();
 			continue;
 		}
@@ -211,7 +205,7 @@ bool Iterator::Next() {
 }
 
 void Iterator::PopNode() {
-	if (nodes.top().node.DecodeARTNodeType() == NType::PREFIX) {
+	if (nodes.top().node.GetType() == NType::PREFIX) {
 		auto prefix_byte_count = Prefix::Get(*art, nodes.top().node).data[Node::PREFIX_SIZE];
 		current_key.Pop(prefix_byte_count);
 	} else {