btree: delete, search

Author: yangtau

Project/btree.cpp

@@ -13,26 +13,38 @@
 
 uint16_t NodeBlock::size() {
     // keep an empty item as temp used when splitting a full block
+#ifdef DEBUG_BTREE
     return 4;
-    //return ((BLOCK_SIZE - sizeof(BlockHeader)) / sizeof(KeyValue));
+#else
+    return ((BLOCK_SIZE - sizeof(BlockHeader)) / sizeof(KeyValue));
+#endif // DEBUG_BTREE   
 }
 
-bool NodeBlock::isFull() {
+bool NodeBlock::full() {
     assert(header.count <= NodeBlock::size());
     return header.count == NodeBlock::size();
 }
 
-bool NodeBlock::isEmpty() {
+bool NodeBlock::empty() {
     return header.count == 0;
 }
 
+bool NodeBlock::eMin() {
+    return header.count == size() / 2;
+}
+
+bool NodeBlock::geMin() {
+    return header.count >= size() / 2;
+}
+
 uint16_t NodeBlock::find(uint64_t key) {
-    assert(!isEmpty());
+    assert(!empty());
     // TODO: diff between interior node and leaf
     uint16_t i = 0;
-    if (header.type == BLOCK_TYPE_NODE) i++;
+    if (!isLeaf()) i++;
     uint16_t j = header.count - 1;
     if (kv[j].key < key) return header.count;
+
     while (i < j) {
         uint16_t mid = (i + j) / 2;
         if (kv[mid].key < key)
@@ -43,77 +55,46 @@ uint16_t NodeBlock::find(uint64_t key) {
     return j;
 }
 
-bool NodeBlock::insert(KeyValue item, uint16_t index) {
+void NodeBlock::insert(KeyValue item, uint16_t index) {
     assert(index <= header.count);
     memmove(&kv[index + 1], &kv[index],
         sizeof(KeyValue) * (header.count - index));
     kv[index] = item;
     header.count++;
-    return true;
 }
 
-void NodeBlock::split(NodeBlock* nextNode, uint32_t index) {
+void NodeBlock::split(NodeBlock* nextNode) {
     nextNode->header.type = header.type;
 
     // move kv
     memcpy(&nextNode->kv[0], &kv[(NodeBlock::size() + 1) / 2], NodeBlock::size() / 2 * sizeof(KeyValue));
     this->header.count = (NodeBlock::size() + 1) / 2;
     nextNode->header.count = NodeBlock::size() / 2;
 
-    if (nextNode->header.type == BLOCK_TYPE_LEAF) {
-        nextNode->header.next = this->header.next;
-        this->header.next = index;
-    }
+    // chain brother
+    nextNode->header.next = this->header.next;
+    this->header.next = nextNode->header.index;
 }
 
-//void BTree::setRootIndex(uint32_t index) {
-//    rootIndex = index;
-//    storage.setIndexOfRoot(rootIndex);
-//}
+void NodeBlock::merge(NodeBlock * nextNode) {
+    memcpy(&kv[0], &nextNode->kv[0], nextNode->header.count);
 
-// 如果没有分裂，返回的value值为0。否则，返回要插入的值
-KeyValue BTree::insert(KeyValue kv, NodeBlock* cur) {
-    assert(cur->header.type == BLOCK_TYPE_LEAF ||
-        cur->header.type == BLOCK_TYPE_NODE);
-
-    KeyValue res;
-    res.value = 0;
-
-    uint16_t i = cur->find(kv.key);
-
-    if (cur->header.type == BLOCK_TYPE_LEAF) {
-        cur->insert(kv, i);
-    }
-    else {
-        if (cur->kv[i].key > kv.key) {
-            i--;
-        }
-        NodeBlock* t = (NodeBlock*)storage.getBlock(cur->kv[i].value);
-        KeyValue r = insert(kv, t);
-        if (r.value != 0)
-            cur->insert(r, cur->find(r.key));
-    }
-    if (cur->isFull()) {
-        uint32_t index = 0;
+    header.count += nextNode->header.count;
 
-        NodeBlock* nextNode = (NodeBlock*)storage.getFreeBlock(&index);
-        if (nextNode == NULL) {
-            // TODO: failed to allocate a new block
-        }
-        cur->split(nextNode, index);
-        res = nextNode->kv[0];
-        res.value = index;
-        return res;
-    }
-    return res;
+    header.next = nextNode->header.next;
 }
 
-int BTree::remove(KeyValue kv, NodeBlock* cur) {
-    return 0;
+bool NodeBlock::isLeaf() {
+    assert(header.type == BLOCK_TYPE_LEAF ||
+        header.type == BLOCK_TYPE_NODE);
+    return header.type == BLOCK_TYPE_LEAF;
 }
 
-int BTree::search(KeyValue kv, NodeBlock* cur) {
-    return 0;
+void NodeBlock::remove(uint16_t index) {
+    assert(index < header.count);
+    memmove(&kv[index], &kv[index + 1],
+        sizeof(KeyValue) * (header.count - index - 1));
+    header.count--;
 }
 
 BTree::BTree(StorageManager &s) :root(NULL), storage(s) {
@@ -136,8 +117,9 @@ BTree::BTree(StorageManager &s) :root(NULL), storage(s) {
 }
 
 
+// 如果没有分裂，返回的value值为0。否则，返回要插入的值
 int BTree::insert(KeyValue kv) {
-    if (root->isEmpty()) {
+    if (root->empty()) {
         root->insert(kv, 0);
         return 1;
     }
@@ -148,7 +130,7 @@ int BTree::insert(KeyValue kv) {
         if (newRoot == NULL) {
             // TODO: failed to allocate a new block
         }
-        newRoot->header.count = 1;
+        newRoot->header.count = 2;
         newRoot->header.type = BLOCK_TYPE_NODE;
         newRoot->kv[1] = r;
         newRoot->kv[0].value = root->header.index;
@@ -159,10 +141,127 @@ int BTree::insert(KeyValue kv) {
     return 1;
 }
 
+KeyValue BTree::insert(KeyValue kv, NodeBlock* cur) {
+    KeyValue res;
+    res.value = 0;
+
+    uint16_t i = cur->find(kv.key);
+
+    if (cur->isLeaf()) {
+        cur->insert(kv, i);
+    }
+    else {
+        if (cur->kv[i].key > kv.key) {
+            i--;
+        }
+        NodeBlock* t = (NodeBlock*)storage.getBlock(cur->kv[i].value);
+        KeyValue r = insert(kv, t);
+        if (r.value != 0)
+            cur->insert(r, cur->find(r.key));
+    }
+
+
+    if (cur->full()) {
+        uint32_t index = 0;
+
+        NodeBlock* nextNode = (NodeBlock*)storage.getFreeBlock(&index);
+        if (nextNode == NULL) {
+            // TODO: failed to allocate a new block
+        }
+        cur->split(nextNode);
+        res = nextNode->kv[0];
+        res.value = index;
+        return res;
+    }
+    return res;
+}
+
+void BTree::remove(uint64_t key, NodeBlock* cur) {
+    uint16_t i = cur->find(key);
+
+    if (cur->isLeaf()) {
+        if (cur->kv[i].key > key) return;
+        else {
+            cur->remove(i);
+        }
+    }
+    else {
+        if (cur->kv[i].key > key) {
+            i--;
+        }
+        NodeBlock* s = (NodeBlock*)storage.getBlock(cur->kv[i].value);
+        remove(key, s);
+
+        // update the key in parent
+        cur->kv[i].key = s->kv[0].key;
+
+        if (s->geMin()) return;
+
+        // maintain
+        if (i > 0) {
+            NodeBlock *left = (NodeBlock*)storage.getBlock(cur->kv[i - 1].value);
+            if (left->eMin()) {
+                // merge
+                left->merge(s);
+                cur->remove(i);
+
+                storage.freeBlock(s->header.index);
+            }
+            else {
+                s->insert(left->kv[left->header.count - 1], 0);
+                left->remove(left->header.count - 1);
+            }
+        }
+        else {
+            NodeBlock *right = (NodeBlock*)storage.getBlock(cur->kv[i + 1].value);
+            if (right->eMin()) {
+                // merge
+                s->merge(right);
+                cur->remove(i + 1);
+
+                storage.freeBlock(right->header.index);
+            }
+            else {
+                s->insert(right->kv[0], s->header.count);
+                right->remove(0);
+                cur->kv[i + 1].key = right->kv[0].key;
+            }
+        }
+    }
+}
+
+
 int BTree::remove(uint64_t key) {
+    if (root->empty()) {
+        return 0;
+    }
+    remove(key, root);
+    if (!root->isLeaf() && root->header.count == 1) {
+        NodeBlock* s = (NodeBlock*)storage.getBlock(root->kv[0].value);
+        root = s;
+        storage.freeBlock(s->header.index);
+    }
     return 0;
 }
 
-int BTree::search(uint64_t key, uint32_t* value) {
-    return 0;
+
+KeyValue BTree::search(uint64_t key, NodeBlock* cur) {
+    uint16_t i = cur->find(key);
+    if (cur->isLeaf()) {
+        if (cur->kv[i].key == key)
+            return cur->kv[i];
+    }
+    else {
+        if (cur->kv[i].key > key) i--;
+        NodeBlock* s = (NodeBlock*)storage.getBlock(root->kv[i].value);
+        return search(key, s);
+    }
+    KeyValue res;
+    res.value = 0;
+    return res;
+}
+
+
+KeyValue BTree::search(uint64_t key) {
+    return search(key, root);
 }

Project/btree.h

@@ -8,6 +8,7 @@
 //
 
 #pragma once
+#define DEBUG_BTREE
 
 #include <inttypes.h>
 #include "block.h"
@@ -30,22 +31,40 @@ struct NodeBlock {
     BlockHeader header;
 
     // The first key is empty, if the block is an interior node
+#ifdef DEBUG_BTREE
     KeyValue kv[4];
+#else
+    KeyValue kv[1];
+#endif // DEBUG_BTREE   
 
     static uint16_t size();
 
-    bool isFull();
+    bool full();
 
-    bool isEmpty();
+    bool empty();
+
+    // equal
+    bool eMin();
+
+    // greater or equal
+    // no need to maintain
+    bool geMin();
 
     ///
     // @brief
-    // the index of first item whose key is bigger than or equal with `key`
+    // return the index of first item whose key is not less than `key`
+    // if keys of all items is less than `key`, return `header.count`
     uint16_t find(uint64_t key);
 
-    bool insert(KeyValue item, uint16_t index);
+    void insert(KeyValue item, uint16_t index);
+
+    void split(NodeBlock* nextNode);
 
-    void split(NodeBlock* nextNode, uint32_t index);
+    void merge(NodeBlock* nextNode);
+
+    bool isLeaf();
+
+    void remove(uint16_t index);
 };
 
 #pragma pack()
@@ -54,15 +73,15 @@ class BTree {
 private:
     StorageManager &storage;
     NodeBlock* root;
-    
+
     //void setRootIndex(uint32_t index);
     KeyValue insert(KeyValue kv, NodeBlock* cur);
-    int remove(KeyValue kv, NodeBlock* cur);
-    int search(KeyValue kv, NodeBlock* cur);
+    void remove(uint64_t key, NodeBlock* cur);
+    KeyValue search(uint64_t key, NodeBlock* cur);
 
 public:
     BTree(StorageManager &s);
     int insert(KeyValue kv);
     int remove(uint64_t key);
-    int search(uint64_t key, uint32_t* value);
+    KeyValue search(uint64_t key);
 };

Project/storage.cpp

@@ -61,6 +61,14 @@ void * StorageManager::getFreeBlock(uint32_t *index) {
     return b;
 }
 
+void StorageManager::freeBlock(uint32_t index) {
+    RecordBlock *b = (RecordBlock *)readBlock(index);
+
+    b->header.next = meta->free;
+    meta->free = index;
+    meta->idle++;
+}
+
 bool StorageManager::save() {
     for (auto &x : buffers) {
         if (x.second->header.reserved == 1) {

Project/storage.h

@@ -41,6 +41,8 @@ class StorageManager {
 
     void* getFreeBlock(uint32_t *index);
 
+    void freeBlock(uint32_t index);
+
     bool save();
 
     uint32_t getIndexOfRoot();