void BPlusTree::deleteEntry(int key) {
BufferManager *bm = BufferManager::getInstance();
//lookup till the required node
TreeNode* c = root;
while( c->isLeaf() ) {
int sKey = -1;
int finalKey = -1;
for(int i=0; i<(c->getTotalPairs()); i++){
sKey=c->getKey(i);
if(sKey>key){
finalKey=i;
break;
}
}
if(finalKey==-1) {
int m=c->getTotalPairs();
c = new TreeNode(bm->pinPage(dbName, c->getRid(m)));
}
else
c = new TreeNode(bm->pinPage(dbName, c->getRid(finalKey)));
}
deleteFromNode(c, key);
}
int BPlusTree::lookup(int key) {
BufferManager *bm = BufferManager::getInstance();
TreeNode* c = root;
while( c->isLeaf() ) {
int sKey = -1;
int finalKey = -1;
for(int i=0; i<(c->getTotalPairs()); i++){
sKey=c->getKey(i);
if(sKey>key){
finalKey=i;
break;
}
}
if(finalKey==-1) {
int m=c->getTotalPairs();
c = new TreeNode(bm->pinPage(dbName, c->getRid(m)));
}
else
c = new TreeNode(bm->pinPage(dbName, c->getRid(finalKey)));
}
int keyExists = -1;
int position;
for(int i=0; i<(c->getTotalPairs()); i++){
if(key == c->getKey(i)){
keyExists = key;
position=i;
}
}
if(keyExists != -1 ){
return c->getRid(position);
}
else
{
return -1;
}
}
TreeNode* BPlusTree::getChild(TreeNode *curNode, int key) {
BufferManager *bm = BufferManager::getInstance(dbName);
return new TreeNode(bm->pinPage(
curNode->getChildPointer(key)));
}
void BPlusTree::recursiveDeleteEntry(TreeNode *node, int key,
int pointer, TreeNode** trace, int level) {
BufferManager *bm = BufferManager::getInstance(dbName);
int noPairsInNode = node->getNoPairs();
int node_diskBlockId;
int keyCount;
int ithKey;
if (node->isLeaf()) {
cout << "delete key: " << key <<
" pointer: " << pointer << " in leaf" << endl;
ithKey = readInt(node->getBuffPage(), 2 * SIZE_INT + PTR_SIZE);
for (keyCount = 0; keyCount < noPairsInNode &&
key != ithKey; keyCount++) {
ithKey = readInt(node->getBuffPage(),
2 * SIZE_INT + (keyCount + 1) * PAIR_SIZE + PTR_SIZE);
}
moveBytes(node->getBuffPage() +
2 * SIZE_INT + (keyCount + 1) * PAIR_SIZE,
node->getBuffPage() +
2 * SIZE_INT + keyCount*PAIR_SIZE,
(noPairsInNode - keyCount - 1) * PAIR_SIZE);
node->setNoPairs(noPairsInNode - 1);
} else {
cout << "delete key: " << key <<
" pointer: " << pointer << " in non leaf" << endl;
ithKey = readInt(node->getBuffPage(), 2 * SIZE_INT + PTR_SIZE);
for (keyCount = 0; keyCount < noPairsInNode &&
key != ithKey; keyCount++) {
//cout<<"ithKey "<<ithKey<<endl;
ithKey = readInt(node->getBuffPage(),
2 * SIZE_INT + (keyCount + 1) * PAIR_SIZE + PTR_SIZE);
}
moveBytes(node->getBuffPage() + 2 * SIZE_INT +
(keyCount + 1) * PAIR_SIZE + PTR_SIZE,
node->getBuffPage() + 2 * SIZE_INT +
keyCount * PAIR_SIZE + PTR_SIZE,
(noPairsInNode - keyCount - 1) * PAIR_SIZE);
node->setNoPairs(noPairsInNode - 1);
}
noPairsInNode = node->getNoPairs();
//node is root and only one pointer in it after deletion
if (level == 0) {
//root is not a leaf
if (node->isLeaf() == 0 && noPairsInNode == 0) {
cout << "root is not a leaf(termination condition)" << endl;
int rootChildId = readInt(node->getBuffPage(), 2 * SIZE_INT);
TreeNode *rootChildNode =
new TreeNode(bm->pinPage(rootChildId));
moveBytes(rootChildNode->getBuffPage(),
node->getBuffPage(),
BLOCK_SIZE);
bm->unpinPage(rootChildId, false);
StorageManager::freeBlock(dbName, rootChildId);
}
cout << "terminates" << endl;
//no unpin needed here
} else if (noPairsInNode < (maxNoPairs + 1) / 2 && level != 0) {
TreeNode *parentNode = trace[level - 1];
int noPairsInParent = parentNode->getNoPairs();
int kDash;
int searchKey = readInt(node->getBuffPage(),
2 * SIZE_INT + PTR_SIZE);
ithKey = readInt(parentNode->getBuffPage(),
2 * SIZE_INT + PTR_SIZE);
for (keyCount = 0; keyCount < noPairsInParent &&
searchKey >= ithKey; keyCount++) {
ithKey = readInt(parentNode->getBuffPage(),
2 * SIZE_INT + (keyCount + 1) * PAIR_SIZE + PTR_SIZE);
}
TreeNode *siblingNode;
int siblingNodeId;
int swapCheck = 0;
int noPairsInSibling;
int nodeToBeDeleted;
//finding N'
/**
* sibling is the leftmost node wherein swapping
* the pointers N and N' is needed
*/
if (keyCount == 0) {
//sibling to unpined using siblingNodeId
node_diskBlockId = readInt(parentNode->getBuffPage(),
2 * SIZE_INT);
siblingNodeId = readInt(parentNode->getBuffPage(),
2 * SIZE_INT + PAIR_SIZE);
siblingNode = new TreeNode(bm->pinPage(siblingNodeId));
kDash = ithKey;
swapCheck = 1;
nodeToBeDeleted = siblingNodeId;
} /**
* sibling is not thethe leftmost node
*/
else {
node_diskBlockId = readInt(parentNode->getBuffPage(),
2 * SIZE_INT + keyCount * PAIR_SIZE);
siblingNodeId = readInt(parentNode->getBuffPage(),
2 * SIZE_INT + (keyCount - 1) * PAIR_SIZE);
siblingNode = new TreeNode(bm->pinPage(siblingNodeId));
kDash = readInt(parentNode->getBuffPage(),
2 * SIZE_INT + (keyCount - 1) *
PAIR_SIZE + PTR_SIZE);
nodeToBeDeleted = readInt(parentNode->getBuffPage(),
2 * SIZE_INT + (keyCount) * PAIR_SIZE);
}
noPairsInSibling = siblingNode->getNoPairs();
int mergeCheck = 0;
if (node->isLeaf()) {
if (node->getNoPairs() + noPairsInSibling <= maxNoPairs) {
mergeCheck = 1;
}
} else {
if (node->getNoPairs() + noPairsInSibling +
1 <= maxNoPairs) {
mergeCheck = 1;
}
}
if (mergeCheck == 1) {
cout << "merging case" << endl;
/**
* swaping the names of the node , sibling we always make
* sure that we dump(or merge ) the content of
* left node into right node ,but the siblingNodeId is
* same(new treenode which is not in trace)
*/
if (swapCheck == 1) {
TreeNode *temp;
temp = node;
node = siblingNode;
siblingNode = temp;
}
if (node->isLeaf()) {
noPairsInNode = node->getNoPairs();
noPairsInSibling = siblingNode->getNoPairs();
moveBytes(node->getBuffPage() + 2 * SIZE_INT,
siblingNode->getBuffPage() +
2 * SIZE_INT + (noPairsInSibling) * PAIR_SIZE,
noPairsInNode * PAIR_SIZE);
moveBytes(node->getBuffPage() + BLOCK_SIZE - PTR_SIZE,
siblingNode->getBuffPage() + BLOCK_SIZE - PTR_SIZE,
PTR_SIZE);
siblingNode->setNoPairs(noPairsInSibling +
noPairsInNode);
} else {
noPairsInNode = node->getNoPairs();
noPairsInSibling = siblingNode->getNoPairs();
writeInt(siblingNode->getBuffPage(),
2 * SIZE_INT + noPairsInSibling *
PAIR_SIZE + PTR_SIZE,
kDash);
moveBytes(node->getBuffPage() + 2 * SIZE_INT,
siblingNode->getBuffPage() + 2 * SIZE_INT +
(noPairsInSibling + 1) * PAIR_SIZE,
noPairsInNode * PAIR_SIZE + PTR_SIZE);
siblingNode->setNoPairs(noPairsInSibling +
noPairsInNode + 1);
}
if (swapCheck == 1) {
bm->unpinPage(trace[level]->getBuffPage(), true);
bm->unpinPage(siblingNodeId, false);
StorageManager::freeBlock(dbName, siblingNodeId);
delete trace[level];
} else {
bm->unpinPage(trace[level]->getBuffPage(), false);
bm->unpinPage(siblingNodeId, true);
StorageManager::freeBlock(dbName, node_diskBlockId);
delete trace[level];
}
cout << "kDash: " << kDash << endl;
recursiveDeleteEntry(parentNode, kDash,
nodeToBeDeleted, trace, level - 1);
} //redistribution
else {
cout << "redistribution ";
//if N' is predecessor of N
if (swapCheck != 1) {
if (node->isLeaf()) {
cout << " leaf,middle node" << endl;
int lastKeyInSibling = readInt(
siblingNode->getBuffPage(),
2 * SIZE_INT + noPairsInSibling *
PAIR_SIZE - PTR_SIZE);
int lastRidInSibling = readInt(
siblingNode->getBuffPage(),
2 * SIZE_INT + (noPairsInSibling - 1) *
PAIR_SIZE);
moveBytes(node->getBuffPage() + 2 * SIZE_INT,
node->getBuffPage() +
2 * SIZE_INT + PAIR_SIZE,
noPairsInNode * PAIR_SIZE);
siblingNode->setNoPairs(noPairsInSibling - 1);
noPairsInSibling = siblingNode->getNoPairs();
writeInt(node->getBuffPage(), 2 * SIZE_INT,
lastRidInSibling);
writeInt(node->getBuffPage(),
2 * SIZE_INT + PTR_SIZE, lastKeyInSibling);
node->setNoPairs(noPairsInNode + 1);
//node is not the first child of parent node
writeInt(parentNode->getBuffPage(),
2 * SIZE_INT + (keyCount - 1) * PAIR_SIZE +
PTR_SIZE, lastKeyInSibling);
} else {
cout << " non leaf,middle node" << endl;
int lastKeyInSibling = readInt(
siblingNode->getBuffPage(), 2 * SIZE_INT +
noPairsInSibling * PAIR_SIZE - PTR_SIZE);
int lastPtrInSibling = readInt(
siblingNode->getBuffPage(), 2 * SIZE_INT +
noPairsInSibling * PAIR_SIZE);
moveBytes(node->getBuffPage() + 2 * SIZE_INT,
node->getBuffPage() + 2 * SIZE_INT +
PAIR_SIZE, noPairsInNode *
PAIR_SIZE + PTR_SIZE);
siblingNode->setNoPairs(noPairsInSibling - 1);
noPairsInSibling = siblingNode->getNoPairs();
writeInt(node->getBuffPage(), 2 * SIZE_INT,
lastPtrInSibling);
writeInt(node->getBuffPage(), 2 * SIZE_INT +
PTR_SIZE, kDash);
node->setNoPairs(noPairsInNode + 1);
writeInt(parentNode->getBuffPage(), 2 * SIZE_INT +
(keyCount - 1) * PAIR_SIZE + PTR_SIZE,
lastKeyInSibling);
}
} else {
if (node->isLeaf()) {
cout << " leaf,leftmost node" << endl;
int firstRidInSibling = readInt(
siblingNode->getBuffPage(), 2 * SIZE_INT);
int firstKeyInSibling = readInt(
siblingNode->getBuffPage(),
2 * SIZE_INT + PTR_SIZE);
moveBytes(siblingNode->getBuffPage() +
2 * SIZE_INT + PAIR_SIZE,
siblingNode->getBuffPage() + 2 * SIZE_INT,
(noPairsInSibling - 1) * PAIR_SIZE);
siblingNode->setNoPairs(noPairsInSibling - 1);
noPairsInSibling = siblingNode->getNoPairs();
writeInt(node->getBuffPage(), 2 * SIZE_INT +
noPairsInNode*PAIR_SIZE, firstRidInSibling);
writeInt(node->getBuffPage(), 2 * SIZE_INT +
noPairsInNode * PAIR_SIZE + PTR_SIZE,
firstKeyInSibling);
node->setNoPairs(noPairsInNode + 1);
//node is first child of parent node
firstKeyInSibling = readInt(
siblingNode->getBuffPage(),
2 * SIZE_INT + PTR_SIZE);
writeInt(parentNode->getBuffPage(),
2 * SIZE_INT + PTR_SIZE,
firstKeyInSibling);
} else {
cout << " non leaf,leftmost node" << endl;
int firstPtrInSibling = readInt(
siblingNode->getBuffPage(), 2 * SIZE_INT);
int firstKeyInSibling = readInt(
siblingNode->getBuffPage(),
2 * SIZE_INT + PTR_SIZE);
moveBytes(siblingNode->getBuffPage() +
2 * SIZE_INT + PAIR_SIZE,
siblingNode->getBuffPage() + 2 * SIZE_INT,
(noPairsInSibling - 1) * PAIR_SIZE +
PTR_SIZE);
siblingNode->setNoPairs(noPairsInSibling - 1);
noPairsInSibling = siblingNode->getNoPairs();
writeInt(node->getBuffPage(), 2 * SIZE_INT +
noPairsInNode * PAIR_SIZE +
PTR_SIZE, kDash);
writeInt(node->getBuffPage(), 2 * SIZE_INT +
(noPairsInNode + 1) * PAIR_SIZE,
firstPtrInSibling);
node->setNoPairs(noPairsInNode + 1);
writeInt(parentNode->getBuffPage(),
2 * SIZE_INT + PTR_SIZE,
firstKeyInSibling);
}
}
bm->unpinPage(trace[level]->getBuffPage(), true);
bm->unpinPage(siblingNodeId, true);
delete trace[level];
for (int i = level - 1; i >= 1; i--) {
bm->unpinPage(trace[i]->getBuffPage(), false);
delete trace[i];
}
}
}
cout << key << "key deleted at level " << level << endl << endl;
}
void BPlusTree::insertEntry(int key, int rid) {
BufferManager *bm = BufferManager::getInstance(dbName);
int height;
TreeNode **trace = new TreeNode *[10];
for (int i = 0; i < 10; i++)
trace[i] = NULL;
TreeNode *leafNode = getLeaf(key, trace, &height);
//cout<<endl<<"height of the tree: "<<height<<endl;
if (leafNode == NULL)
cout << "exception null node" << endl;
cout << "lookup " << lookUpWithoutUnpin(key, leafNode) << endl;
if (lookUpWithoutUnpin(key, leafNode) != -1) {
cout << "key already exists" << endl;
for (int i = height; i >= 1; i--) {
//cout<<"unpinning trace:"<<endl;
bm->unpinPage(trace[i]->getBuffPage(), false);
delete trace[i];
}
}
else {
int nofPairs = readInt(leafNode->getBuffPage(), 0);
//if num of pairs less than n-1
if (nofPairs < maxNoPairs) {
insertInLeaf(leafNode, key, rid);
if (height != 0) {
bm->unpinPage(leafNode->getBuffPage(), true);
//cout<<"unpinning the leaf node which is not a root"<<endl;
}
//delete leafNode;
for (int i = height - 1; i >= 1; i--) {
//cout<<"unpinning trace:"<<endl;
bm->unpinPage(trace[i]->getBuffPage(), false);
delete trace[i];
}
} else {
int newLeafId = StorageManager::allocateBlock(dbName);
char* newLeafNodeBuff = bm->pinPage(newLeafId);
TreeNode *newLeafNode = new TreeNode(newLeafNodeBuff);
int divideKeyOffset = maxNoPairs / 2;
//cout<<"divideKeyOffset: "<<divideKeyOffset<<endl;
int divideKey = readInt(leafNode->getBuffPage(),
2 * SIZE_INT + divideKeyOffset * PAIR_SIZE + PTR_SIZE);
cout << "divideKey: " << divideKey << endl;
if (key < divideKey) {
moveBytes(leafNode->getBuffPage() +
2 * SIZE_INT + divideKeyOffset*PAIR_SIZE,
newLeafNode->getBuffPage() + 2 * SIZE_INT,
(maxNoPairs - divideKeyOffset) * PAIR_SIZE);
//writing "nofPairs" into new leaf
//writeInt(newLeafNode->getBuffPage(),0,(maxNoPairs+1)/2);
newLeafNode->setNoPairs((maxNoPairs + 1) / 2);
//writing "isLeaf" into new leaf
//writeInt(newLeafNode->getBuffPage(),SIZE_INT,1);
newLeafNode->setIsLeaf(1);
//copying P(n) of leaf to P(n) of new leaf
moveBytes(leafNode->getBuffPage() +
BLOCK_SIZE - PTR_SIZE,
newLeafNode->getBuffPage() +
BLOCK_SIZE - PTR_SIZE, PTR_SIZE);
//make p(n) of leaf to point to new leaf
writeInt(leafNode->getBuffPage(),
BLOCK_SIZE - PTR_SIZE, newLeafId);
leafNode->setNoPairs(maxNoPairs / 2);
insertInLeaf(leafNode, key, rid);
bm->unpinPage(newLeafId, true);
insertInParent(leafNode, divideKey,
newLeafId, trace, height);
} else {
moveBytes(leafNode->getBuffPage() +
2 * SIZE_INT + (divideKeyOffset + 1) * PAIR_SIZE,
newLeafNode->getBuffPage() + 2 * SIZE_INT,
(maxNoPairs - divideKeyOffset - 1) * PAIR_SIZE);
//writing "nofPairs" into new leaf
//writeInt(newLeafNode->getBuffPage(),0,maxNoPairs-divideKeyOffset-1);
newLeafNode->setNoPairs(maxNoPairs - divideKeyOffset - 1);
//writing "isLeaf" into new leaf
//writeInt(newLeafNode->getBuffPage(),SIZE_INT,1);
newLeafNode->setIsLeaf(1);
//copying P(n) of leaf to P(n) of new leaf
moveBytes(leafNode->getBuffPage() +
BLOCK_SIZE - PTR_SIZE, newLeafNode->getBuffPage() +
BLOCK_SIZE - PTR_SIZE, PTR_SIZE);
//make p(n) of leaf to point to new leaf
writeInt(leafNode->getBuffPage(),
BLOCK_SIZE - PTR_SIZE, newLeafId);
//writing "nofPairs" into leaf
leafNode->setNoPairs(divideKeyOffset + 1);
insertInLeaf(newLeafNode, key, rid);
int startKey = readInt(newLeafNode->getBuffPage(),
2 * SIZE_INT + PTR_SIZE);
bm->unpinPage(newLeafId, true);
//cout<<"task completed and unpinnednew leaf id"<<endl;
insertInParent(leafNode, startKey,
newLeafId, trace, height);
}
}
//bm->unpinPage(leafId,true);
cout << endl << key << " inserted" << endl << endl;
}
//free (trace);
//cout<<"no of pairs in root: "<<readInt(root->getBuffPage(), 0)<<endl;
}
void BPlusTree::insertInParent(TreeNode *node,
int startKeyInSplitNode,
int splitNodeId,
TreeNode** trace, int level) {
BufferManager *bm = BufferManager::getInstance(dbName);
//cout<<endl<<"level: "<<level<<"startKeyInSplitNode: "<<startKeyInSplitNode<<endl;
if (level == 0) {
//cout<<"parent is root"<<endl;
int newId = StorageManager::allocateBlock(dbName);
char* newNodeBuff = bm->pinPage(newId);
TreeNode *newNode = new TreeNode(newNodeBuff);
//copying the content of old root to new node
moveBytes(root->getBuffPage(), newNode->getBuffPage(),
BLOCK_SIZE);
root->setNoPairs(1);
root->setIsLeaf(0);
writeInt(root->getBuffPage(), 2 * SIZE_INT, newId);
writeInt(root->getBuffPage(),
2 * SIZE_INT + PTR_SIZE, startKeyInSplitNode);
writeInt(root->getBuffPage(),
2 * SIZE_INT + PAIR_SIZE, splitNodeId);
bm->unpinPage(newId, true);
delete newNode;
cout << "parent is root: done" << endl;
} else {
//cout<<"else case entered"<<endl;
TreeNode *parentNode = trace[level - 1];
int noPairs = parentNode->getNoPairs();
cout << "no of pairs" << noPairs << endl;
if (noPairs < maxNoPairs) {
//int childId = getDiskBlockId( node->getBuffPage() );
int firstKeyInNode = readInt(node->getBuffPage(),
2 * SIZE_INT + PTR_SIZE);
int keyCount;
int ithKey = readInt(parentNode->getBuffPage(),
2 * SIZE_INT + PTR_SIZE);
for (keyCount = 0; keyCount < noPairs &&
firstKeyInNode >= ithKey; keyCount++) {
ithKey = readInt(parentNode->getBuffPage(),
2 * SIZE_INT + (keyCount + 1) * PAIR_SIZE + PTR_SIZE);
}
cout << " keycount: " << keyCount << " stop Key " << ithKey << endl;
if (keyCount < noPairs) {
moveBytes(parentNode->getBuffPage() + 2 * SIZE_INT +
keyCount * PAIR_SIZE + PTR_SIZE,
parentNode->getBuffPage() + 2 * SIZE_INT +
(keyCount + 1) * PAIR_SIZE + PTR_SIZE,
(noPairs - keyCount) * PAIR_SIZE);
//writes split key
writeInt(parentNode->getBuffPage(),
2 * SIZE_INT + keyCount * PAIR_SIZE +
PTR_SIZE, startKeyInSplitNode);
//writes split node id just after split key
writeInt(parentNode->getBuffPage(),
2 * SIZE_INT + (keyCount + 1) * PAIR_SIZE, splitNodeId);
} else {
//writes split key to k of nth pair(new apir)
writeInt(parentNode->getBuffPage(),
2 * SIZE_INT + noPairs * PAIR_SIZE + PTR_SIZE,
startKeyInSplitNode);
//writes splitNodeId to p(n)( at the end)
writeInt(parentNode->getBuffPage(),
2 * SIZE_INT + (noPairs + 1) * PAIR_SIZE, splitNodeId);
}
parentNode->setNoPairs(noPairs + 1);
bm->unpinPage(trace[level]->getBuffPage(), true);
delete trace[level];
for (int i = level - 1; i >= 1; i--) {
bm->unpinPage(trace[i]->getBuffPage(), false);
delete trace[i];
}
} else {
cout << "parent splitting" << endl;
int newNodeId = StorageManager::allocateBlock(dbName);
char* newNodeBuff = bm->pinPage(newNodeId);
TreeNode *newNode = new TreeNode(newNodeBuff);
char temp[BLOCK_SIZE + 1];
moveBytes(parentNode->getBuffPage() + 2 * SIZE_INT,
temp, BLOCK_SIZE - 2 * SIZE_INT);
int keyCount;
int ithKey = readInt(temp, PTR_SIZE);
for (keyCount = 0; keyCount < maxNoPairs &&
startKeyInSplitNode > ithKey; keyCount++) {
ithKey = readInt(temp,
(keyCount + 1) * PAIR_SIZE + PTR_SIZE);
}
if (keyCount < maxNoPairs) {
moveBytes(temp + keyCount * PAIR_SIZE + PTR_SIZE,
temp + (keyCount + 1) * PAIR_SIZE + PTR_SIZE,
(maxNoPairs - keyCount) * PAIR_SIZE);
writeInt(temp, keyCount * PAIR_SIZE + PTR_SIZE,
startKeyInSplitNode);
writeInt(temp, (keyCount + 1) * PAIR_SIZE, splitNodeId);
} else {
writeInt(temp, maxNoPairs * PAIR_SIZE + PTR_SIZE,
startKeyInSplitNode);
writeInt(temp, (maxNoPairs + 1) * PAIR_SIZE, splitNodeId);
}
moveBytes(temp, parentNode->getBuffPage() + 2 * SIZE_INT,
(maxNoPairs / 2) * PAIR_SIZE + PTR_SIZE);
int splitKey = readInt(temp,
(maxNoPairs / 2) * PAIR_SIZE + PTR_SIZE);
moveBytes(temp + (maxNoPairs / 2 + 1) * PAIR_SIZE,
newNode->getBuffPage() + 2 * SIZE_INT,
((maxNoPairs + 1) / 2) * PAIR_SIZE + PTR_SIZE);
parentNode->setNoPairs(maxNoPairs / 2);
newNode->setNoPairs((maxNoPairs + 1) / 2);
newNode->setIsLeaf(0);
bm->unpinPage(newNodeId, true);
delete newNode;
insertInParent(parentNode, splitKey,
newNodeId, trace, level - 1);
bm->unpinPage(trace[level]->getBuffPage(), true);
delete trace[level];
}
}
cout << "done" << endl;
}
void BPlusTree::deleteFromNode(TreeNode* N, int key) {
BufferManager *bm = BufferManager::getInstance();
//finding the location of pair to be deleted
int i;
for(i=1;i<=N->getTotalPairs();i++) {
if(N->getKey(i)==key) break;
}
//deleting the pair
moveBytes( N->getBuffPage(), 8*i, 8+8*i, (N->getTotalPairs()-i+1)*8+4 );
N->updateSlot(1, N->getTotalPairs()-1);
//if N is root AND has only one child
if(N->getSlot(BLOCK_SIZE/4)==-1 && N->getSlot(1)==1) {
//delete that node and make its only child as root
int newRootId = N->getSlot(3);
root = new TreeNode(bm->pinPage(dbName, N->getSlot(3)));
int blockToFree = N->getSlot(BLOCK_SIZE/4-1);
bm->unpinPage(dbName, blockToFree, true);
StorageManager::freeBlock(dbName, blockToFree);
root->updateSlot(BLOCK_SIZE/4, -1);
}
else {
int parentPtr = readInt(N->getBuffPage(), BLOCK_SIZE-4);
TreeNode* parent = new TreeNode(bm->pinPage(dbName, parentPtr));
int loc=parent->findPtr(N->getNodeId());
bool correct;
int NDashId,keyDash;
//finding next or previous node and the value between them
if(loc>1) {
correct=true;
NDashId = loc-1;
keyDash = parent->getKey(loc-1);
} else {
correct=false;
NDashId = loc+1;
keyDash = parent->getKey(loc);
}
TreeNode* NDash = new TreeNode(bm->pinPage(dbName, NDashId));
//if N and NDash can coalesce in one node
if(N->getTotalPairs()+NDash->getTotalPairs()-1 == BT_N) {
//swapping if successive nodes r in reverse order
if(correct==false) {
TreeNode* temp;
temp = N;
N = NDash;
NDash = temp;
}
//coalescing nodes
if(!N->isLeaf()) {
int num = NDash->getTotalPairs();
NDash->updateSlot(2*NDash->getTotalPairs()+2, keyDash);
for(int i=0;i<(N->getTotalPairs()*2);i++) {
NDash->updateSlot(2*NDash->getTotalPairs()+2+i, N->getSlot(i+2));
NDash->updateSlot(1,NDash->getTotalPairs()+num);
}
}
else {
int num = NDash->getTotalPairs();
NDash->updateSlot(2*NDash->getTotalPairs()+2, keyDash);
for(int i=0;i<(N->getTotalPairs()*2);i++)
NDash->updateSlot(2*NDash->getTotalPairs()+2+i, N->getSlot(i+2));
NDash->updateSlot(1,NDash->getTotalPairs()+num);
NDash->updateSlot(2+2*BT_N+1,N->getSlot(2+2*BT_N+1));
}
deleteFromNode(parent, keyDash);
}
//if NDash is predecessor
if(correct==true){
if(!N->isLeaf()) {
//removing last key and pointer to next leaf
int lastKey = NDash->getSlot(2+NDash->getTotalPairs()*2);
int lastPtr = NDash->getSlot(2+NDash->getTotalPairs()*2+1);
NDash->updateSlot(1,NDash->getTotalPairs()+1);
//adding one pair to N
moveBytes(N->getBuffPage(), 16, 8, N->getTotalPairs()*8+4);
N->updateSlot(1, N->getTotalPairs()+1);
N->updateSlot(3, lastPtr);
N->updateSlot(4, keyDash);
//replacing keyDash in parent by the removed key
int location = parent->findKey(keyDash);
parent->updateSlot(2+2*location, lastKey);
} else {
//removing last key and pointer to next leaf
int lastKey = NDash->getSlot(2+NDash->getTotalPairs()*2);
int lastPtr = NDash->getSlot(2+NDash->getTotalPairs()*2-1);
NDash->updateSlot(1,NDash->getTotalPairs()+1);
//adding one pair to N
moveBytes(N->getBuffPage(), 16, 8, N->getTotalPairs()*8);
N->updateSlot(1, N->getTotalPairs()+1);
N->updateSlot(3, lastPtr);
N->updateSlot(4, keyDash);
//replacing keyDash in parent by the removed key
int location = parent->findKey(keyDash);
parent->updateSlot(2+2*location, lastKey);
}
} else {
if(!NDash->isLeaf()) {
//removing last key and pointer to next leaf
int lastKey = N->getSlot(2+N->getTotalPairs()*2);
int lastPtr = N->getSlot(2+N->getTotalPairs()*2+1);
N->updateSlot(1,N->getTotalPairs()+1);
//adding one pair to NDash
moveBytes(NDash->getBuffPage(), 16, 8, NDash->getTotalPairs()*8+4);
NDash->updateSlot(1, NDash->getTotalPairs()+1);
NDash->updateSlot(3, lastPtr);
NDash->updateSlot(4, keyDash);
//replacing keyDash in parent by the removed key
int location = parent->findKey(keyDash);
parent->updateSlot(2+2*location, lastKey);
} else {
//removing last key and pointer to next leaf
int lastKey = N->getSlot(2+N->getTotalPairs()*2);
int lastPtr = N->getSlot(2+N->getTotalPairs()*2-1);
N->updateSlot(1,N->getTotalPairs()+1);
//adding one pair to NDash
moveBytes(NDash->getBuffPage(), 16, 8, NDash->getTotalPairs()*8);
NDash->updateSlot(1, NDash->getTotalPairs()+1);
NDash->updateSlot(3, lastPtr);
NDash->updateSlot(4, keyDash);
//replacing keyDash in parent by the removed key
int location = parent->findKey(keyDash);
parent->updateSlot(2+2*location, lastKey);
}
}
}
}
void BPlusTree::insertEntry(int key, int rid) {
cout<<"a\n";
BufferManager *bm = BufferManager::getInstance();
TreeNode* c = root;
cout<<"b\n";
while( c->isLeaf() ) {
cout<<"a1\n";
int sKey = -1;
int finalKey = -1;
for(int i=0; i<(c->getTotalPairs()); i++){
cout<<"a2\n";
sKey=c->getKey(i);
if(sKey>key){
finalKey=i;
break;
}
}
if(finalKey==-1) {
int m=c->getTotalPairs();
c = new TreeNode(bm->pinPage(dbName, c->getRid(m)));
cout<<"a3\n";
}
else
cout<<"aelse\n";
c = new TreeNode(bm->pinPage(dbName, c->getRid(finalKey)));
}
cout<<"a\n";
/* int keyExists = -1;
int position;
for(int i=0; i<(c->getTotalPairs()); i++){
if(key == c->getKey(i)){
keyExists = key;
position=i;
}
}
*/
if(c->getTotalPairs() < BT_N){
cout<<"inif 1\n";
insert_in_leaf(c, key, rid);
cout<<"inserted in leaf\n";
}
else {
cout<<"inelse 1\n";
int temp;
int* tempPtr = &temp;
//creating new node
int newNodeId = StorageManager::allocateBlock(dbName);
int* newNodeIdPtr = &newNodeId;
TreeNode * newNode = new TreeNode(bm->pinPage(dbName, newNodeId));
writeInt(newNode->getBuffPage(), BLOCK_SIZE-4, readInt(c->getBuffPage(), BLOCK_SIZE-4));
writeInt(newNode->getBuffPage(), BLOCK_SIZE-8, newNodeId);
//creating temp node & copying data to temp node
char *tempForTempNode = (char *)calloc(BLOCK_SIZE,sizeof(char));
memcpy(tempForTempNode, c->getBuffPage(), 8+8*BT_N);
TreeNode * tempNode = new TreeNode(tempForTempNode);
insert_in_leaf(newNode, key, rid);
//add new node newNode in the linked list
memcpy( (newNode->getBuffPage())+(8+BT_N*8), (c->getBuffPage())+(8+BT_N*8), 4);
memcpy( (c->getBuffPage())+(8+BT_N*8), newNodeIdPtr, 4);
//no erasing, but overwriting
//write first half of tempNode into original one
temp = ceil((float)(BT_N/2));
memcpy( (c->getBuffPage())+8, tempNode->getBuffPage()+8, 8*temp);
memcpy( c->getBuffPage(), tempPtr, 4);
//copy second half into newNode
memcpy( (newNode->getBuffPage())+8, (tempNode->getBuffPage())+(8+8*temp), 8*(BT_N - temp));
temp = BT_N - temp;
memcpy( newNode->getBuffPage(), tempPtr, 4);
temp = 1;
memcpy( (newNode->getBuffPage())+4, tempPtr, 4);
//taking smallest key of new node to update(insert) in parent
int smallestKey = newNode->getRid(1);
insert_in_parent(c, smallestKey, newNode);
}
}
void BPlusTree::insert_in_parent( TreeNode* N, int key, TreeNode* NDash) {
BufferManager *bm = BufferManager::getInstance();
if(N->isRoot()) {
//creating new node
int newNodeId = StorageManager::allocateBlock(dbName);
int* newNodeIdPtr = &newNodeId;
TreeNode * R = new TreeNode(bm->pinPage(dbName, newNodeId));
writeInt( R->getBuffPage(), 0, 1 );
writeInt( R->getBuffPage(), 4, 2 );
writeInt( R->getBuffPage(), 8, N->getNodeId() );
writeInt( R->getBuffPage(), 12, key );
writeInt( R->getBuffPage(), 16, NDash->getNodeId() );
writeInt( R->getBuffPage(), BLOCK_SIZE-4, -1 );
writeInt( R->getBuffPage(), BLOCK_SIZE-8, newNodeId );
writeInt( N->getBuffPage(), BLOCK_SIZE-4, R->getNodeId() );
}
TreeNode* P = new TreeNode(bm->pinPage(dbName, N->getParent()));
if(P->getTotalPairs() < BT_N) {
//finding the location of pointer to N in the parent
int i;
for(i=1;i<=P->getTotalPairs();i++) {
if(P->getKey(i)==N->getNodeId()) break;
}
//inserting the pair in parent p just after N
writeInt( P->getBuffPage(), 0, P->getTotalPairs()+1 );
moveBytes(P->getBuffPage(), 8*P->getTotalPairs()-(8+8*i)+4, 8+8*i, 8);//****
writeInt( P->getBuffPage(), 8+8*i, NDash->getNodeId() );//****
writeInt( P->getBuffPage(), 12+8*i, key );//****
} else {
//allocating temporary memory T
char * T = (char *)calloc(BLOCK_SIZE+8,sizeof(char));
memcpy(T, P->getBuffPage(), 12+8*BT_N);
//finding the location of pointer to N in the parent
int i;
for(i=1; i <= ((TreeNode*)T)->getTotalPairs(); i++) {
if(P->getKey(i)==N->getNodeId()) break;
}
//inserting the pair in temp memory
moveBytes(T, 8+8*i+8, 8+8*i,(P->getTotalPairs()-i)*8);
writeInt(T, 8+8*i, NDash->getNodeId());
writeInt(T, 12+8*i, key);
//temp
int temp = ceil(BT_N/2);
int* tempPtr = &temp;
//keep only first half of T in P
memcpy(P->getBuffPage(), T, 8+8*temp);
writeInt(P->getBuffPage(), 4,temp);
int newKey = P->getKey(temp);
//new node
int PDashId = StorageManager::allocateBlock(dbName);
int* PDashIdPtr = &PDashId;
TreeNode * PDash = new TreeNode(bm->pinPage(dbName, PDashId));
writeInt(PDash->getBuffPage(), BLOCK_SIZE-4, readInt(P->getBuffPage(), BLOCK_SIZE-4));
writeInt(PDash->getBuffPage(), BLOCK_SIZE-8, PDashId);
//copying to new node
memcpy(PDash->getBuffPage(), T+8+8*temp, 8*BT_N-8*temp+4);
writeInt(PDash->getBuffPage(), 4, BT_N-temp);
insert_in_parent(P,newKey,PDash);
}
}
