RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-20 13:55:08 +00:00
Code Issues Activity Actions

LibSQL: Use Block::Index everywhere; rename pointer to block_index

Browse source 
No functional changes.
This commit is contained in:
Jelle Raaijmakers 2023-04-23 13:59:56 +02:00 • committed by Tim Flynn
parent 6601ff9d65
commit fdac8331cc
19 changed files with 202 additions and 203 deletions
Download patch file Download diff file Expand all files Collapse all files

108
Userland/Libraries/LibSQL/TreeNode.cpp
View file

@ -12,30 +12,30 @@
namespace SQL {
DownPointer::DownPointer(TreeNode* owner, u32 pointer)
DownPointer::DownPointer(TreeNode* owner, Block::Index block_index)
: m_owner(owner)
, m_pointer(pointer)
, m_block_index(block_index)
, m_node(nullptr)
{
}
DownPointer::DownPointer(TreeNode* owner, TreeNode* node)
: m_owner(owner)
, m_pointer((node) ? node->pointer() : 0)
, m_block_index((node) ? node->block_index() : 0)
, m_node(adopt_own_if_nonnull(node))
{
}
DownPointer::DownPointer(TreeNode* owner, DownPointer& down)
: m_owner(owner)
, m_pointer(down.m_pointer)
, m_block_index(down.m_block_index)
, m_node(move(down.m_node))
{
}
DownPointer::DownPointer(DownPointer&& other)
: m_owner(other.m_owner)
, m_pointer(other.pointer())
, m_block_index(other.block_index())
, m_node(other.m_node ? move(other.m_node) : nullptr)
{
}
@ -49,14 +49,14 @@ TreeNode* DownPointer::node()
void DownPointer::deserialize(Serializer& serializer)
{
if (m_node || !m_pointer)
if (m_node || !m_block_index)
return;
serializer.read_storage(m_pointer);
m_node = serializer.make_and_deserialize<TreeNode>(m_owner->tree(), m_owner, m_pointer);
serializer.read_storage(m_block_index);
m_node = serializer.make_and_deserialize<TreeNode>(m_owner->tree(), m_owner, m_block_index);
}
TreeNode::TreeNode(BTree& tree, u32 pointer)
: IndexNode(pointer)
TreeNode::TreeNode(BTree& tree, Block::Index block_index)
: IndexNode(block_index)
, m_tree(tree)
, m_up(nullptr)
, m_entries()
@ -64,8 +64,8 @@ TreeNode::TreeNode(BTree& tree, u32 pointer)
{
}
TreeNode::TreeNode(BTree& tree, TreeNode* up, u32 pointer)
: IndexNode(pointer)
TreeNode::TreeNode(BTree& tree, TreeNode* up, Block::Index block_index)
: IndexNode(block_index)
, m_tree(tree)
, m_up(up)
, m_entries()
@ -75,8 +75,8 @@ TreeNode::TreeNode(BTree& tree, TreeNode* up, u32 pointer)
m_is_leaf = true;
}
TreeNode::TreeNode(BTree& tree, TreeNode* up, DownPointer& left, u32 pointer)
: IndexNode(pointer)
TreeNode::TreeNode(BTree& tree, TreeNode* up, DownPointer& left, Block::Index block_index)
: IndexNode(block_index)
, m_tree(tree)
, m_up(up)
, m_entries()
@ -85,20 +85,20 @@ TreeNode::TreeNode(BTree& tree, TreeNode* up, DownPointer& left, u32 pointer)
if (left.m_node != nullptr)
left.m_node->m_up = this;
m_down.append(DownPointer(this, left));
m_is_leaf = left.pointer() == 0;
if (!pointer)
set_pointer(m_tree.request_new_block_index());
m_is_leaf = left.block_index() == 0;
if (!block_index)
set_block_index(m_tree.request_new_block_index());
}
TreeNode::TreeNode(BTree& tree, TreeNode* up, TreeNode* left, u32 pointer)
: IndexNode(pointer)
TreeNode::TreeNode(BTree& tree, TreeNode* up, TreeNode* left, Block::Index block_index)
: IndexNode(block_index)
, m_tree(tree)
, m_up(up)
, m_entries()
, m_down()
{
m_down.append(DownPointer(this, left));
m_is_leaf = left->pointer() == 0;
m_is_leaf = left->block_index() == 0;
}
void TreeNode::deserialize(Serializer& serializer)
@ -130,12 +130,12 @@ void TreeNode::serialize(Serializer& serializer) const
if (sz > 0) {
for (auto ix = 0u; ix < size(); ix++) {
auto& entry = m_entries[ix];
dbgln_if(SQL_DEBUG, "Serializing Left[{}] = {}", ix, m_down[ix].pointer());
serializer.serialize<u32>(is_leaf() ? 0u : m_down[ix].pointer());
dbgln_if(SQL_DEBUG, "Serializing Left[{}] = {}", ix, m_down[ix].block_index());
serializer.serialize<u32>(is_leaf() ? 0u : m_down[ix].block_index());
serializer.serialize<Key>(entry);
}
dbgln_if(SQL_DEBUG, "Serializing Right = {}", m_down[size()].pointer());
serializer.serialize<u32>(is_leaf() ? 0u : m_down[size()].pointer());
dbgln_if(SQL_DEBUG, "Serializing Right = {}", m_down[size()].block_index());
serializer.serialize<u32>(is_leaf() ? 0u : m_down[size()].block_index());
}
}
@ -151,7 +151,7 @@ size_t TreeNode::length() const
bool TreeNode::insert(Key const& key)
{
dbgln_if(SQL_DEBUG, "[#{}] INSERT({})", pointer(), key.to_deprecated_string());
dbgln_if(SQL_DEBUG, "[#{}] INSERT({})", block_index(), key.to_deprecated_string());
if (!is_leaf())
return node_for(key)->insert_in_leaf(key);
return insert_in_leaf(key);
@ -159,16 +159,16 @@ bool TreeNode::insert(Key const& key)
bool TreeNode::update_key_pointer(Key const& key)
{
dbgln_if(SQL_DEBUG, "[#{}] UPDATE({}, {})", pointer(), key.to_deprecated_string(), key.pointer());
dbgln_if(SQL_DEBUG, "[#{}] UPDATE({}, {})", block_index(), key.to_deprecated_string(), key.block_index());
if (!is_leaf())
return node_for(key)->update_key_pointer(key);
for (auto ix = 0u; ix < size(); ix++) {
if (key == m_entries[ix]) {
dbgln_if(SQL_DEBUG, "[#{}] {} == {}",
pointer(), key.to_deprecated_string(), m_entries[ix].to_deprecated_string());
if (m_entries[ix].pointer() != key.pointer()) {
m_entries[ix].set_pointer(key.pointer());
block_index(), key.to_deprecated_string(), m_entries[ix].to_deprecated_string());
if (m_entries[ix].block_index() != key.block_index()) {
m_entries[ix].set_block_index(key.block_index());
dump_if(SQL_DEBUG, "To WAL");
tree().serializer().serialize_and_write<TreeNode>(*this);
}
@ -184,20 +184,20 @@ bool TreeNode::insert_in_leaf(Key const& key)
if (!m_tree.duplicates_allowed()) {
for (auto& entry : m_entries) {
if (key == entry) {
dbgln_if(SQL_DEBUG, "[#{}] duplicate key {}", pointer(), key.to_deprecated_string());
dbgln_if(SQL_DEBUG, "[#{}] duplicate key {}", block_index(), key.to_deprecated_string());
return false;
}
}
}
dbgln_if(SQL_DEBUG, "[#{}] insert_in_leaf({})", pointer(), key.to_deprecated_string());
dbgln_if(SQL_DEBUG, "[#{}] insert_in_leaf({})", block_index(), key.to_deprecated_string());
just_insert(key, nullptr);
return true;
}
u32 TreeNode::down_pointer(size_t ix) const
Block::Index TreeNode::down_pointer(size_t ix) const
{
return m_down[ix].pointer();
return m_down[ix].block_index();
}
TreeNode* TreeNode::down_node(size_t ix)
@ -213,12 +213,12 @@ TreeNode* TreeNode::node_for(Key const& key)
for (size_t ix = 0; ix < size(); ix++) {
if (key < m_entries[ix]) {
dbgln_if(SQL_DEBUG, "[{}] {} < {} v{}",
pointer(), (DeprecatedString)key, (DeprecatedString)m_entries[ix], m_down[ix].pointer());
block_index(), (DeprecatedString)key, (DeprecatedString)m_entries[ix], m_down[ix].block_index());
return down_node(ix)->node_for(key);
}
}
dbgln_if(SQL_DEBUG, "[#{}] {} >= {} v{}",
pointer(), key.to_deprecated_string(), (DeprecatedString)m_entries[size() - 1], m_down[size()].pointer());
block_index(), key.to_deprecated_string(), (DeprecatedString)m_entries[size() - 1], m_down[size()].block_index());
return down_node(size())->node_for(key);
}
@ -229,42 +229,42 @@ Optional<u32> TreeNode::get(Key& key)
if (key < m_entries[ix]) {
if (is_leaf()) {
dbgln_if(SQL_DEBUG, "[#{}] {} < {} -> 0",
pointer(), key.to_deprecated_string(), (DeprecatedString)m_entries[ix]);
block_index(), key.to_deprecated_string(), (DeprecatedString)m_entries[ix]);
return {};
} else {
dbgln_if(SQL_DEBUG, "[{}] {} < {} ({} -> {})",
pointer(), key.to_deprecated_string(), (DeprecatedString)m_entries[ix],
ix, m_down[ix].pointer());
block_index(), key.to_deprecated_string(), (DeprecatedString)m_entries[ix],
ix, m_down[ix].block_index());
return down_node(ix)->get(key);
}
}
if (key == m_entries[ix]) {
dbgln_if(SQL_DEBUG, "[#{}] {} == {} -> {}",
pointer(), key.to_deprecated_string(), (DeprecatedString)m_entries[ix],
m_entries[ix].pointer());
key.set_pointer(m_entries[ix].pointer());
return m_entries[ix].pointer();
block_index(), key.to_deprecated_string(), (DeprecatedString)m_entries[ix],
m_entries[ix].block_index());
key.set_block_index(m_entries[ix].block_index());
return m_entries[ix].block_index();
}
}
if (m_entries.is_empty()) {
dbgln_if(SQL_DEBUG, "[#{}] {} Empty node??", pointer(), key.to_deprecated_string());
dbgln_if(SQL_DEBUG, "[#{}] {} Empty node??", block_index(), key.to_deprecated_string());
VERIFY_NOT_REACHED();
}
if (is_leaf()) {
dbgln_if(SQL_DEBUG, "[#{}] {} > {} -> 0",
pointer(), key.to_deprecated_string(), (DeprecatedString)m_entries[size() - 1]);
block_index(), key.to_deprecated_string(), (DeprecatedString)m_entries[size() - 1]);
return {};
}
dbgln_if(SQL_DEBUG, "[#{}] {} > {} ({} -> {})",
pointer(), key.to_deprecated_string(), (DeprecatedString)m_entries[size() - 1],
size(), m_down[size()].pointer());
block_index(), key.to_deprecated_string(), (DeprecatedString)m_entries[size() - 1],
size(), m_down[size()].block_index());
return down_node(size())->get(key);
}
void TreeNode::just_insert(Key const& key, TreeNode* right)
{
dbgln_if(SQL_DEBUG, "[#{}] just_insert({}, right = {})",
pointer(), (DeprecatedString)key, (right) ? right->pointer() : 0);
block_index(), (DeprecatedString)key, (right) ? right->block_index() : 0);
dump_if(SQL_DEBUG, "Before");
for (auto ix = 0u; ix < size(); ix++) {
if (key < m_entries[ix]) {
@ -336,25 +336,25 @@ void TreeNode::dump_if(int flag, DeprecatedString&& msg)
if (!flag)
return;
StringBuilder builder;
builder.appendff("[#{}] ", pointer());
builder.appendff("[#{}] ", block_index());
if (!msg.is_empty())
builder.appendff("{}", msg);
builder.append(": "sv);
if (m_up)
builder.appendff("[^{}] -> ", m_up->pointer());
builder.appendff("[^{}] -> ", m_up->block_index());
else
builder.append("* -> "sv);
for (size_t ix = 0; ix < m_entries.size(); ix++) {
if (!is_leaf())
builder.appendff("[v{}] ", m_down[ix].pointer());
builder.appendff("[v{}] ", m_down[ix].block_index());
else
VERIFY(m_down[ix].pointer() == 0);
VERIFY(m_down[ix].block_index() == 0);
builder.appendff("'{}' ", (DeprecatedString)m_entries[ix]);
}
if (!is_leaf())
builder.appendff("[v{}]", m_down[size()].pointer());
builder.appendff("[v{}]", m_down[size()].block_index());
else
VERIFY(m_down[size()].pointer() == 0);
VERIFY(m_down[size()].block_index() == 0);
builder.appendff(" (size {}", (int)size());
if (is_leaf())
builder.append(", leaf"sv);
@ -369,7 +369,7 @@ void TreeNode::list_node(int indent)
warn(" ");
};
do_indent();
warnln("--> #{}", pointer());
warnln("--> #{}", block_index());
for (auto ix = 0u; ix < size(); ix++) {
if (!is_leaf())
down_node(ix)->list_node(indent + 2);