CMU数据库(15-445)-实验2-B+树索引实现(中）删除

3. Delete 实现

附上实验2的第一部分🔗 https://www.cnblogs.com/JayL-zxl/p/14324297.html

3. 1 删除算法原理

如果叶子结点中没有相应的key，则删除失败。否则执行下面的步骤

图片来自于这篇博文 https://www.programiz.com/dsa/deletion-from-a-b-plus-tree

情况1 要删除的要素就只在叶子结点
1. 删除叶子结点中对应的key。删除后若结点的key的个数大于等于\(\frac{m-1}{2}\)，删除操作结束。
2. 若兄弟结点key有多余（\(>\frac{m-1}{2}\)），向兄弟结点借一个关键字，然后用兄弟结点的median key替代父结点。
情况2 要删除的元素不仅在叶子结点而且在内部结点出现
1. 如果结点中的元素个数\(> \frac{m-1}{2}\)，只需从叶结点删除key值，同时从内部节点删除键。用key元素的后继元素补充内部节点的空余空间。
2. 如果节点中元素个数等于\(\frac{m-1}{2}\)，则删除该键并从其直接兄弟借一个键。用借来的键填充内部结点中所形成的空空间。
3. 和情况2的第一种情况类似。只不过空洞结点是当前结点的祖父结点。
情况3 这种情况是树的高度会缩小的情况。

cmu这里给了演示网站 https://www.cs.usfca.edu/~galles/visualization/BPlusTree.html

算法描述见下表

3.2 删除算法实现

如果当前是空树则立即返回
否则先找到要删除的key所在的page

随后调用RemoveAndDeleteRecord在叶page上直接删除key值

同样还是经典的二分查找

INDEX_TEMPLATE_ARGUMENTS
int B_PLUS_TREE_LEAF_PAGE_TYPE::RemoveAndDeleteRecord(const KeyType &key, const KeyComparator &comparator) {

  int l=0,r=GetSize()-1;
  if(l>r||comparator(key,array[l].first)<0||comparator(key,array[r].first)>0)return GetSize();
  while(l<=r){
    int mid=(l+r)>>1;
    if(comparator(key, KeyAt(mid)) < 0){
      r=mid;
    }
    else if (comparator(key, KeyAt(mid)) > 0) l=mid+1;
    else{
      memmove(array + mid, array + mid + 1,static_cast<size_t>((GetSize() - mid - 1)*sizeof(MappingType)));
      IncreaseSize(-1);
      break;
    }
  }

  return GetSize();
}

删除之后的叶子结点有两种情况

叶子结点内关键字个数小于最小值向下执行。否则结束

-- 调用CoalesceOrRedistribute

1.如果当前结点是根节点则调用AdjustRoot(node)

INDEX_TEMPLATE_ARGUMENTS
bool BPLUSTREE_TYPE::AdjustRoot(BPlusTreePage *old_root_node) {
  //case 2
  if (old_root_node->IsLeafPage()) {
    if (old_root_node->GetSize() == 0) {
      root_page_id_ = INVALID_PAGE_ID;
      UpdateRootPageId(false);
      return true;
    }
    return false;
  }
  //  case 1
  if (old_root_node->GetSize() == 2) {
    auto root =reinterpret_cast<BPlusTreeInternalPage<KeyType, page_id_t,KeyComparator> *>(old_root_node);
    root_page_id_ = root->ValueAt(1);
    UpdateRootPageId(false);
    auto page = buffer_pool_manager_->FetchPage(root_page_id_);
    if (page == nullptr) {
      throw "no page can used while AdjustRoot";
    }
    auto new_root =reinterpret_cast<BPlusTreeInternalPage<KeyType, page_id_t,KeyComparator> *>(page);
    new_root->SetParentPageId(INVALID_PAGE_ID);
    buffer_pool_manager_->UnpinPage(root_page_id_, true);
    return true;
  }
  return false;
}

2.否则应该找它的兄弟节点

调用CoalesceOrRedistribute

a. 如果兄弟结点的size+当前结点的size大于最大值则需要重新分配

-- 调用Redistribute函数

INDEX_TEMPLATE_ARGUMENTS
template <typename N>
bool BPLUSTREE_TYPE::CoalesceOrRedistribute(N *node, Transaction *transaction) {
  if (node->IsRootPage()) {
    return AdjustRoot(node);
  }
  if (node->IsLeafPage()) {
    if (node->GetSize() >= node->GetMinSize()) {
      return false;
    }
  } else {
    if (node->GetSize() > node->GetMinSize()) {
      return false;
    }
  }
  auto page = buffer_pool_manager_->FetchPage(node->GetParentPageId());
  if (page == nullptr) {
    throw "no page can used while CoalesceOrRedistribute";
  }
  auto parent =reinterpret_cast<BPlusTreeInternalPage<KeyType, page_id_t,KeyComparator> *>(page);
  int value_index = parent->ValueIndex(node->GetPageId());
  //sibling page  always find left page
  int sibling_page_id;
  if (value_index == 0) {
    sibling_page_id = parent->ValueAt(value_index + 1);
  } else {
    sibling_page_id = parent->ValueAt(value_index - 1);
  }

  // fetch sibling node
  auto sibling_page = buffer_pool_manager_->FetchPage(sibling_page_id);
  if (sibling_page == nullptr) {
    throw Exception("all page are pinned while CoalesceOrRedistribute");
  }

  // put sibling node to PageSet
  sibling_page->WLatch();
  transaction->AddIntoPageSet(sibling_page);
  auto sibling = reinterpret_cast<N *>(sibling_page);
  bool is_redistribute = false;
  // If sibling's size + input
  //  page's size > page's max size, then redistribute.
  if (sibling->GetSize() + node->GetSize() > node->GetMaxSize()) {
    is_redistribute = true;
    //TODO need to modify parent
    buffer_pool_manager_->UnpinPage(parent->GetPageId(), true);
  }
  // exec  redistribute
  if (is_redistribute) {
    Redistribute<N>(sibling, node, value_index);
    return false;
  }

 //Otherwise, merge.
  bool ret;
  if (value_index == 0) {
    Coalesce<N>(node, sibling, parent, 1, transaction);
    transaction->AddIntoDeletedPageSet(sibling_page_id);
    // node should not be deleted
    ret = false;
  } else {
    Coalesce<N>(sibling, node, parent, value_index, transaction);
    // node should be deleted
    ret = true;
  }
  //TODO unpin parent
  buffer_pool_manager_->UnpinPage(parent->GetPageId(), true);
  return ret;
}

重新分配的时候有两种情况

(1) 移动它左边结点最大的的元素到当前结点的第一个元素---对应MoveLastToFrontOf函数

注意这里对于internalPage和LeafPage并不一样

首先看对于LeafPage的实现

整体逻辑非常简单

就是把元素append到末尾
然后就是修改父亲结点的元素。

INDEX_TEMPLATE_ARGUMENTS
void B_PLUS_TREE_LEAF_PAGE_TYPE::MoveLastToFrontOf(BPlusTreeLeafPage *recipient,int parentIndex,
                                                   BufferPoolManager *buffer_pool_manager) {
  MappingType pair = GetItem(GetSize() - 1);
  IncreaseSize(-1);
  recipient->CopyFirstFrom(pair, parentIndex, buffer_pool_manager);
}
INDEX_TEMPLATE_ARGUMENTS
void B_PLUS_TREE_LEAF_PAGE_TYPE::CopyFirstFrom(const MappingType &item, int parentIndex,
                                               BufferPoolManager *buffer_pool_manager) {
  assert(GetSize() + 1 < GetMaxSize());
  memmove(array + 1, array, GetSize()*sizeof(MappingType));
  IncreaseSize(1);
  array[0] = item;

  auto page = buffer_pool_manager->FetchPage(GetParentPageId());
  if (page == nullptr) {
    throw "no page can used while CopyFirstFrom";
  }
  // get parent
  auto parent =reinterpret_cast<BPlusTreeInternalPage<KeyType, decltype(GetPageId()),KeyComparator> *>(page->GetData());

  parent->SetKeyAt(parentIndex, item.first);

  buffer_pool_manager->UnpinPage(GetParentPageId(), true);
}

然后看对于InternalPage的实现

这里和leafpage不一样的就是最后一个元素在GetSize()处
这里要修改移动元素value值（所指向的结点）的parent结点

INDEX_TEMPLATE_ARGUMENTS
void B_PLUS_TREE_INTERNAL_PAGE_TYPE::MoveLastToFrontOf(BPlusTreeInternalPage *recipient,  int parent_index,
                                                       BufferPoolManager *buffer_pool_manager) {
  assert(GetSize() > 1);
  IncreaseSize(-1);
  MappingType pair = array[GetSize()];
  page_id_t child_page_id = pair.second;

  recipient->CopyFirstFrom(pair,parent_index, buffer_pool_manager);

  // update parent page id
  auto page = buffer_pool_manager->FetchPage(child_page_id);
  if (page == nullptr) {
    throw "no page can used while MoveLastFrontOf";
  }
  //把要移动元素所指向的结点的parent指针修改。
  auto child = reinterpret_cast<BPlusTreePage *>(page->GetData());
  child->SetParentPageId(recipient->GetPageId());

  assert(child->GetParentPageId() == recipient->GetPageId());
  buffer_pool_manager->UnpinPage(child->GetPageId(), true);
}

/* Append an entry at the beginning.
 * Since it is an internal page, the moved entry(page)'s parent needs to be updated.
 * So I need to 'adopt' it by changing its parent page id, which needs to be persisted with BufferPoolManger
 */
INDEX_TEMPLATE_ARGUMENTS
void B_PLUS_TREE_INTERNAL_PAGE_TYPE::CopyFirstFrom(const MappingType &pair, int parent_index,BufferPoolManager *buffer_pool_manager) {
  assert(GetSize() + 1 < GetMaxSize());

  auto page = buffer_pool_manager->FetchPage(GetParentPageId());
  if (page == nullptr) {
    throw "no page can used while CopyFirstFrom";
  }
  auto parent = reinterpret_cast<BPlusTreeInternalPage *>(page->GetData());

  auto key = parent->KeyAt(parent_index);

  // set parent key to the last of current page
  parent->SetKeyAt(parent_index, pair.first);

  InsertNodeAfter(array[0].second, key, array[0].second);
  array[0].second = pair.second;

  buffer_pool_manager->UnpinPage(parent->GetPageId(), true);
}

(2) 移动它右边结点最小的元素到当前结点的最后一个元素---对应了MoveFirstToEndOf函数

注意这里对于internalPage和LeafPage并不一样

首先看对于LeafPage的实现

取右边的第一个元素，然后把其他元素都向前移动一个位置(用memmove实现)
然后调用CopyLastFrom函数把元素拷贝过去
随后修改node对应parent的key值

INDEX_TEMPLATE_ARGUMENTS
void B_PLUS_TREE_LEAF_PAGE_TYPE::MoveFirstToEndOf(BPlusTreeLeafPage *recipient,BufferPoolManager *buffer_pool_manager) {
  MappingType pair = GetItem(0);
  IncreaseSize(-1);
  memmove(array, array + 1, static_cast<size_t>(GetSize()*sizeof(MappingType)));

  recipient->CopyLastFrom(pair);

  auto page = buffer_pool_manager->FetchPage(GetParentPageId());
  if (page == nullptr) {
    throw "no page can used while MoveFirstToEndOf";
  }
  auto parent =reinterpret_cast<BPlusTreeInternalPage<KeyType, decltype(GetPageId()),KeyComparator> *>(page->GetData());
  parent->SetKeyAt(parent->ValueIndex(GetPageId()), pair.first);
  buffer_pool_manager->UnpinPage(GetParentPageId(), true);
}

/*
 * Copy the item into the end of my item list. (Append item to my array)
 */
INDEX_TEMPLATE_ARGUMENTS
void B_PLUS_TREE_LEAF_PAGE_TYPE::CopyLastFrom(const MappingType &item) {
  assert(GetSize() + 1 <= GetMaxSize());
  array[GetSize()] = item;
  IncreaseSize(1);
}

然后看对于InternalPage的实现

这里需要注意的是internalPage的一个key是在index=1的位置(因为第一个位置就是一个没有key值的指针位置)
因为是内部页，所以要修改它的孩子结点的指向。
还要修改内部结点父结点对应的key

INDEX_TEMPLATE_ARGUMENTS
void B_PLUS_TREE_INTERNAL_PAGE_TYPE::MoveFirstToEndOf(BPlusTreeInternalPage *recipient,BufferPoolManager *buffer_pool_manager) {
  assert(GetSize() > 1);
  MappingType pair{KeyAt(1), ValueAt(0)};
  page_id_t child_page_id = ValueAt(0);
  SetValueAt(0, ValueAt(1));
  Remove(1);

  recipient->CopyLastFrom(pair, buffer_pool_manager);

  // update child parent page id
  auto page = buffer_pool_manager->FetchPage(child_page_id);
  if (page == nullptr) {
    throw "no page can  used while MoveFirstToEndOf";
  }
  auto child = reinterpret_cast<BPlusTreePage *>(page);
  child->SetParentPageId(recipient->GetPageId());

  assert(child->GetParentPageId() == recipient->GetPageId());
  buffer_pool_manager->UnpinPage(child->GetPageId(), true);
}

/* Append an entry at the end.
 * Since it is an internal page, the moved entry(page)'s parent needs to be updated.
 * So I need to 'adopt' it by changing its parent page id, which needs to be persisted with BufferPoolManger
 */
INDEX_TEMPLATE_ARGUMENTS
void B_PLUS_TREE_INTERNAL_PAGE_TYPE::CopyLastFrom(const MappingType &pair, BufferPoolManager *buffer_pool_manager) {
  assert(GetSize() + 1 <= GetMaxSize());

  auto page = buffer_pool_manager->FetchPage(GetParentPageId());
  if (page == nullptr) {
    throw Exception("all page are pinned while CopyLastFrom");
  }
  auto parent = reinterpret_cast<BPlusTreeInternalPage *>(page);

  auto index = parent->ValueIndex(GetPageId());
  auto key = parent->KeyAt(index + 1);

  array[GetSize()] = {key, pair.second};
  IncreaseSize(1);
  parent->SetKeyAt(index + 1, pair.first);
  buffer_pool_manager->UnpinPage(parent->GetPageId(), true);
}

b.否则需要进行merge操作

-- 调用Coalesce函数

Coalesce函数比较简单
首先把node结点的所有元素都移动到它的兄弟节点上
调整父结点。也就是把array向前移动
递归调用CoalesceOrRedistribute函数

INDEX_TEMPLATE_ARGUMENTS
template <typename N>
void BPLUSTREE_TYPE::Coalesce(N *neighbor_node, N *node,BPlusTreeInternalPage<KeyType, page_id_t, KeyComparator> *parent,int index, Transaction *transaction) {
  // assumption: neighbor_node is predecessor of node
  //LOG_DEBUG("index %d",index);
  node->MoveAllTo(neighbor_node,index,buffer_pool_manager_);
  LOG_DEBUG("size %d",node->GetSize());
  // adjust parent
  parent->Remove(index);

  //recursive
  if (CoalesceOrRedistribute(parent, transaction)) {
    transaction->AddIntoDeletedPageSet(parent->GetPageId());
  }

}

Internal内的 Remove函数

INDEX_TEMPLATE_ARGUMENTS
void B_PLUS_TREE_INTERNAL_PAGE_TYPE::Remove(int index) {
  assert(0 <= index && index < GetSize());
  memmove(array+index,array+index+1,(GetSize()-index-1)*sizeof(MappingType));
  IncreaseSize(-1);

}

好了删除算法已经实现了。首先我们可以通过test函数

cd build
make b_plus_tree_delete_test
./test/b_plus_tree_delete_test --gtest_also_run_disabled_tests

然后我们自己做一些test。这里我就拿一个例子来看

插入10、5、7、4、9得到下图是正确的🌟

然后删除元素7

可以发现是完全正确的好了。第二部分就完成了。下面就是最后一部分对于🔒的实现和迭代器的实现

周小伦