duckdb 1.1.4-dev2.0 → 1.1.4-dev9.0

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

@@ -1,238 +0,0 @@
-#include "duckdb/execution/index/art/fixed_size_allocator.hpp"
-
-namespace duckdb {
-
-constexpr idx_t FixedSizeAllocator::BASE[];
-constexpr uint8_t FixedSizeAllocator::SHIFT[];
-
-FixedSizeAllocator::FixedSizeAllocator(const idx_t allocation_size, Allocator &allocator)
-    : allocation_size(allocation_size), total_allocations(0), allocator(allocator) {
-
-	// calculate how many allocations fit into one buffer
-
-	idx_t bits_per_value = sizeof(validity_t) * 8;
-	idx_t curr_alloc_size = 0;
-
-	bitmask_count = 0;
-	allocations_per_buffer = 0;
-
-	while (curr_alloc_size < BUFFER_ALLOC_SIZE) {
-		if (!bitmask_count || (bitmask_count * bits_per_value) % allocations_per_buffer == 0) {
-			bitmask_count++;
-			curr_alloc_size += sizeof(validity_t);
-		}
-
-		auto remaining_alloc_size = BUFFER_ALLOC_SIZE - curr_alloc_size;
-		auto remaining_allocations = MinValue(remaining_alloc_size / allocation_size, bits_per_value);
-
-		if (remaining_allocations == 0) {
-			break;
-		}
-
-		allocations_per_buffer += remaining_allocations;
-		curr_alloc_size += remaining_allocations * allocation_size;
-	}
-
-	allocation_offset = bitmask_count * sizeof(validity_t);
-}
-
-FixedSizeAllocator::~FixedSizeAllocator() {
-	for (auto &buffer : buffers) {
-		allocator.FreeData(buffer.ptr, BUFFER_ALLOC_SIZE);
-	}
-}
-
-Node FixedSizeAllocator::New() {
-
-	// no more free pointers
-	if (buffers_with_free_space.empty()) {
-
-		// add a new buffer
-		idx_t buffer_id = buffers.size();
-		D_ASSERT(buffer_id <= (uint32_t)DConstants::INVALID_INDEX);
-		auto buffer = allocator.AllocateData(BUFFER_ALLOC_SIZE);
-		buffers.emplace_back(buffer, 0);
-		buffers_with_free_space.insert(buffer_id);
-
-		// set the bitmask
-		ValidityMask mask(reinterpret_cast<validity_t *>(buffer));
-		mask.SetAllValid(allocations_per_buffer);
-	}
-
-	// return a pointer
-	D_ASSERT(!buffers_with_free_space.empty());
-	auto buffer_id = (uint32_t)*buffers_with_free_space.begin();
-
-	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffers[buffer_id].ptr);
-	ValidityMask mask(bitmask_ptr);
-	auto offset = GetOffset(mask, buffers[buffer_id].allocation_count);
-
-	buffers[buffer_id].allocation_count++;
-	total_allocations++;
-	if (buffers[buffer_id].allocation_count == allocations_per_buffer) {
-		buffers_with_free_space.erase(buffer_id);
-	}
-
-	return Node(buffer_id, offset);
-}
-
-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.GetOffset()));
-	mask.SetValid(ptr.GetOffset());
-	buffers_with_free_space.insert(ptr.GetBufferId());
-
-	D_ASSERT(total_allocations > 0);
-	D_ASSERT(buffers[ptr.GetBufferId()].allocation_count > 0);
-	buffers[ptr.GetBufferId()].allocation_count--;
-	total_allocations--;
-}
-
-void FixedSizeAllocator::Reset() {
-
-	for (auto &buffer : buffers) {
-		allocator.FreeData(buffer.ptr, BUFFER_ALLOC_SIZE);
-	}
-	buffers.clear();
-	buffers_with_free_space.clear();
-	total_allocations = 0;
-}
-
-void FixedSizeAllocator::Merge(FixedSizeAllocator &other) {
-
-	D_ASSERT(allocation_size == other.allocation_size);
-
-	// remember the buffer count and merge the buffers
-	idx_t buffer_count = buffers.size();
-	for (auto &buffer : other.buffers) {
-		buffers.push_back(buffer);
-	}
-	other.buffers.clear();
-
-	// merge the buffers with free spaces
-	for (auto &buffer_id : other.buffers_with_free_space) {
-		buffers_with_free_space.insert(buffer_id + buffer_count);
-	}
-	other.buffers_with_free_space.clear();
-
-	// add the total allocations
-	total_allocations += other.total_allocations;
-}
-
-bool FixedSizeAllocator::InitializeVacuum() {
-
-	if (total_allocations == 0) {
-		Reset();
-		return false;
-	}
-
-	auto total_available_allocations = allocations_per_buffer * buffers.size();
-	D_ASSERT(total_available_allocations >= total_allocations);
-	auto total_free_positions = total_available_allocations - total_allocations;
-
-	// vacuum_count buffers can be freed
-	auto vacuum_count = total_free_positions / allocations_per_buffer;
-
-	// calculate the vacuum threshold adaptively
-	D_ASSERT(vacuum_count < buffers.size());
-	idx_t memory_usage = GetMemoryUsage();
-	idx_t excess_memory_usage = vacuum_count * BUFFER_ALLOC_SIZE;
-	auto excess_percentage = (double)excess_memory_usage / (double)memory_usage;
-	auto threshold = (double)VACUUM_THRESHOLD / 100.0;
-	if (excess_percentage < threshold) {
-		return false;
-	}
-
-	min_vacuum_buffer_id = buffers.size() - vacuum_count;
-
-	// remove all invalid buffers from the available buffer list to ensure that we do not reuse them
-	auto it = buffers_with_free_space.begin();
-	while (it != buffers_with_free_space.end()) {
-		if (*it >= min_vacuum_buffer_id) {
-			it = buffers_with_free_space.erase(it);
-		} else {
-			it++;
-		}
-	}
-
-	return true;
-}
-
-void FixedSizeAllocator::FinalizeVacuum() {
-
-	// free all (now unused) buffers
-	while (min_vacuum_buffer_id < buffers.size()) {
-		allocator.FreeData(buffers.back().ptr, BUFFER_ALLOC_SIZE);
-		buffers.pop_back();
-	}
-}
-
-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
-
-	auto new_ptr = New();
-
-	// new increases the allocation count
-	total_allocations--;
-
-	memcpy(Get(new_ptr), Get(ptr), allocation_size);
-	return new_ptr;
-}
-
-void FixedSizeAllocator::Verify() const {
-#ifdef DEBUG
-	auto total_available_allocations = allocations_per_buffer * buffers.size();
-	D_ASSERT(total_available_allocations >= total_allocations);
-	D_ASSERT(buffers.size() >= buffers_with_free_space.size());
-#endif
-}
-
-uint32_t FixedSizeAllocator::GetOffset(ValidityMask &mask, const idx_t allocation_count) {
-
-	auto data = mask.GetData();
-
-	// fills up a buffer sequentially before searching for free bits
-	if (mask.RowIsValid(allocation_count)) {
-		mask.SetInvalid(allocation_count);
-		return allocation_count;
-	}
-
-	// get an entry with free bits
-	for (idx_t entry_idx = 0; entry_idx < bitmask_count; entry_idx++) {
-		if (data[entry_idx] != 0) {
-
-			// find the position of the free bit
-			auto entry = data[entry_idx];
-			idx_t first_valid_bit = 0;
-
-			// this loop finds the position of the rightmost set bit in entry and stores it
-			// in first_valid_bit
-			for (idx_t i = 0; i < 6; i++) {
-				// set the left half of the bits of this level to zero and test if the entry is still not zero
-				if (entry & BASE[i]) {
-					// first valid bit is in the rightmost s[i] bits
-					// permanently set the left half of the bits to zero
-					entry &= BASE[i];
-				} else {
-					// first valid bit is in the leftmost s[i] bits
-					// shift by s[i] for the next iteration and add s[i] to the position of the rightmost set bit
-					entry >>= SHIFT[i];
-					first_valid_bit += SHIFT[i];
-				}
-			}
-			D_ASSERT(entry);
-
-			auto prev_bits = entry_idx * sizeof(validity_t) * 8;
-			D_ASSERT(mask.RowIsValid(prev_bits + first_valid_bit));
-			mask.SetInvalid(prev_bits + first_valid_bit);
-			return (prev_bits + first_valid_bit);
-		}
-	}
-
-	throw InternalException("Invalid bitmask of FixedSizeAllocator");
-}
-
-} // namespace duckdb

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

@@ -1,196 +0,0 @@
-#include "duckdb/execution/index/art/node16.hpp"
-#include "duckdb/execution/index/art/node4.hpp"
-#include "duckdb/execution/index/art/node48.hpp"
-#include "duckdb/common/numeric_utils.hpp"
-
-namespace duckdb {
-
-Node16 &Node16::New(ART &art, Node &node) {
-
-	node = Node::GetAllocator(art, NType::NODE_16).New();
-	node.SetMetadata(static_cast<uint8_t>(NType::NODE_16));
-	auto &n16 = Node::RefMutable<Node16>(art, node, NType::NODE_16);
-
-	n16.count = 0;
-	return n16;
-}
-
-void Node16::Free(ART &art, Node &node) {
-
-	D_ASSERT(node.HasMetadata());
-	auto &n16 = Node::RefMutable<Node16>(art, node, NType::NODE_16);
-
-	// free all children
-	for (idx_t i = 0; i < n16.count; i++) {
-		Node::Free(art, n16.children[i]);
-	}
-}
-
-Node16 &Node16::GrowNode4(ART &art, Node &node16, Node &node4) {
-
-	auto &n4 = Node::RefMutable<Node4>(art, node4, NType::NODE_4);
-	auto &n16 = New(art, node16);
-
-	n16.count = n4.count;
-	for (idx_t i = 0; i < n4.count; i++) {
-		n16.key[i] = n4.key[i];
-		n16.children[i] = n4.children[i];
-	}
-
-	n4.count = 0;
-	Node::Free(art, node4);
-	return n16;
-}
-
-Node16 &Node16::ShrinkNode48(ART &art, Node &node16, Node &node48) {
-
-	auto &n16 = New(art, node16);
-	auto &n48 = Node::RefMutable<Node48>(art, node48, NType::NODE_48);
-
-	n16.count = 0;
-	for (idx_t i = 0; i < Node::NODE_256_CAPACITY; i++) {
-		D_ASSERT(n16.count <= Node::NODE_16_CAPACITY);
-		if (n48.child_index[i] != Node::EMPTY_MARKER) {
-			n16.key[n16.count] = UnsafeNumericCast<uint8_t>(i);
-			n16.children[n16.count] = n48.children[n48.child_index[i]];
-			n16.count++;
-		}
-	}
-
-	n48.count = 0;
-	Node::Free(art, node48);
-	return n16;
-}
-
-void Node16::InitializeMerge(ART &art, const ARTFlags &flags) {
-
-	for (idx_t i = 0; i < count; i++) {
-		children[i].InitializeMerge(art, flags);
-	}
-}
-
-void Node16::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
-
-	D_ASSERT(node.HasMetadata());
-	auto &n16 = Node::RefMutable<Node16>(art, node, NType::NODE_16);
-
-	// ensure that there is no other child at the same byte
-	for (idx_t i = 0; i < n16.count; i++) {
-		D_ASSERT(n16.key[i] != byte);
-	}
-
-	// insert new child node into node
-	if (n16.count < Node::NODE_16_CAPACITY) {
-		// still space, just insert the child
-		idx_t child_pos = 0;
-		while (child_pos < n16.count && n16.key[child_pos] < byte) {
-			child_pos++;
-		}
-		// move children backwards to make space
-		for (idx_t i = n16.count; i > child_pos; i--) {
-			n16.key[i] = n16.key[i - 1];
-			n16.children[i] = n16.children[i - 1];
-		}
-
-		n16.key[child_pos] = byte;
-		n16.children[child_pos] = child;
-		n16.count++;
-
-	} else {
-		// node is full, grow to Node48
-		auto node16 = node;
-		Node48::GrowNode16(art, node, node16);
-		Node48::InsertChild(art, node, byte, child);
-	}
-}
-
-void Node16::DeleteChild(ART &art, Node &node, const uint8_t byte) {
-
-	D_ASSERT(node.HasMetadata());
-	auto &n16 = Node::RefMutable<Node16>(art, node, NType::NODE_16);
-
-	idx_t child_pos = 0;
-	for (; child_pos < n16.count; child_pos++) {
-		if (n16.key[child_pos] == byte) {
-			break;
-		}
-	}
-
-	D_ASSERT(child_pos < n16.count);
-
-	// free the child and decrease the count
-	Node::Free(art, n16.children[child_pos]);
-	n16.count--;
-
-	// potentially move any children backwards
-	for (idx_t i = child_pos; i < n16.count; i++) {
-		n16.key[i] = n16.key[i + 1];
-		n16.children[i] = n16.children[i + 1];
-	}
-
-	// shrink node to Node4
-	if (n16.count < Node::NODE_4_CAPACITY) {
-		auto node16 = node;
-		Node4::ShrinkNode16(art, node, node16);
-	}
-}
-
-void Node16::ReplaceChild(const uint8_t byte, const Node child) {
-	for (idx_t i = 0; i < count; i++) {
-		if (key[i] == byte) {
-			children[i] = child;
-			return;
-		}
-	}
-}
-
-optional_ptr<const Node> Node16::GetChild(const uint8_t byte) const {
-	for (idx_t i = 0; i < count; i++) {
-		if (key[i] == byte) {
-			D_ASSERT(children[i].HasMetadata());
-			return &children[i];
-		}
-	}
-	return nullptr;
-}
-
-optional_ptr<Node> Node16::GetChildMutable(const uint8_t byte) {
-	for (idx_t i = 0; i < count; i++) {
-		if (key[i] == byte) {
-			D_ASSERT(children[i].HasMetadata());
-			return &children[i];
-		}
-	}
-	return nullptr;
-}
-
-optional_ptr<const Node> Node16::GetNextChild(uint8_t &byte) const {
-	for (idx_t i = 0; i < count; i++) {
-		if (key[i] >= byte) {
-			byte = key[i];
-			D_ASSERT(children[i].HasMetadata());
-			return &children[i];
-		}
-	}
-	return nullptr;
-}
-
-optional_ptr<Node> Node16::GetNextChildMutable(uint8_t &byte) {
-	for (idx_t i = 0; i < count; i++) {
-		if (key[i] >= byte) {
-			byte = key[i];
-			D_ASSERT(children[i].HasMetadata());
-			return &children[i];
-		}
-	}
-	return nullptr;
-}
-
-void Node16::Vacuum(ART &art, const ARTFlags &flags) {
-
-	for (idx_t i = 0; i < count; i++) {
-		children[i].Vacuum(art, flags);
-	}
-}
-
-} // namespace duckdb

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

@@ -1,189 +0,0 @@
-#include "duckdb/execution/index/art/node4.hpp"
-
-#include "duckdb/execution/index/art/prefix.hpp"
-#include "duckdb/execution/index/art/node16.hpp"
-
-namespace duckdb {
-
-Node4 &Node4::New(ART &art, Node &node) {
-
-	node = Node::GetAllocator(art, NType::NODE_4).New();
-	node.SetMetadata(static_cast<uint8_t>(NType::NODE_4));
-	auto &n4 = Node::RefMutable<Node4>(art, node, NType::NODE_4);
-
-	n4.count = 0;
-	return n4;
-}
-
-void Node4::Free(ART &art, Node &node) {
-
-	D_ASSERT(node.HasMetadata());
-	auto &n4 = Node::RefMutable<Node4>(art, node, NType::NODE_4);
-
-	// free all children
-	for (idx_t i = 0; i < n4.count; i++) {
-		Node::Free(art, n4.children[i]);
-	}
-}
-
-Node4 &Node4::ShrinkNode16(ART &art, Node &node4, Node &node16) {
-
-	auto &n4 = New(art, node4);
-	auto &n16 = Node::RefMutable<Node16>(art, node16, NType::NODE_16);
-
-	D_ASSERT(n16.count <= Node::NODE_4_CAPACITY);
-	n4.count = n16.count;
-	for (idx_t i = 0; i < n16.count; i++) {
-		n4.key[i] = n16.key[i];
-		n4.children[i] = n16.children[i];
-	}
-
-	n16.count = 0;
-	Node::Free(art, node16);
-	return n4;
-}
-
-void Node4::InitializeMerge(ART &art, const ARTFlags &flags) {
-
-	for (idx_t i = 0; i < count; i++) {
-		children[i].InitializeMerge(art, flags);
-	}
-}
-
-void Node4::InsertChild(ART &art, Node &node, const uint8_t byte, const Node child) {
-
-	D_ASSERT(node.HasMetadata());
-	auto &n4 = Node::RefMutable<Node4>(art, node, NType::NODE_4);
-
-	// ensure that there is no other child at the same byte
-	for (idx_t i = 0; i < n4.count; i++) {
-		D_ASSERT(n4.key[i] != byte);
-	}
-
-	// insert new child node into node
-	if (n4.count < Node::NODE_4_CAPACITY) {
-		// still space, just insert the child
-		idx_t child_pos = 0;
-		while (child_pos < n4.count && n4.key[child_pos] < byte) {
-			child_pos++;
-		}
-		// move children backwards to make space
-		for (idx_t i = n4.count; i > child_pos; i--) {
-			n4.key[i] = n4.key[i - 1];
-			n4.children[i] = n4.children[i - 1];
-		}
-
-		n4.key[child_pos] = byte;
-		n4.children[child_pos] = child;
-		n4.count++;
-
-	} else {
-		// node is full, grow to Node16
-		auto node4 = node;
-		Node16::GrowNode4(art, node, node4);
-		Node16::InsertChild(art, node, byte, child);
-	}
-}
-
-void Node4::DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte) {
-
-	D_ASSERT(node.HasMetadata());
-	auto &n4 = Node::RefMutable<Node4>(art, node, NType::NODE_4);
-
-	idx_t child_pos = 0;
-	for (; child_pos < n4.count; child_pos++) {
-		if (n4.key[child_pos] == byte) {
-			break;
-		}
-	}
-
-	D_ASSERT(child_pos < n4.count);
-	D_ASSERT(n4.count > 1);
-
-	// free the child and decrease the count
-	Node::Free(art, n4.children[child_pos]);
-	n4.count--;
-
-	// potentially move any children backwards
-	for (idx_t i = child_pos; i < n4.count; i++) {
-		n4.key[i] = n4.key[i + 1];
-		n4.children[i] = n4.children[i + 1];
-	}
-
-	// this is a one way node, compress
-	if (n4.count == 1) {
-
-		// we need to keep track of the old node pointer
-		// because Concatenate() might overwrite that pointer while appending bytes to
-		// the prefix (and by doing so overwriting the subsequent node with
-		// new prefix nodes)
-		auto old_n4_node = node;
-
-		// get only child and concatenate prefixes
-		auto child = *n4.GetChildMutable(n4.key[0]);
-		Prefix::Concatenate(art, prefix, n4.key[0], child);
-
-		n4.count--;
-		Node::Free(art, old_n4_node);
-	}
-}
-
-void Node4::ReplaceChild(const uint8_t byte, const Node child) {
-	for (idx_t i = 0; i < count; i++) {
-		if (key[i] == byte) {
-			children[i] = child;
-			return;
-		}
-	}
-}
-
-optional_ptr<const Node> Node4::GetChild(const uint8_t byte) const {
-	for (idx_t i = 0; i < count; i++) {
-		if (key[i] == byte) {
-			D_ASSERT(children[i].HasMetadata());
-			return &children[i];
-		}
-	}
-	return nullptr;
-}
-
-optional_ptr<Node> Node4::GetChildMutable(const uint8_t byte) {
-	for (idx_t i = 0; i < count; i++) {
-		if (key[i] == byte) {
-			D_ASSERT(children[i].HasMetadata());
-			return &children[i];
-		}
-	}
-	return nullptr;
-}
-
-optional_ptr<const Node> Node4::GetNextChild(uint8_t &byte) const {
-	for (idx_t i = 0; i < count; i++) {
-		if (key[i] >= byte) {
-			byte = key[i];
-			D_ASSERT(children[i].HasMetadata());
-			return &children[i];
-		}
-	}
-	return nullptr;
-}
-
-optional_ptr<Node> Node4::GetNextChildMutable(uint8_t &byte) {
-	for (idx_t i = 0; i < count; i++) {
-		if (key[i] >= byte) {
-			byte = key[i];
-			D_ASSERT(children[i].HasMetadata());
-			return &children[i];
-		}
-	}
-	return nullptr;
-}
-
-void Node4::Vacuum(ART &art, const ARTFlags &flags) {
-
-	for (idx_t i = 0; i < count; i++) {
-		children[i].Vacuum(art, flags);
-	}
-}
-
-} // namespace duckdb

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

@@ -1,65 +0,0 @@
-#include "duckdb/execution/index/unknown_index.hpp"
-#include "duckdb/parser/parsed_data/create_index_info.hpp"
-
-namespace duckdb {
-
-//-------------------------------------------------------------------------------
-// Unknown index
-//-------------------------------------------------------------------------------
-
-UnknownIndex::UnknownIndex(const string &name, const string &index_type, IndexConstraintType index_constraint_type,
-                           const vector<column_t> &column_ids, TableIOManager &table_io_manager,
-                           const vector<unique_ptr<Expression>> &unbound_expressions, AttachedDatabase &db,
-                           const CreateIndexInfo &create_info_p, IndexStorageInfo storage_info_p)
-    : Index(name, index_type, index_constraint_type, column_ids, table_io_manager, unbound_expressions, db),
-      create_info(create_info_p), storage_info(std::move(storage_info_p)) {
-}
-
-string UnknownIndex::GenerateErrorMessage() const {
-	return StringUtil::Format(
-	    R"(Unknown index type "%s" for index "%s". You probably need to load an extension containing this index type)",
-	    index_type.c_str(), name.c_str());
-}
-
-ErrorData UnknownIndex::Append(IndexLock &, DataChunk &, Vector &) {
-	throw MissingExtensionException(GenerateErrorMessage());
-}
-void UnknownIndex::VerifyAppend(DataChunk &) {
-	throw MissingExtensionException(GenerateErrorMessage());
-}
-void UnknownIndex::VerifyAppend(DataChunk &, ConflictManager &) {
-	throw MissingExtensionException(GenerateErrorMessage());
-}
-void UnknownIndex::CommitDrop(IndexLock &) {
-	throw MissingExtensionException(GenerateErrorMessage());
-}
-void UnknownIndex::Delete(IndexLock &, DataChunk &, Vector &) {
-	throw MissingExtensionException(GenerateErrorMessage());
-}
-ErrorData UnknownIndex::Insert(IndexLock &, DataChunk &, Vector &) {
-	throw MissingExtensionException(GenerateErrorMessage());
-}
-IndexStorageInfo UnknownIndex::GetStorageInfo(bool) {
-	throw MissingExtensionException(GenerateErrorMessage());
-}
-bool UnknownIndex::MergeIndexes(IndexLock &, Index &) {
-	throw MissingExtensionException(GenerateErrorMessage());
-}
-void UnknownIndex::Vacuum(IndexLock &) {
-	throw MissingExtensionException(GenerateErrorMessage());
-}
-idx_t UnknownIndex::GetInMemorySize(IndexLock &) {
-	throw MissingExtensionException(GenerateErrorMessage());
-}
-void UnknownIndex::CheckConstraintsForChunk(DataChunk &, ConflictManager &) {
-	throw MissingExtensionException(GenerateErrorMessage());
-}
-string UnknownIndex::VerifyAndToString(IndexLock &, bool) {
-	throw MissingExtensionException(GenerateErrorMessage());
-}
-
-string UnknownIndex::GetConstraintViolationMessage(VerifyExistenceType, idx_t, DataChunk &) {
-	throw MissingExtensionException(GenerateErrorMessage());
-}
-
-} // namespace duckdb