【CMU15-445数据库】bustub Project #2:B+ Tree(中)

本篇继续讲解 Project 2:B+ 树的实现。让我们先从相对简单的迭代器实现开始,然后讲述删除的实现。因为删除部分篇幅较长,并发控制我们放到下一篇再讲。

迭代器(Iterator)

熟悉 C++ 的同学们应该知道,迭代器(Iterator)是 STL 中非常重要的一个概念,它将容器与对容器的操作解耦,容器提供 begin()end() 等返回迭代器的函数,而算法直接依托这些迭代器进行操作,不再附属于容器本身。其设计也与传统的数组(指针)兼容(++, -- 移动,==, != 判断,*, -> 解引用)。这里就是让我们为 B+ 树实现一个迭代器。

先来看 BPlusTree 类中的接口,一共有三个函数要实现:Begin()Begin(const KeyType &key)End(),其中第二个的意思是找到下界为 key 的位置。bustub 也为我们定义了迭代器的类型:

在这里插入图片描述
图里是我修改后的状态,下面来讲实现的思路。B+ 树的所有数据存在于最下层的叶节点,迭代器也是在叶节点内和叶节点之间移动。因此,一个迭代器的位置由两部分组成:在哪个叶节点(用其编号和指针表示,二者同步变化)和在叶节点中第几个位置(用索引表示,即 index_in_leaf_ 成员)。于是,迭代器相等的判断就是叶节点编号相同且叶内索引相同。由于迭代器会在不同节点间移动,它需要有能够获取和返还 page 的能力,所以将 buffer_pool_manager_ 也作为一个它的成员,在构造函数中由外部传入。规定 page_id_INVALID_PAGE_ID 表示无效迭代器(即 End() 返回的迭代器)。实现上唯一需要注意的就是 operator++() 中跳页的处理,如下:

在这里插入图片描述

Tips:注意这个 operator++() 对应的是前加,也就是 ++it 的情况,所以先做操作,再返回 *this。关于 C++ 操作符重载可以参考这个链接:What are the basic rules and idioms for operator overloading?

回到 BPlusTree 类,实现三个函数。首先 Begin(),一路向下找到最左边的叶节点即可:

在这里插入图片描述
第二个 Begin(const KeyType &key),我们已经实现了 GetLeafPage(),所以已经能够找到目标页,还需要找到目标索引,不妨在 LeafPage 类中加一个 LowerBound() 函数:

在这里插入图片描述
在这里插入图片描述
End() 函数就不用贴了,构造一个 INVALID_PAGE_ID 的迭代器即可。

删除(Remove)

本节实验的第二大重点,还是先文字描述一下过程:

  1. 如果是空树,返回。否则找到键所在叶节点,从叶节点中删除键值。如果删除后没有下溢出或该叶节点是根节点,返回。
  2. 如果删除后叶节点下溢出(键值对个数小于 min_size , min_size = ( max_size + 1 ) / 2 \text{min\_size}, \text{min\_size} = (\text{max\_size}+1) / 2 min_size,min_size=(max_size+1)/2),考察兄弟节点:如果兄弟节点键值对个数大于 min_size \text{min\_size} min_size,从兄弟节点借一个键值对(左侧兄弟就借尾,右侧兄弟就借头),同时用借的键替换父节点中该节点位置的键。
  3. 如果兄弟节点键值对数不够借出,将该节点与兄弟节点合并,更新 next_page_id_,同时删除父节点中该位置的键值。
  4. 如果删除后父节点(内部节点)下溢出,仍然是借&修改或合并&删除两种方法处理,但规则与叶节点不同:借&修改时,要把兄弟节点的键上移,父节点的键下移给该节点,同时把一个兄弟节点的值给该节点;合并&删除时,要把父节点的键和兄弟节点的键值一块和该节点合并。
  5. 如果下溢出达到根节点,而且根节点只剩下一个子节点,说明树应该减少一层,将唯一的子节点设为新的根。

虽然总体描述看起来不太复杂,但实际上手时细节较多,尤其是内部节点的借和合并两种情况。下面和代码一块给出具体说明和例子。

关于从兄弟节点借以及合并应该选择哪边,我查阅资料并没有强制规定,所以我这里按一般习惯优先选择左侧兄弟。插入时使用了 while(true) 的写法,这里换一种,用递归调用,定义函数 HandleUnderflow()

传递参数的设计,回想在插入时,我们的设计是传递两个分裂的子节点对象和分裂点的键,因为要修改它们和父节点的关系;而这里下溢出只涉及一个节点,所以我们传递发生下溢出需要进行处理的那个节点即可。

Remove() 函数,在叶节点做删除,如果发生下溢出,第一次调用 HandleOverflow()。叶节点中删除键值的逻辑还是放到 LeafPage 的一个函数 Remove() 中。

在这里插入图片描述
HandleUnderflow() 的第一步,处理根节点情况。

在这里插入图片描述
第二步,尝试向兄弟节点借。首先要找到兄弟节点,写成一个单独的函数 GetSiblings()。最左侧的节点只有右兄弟,最右侧的节点只有左兄弟,其它节点有两个兄弟。

在这里插入图片描述
HandleUnderflow() 中调用 GetSiblings() 并获取到兄弟节点的 Page:

在这里插入图片描述
尝试向兄弟借,写为函数 TryBorrow(),用一个 bool 参数 sibling_at_left 标识兄弟节点是在左边还是右边。叶节点/内部节点,兄弟在左/在右一共有四种情况,不过通过一点技巧可以适当简化代码:定义 parent_update_atsibling_borrow_atupdate_key,分别代表父节点更新的位置,更新的键和从兄弟节点借的位置。可以看出,父节点更新的位置就是该节点和兄弟节点两个值夹在中间的那个键,如果兄弟在左,那就是该节点值相配的那个键,兄弟在右则加一。从兄弟节点借的位置就是根据兄弟在左或在右对应兄弟的最后一个/第一个键,特别要注意对于内部节点 key[0] 是无效的,要取 1。定义这些变量后,分情况讨论设定好 update_key,最后统一做父节点更新即可,框架如下:

在这里插入图片描述
具体情况的讨论,让我们先从比较简单的叶节点情况开始,实际上就如上面描述的,将一个兄弟节点的键值拿过来,在兄弟节点中将其移除。父节点中更新的键,如果兄弟在左边,则用该节点新的第 0 个键(也就是刚借过来的),在右边用兄弟的第 0 个键即可(兄弟原来的第 1 个键,0 号被借走)。

在这里插入图片描述

然后就是比较麻烦的内部节点的情况,因为一是规则和叶节点不一样,二是涉及值(子节点)的移交,也花费了我很多时间才梳理清楚。这里我直接放我总结的规则以及用官方提供的 b_plus_tree_printer 生成的例子。

  • 如果兄弟节点在左边:父节点中该节点 value 左侧 key 插到该节点 key[1],父节点 key 改为兄弟节点 key[size-1],该节点 value[1] 改为原 value[0],value[0] 改为兄弟 value[size-1],兄弟节点 key,value[size-1] 删除

例子:
在这里插入图片描述

注意第 0 个值(箭头)实际位置是在第 0 个键(空格)右侧

详解:从树中删除 3,导致叶节点 10 下溢,15 合并到 10 中(合并下面再讲),16 只剩 10 一个值,需要从 3 借,借的键为 -1,值为 14 号节点,该节点交给 16 后要挂在原 value[0],即 10 号节点的左侧,10 号节点右移到原 15 号节点(现废弃)位置。-1 键交给父节点 17 号,更新位置为 3 和 16 箭头相夹的 key[1],原 17 号 key[1] 交给 16 号节点插入到 key[1] 位置。

  • 如果兄弟节点在右边:父节点中该节点 value 右侧 key 搭配兄弟节点 value[0] 插到该节点最右边,父节点 key 改为兄弟节点 key[1],兄弟节点 value[0] 和 key[1] 删除。

例子:

在这里插入图片描述

详解:从树中删除 1,导致叶节点 1 下溢,2 合并到 1 中(合并下面再讲),3 只剩 1 一个值,需要从 7 借,借的键为 4,上移到父节点中;借的值为 4 号节点,搭配父节点下移的键 3 插入 3 号节点最右侧。

这个过程博主觉得跟平衡二叉树的旋转比较类似,结合一个例子推一遍就清楚要如何操作了。其中感觉比较奇怪的可能是兄弟在左边时要把原 value[0] 移到 value[1],把新借的放到 value[0] 这步,这是因为内部节点理论上是 <值0,键0,值1,…,键n-1,值n> 的结构,而 bustub 将其定义为 <(键0 - 无效,值0),(键1,值1),…,(键n,值n)> 的结构,导致左右侧的操作是不对称的。如果定义反过来:<(值0,键0),(值1,键1),…,(值n,键n - 无效)>,那么这里处理方法也要反过来。

代码

在这里插入图片描述
注意交接值时不要忘记把子节点的 parent_page_id_ 指针更新。

回到 HandleUnderflow(),那么只要尝试从左边或右边兄弟借,有一个借成功即可。按之前所说,这里优先左边:

在这里插入图片描述
UnpinSiblings() 的作用是判断两个兄弟是否存在,若存在就释放,因为下面合并也会用到所以提成一个函数。和 Insert() 一样还是注意用完把所有页都归还。

如果左右兄弟都不能借,则与其中之一合并,写为函数 MergePage()。合并不存在一方向一方取的关系,因此我们只需要知道两个页哪个在左哪个在右即可,只需分叶节点和内部节点两类进行讨论。

还是先讨论较为简单的叶节点情况,要做的事有:(1)把右侧节点的键值对插入左侧节点;(2)将左侧节点的 next_page_id_ 指针更新为右侧节点的;(3)在父节点中移除右节点值位置的键值,代码如下:

在这里插入图片描述
内部节点的情况,我们说要把父节点的键和兄弟节点的键值一块和该节点合并,具体来说就是在左侧节点的尾部,插入:(父节点中右节点位置的 key,右节点 value[0]),(右节点 key[1],右节点 value[1]),…(右节点剩余内容),然后把父节点中右节点位置的键值删掉。

来看一个复合的例子:

在这里插入图片描述
详解:删除 1,1 号节点下溢,和 2 号合并;3号节点中只剩余一个值,下溢,和 6 号节点合并,把父节点的键 3 拿下来,接 6 号节点的 value[0](4 号节点),key[1](4),value[1](5 号节点);7 号节点删除 3 后下溢,从右兄弟 14 号节点借,父节点键 5 搭配右兄弟 value[0](10 号节点)给 7 号节点,右兄弟 key[1] 给父节点。

流程:叶节点合并 → 内部节点合并 → 内部节点向右兄弟借

代码

在这里插入图片描述
其中 SetPageParentId() 只是一个获取页,设置父节点指针,归还页的辅助函数。

刚才也说了合并时只需知道两个页哪个在左哪个在右,那么在调用前我们可以用一个简单的判断,仍然是优先与左侧兄弟合并。

在这里插入图片描述

最后,做好清理工作,如果父节点下溢出,进行下一轮递归调用。

在这里插入图片描述

稍事休息?

本节实验的本地测试依然很水,不过到这里,恭喜你应该已经能通过 Autograder 的 Checkpoint 1 了:

在这里插入图片描述
不过 Checkpoint 1 除了 ScaleTest 之外其它几个测试我怀疑可能就是本地那几个数据,总体来说要求还是较低,不能验证你的插入和删除实现是否完全正确,而 Checkpoint 2 的测试就丰富很多。但 Checkpoint 2 的测试大半又是加了并发的,那么能不能在没实现并发前用这些数据也帮助验证插入和删除的实现是否正确呢?

这时候就要发挥我们的灵活思维了:虽然 PPT 介绍了一套逐层上锁的方法,但不妨碍我们可以直接粗暴地上一把大锁啊(doge),虽然效率会比较低,但只要不超时肯定是正确的。甚至文档里专门告诉 CMU 的学生会对代码进行人工检查,不要试图用这种方式作弊:

在这里插入图片描述
但不妨碍我们先这么做一下,验证前面的内容是否都实现正确,这样我们后面就能集中在并发控制的实现上了,而不用担心是前面有隐藏 bug 导致测试过不了。

在这里插入图片描述

博主这么提交在 Leaderboard 上显示的时间是 12.70,基本是所有通过了的里面倒数的,不过说明前面的实现没问题了。那我们下节继续把并发控制实现,争取排名向前冲~

BPlusTree_Java实现 package bplustree; import java.util.*; import com.xuedi.IO.*; import com.xuedi.maths.*; ////// DisposeRoot ///////的key参数有些问题 public class BTree { //用于记录每个节点的键值数量 public int keyAmount; //树的根节点 public Node root; public BTree(int keyAmount) { this.keyAmount = keyAmount; this.root = new Node(keyAmount); } //在B树插入叶节点///////////////////////////////////////////////////////////// public void insert(long key,Object pointer) { //找到应该插入的节点 Node theNode = search(key,root); //在叶节点找到空闲空间,有的话就把键放在那里 if( !isFull(theNode) ) { putKeyToNode(key,pointer,theNode); }else{ //如果在适当的叶节点没有空间,就把该叶节点分裂成两个,并正确分配键值 Node newNode = separateLeaf(key,pointer,theNode); //如果分裂的是根节点,就新建一个新的根节点将新建的节点作为他的字节点 if( isRoot(theNode) ) { DisposeRoot(theNode,newNode,newNode.keys[0]); }else{ //将新建立的节点的指针插入到上层节点 insertToInnerNode(theNode.parent,newNode,newNode.keys[0]); } } } //lowerNode是下级节点分离后新建立的那个节点/////////////////////////////////////// //upperNode是lowerNode的上层节点 private void insertToInnerNode(Node upperNode,Node lowerNode,long key) { //上层节点有空位就直接插入 if( !isFull(upperNode) ) { putKeyToNode(key,lowerNode,upperNode); //重置父节点指针 pointerRedirect(upperNode); return; }else{ //如果分裂的是根节点,就新建一个新的根节点将新建的节点作为他的子节点 Node newNode; if( isRoot(upperNode) ) { newNode = separateInnerNode(key,lowerNode,upperNode); Node newRoot = new Node(this.keyAmount); newRoot.pointer[0] = upperNode; newRoot.pointer[1] = newNode; upperNode.parent = newRoot; newNode.parent = newRoot; newRoot.keyAmount = 1; newRoot.keys[0] = key; root = newRoot; //重置父节点指针 pointerRedirect(upperNode); return; }else{ //上层非根节点没有空位进行分裂和插入操作 newNode = separateInnerNode(key,lowerNode,upperNode); //重置父节点指针 pointerRedirect(upperNode); //记录要向上插入的键值在源节点的位置(该键值在separateInnerNode()被保留在srcNode) int keyToUpperNodePosition = upperNode.keyAmount; //向上递归插入 insertToInnerNode(upperNode.parent,newNode,upperNode.keys[keyToUpperNodePosition]); //重置父节点指针 pointerRedirect(newNode); } } } //将对应的内部节点进行分裂并正确分配键值,返回新建的节点 private Node separateInnerNode(long key,Object pointer,Node srcNode) { Node newNode = new Node(this.keyAmount); //因为我在Node预制了一个位置用于插入,而下面的函数(putKeyToLeaf())不进行越界检查 //所以可以将键-指针对先插入到元节点,然后再分别放到两个节点 putKeyToNode(key,pointer,srcNode); //先前节点后来因该有(n+1)/2取上界个键-值针对 int ptrSaveAmount = (int)com.xuedi.maths.NumericalBound.getBound(0,(double)(this.keyAmount+1)/2); int keySaveAmount = (int)com.xuedi.maths.NumericalBound.getBound(0,(double)(this.keyAmount)/2); int keyMoveAmount = (int)com.xuedi.maths.NumericalBound.getBound(1,(double)(this.keyAmount)/2); //(n+1)/2取上界个指针和n/2取上界个键留在源节点 //剩下的n+1)/2取下界个指n/2取下界个键留在源节点 for (int k = ptrSaveAmount; k < srcNode.keyAmount; k++) { newNode.add(srcNode.keys[k], srcNode.pointer[k]); } newNode.pointer[newNode.keyAmount] = srcNode.pointer[srcNode.pointer.length-1]; srcNode.keyAmount = keySaveAmount; return newNode; } //将对应的叶节点进行分裂并正确分配键值,返回新建的节点/////////////////////////////// private Node separateLeaf(long key,Object pointer,Node srcNode) { Node newNode = new Node(this.keyAmount); //兄弟间的指针传递 newNode.pointer[this.keyAmount] = srcNode.pointer[this.keyAmount]; //因为我在Node预制了一个位置用于插入,而下面的函数(putKeyToLeaf())不进行越界检查 //所以可以将键-指针对先插入到元节点,然后再分别放到两个节点 putKeyToNode(key,pointer,srcNode); //先前节点后来因该有(n+1)/2取上界个键-值针对 int oldNodeSize = (int)com.xuedi.maths.NumericalBound.getBound(0,(double)(this.keyAmount+1)/2); for(int k = oldNodeSize; k <= this.keyAmount; k++) { newNode.add(srcNode.keys[k],srcNode.pointer[k]); } srcNode.keyAmount = oldNodeSize; //更改指针--让新节点成为就节点的右边的兄弟 srcNode.pointer[this.keyAmount] = newNode; return newNode; } //把键值放到叶节点--这个函数不进行越界检查//////////////////////////////////////// private void putKeyToNode(long key,Object pointer,Node theNode) { int position = getInsertPosition(key,theNode); //进行搬迁动作--------叶节点的搬迁 if( isLeaf(theNode) ) { if(theNode.keyAmount <= position) { theNode.add(key,pointer); return; } else{ for (int j = theNode.keyAmount - 1; j >= position; j--) { theNode.keys[j + 1] = theNode.keys[j]; theNode.pointer[j + 1] = theNode.pointer[j]; } theNode.keys[position] = key; theNode.pointer[position] = pointer; } }else{ //内部节点的搬迁----有一定的插入策略: //指针的插入比数据的插入多出一位 for (int j = theNode.keyAmount - 1; j >= position; j--) { theNode.keys[j + 1] = theNode.keys[j]; theNode.pointer[j + 2] = theNode.pointer[j+1]; } theNode.keys[position] = key; theNode.pointer[position+1] = pointer; } //键值数量加1 theNode.keyAmount++; } //获得正确的插入位置 private int getInsertPosition(long key,Node node) { //将数据插入到相应的位置 int position = 0; for (int i = 0; i < node.keyAmount; i++) { if (node.keys[i] > key) break; position++; } return position; } //有用的辅助函数//////////////////////////////////////////////////////////////// //判断某个结点是否已经装满了 private boolean isFull(Node node) { if(node.keyAmount >= this.keyAmount) return true; else return false; } //判断某个节点是否是叶子结点 private boolean isLeaf(Node node) { //int i = 0; if(node.keyAmount == 0) return true; //如果向下的指针是Node型,则肯定不是叶子节点 if(node.pointer[0] instanceof Node) return false; return true; } private boolean isRoot(Node node) { if( node.equals(this.root) ) return true; return false; } //给内部节点的自己点重新定向自己的父亲 private void pointerRedirect(Node node) { for(int i = 0; i <= node.keyAmount; i++) { ((Node)node.pointer[i]).parent = node; } } //新建一个新的根节点将新建的节点作为他的字节点 private void DisposeRoot(Node child1,Node child2,long key) { Node newRoot = new Node(this.keyAmount); newRoot.pointer[0] = child1; newRoot.pointer[1] = child2; newRoot.keyAmount = 1; newRoot.keys[0] = key; root = newRoot; //如果两个孩子是叶节点就让他们两个相连接 if( isLeaf(child1) ) { //兄弟间的指针传递 child2.pointer[this.keyAmount] = child1.pointer[this.keyAmount]; child1.pointer[this.keyAmount] = child2; } pointerRedirect(root); return; } /////////////////////////////////////////////////////////////////////////////// //用于寻找键值key所在的或key应该插入的节点 //key为键值,curNode为当前节点--一般从root节点开始 public Node search(long key,Node curNode) { if (isLeaf(curNode)) return curNode; for (int i = 0; i < this.keyAmount; i++) { if (key < curNode.keys[i]) //判断是否是第一个值 return search(key, (Node) curNode.pointer[i]); else if (key >= curNode.keys[i]) { if (i == curNode.keyAmount - 1) //如果后面没有值 { //如果key比最后一个键值大,则给出最后一个指针进行递归查询 return search(key,(Node) curNode.pointer[curNode.keyAmount]); } else { if (key < curNode.keys[i + 1]) return search(key, (Node) curNode.pointer[i + 1]); } } } //永远也不会到达这里 return null; } }
评论 28
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值