duckdb 0.8.2-dev11.0 → 0.8.2-dev1182.0

package/src/duckdb/src/execution/aggregate_hashtable.cpp

@@ -58,9 +58,6 @@ GroupedAggregateHashTable::GroupedAggregateHashTable(ClientContext &context, All
 	data_collection = make_uniq<TupleDataCollection>(buffer_manager, layout);
 	data_collection->InitializeAppend(td_pin_state, TupleDataPinProperties::KEEP_EVERYTHING_PINNED);
 
-	hashes_hdl = buffer_manager.Allocate(Storage::BLOCK_SIZE);
-	hashes_hdl_ptr = hashes_hdl.Ptr();
-
 	switch (entry_type) {
 	case HtEntryType::HT_WIDTH_64: {
 		hash_prefix_shift = (HASH_WIDTH - sizeof(aggr_ht_entry_64::salt)) * 8;
@@ -100,7 +97,7 @@ void GroupedAggregateHashTable::Destroy() {
 	}
 
 	// There are aggregates with destructors: Call the destructor for each of the aggregates
-	RowOperationsState state(aggregate_allocator->GetAllocator());
+	RowOperationsState state(*aggregate_allocator);
 	TupleDataChunkIterator iterator(*data_collection, TupleDataPinProperties::DESTROY_AFTER_DONE, false);
 	auto &row_locations = iterator.GetChunkState().row_locations;
 	do {
@@ -182,10 +179,8 @@ void GroupedAggregateHashTable::Resize(idx_t size) {
 
 	bitmask = capacity - 1;
 	const auto byte_size = capacity * sizeof(ENTRY);
-	if (byte_size > (idx_t)Storage::BLOCK_SIZE) {
-		hashes_hdl = buffer_manager.Allocate(byte_size);
-		hashes_hdl_ptr = hashes_hdl.Ptr();
-	}
+	hashes_hdl = buffer_manager.GetBufferAllocator().Allocate(byte_size);
+	hashes_hdl_ptr = hashes_hdl.get();
 	memset(hashes_hdl_ptr, 0, byte_size);
 
 	if (Count() != 0) {
@@ -277,7 +272,7 @@ idx_t GroupedAggregateHashTable::AddChunk(AggregateHTAppendState &state, DataChu
 	auto &aggregates = layout.GetAggregates();
 	idx_t filter_idx = 0;
 	idx_t payload_idx = 0;
-	RowOperationsState row_state(aggregate_allocator->GetAllocator());
+	RowOperationsState row_state(*aggregate_allocator);
 	for (idx_t i = 0; i < aggregates.size(); i++) {
 		auto &aggr = aggregates[i];
 		if (filter_idx >= filter.size() || i < filter[filter_idx]) {
@@ -322,7 +317,7 @@ void GroupedAggregateHashTable::FetchAggregates(DataChunk &groups, DataChunk &re
 	Vector addresses(LogicalType::POINTER);
 	FindOrCreateGroups(append_state, groups, addresses);
 	// now fetch the aggregates
-	RowOperationsState row_state(aggregate_allocator->GetAllocator());
+	RowOperationsState row_state(*aggregate_allocator);
 	RowOperations::FinalizeStates(row_state, layout, addresses, result, 0);
 }
 
@@ -581,7 +576,7 @@ void GroupedAggregateHashTable::Combine(GroupedAggregateHashTable &other) {
 	}
 
 	FlushMoveState state(*other.data_collection);
-	RowOperationsState row_state(aggregate_allocator->GetAllocator());
+	RowOperationsState row_state(*aggregate_allocator);
 	while (state.Scan()) {
 		FindOrCreateGroups(state.append_state, state.groups, state.hashes, state.group_addresses, state.new_groups_sel);
 		RowOperations::CombineStates(row_state, layout, state.scan_state.chunk_state.row_locations,
@@ -591,14 +586,27 @@ void GroupedAggregateHashTable::Combine(GroupedAggregateHashTable &other) {
 	Verify();
 }
 
-void GroupedAggregateHashTable::Partition(vector<GroupedAggregateHashTable *> &partition_hts, idx_t radix_bits) {
+void GroupedAggregateHashTable::Append(GroupedAggregateHashTable &other) {
+	data_collection->Combine(other.GetDataCollection());
+
+	// Inherit ownership to all stored aggregate allocators
+	stored_allocators.emplace_back(other.aggregate_allocator);
+	for (const auto &stored_allocator : other.stored_allocators) {
+		stored_allocators.emplace_back(stored_allocator);
+	}
+}
+
+void GroupedAggregateHashTable::Partition(vector<GroupedAggregateHashTable *> &partition_hts, idx_t radix_bits,
+                                          bool sink_done) {
 	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
 	D_ASSERT(partition_hts.size() == num_partitions);
 
 	// Partition the data
+	auto pin_properties =
+	    sink_done ? TupleDataPinProperties::UNPIN_AFTER_DONE : TupleDataPinProperties::KEEP_EVERYTHING_PINNED;
 	auto partitioned_data =
 	    make_uniq<RadixPartitionedTupleData>(buffer_manager, layout, radix_bits, layout.ColumnCount() - 1);
-	partitioned_data->Partition(*data_collection, TupleDataPinProperties::KEEP_EVERYTHING_PINNED);
+	partitioned_data->Partition(*data_collection, pin_properties);
 	D_ASSERT(partitioned_data->GetPartitions().size() == num_partitions);
 
 	// Move the partitioned data collections to the partitioned hash tables and initialize the 1st part of the HT
@@ -606,9 +614,17 @@ void GroupedAggregateHashTable::Partition(vector<GroupedAggregateHashTable *> &p
 	for (idx_t partition_idx = 0; partition_idx < num_partitions; partition_idx++) {
 		auto &partition_ht = *partition_hts[partition_idx];
 		partition_ht.data_collection = std::move(partitions[partition_idx]);
-		partition_ht.aggregate_allocator = aggregate_allocator;
-		partition_ht.InitializeFirstPart();
-		partition_ht.Verify();
+
+		// Inherit ownership to all stored aggregate allocators
+		partition_ht.stored_allocators.emplace_back(aggregate_allocator);
+		for (const auto &stored_allocator : stored_allocators) {
+			partition_ht.stored_allocators.emplace_back(stored_allocator);
+		}
+
+		if (!sink_done) {
+			partition_ht.InitializeFirstPart();
+			partition_ht.Verify();
+		}
 	}
 }
 
@@ -631,7 +647,7 @@ idx_t GroupedAggregateHashTable::Scan(TupleDataParallelScanState &gstate, TupleD
                                       DataChunk &result) {
 	data_collection->Scan(gstate, lstate, result);
 
-	RowOperationsState row_state(aggregate_allocator->GetAllocator());
+	RowOperationsState row_state(*aggregate_allocator);
 	const auto group_cols = layout.ColumnCount() - 1;
 	RowOperations::FinalizeStates(row_state, layout, lstate.chunk_state.row_locations, result, group_cols);
 
@@ -644,7 +660,7 @@ void GroupedAggregateHashTable::Finalize() {
 	}
 
 	// Early release hashes (not needed for partition/scan) and data collection (will be pinned again when scanning)
-	hashes_hdl.Destroy();
+	hashes_hdl.Reset();
 	data_collection->FinalizePinState(td_pin_state);
 	data_collection->Unpin();
 

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/prefix_segment.hpp"
 #include "duckdb/execution/index/art/leaf_segment.hpp"
 #include "duckdb/execution/index/art/prefix.hpp"
 #include "duckdb/execution/index/art/leaf.hpp"
@@ -44,7 +43,7 @@ ART::ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
 	}
 
 	// initialize all allocators
-	allocators.emplace_back(make_uniq<FixedSizeAllocator>(sizeof(PrefixSegment), buffer_manager.GetBufferAllocator()));
+	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()));
@@ -306,10 +305,12 @@ bool Construct(ART &art, vector<ARTKey> &keys, row_t *row_ids, Node &node, KeySe
 			return false;
 		}
 
+		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, node, start_key, prefix_start, row_ids[key_section.start]);
+			Leaf::New(art, ref_node, row_ids[key_section.start]);
 		} else {
-			Leaf::New(art, node, start_key, prefix_start, row_ids + key_section.start, num_row_ids);
+			Leaf::New(art, ref_node, row_ids + key_section.start, num_row_ids);
 		}
 		return true;
 	}
@@ -320,17 +321,20 @@ bool Construct(ART &art, vector<ARTKey> &keys, row_t *row_ids, Node &node, KeySe
 	vector<KeySection> child_sections;
 	GetChildSections(child_sections, keys, key_section);
 
-	auto node_type = Node::GetARTNodeTypeByCount(child_sections.size());
-	Node::New(art, node, node_type);
-
+	// set the prefix
+	reference<Node> ref_node(node);
 	auto prefix_length = key_section.depth - prefix_start;
-	node.GetPrefix(art).Initialize(art, start_key, prefix_start, prefix_length);
+	Prefix::New(art, ref_node, start_key, prefix_start, prefix_length);
+
+	// set the node
+	auto node_type = Node::GetARTNodeTypeByCount(child_sections.size());
+	Node::New(art, ref_node, node_type);
 
 	// recurse on each child section
 	for (auto &child_section : child_sections) {
 		Node new_child;
 		auto no_violation = Construct(art, keys, row_ids, new_child, child_section, has_constraint);
-		Node::InsertChild(art, node, child_section.key_byte, new_child);
+		Node::InsertChild(art, ref_node, child_section.key_byte, new_child);
 		if (!no_violation) {
 			return false;
 		}
@@ -485,73 +489,75 @@ bool ART::InsertToLeaf(Node &leaf_node, const row_t &row_id) {
 
 bool ART::Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id) {
 
+	// node is currently empty, create a leaf here with the key
 	if (!node.IsSet()) {
-		// node is currently empty, create a leaf here with the key
-		Leaf::New(*this, node, key, depth, 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);
 		return true;
 	}
 
-	if (node.DecodeARTNodeType() == NType::LEAF) {
+	auto node_type = node.DecodeARTNodeType();
 
-		// add a row ID to a leaf, if they have the same key
-		auto &leaf = Leaf::Get(*this, node);
-		auto mismatch_position = leaf.prefix.KeyMismatchPosition(*this, key, depth);
-		if (mismatch_position == leaf.prefix.count && depth + leaf.prefix.count == key.len) {
-			return InsertToLeaf(node, row_id);
-		}
+	// insert the row ID into this leaf
+	if (node_type == NType::LEAF) {
+		return InsertToLeaf(node, row_id);
+	}
 
-		// replace leaf with Node4 and store both leaves in it
-		auto old_node = node;
-		auto &new_n4 = Node4::New(*this, node);
-		new_n4.prefix.Initialize(*this, key, depth, mismatch_position);
+	if (node_type != NType::PREFIX) {
+		D_ASSERT(depth < key.len);
+		auto child = node.GetChild(*this, key[depth]);
 
-		auto key_byte = old_node.GetPrefix(*this).Reduce(*this, mismatch_position);
-		Node4::InsertChild(*this, node, key_byte, old_node);
+		// recurse, if a child exists at key[depth]
+		if (child) {
+			bool success = Insert(*child, key, depth + 1, row_id);
+			node.ReplaceChild(*this, key[depth], *child);
+			return success;
+		}
 
+		// insert a new leaf node at key[depth]
 		Node leaf_node;
-		Leaf::New(*this, leaf_node, key, depth + mismatch_position + 1, row_id);
-		Node4::InsertChild(*this, node, key[depth + mismatch_position], 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);
+		}
+		Node::InsertChild(*this, node, key[depth], leaf_node);
 		return true;
 	}
 
-	// handle prefix of inner node
-	auto &old_node_prefix = node.GetPrefix(*this);
-	if (old_node_prefix.count) {
-
-		auto mismatch_position = old_node_prefix.KeyMismatchPosition(*this, key, depth);
-		if (mismatch_position != old_node_prefix.count) {
-
-			// prefix differs, create new node
-			auto old_node = node;
-			auto &new_n4 = Node4::New(*this, node);
-			new_n4.prefix.Initialize(*this, key, depth, mismatch_position);
+	// this is a prefix node, traverse
+	reference<Node> next_node(node);
+	auto mismatch_position = Prefix::Traverse(*this, next_node, key, depth);
 
-			auto key_byte = old_node_prefix.Reduce(*this, mismatch_position);
-			Node4::InsertChild(*this, node, key_byte, old_node);
-
-			Node leaf_node;
-			Leaf::New(*this, leaf_node, key, depth + mismatch_position + 1, row_id);
-			Node4::InsertChild(*this, node, key[depth + mismatch_position], leaf_node);
-
-			return true;
-		}
-		depth += node.GetPrefix(*this).count;
+	// prefix matches key
+	if (next_node.get().DecodeARTNodeType() != NType::PREFIX) {
+		return Insert(next_node, key, depth, row_id);
 	}
 
-	// recurse
-	D_ASSERT(depth < key.len);
-	auto child = node.GetChild(*this, key[depth]);
-	if (child) {
-		bool success = Insert(*child, key, depth + 1, row_id);
-		node.ReplaceChild(*this, key[depth], *child);
-		return success;
-	}
+	// prefix does not match the key, we need to create a new Node4; this new Node4 has two children,
+	// the remaining part of the prefix, and the new leaf
+	Node remaining_prefix;
+	auto prefix_byte = Prefix::GetByte(*this, next_node, mismatch_position);
+	Prefix::Split(*this, next_node, remaining_prefix, mismatch_position);
+	Node4::New(*this, next_node);
+
+	// insert remaining prefix
+	Node4::InsertChild(*this, next_node, prefix_byte, remaining_prefix);
 
-	// insert at position
+	// insert new leaf
 	Node leaf_node;
-	Leaf::New(*this, leaf_node, key, depth + 1, row_id);
-	Node::InsertChild(*this, node, key[depth], 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);
+	}
+	Node4::InsertChild(*this, next_node, key[depth], leaf_node);
 	return true;
 }
 
@@ -614,9 +620,18 @@ void ART::Erase(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id)
 		return;
 	}
 
-	// delete a row ID from a leaf
-	if (node.DecodeARTNodeType() == NType::LEAF) {
-		auto &leaf = Leaf::Get(*this, node);
+	// handle prefix
+	reference<Node> next_node(node);
+	if (next_node.get().DecodeARTNodeType() == NType::PREFIX) {
+		Prefix::Traverse(*this, next_node, key, depth);
+		if (next_node.get().DecodeARTNodeType() == 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) {
@@ -626,34 +641,35 @@ void ART::Erase(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id)
 		return;
 	}
 
-	// handle prefix
-	auto &node_prefix = node.GetPrefix(*this);
-	if (node_prefix.count) {
-		if (node_prefix.KeyMismatchPosition(*this, key, depth) != node_prefix.count) {
-			return;
-		}
-		depth += node_prefix.count;
-	}
-
-	auto child = node.GetChild(*this, key[depth]);
+	D_ASSERT(depth < key.len);
+	auto child = next_node.get().GetChild(*this, key[depth]);
 	if (child) {
 		D_ASSERT(child->IsSet());
 
-		if (child->DecodeARTNodeType() == NType::LEAF) {
+		auto temp_depth = depth + 1;
+		reference<Node> child_node(*child);
+		if (child_node.get().DecodeARTNodeType() == NType::PREFIX) {
+			Prefix::Traverse(*this, child_node, key, temp_depth);
+			if (child_node.get().DecodeARTNodeType() == NType::PREFIX) {
+				return;
+			}
+		}
+
+		if (child_node.get().DecodeARTNodeType() == NType::LEAF) {
 			// leaf found, remove entry
-			auto &leaf = Leaf::Get(*this, *child);
+			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
-				Node::DeleteChild(*this, node, key[depth]);
+				Node::DeleteChild(*this, next_node, node, key[depth]);
 			}
 			return;
 		}
 
 		// recurse
 		Erase(*child, key, depth + 1, row_id);
-		node.ReplaceChild(*this, key[depth], *child);
+		next_node.get().ReplaceChild(*this, key[depth], *child);
 	}
 }
 
@@ -733,35 +749,28 @@ void ART::SearchEqualJoinNoFetch(ARTKey &key, idx_t &result_size) {
 Node ART::Lookup(Node node, const ARTKey &key, idx_t depth) {
 
 	while (node.IsSet()) {
-		if (node.DecodeARTNodeType() == NType::LEAF) {
-			auto &leaf = Leaf::Get(*this, node);
 
-			// check if leaf contains key
-			for (idx_t i = 0; i < leaf.prefix.count; i++) {
-				if (leaf.prefix.GetByte(*this, i) != key[i + depth]) {
-					return Node();
-				}
+		// traverse prefix, if exists
+		reference<Node> next_node(node);
+		if (next_node.get().DecodeARTNodeType() == NType::PREFIX) {
+			Prefix::Traverse(*this, next_node, key, depth);
+			if (next_node.get().DecodeARTNodeType() == NType::PREFIX) {
+				return Node();
 			}
-			return node;
 		}
-		auto &node_prefix = node.GetPrefix(*this);
-		if (node_prefix.count) {
-			for (idx_t pos = 0; pos < node_prefix.count; pos++) {
-				if (key[depth + pos] != node_prefix.GetByte(*this, pos)) {
-					// prefix mismatch, subtree of node does not contain key
-					return Node();
-				}
-			}
-			depth += node_prefix.count;
+
+		if (next_node.get().DecodeARTNodeType() == NType::LEAF) {
+			return next_node.get();
 		}
 
-		// prefix matches key, but no child at byte, does not contain key
-		auto child = node.GetChild(*this, key[depth]);
+		D_ASSERT(depth < key.len);
+		auto child = next_node.get().GetChild(*this, key[depth]);
 		if (!child) {
+			// prefix matches key, but no child at byte, ART/subtree does not contain key
 			return Node();
 		}
 
-		// recurse into child
+		// lookup in child node
 		node = *child;
 		D_ASSERT(node.IsSet());
 		depth++;
@@ -771,21 +780,21 @@ Node ART::Lookup(Node node, const ARTKey &key, idx_t depth) {
 }
 
 //===--------------------------------------------------------------------===//
-// Greater Than
-// Returns: True (If found leaf >= key)
-//          False (Otherwise)
+// Greater Than and Less Than
 //===--------------------------------------------------------------------===//
 
-bool ART::SearchGreater(ARTIndexScanState &state, ARTKey &key, bool inclusive, idx_t max_count,
-                        vector<row_t> &result_ids) {
+bool ART::SearchGreater(ARTIndexScanState &state, ARTKey &key, bool equal, idx_t max_count, vector<row_t> &result_ids) {
 
-	auto &it = state.iterator;
+	if (!tree->IsSet()) {
+		return true;
+	}
+	Iterator &it = state.iterator;
 
-	// greater than scan: first set the iterator to the node at which we will start our scan by finding the lowest node
-	// that satisfies our requirement
+	// find the lowest value that satisfies the predicate
 	if (!it.art) {
 		it.art = this;
-		if (!it.LowerBound(*tree, key, inclusive)) {
+		if (!it.LowerBound(*tree, key, equal, 0)) {
+			// early-out, if the maximum value in the ART is lower than the lower bound
 			return true;
 		}
 	}
@@ -796,86 +805,84 @@ bool ART::SearchGreater(ARTIndexScanState &state, ARTKey &key, bool inclusive, i
 	return it.Scan(empty_key, max_count, result_ids, false);
 }
 
-//===--------------------------------------------------------------------===//
-// Less Than
-//===--------------------------------------------------------------------===//
-
-bool ART::SearchLess(ARTIndexScanState &state, ARTKey &upper_bound, bool inclusive, idx_t max_count,
+bool ART::SearchLess(ARTIndexScanState &state, ARTKey &upper_bound, bool equal, idx_t max_count,
                      vector<row_t> &result_ids) {
 
 	if (!tree->IsSet()) {
 		return true;
 	}
-
-	auto &it = state.iterator;
+	Iterator &it = state.iterator;
 
 	if (!it.art) {
 		it.art = this;
-		// first find the minimum value in the ART: we start scanning from this value
+		// find the minimum value in the ART: we start scanning from this value
 		it.FindMinimum(*tree);
-		// early out min value higher than upper bound query
-		if (it.cur_key > upper_bound) {
+		// early-out, if the minimum value is higher than the upper bound
+		if (it.current_key > upper_bound) {
 			return true;
 		}
 	}
 
 	// now continue the scan until we reach the upper bound
-	return it.Scan(upper_bound, max_count, result_ids, inclusive);
+	return it.Scan(upper_bound, max_count, result_ids, equal);
 }
 
 //===--------------------------------------------------------------------===//
 // Closed Range Query
 //===--------------------------------------------------------------------===//
 
-bool ART::SearchCloseRange(ARTIndexScanState &state, ARTKey &lower_bound, ARTKey &upper_bound, bool left_inclusive,
-                           bool right_inclusive, idx_t max_count, vector<row_t> &result_ids) {
-	auto &it = state.iterator;
+bool ART::SearchCloseRange(ARTIndexScanState &state, ARTKey &lower_bound, ARTKey &upper_bound, bool left_equal,
+                           bool right_equal, idx_t max_count, vector<row_t> &result_ids) {
+
+	Iterator &it = state.iterator;
 
-	// first find the first node that satisfies the left predicate
+	// find the first node that satisfies the left predicate
 	if (!it.art) {
 		it.art = this;
-		if (!it.LowerBound(*tree, lower_bound, left_inclusive)) {
+		if (!it.LowerBound(*tree, lower_bound, left_equal, 0)) {
+			// early-out, if the maximum value in the ART is lower than the lower bound
 			return true;
 		}
 	}
 
 	// now continue the scan until we reach the upper bound
-	return it.Scan(upper_bound, max_count, result_ids, right_inclusive);
+	return it.Scan(upper_bound, max_count, result_ids, right_equal);
 }
 
-bool ART::Scan(const Transaction &transaction, const DataTable &table, IndexScanState &table_state,
-               const idx_t max_count, vector<row_t> &result_ids) {
-	auto &state = table_state.Cast<ARTIndexScanState>();
+bool ART::Scan(const Transaction &transaction, const DataTable &table, IndexScanState &state, const idx_t max_count,
+               vector<row_t> &result_ids) {
+
+	auto &scan_state = state.Cast<ARTIndexScanState>();
 	vector<row_t> row_ids;
 	bool success;
 
 	// FIXME: the key directly owning the data for a single key might be more efficient
-	D_ASSERT(state.values[0].type().InternalType() == types[0]);
+	D_ASSERT(scan_state.values[0].type().InternalType() == types[0]);
 	ArenaAllocator arena_allocator(Allocator::Get(db));
-	auto key = CreateKey(arena_allocator, types[0], state.values[0]);
+	auto key = CreateKey(arena_allocator, types[0], scan_state.values[0]);
 
-	if (state.values[1].IsNull()) {
+	if (scan_state.values[1].IsNull()) {
 
 		// single predicate
 		lock_guard<mutex> l(lock);
-		switch (state.expressions[0]) {
+		switch (scan_state.expressions[0]) {
 		case ExpressionType::COMPARE_EQUAL:
 			success = SearchEqual(key, max_count, row_ids);
 			break;
 		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			success = SearchGreater(state, key, true, max_count, row_ids);
+			success = SearchGreater(scan_state, key, true, max_count, row_ids);
 			break;
 		case ExpressionType::COMPARE_GREATERTHAN:
-			success = SearchGreater(state, key, false, max_count, row_ids);
+			success = SearchGreater(scan_state, key, false, max_count, row_ids);
 			break;
 		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			success = SearchLess(state, key, true, max_count, row_ids);
+			success = SearchLess(scan_state, key, true, max_count, row_ids);
 			break;
 		case ExpressionType::COMPARE_LESSTHAN:
-			success = SearchLess(state, key, false, max_count, row_ids);
+			success = SearchLess(scan_state, key, false, max_count, row_ids);
 			break;
 		default:
-			throw InternalException("Operation not implemented");
+			throw InternalException("Index scan type not implemented");
 		}
 
 	} else {
@@ -883,12 +890,12 @@ bool ART::Scan(const Transaction &transaction, const DataTable &table, IndexScan
 		// two predicates
 		lock_guard<mutex> l(lock);
 
-		D_ASSERT(state.values[1].type().InternalType() == types[0]);
-		auto upper_bound = CreateKey(arena_allocator, types[0], state.values[1]);
+		D_ASSERT(scan_state.values[1].type().InternalType() == types[0]);
+		auto upper_bound = CreateKey(arena_allocator, types[0], scan_state.values[1]);
 
-		bool left_inclusive = state.expressions[0] == ExpressionType ::COMPARE_GREATERTHANOREQUALTO;
-		bool right_inclusive = state.expressions[1] == ExpressionType ::COMPARE_LESSTHANOREQUALTO;
-		success = SearchCloseRange(state, key, upper_bound, left_inclusive, right_inclusive, max_count, row_ids);
+		bool left_equal = scan_state.expressions[0] == ExpressionType ::COMPARE_GREATERTHANOREQUALTO;
+		bool right_equal = scan_state.expressions[1] == ExpressionType ::COMPARE_LESSTHANOREQUALTO;
+		success = SearchCloseRange(scan_state, key, upper_bound, left_equal, right_equal, max_count, row_ids);
 	}
 
 	if (!success) {
@@ -1136,6 +1143,9 @@ bool ART::MergeIndexes(IndexLock &state, Index &other_index) {
 //===--------------------------------------------------------------------===//
 
 string ART::VerifyAndToString(IndexLock &state, const bool only_verify) {
+	// FIXME: this can be improved by counting the allocations of each node type,
+	// FIXME: and by asserting that each fixed-size allocator lists an equal number of
+	// FIXME: allocations of that type
 	return VerifyAndToStringInternal(only_verify);
 }
 

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

@@ -114,7 +114,7 @@ void FixedSizeAllocator::Merge(FixedSizeAllocator &other) {
 	}
 	other.buffers.clear();
 
-	// merge the vectors containing all buffers with free space
+	// merge the buffers with free spaces
 	for (auto &buffer_id : other.buffers_with_free_space) {
 		buffers_with_free_space.insert(buffer_id + buffer_count);
 	}