活动介绍
file-type

实现后根遍历与树高度计算的树结构扩展

版权申诉

ZIP文件

5星 · 超过95%的资源 | 430KB | 更新于2024-11-01 | 81 浏览量 | 2 下载量 举报 收藏
download 限时特惠:#14.90
树的孩子兄弟链表特别适合于实现树的遍历和修改操作。后根遍历(PostOrder Traversal)是一种深度优先遍历树的算法,访问顺序是先左子树、后右子树,最后访问根节点。树的高度(Height of a Tree)是指从树的根节点到最远叶子节点的最长路径上的边数。通过递归的方法,我们可以计算出树的高度。本文档将详细探讨如何在孩子兄弟链表模板类中增加特定函数成员来实现树的后根遍历和求树的高度的功能。" 知识点详细说明: 1. 树的孩子兄弟链表: - 树的孩子兄弟链表是一种使用链表方式表示树结构的方法。在这种表示法中,每个节点被表示为一个对象,该对象含有三个部分:一个数据域用于存储节点值,一个指针域指向该节点的第一个孩子节点,另一个指针域指向该节点的下一个兄弟节点。 - 孩子兄弟链表的优点在于,它能够方便地处理树的插入和删除操作,尤其是在处理具有多个孩子节点的树结构时。 - 实现树的遍历操作(如前序遍历、中序遍历、后根遍历等)时,使用孩子兄弟链表结构可以简化代码的复杂度。 2. 树的后根遍历(PostOrder Traversal): - 后根遍历是指先访问某个节点的所有子树,然后再访问该节点本身的过程。 - 在孩子兄弟链表的表示方式中,要实现后根遍历,通常需要递归地访问当前节点的子节点,然后访问当前节点本身。 - 实现PostRootOrder()函数的伪代码逻辑可能是: ```pseudo function PostRootOrder(node): if node is null: return for each child in node.children: PostRootOrder(child) visit node ``` - 其中,visit node表示对当前节点进行访问的代码,可能是打印节点值,或者执行其他操作。 3. 树的高度(Height of a Tree): - 树的高度是指从根节点到树中任意叶子节点的最长路径上边的数量。高度是一个重要的属性,因为它可以用来确定树的深度。 - 求树的高度通常采用递归方法,即对树的每个节点,其高度是其所有子树高度的最大值加1(代表当前节点的边)。 - 实现Height()函数的伪代码逻辑可能是: ```pseudo function Height(node): if node is null: return 0 max_height = 0 for each child in node.children: child_height = Height(child) max_height = max(max_height, child_height) return max_height + 1 ``` - 在这个函数中,Height(node)返回以node为根的子树的高度。如果node是空的(null),则高度定义为0,表示没有节点。否则,计算每个子树的高度,并更新最大值。 4. 验证函数成员的正确性: - 在增加PostRootOrder()和Height()函数成员后,需要进行验证以确保实现的正确性。 - 验证可以包括但不限于以下步骤: a) 创建测试用例,构建不同结构的树。 b) 对每棵树使用PostRootOrder()函数,检查后根遍历的结果是否符合预期。 c) 对每棵树使用Height()函数,检查计算出的高度是否正确。 d) 使用边界条件测试,包括空树和只有一层节点的树,以及具有多个分支的复杂树结构。 e) 可以编写自动化测试脚本,以程序化方式验证不同树结构上的遍历和高度计算结果。 通过这些知识点的详细解释,我们可以清楚地了解树的孩子兄弟链表如何实现特定的树操作,以及如何在其中实现后根遍历和计算树高度这两个重要的功能。

相关推荐

filetype
filetype

/* Copyright (c) 2023 Renmin University of China RMDB is licensed under Mulan PSL v2. You can use this software according to the terms and conditions of the Mulan PSL v2. You may obtain a copy of Mulan PSL v2 at: http://license.coscl.org.cn/MulanPSL2 THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. See the Mulan PSL v2 for more details. */ #include "ix_index_handle.h" #include "ix_scan.h" /** * @brief 在当前node中查找第一个>=target的key_idx * * @return key_idx,范围为[0,num_key),如果返回的key_idx=num_key,则表示target大于最后一个key * @note 返回key index(同时也是rid index),作为slot no */ int IxNodeHandle::lower_bound(const char *target) const { int left = 0, right = get_size(); while (left < right) { int mid = left + (right - left) / 2; int cmp = ix_compare(get_key(mid), target, file_hdr->col_types_, file_hdr->col_lens_); if (cmp < 0) { left = mid + 1; } else { right = mid; } } return left; } /** * @brief 在当前node中查找第一个>target的key_idx * * @return key_idx,范围为[1,num_key),如果返回的key_idx=num_key,则表示target大于等于最后一个key * @note 注意此处的范围从1开始 */ int IxNodeHandle::upper_bound(const char *target) const { // 将left初始值从1改为0,确保从第一个键开始搜索 int left = 0, right = get_size(); while (left < right) { int mid = left + (right - left) / 2; // 比较中间键与目标键 if (ix_compare(get_key(mid), target, file_hdr->col_types_, file_hdr->col_lens_) <= 0) { left = mid + 1; } else { right = mid; } } return left; } /** * @brief 用于叶子结点根据key来查找该结点中的键值对 * 值value作为传出参数,函数返回是否查找成功 * * @param key 目标key * @param[out] value 传出参数,目标key对应的Rid * @return 目标key是否存在 */ bool IxNodeHandle::leaf_lookup(const char *key, Rid **value) { int pos = lower_bound(key); if (pos < get_size() && ix_compare(get_key(pos), key, file_hdr->col_types_, file_hdr->col_lens_) == 0) { *value = get_rid(pos); return true; } return false; } /** * 用于内部结点(非叶子节点)查找目标key所在的孩子结点(子树) * @param key 目标key * @return page_id_t 目标key所在的孩子节点(子树)的存储页面编号 */ page_id_t IxNodeHandle::internal_lookup(const char *key) { // 处理最小键值情况(保持不变) if (key == nullptr) { return value_at(0); } // 更可靠的最小键值检查(保持不变) bool is_min_key = true; for (int i = 0; i < file_hdr->col_tot_len_; i++) { if (static_cast<unsigned char>(key[i]) != 0) { is_min_key = false; break; } } if (is_min_key) { return value_at(0); } int pos = upper_bound(key); // 修复:直接返回pos位置的值,而不是pos-1 return value_at(pos); } /** * @brief 在指定位置插入n个连续的键值对 * 将key的前n位插入到原来keys中的pos位置;将rid的前n位插入到原来rids中的pos位置 * * @param pos 要插入键值对的位置 * @param (key, rid) 连续键值对的起始地址,也就是第一个键值对,可以通过(key, rid)来获取n个键值对 * @param n 键值对数量 * @note [0,pos) [pos,num_key) * key_slot * / \ * / \ * [0,pos) [pos,pos+n) [pos+n,num_key+n) * key key_slot */ void IxNodeHandle::insert_pairs(int pos, const char *key, const Rid *rid, int n) { assert(pos >= 0 && pos <= get_size()); assert(get_size() + n <= get_max_size()); // 移动键数组 char *keys_dst = get_key(pos + n); char *keys_src = get_key(pos); int keys_bytes = (get_size() - pos) * file_hdr->col_tot_len_; memmove(keys_dst, keys_src, keys_bytes); // 移动值数组 Rid *rids_dst = get_rid(pos + n); Rid *rids_src = get_rid(pos); int rids_bytes = (get_size() - pos) * sizeof(Rid); memmove(rids_dst, rids_src, rids_bytes); // 插入新键值对 memcpy(get_key(pos), key, n * file_hdr->col_tot_len_); memcpy(get_rid(pos), rid, n * sizeof(Rid)); set_size(get_size() + n); // 修正拼写错误 } /** * @brief 用于在结点中插入单个键值对。 * 函数返回插入后的键值对数量 * * @param (key, value) 要插入的键值对 * @return int 键值对数量 */ int IxNodeHandle::insert(const char *key, const Rid &value) { int pos = lower_bound(key); if (pos < get_size() && ix_compare(get_key(pos), key, file_hdr->col_types_, file_hdr->col_lens_) == 0) { return get_size(); // 键已存在,不插入 } insert_pair(pos, key, value); return get_size(); } /** * @brief 用于在结点中的指定位置删除单个键值对 * * @param pos 要删除键值对的位置 */ void IxNodeHandle::erase_pair(int pos) { assert(pos >= 0 && pos < get_size()); // 移动键数组 char *keys_dst = get_key(pos); char *keys_src = get_key(pos + 1); int keys_bytes = (get_size() - pos - 1) * file_hdr->col_tot_len_; memmove(keys_dst, keys_src, keys_bytes); // 移动值数组 Rid *rids_dst = get_rid(pos); Rid *rids_src = get_rid(pos + 1); int rids_bytes = (get_size() - pos - 1) * sizeof(Rid); memmove(rids_dst, rids_src, rids_bytes); set_size(get_size() - 1); } /** * @brief 用于在结点中删除指定key的键值对。函数返回删除后的键值对数量 * * @param key 要删除的键值对key值 * @return 完成删除操作后的键值对数量 */ int IxNodeHandle::remove(const char *key) { int pos = lower_bound(key); if (pos < get_size() && ix_compare(get_key(pos), key, file_hdr->col_types_, file_hdr->col_lens_) == 0) { erase_pair(pos); } return get_size(); } IxIndexHandle::IxIndexHandle(DiskManager *disk_manager, BufferPoolManager *buffer_pool_manager, int fd) : disk_manager_(disk_manager), buffer_pool_manager_(buffer_pool_manager), fd_(fd), file_hdr_(nullptr) { // 初始化指针 char* buf = new char[PAGE_SIZE]; memset(buf, 0, PAGE_SIZE); // 读取文件头页面 disk_manager_->read_page(fd, IX_FILE_HDR_PAGE, buf, PAGE_SIZE); // 反序列化到file_hdr_ file_hdr_ = new IxFileHdr(); file_hdr_->deserialize(buf); delete[] buf; // 释放缓冲区 // 设置下一个可用页号(基于文件头记录的页数) int next_page_no = file_hdr_->num_pages_; disk_manager_->set_fd2pageno(fd, next_page_no); } /** * @brief 用于查找指定键所在的叶子结点 * @param key 要查找的目标key值 * @param operation 查找到目标键值对后要进行的操作类型 * @param transaction 事务参数,如果不需要则默认传入nullptr * @return [leaf node] and [root_is_latched] 返回目标叶子结点以及根结点是否加锁 * @note need to Unlatch and unpin the leaf node outside! * 注意:用了FindLeafPage之后一定要unlatch叶结点,否则下次latch该结点会堵塞! */ std::pair<IxNodeHandle *, bool> IxIndexHandle::find_leaf_page(const char *key, Operation operation, Transaction *transaction, bool find_first) { std::scoped_lock root_lock(root_latch_); bool root_is_latched = true; if (file_hdr_->root_page_ == IX_NO_PAGE) { return {nullptr, false}; } IxNodeHandle *node = fetch_node(file_hdr_->root_page_); while (!node->is_leaf_page()) { page_id_t child_page_no; if (find_first) { // 使用空指针表示最小键值 child_page_no = node->internal_lookup(nullptr); } else { child_page_no = node->internal_lookup(key); } IxNodeHandle *child = fetch_node(child_page_no); if (root_is_latched) { root_latch_.unlock(); root_is_latched = false; } // 释放当前节点资源 buffer_pool_manager_->unpin_page(node->get_page_id(), false); delete node; node = child; } return {node, root_is_latched}; } /** * @brief 用于查找指定键在叶子结点中的对应的值result * * @param key 查找的目标key值 * @param result 用于存放结果的容器 * @param transaction 事务指针 * @return bool 返回目标键值对是否存在 */ bool IxIndexHandle::get_value(const char *key, std::vector<Rid> *result, Transaction *transaction) { auto [leaf, root_is_latched] = find_leaf_page(key, Operation::FIND, transaction); if (root_is_latched) { root_latch_.unlock(); } Rid *rid; bool found = leaf->leaf_lookup(key, &rid); if (found) { result->push_back(*rid); } buffer_pool_manager_->unpin_page(leaf->get_page_id(), false); return found; } /** * @brief 将传入的一个node拆分(Split)成两个结点,在node的右边生成一个新结点new node * @param node 需要拆分的结点 * @return 拆分得到的new_node * @note need to unpin the new node outside * 注意:本函数执行完毕后,原node和new node都需要在函数外面进行unpin */ IxNodeHandle *IxIndexHandle::split(IxNodeHandle *node) { IxNodeHandle *new_node = create_node(); new_node->set_parent_page_no(node->get_parent_page_no()); // 计算分裂位置 - 确保左右节点都有足够的键 int split_pos = node->get_min_size(); new_node->set_size(node->get_size() - split_pos); // 复制键值对到新结点 memcpy(new_node->get_key(0), node->get_key(split_pos), new_node->get_size() * file_hdr_->col_tot_len_); memcpy(new_node->get_rid(0), node->get_rid(split_pos), new_node->get_size() * sizeof(Rid)); node->set_size(split_pos); // 维护叶子节点双向链表 if (node->is_leaf_page()) { new_node->set_prev_leaf(node->get_page_no()); new_node->set_next_leaf(node->get_next_leaf()); node->set_next_leaf(new_node->get_page_no()); if (new_node->get_next_leaf() != IX_NO_PAGE) { IxNodeHandle *next_leaf = fetch_node(new_node->get_next_leaf()); next_leaf->set_prev_leaf(new_node->get_page_no()); buffer_pool_manager_->unpin_page(next_leaf->get_page_id(), true); delete next_leaf; } else { file_hdr_->last_leaf_ = new_node->get_page_no(); } // 更新第一个叶子指针(如果需要) if (file_hdr_->first_leaf_ == node->get_page_no()) { // 原节点仍然是第一个叶子,不需要更改 } } return new_node; } /** * @brief Insert key & value pair into internal page after split * 拆分(Split)后,向上找到old_node的父结点 * 将new_node的第一个key插入到父结点,其位置在 父结点指向old_node的孩子指针 之后 * 如果插入后>=maxsize,则必须继续拆分父结点,然后在其父结点的父结点再插入,即需要递归 * 直到找到的old_node为根结点时,结束递归(此时将会新建一个根R,关键字为key,old_node和new_node为其孩子) * * @param (old_node, new_node) 原结点为old_node,old_node被分裂之后产生了新的右兄弟结点new_node * @param key 要插入parent的key * @note 一个结点插入了键值对之后需要分裂,分裂后左半部分的键值对保留在原结点,在参数中称为old_node, * 右半部分的键值对分裂为新的右兄弟节点,在参数中称为new_node(参考Split函数来理解old_node和new_node) * @note 本函数执行完毕后,new node和old node都需要在函数外面进行unpin */ void IxIndexHandle::insert_into_parent(IxNodeHandle *old_node, const char *key, IxNodeHandle *new_node, Transaction *transaction) { if (old_node->is_root_page()) { // 创建新根节点 IxNodeHandle *new_root = create_node(); new_root->set_parent_page_no(IX_NO_PAGE); new_root->page_hdr->is_leaf = false; new_root->set_size(1); *new_root->get_rid(0) = Rid{old_node->get_page_no(), 0}; memcpy(new_root->get_key(0), new_node->get_key(0), file_hdr_->col_tot_len_); *new_root->get_rid(1) = Rid{new_node->get_page_no(), 0}; old_node->set_parent_page_no(new_root->get_page_no()); new_node->set_parent_page_no(new_root->get_page_no()); file_hdr_->root_page_ = new_root->get_page_no(); if (old_node->is_leaf_page()) { file_hdr_->first_leaf_ = old_node->get_page_no(); file_hdr_->last_leaf_ = new_node->get_page_no(); } buffer_pool_manager_->unpin_page(new_root->get_page_id(), true); delete new_root; } else { IxNodeHandle *parent = fetch_node(old_node->get_parent_page_no()); // 关键修复:使用传入的key而不是new_node->get_key(0) int insert_pos = parent->insert(key, Rid{new_node->get_page_no(), 0}); if (parent->get_size() >= parent->get_max_size()) { IxNodeHandle *new_parent = split(parent); // 关键修复:使用新父节点的第一个键 insert_into_parent(parent, new_parent->get_key(0), new_parent, transaction); buffer_pool_manager_->unpin_page(new_parent->get_page_id(), true); delete new_parent; } else { maintain_parent(parent); } buffer_pool_manager_->unpin_page(parent->get_page_id(), true); delete parent; } } /** * @brief 将指定键值对插入到B+树中 * @param (key, value) 要插入的键值对 * @param transaction 事务指针 * @return page_id_t 插入到的叶结点的page_no */ page_id_t IxIndexHandle::insert_entry(const char *key, const Rid &value, Transaction *transaction) { auto [leaf, root_is_latched] = find_leaf_page(key, Operation::INSERT, transaction); if (!leaf) { // 处理根节点不存在的情况 IxNodeHandle *new_leaf = create_node(); new_leaf->page_hdr->is_leaf = true; new_leaf->insert(key, value); file_hdr_->root_page_ = new_leaf->get_page_no(); file_hdr_->first_leaf_ = new_leaf->get_page_no(); file_hdr_->last_leaf_ = new_leaf->get_page_no(); if (root_is_latched) { root_latch_.unlock(); } page_id_t ret = new_leaf->get_page_no(); buffer_pool_manager_->unpin_page(new_leaf->get_page_id(), true); delete new_leaf; return ret; } // 检查节点是否已满 if (leaf->get_size() < leaf->get_max_size()) { // 节点未满,直接插入 leaf->insert(key, value); } else { // 节点已满,需要分裂 IxNodeHandle *new_leaf = split(leaf); // 确定键值应该插入哪个节点 if (ix_compare(key, new_leaf->get_key(0), file_hdr_->col_types_, file_hdr_->col_lens_) >= 0) { new_leaf->insert(key, value); } else { leaf->insert(key, value); } // 处理父节点 insert_into_parent(leaf, new_leaf->get_key(0), new_leaf, transaction); // 释放新节点资源 buffer_pool_manager_->unpin_page(new_leaf->get_page_id(), true); delete new_leaf; } // 确保最后释放资源 if (root_is_latched) { root_latch_.unlock(); } page_id_t ret = leaf->get_page_no(); buffer_pool_manager_->unpin_page(leaf->get_page_id(), true); delete leaf; return ret; } /** * @brief 用于删除B+树中含有指定key的键值对 * @param key 要删除的key值 * @param transaction 事务指针 */ bool IxIndexHandle::delete_entry(const char *key, Transaction *transaction) { auto [leaf, root_is_latched] = find_leaf_page(key, Operation::DELETE, transaction); if (!leaf->remove(key)) { if (root_is_latched) { root_latch_.unlock(); } buffer_pool_manager_->unpin_page(leaf->get_page_id(), false); return false; } // 直接使用返回值 if (coalesce_or_redistribute(leaf, transaction, &root_is_latched)) { // 处理合并或重分配结果 } if (root_is_latched) { root_latch_.unlock(); } buffer_pool_manager_->unpin_page(leaf->get_page_id(), true); return true; } /** * @brief 用于处理合并和重分配的逻辑,用于删除键值对后调用 * * @param node 执行完删除操作的结点 * @param transaction 事务指针 * @param root_is_latched 传出参数:根节点是否上锁,用于并发操作 * @return 是否需要删除结点 * @note User needs to first find the sibling of input page. * If sibling's size + input page's size >= 2 * page's minsize, then redistribute. * Otherwise, merge(Coalesce). */ bool IxIndexHandle::coalesce_or_redistribute(IxNodeHandle *node, Transaction *transaction, bool *root_is_latched) { if (node->is_root_page()) { return adjust_root(node); } if (node->get_size() >= node->get_min_size()) { return false; } IxNodeHandle *parent = fetch_node(node->get_parent_page_no()); int index = parent->find_child(node); IxNodeHandle *neighbor; bool is_prev = (index > 0); if (is_prev) { neighbor = fetch_node(parent->value_at(index - 1)); } else { neighbor = fetch_node(parent->value_at(index + 1)); } if (node->get_size() + neighbor->get_size() >= node->get_max_size()) { redistribute(neighbor, node, parent, index); buffer_pool_manager_->unpin_page(parent->get_page_id(), true); buffer_pool_manager_->unpin_page(neighbor->get_page_id(), true); return false; } else { bool parent_deleted = coalesce(&neighbor, &node, &parent, index, transaction, root_is_latched); buffer_pool_manager_->unpin_page(parent->get_page_id(), true); buffer_pool_manager_->unpin_page(neighbor->get_page_id(), true); return parent_deleted; } } /** * @brief 用于当根结点被删除了一个键值对之后的处理 * @param old_root_node 原根节点 * @return bool 根结点是否需要被删除 * @note size of root page can be less than min size and this method is only called within coalesce_or_redistribute() */ bool IxIndexHandle::adjust_root(IxNodeHandle *old_root_node) { if (old_root_node->get_size() > 1 || old_root_node->is_leaf_page()) { return false; } // 根节点只有一个孩子,让孩子成为新的根节点 page_id_t child_page_no = old_root_node->remove_and_return_only_child(); IxNodeHandle *child = fetch_node(child_page_no); child->set_parent_page_no(IX_NO_PAGE); file_hdr_->root_page_ = child_page_no; release_node_handle(*old_root_node); buffer_pool_manager_->unpin_page(child->get_page_id(), true); return true; } /** * @brief 重新分配node和兄弟结点neighbor_node的键值对 * Redistribute key & value pairs from one page to its sibling page. If index == 0, move sibling page's first key * & value pair into end of input "node", otherwise move sibling page's last key & value pair into head of input "node". * * @param neighbor_node sibling page of input "node" * @param node input from method coalesceOrRedistribute() * @param parent the parent of "node" and "neighbor_node" * @param index node在parent中的rid_idx * @note node是之前刚被删除过一个key的结点 * index=0,则neighbor是node后继结点,表示:node(left) neighbor(right) * index>0,则neighbor是node前驱结点,表示:neighbor(left) node(right) * 注意更新parent结点的相关kv对 */ void IxIndexHandle::redistribute(IxNodeHandle *neighbor_node, IxNodeHandle *node, IxNodeHandle *parent, int index) { if (index > 0) { // neighbor是前驱节点 if (!node->is_leaf_page()) { // 内部节点需要移动最后一个键值对 int neighbor_size = neighbor_node->get_size(); node->insert_pair(0, neighbor_node->get_key(neighbor_size - 1), *neighbor_node->get_rid(neighbor_size - 1)); // 解引用 neighbor_node->erase_pair(neighbor_size - 1); parent->set_key(index, node->get_key(0)); maintain_child(node, 0); } else { // 叶子节点需要移动最后一个键值对 int neighbor_size = neighbor_node->get_size(); node->insert_pair(0, neighbor_node->get_key(neighbor_size - 1), *neighbor_node->get_rid(neighbor_size - 1)); // 解引用 neighbor_node->erase_pair(neighbor_size - 1); parent->set_key(index, node->get_key(0)); } } else { // neighbor是后继节点 if (!node->is_leaf_page()) { // 内部节点需要移动第一个键值对 node->insert_pair(node->get_size(), neighbor_node->get_key(0), *neighbor_node->get_rid(0)); // 解引用 neighbor_node->erase_pair(0); parent->set_key(1, neighbor_node->get_key(0)); maintain_child(node, node->get_size() - 1); } else { // 叶子节点需要移动第一个键值对 node->insert_pair(node->get_size(), neighbor_node->get_key(0), *neighbor_node->get_rid(0)); // 解引用 neighbor_node->erase_pair(0); parent->set_key(1, neighbor_node->get_key(0)); } } } /** * @brief 合并(Coalesce)函数是将node和其直接前驱进行合并,也就是和它左边的neighbor_node进行合并; * 假设node一定在右边。如果上层传入的index=0,说明node在左边,那么交换node和neighbor_node,保证node在右边;合并到左结点,实际上就是删除了右结点; * Move all the key & value pairs from one page to its sibling page, and notify buffer pool manager to delete this page. * Parent page must be adjusted to take info of deletion into account. Remember to deal with coalesce or redistribute * recursively if necessary. * * @param neighbor_node sibling page of input "node" (neighbor_node是node的前结点) * @param node input from method coalesceOrRedistribute() (node结点是需要被删除的) * @param parent parent page of input "node" * @param index node在parent中的rid_idx * @return true means parent node should be deleted, false means no deletion happend * @note Assume that *neighbor_node is the left sibling of *node (neighbor -> node) */ bool IxIndexHandle::coalesce(IxNodeHandle **neighbor_node, IxNodeHandle **node, IxNodeHandle **parent, int index, Transaction *transaction, bool *root_is_latched) { if (index == 0) { // 交换node和neighbor_node,保证node在右边 std::swap(*neighbor_node, *node); index = 1; } // 将node合并到neighbor_node int neighbor_insert_pos = (*neighbor_node)->get_size(); (*neighbor_node)->insert_pairs(neighbor_insert_pos, (*node)->get_key(0), (*node)->get_rid(0), (*node)->get_size()); if (!(*node)->is_leaf_page()) { // 内部节点需要更新子节点的父指针 for (int i = 0; i < (*node)->get_size(); i++) { maintain_child(*neighbor_node, neighbor_insert_pos + i); } } else { // 叶子节点需要更新链表指针 (*neighbor_node)->set_next_leaf((*node)->get_next_leaf()); if ((*node)->get_next_leaf() != IX_NO_PAGE) { IxNodeHandle *next_leaf = fetch_node((*node)->get_next_leaf()); next_leaf->set_prev_leaf((*neighbor_node)->get_page_no()); buffer_pool_manager_->unpin_page(next_leaf->get_page_id(), true); } else { file_hdr_->last_leaf_ = (*neighbor_node)->get_page_no(); } } // 从父节点中删除node对应的键值对 (*parent)->remove((*node)->get_key(0)); release_node_handle(**node); // 递归处理父节点 return coalesce_or_redistribute(*parent, transaction, root_is_latched); } /** * @brief 这里把iid转换成了rid,即iid的slot_no作为node的rid_idx(key_idx) * node其实就是把slot_no作为键值对数组的下标 * 换而言之,每个iid对应的索引槽存了一对(key,rid),指向了(要建立索引的属性首地址,插入/删除记录的位置) * * @param iid * @return Rid * @note iid和rid存的不是一个东西,rid是上层传过来的记录位置,iid是索引内部生成的索引槽位置 */ Rid IxIndexHandle::get_rid(const Iid &iid) const { IxNodeHandle *node = fetch_node(iid.page_no); if (iid.slot_no >= node->get_size()) { throw IndexEntryNotFoundError(); } buffer_pool_manager_->unpin_page(node->get_page_id(), false); // unpin it! return *node->get_rid(iid.slot_no); } /** * @brief FindLeafPage + lower_bound * * @param key * @return Iid * @note 上层传入的key本来是int类型,通过(const char *)&key进行了转换 * 可用*(int *)key转换回去 */ Iid IxIndexHandle::lower_bound(const char *key) { return Iid{-1, -1}; } /** * @brief FindLeafPage + upper_bound * * @param key * @return Iid */ Iid IxIndexHandle::upper_bound(const char *key) { return Iid{-1, -1}; } /** * @brief 指向最后一个叶子的最后一个结点的后一个 * 用处在于可以作为IxScan的最后一个 * * @return Iid */ Iid IxIndexHandle::leaf_end() const { IxNodeHandle *node = fetch_node(file_hdr_->last_leaf_); Iid iid = {.page_no = file_hdr_->last_leaf_, .slot_no = node->get_size()}; buffer_pool_manager_->unpin_page(node->get_page_id(), false); // unpin it! return iid; } /** * @brief 指向第一个叶子的第一个结点 * 用处在于可以作为IxScan的第一个 * * @return Iid */ Iid IxIndexHandle::leaf_begin() const { Iid iid = {.page_no = file_hdr_->first_leaf_, .slot_no = 0}; return iid; } /** * @brief 获取一个指定结点 * * @param page_no * @return IxNodeHandle* * @note pin the page, remember to unpin it outside! */ IxNodeHandle *IxIndexHandle::fetch_node(int page_no) const { Page *page = buffer_pool_manager_->fetch_page(PageId{fd_, page_no}); IxNodeHandle *node = new IxNodeHandle(file_hdr_, page); return node; } /** * @brief 创建一个新结点 * * @return IxNodeHandle* * @note pin the page, remember to unpin it outside! * 注意:对于Index的处理是,删除某个页面后,认为该被删除的页面是free_page * 而first_free_page实际上就是最新被删除的页面,初始为IX_NO_PAGE * 在最开始插入时,一直是create node,那么first_page_no一直没变,一直是IX_NO_PAGE * 与Record的处理不同,Record将未插入满的记录页认为是free_page */ IxNodeHandle *IxIndexHandle::create_node() { IxNodeHandle *node; file_hdr_->num_pages_++; PageId new_page_id = {.fd = fd_, .page_no = INVALID_PAGE_ID}; // 从3开始分配page_no,第一次分配之后,new_page_id.page_no=3,file_hdr_.num_pages=4 Page *page = buffer_pool_manager_->new_page(&new_page_id); node = new IxNodeHandle(file_hdr_, page); return node; } /** * @brief 从node开始更新其父节点的第一个key,一直向上更新直到根节点 * * @param node */ void IxIndexHandle::maintain_parent(IxNodeHandle *node) { IxNodeHandle *curr = node; while (curr->get_parent_page_no() != IX_NO_PAGE) { // Load its parent IxNodeHandle *parent = fetch_node(curr->get_parent_page_no()); int rank = parent->find_child(curr); char *parent_key = parent->get_key(rank); char *child_first_key = curr->get_key(0); if (memcmp(parent_key, child_first_key, file_hdr_->col_tot_len_) == 0) { assert(buffer_pool_manager_->unpin_page(parent->get_page_id(), true)); break; } memcpy(parent_key, child_first_key, file_hdr_->col_tot_len_); // 修改了parent node curr = parent; assert(buffer_pool_manager_->unpin_page(parent->get_page_id(), true)); } } /** * @brief 要删除leaf之前调用此函数,更新leaf前驱结点的next指针和后继结点的prev指针 * * @param leaf 要删除的leaf */ void IxIndexHandle::erase_leaf(IxNodeHandle *leaf) { assert(leaf->is_leaf_page()); IxNodeHandle *prev = fetch_node(leaf->get_prev_leaf()); prev->set_next_leaf(leaf->get_next_leaf()); buffer_pool_manager_->unpin_page(prev->get_page_id(), true); IxNodeHandle *next = fetch_node(leaf->get_next_leaf()); next->set_prev_leaf(leaf->get_prev_leaf()); // 注意此处是SetPrevLeaf() buffer_pool_manager_->unpin_page(next->get_page_id(), true); } /** * @brief 删除node时,更新file_hdr_.num_pages * * @param node */ void IxIndexHandle::release_node_handle(IxNodeHandle &node) { file_hdr_->num_pages_--; } /** * @brief 将node的第child_idx个孩子结点的父节点置为node */ void IxIndexHandle::maintain_child(IxNodeHandle *node, int child_idx) { if (!node->is_leaf_page()) { // Current node is inner node, load its child and set its parent to current node int child_page_no = node->value_at(child_idx); IxNodeHandle *child = fetch_node(child_page_no); child->set_parent_page_no(node->get_page_no()); buffer_pool_manager_->unpin_page(child->get_page_id(), true); } }

爱牛仕
  • 粉丝: 120
上传资源 快速赚钱