Stage 12

BPlusSearch

BPlusTree::bPlusSearch(int relId, attrName, attrVal, op) {
    AttrCacheTable::getSearchIndex(relId, attrName, &searchIndex);
    int block = -1, slot = -1;
    if(index == {-1,-1}) {
        block = relCatEntry.firstBlk;
        slot = 0;
        if(block == -1) {
            return RecId{-1,-1};
        }
    } else {
        slot = index + 1;
        if(index >= leafHead.numEntries) {
            block = leafHead.rblock;
            index = 0;
            if(block == -1) {
                return RecId{-1,-1};
            }
        }
    }
    while(StaticBuffer::getStaticBlockType(block) == IND_INTERNAL) {
        if(op == NE || op == LT || op == LE) {
            block = intEntry.lChild;
        } else {
            int entryIndex = 0;
            while(entryIndex < numEntries) {
                int cmpVal = compareAttrs(intEntry.attrVal, attrVal, attrCatEntry.attrType);
                    if(op == EQ || op == GE || op == GT) {
                        break;
                    }
                    entryIndex++;
            }
            if(entryIndex == numEntries) {
                block = intEntry.lChild;
            } else {
                block = intEntry.rChild;
            }
        }
    }
    while(block != -1) {
        IndLeaf leafBlk(block);
        HeadInfo leafHead;
        leafBlk.getHeader(&leafHeader);

        while(index < leafHead.numEntries) {
            int cmpVal;
            if(matching) {
                searchIndex.block = block;
                searchIndex.slot = index;
                AttrCacheTable::setSearchIndex(relId, attrName, &searchIndex);
                return RecId{leafEntry.block, leafEntry.slot};
            } else if(cmpVal > 0) 
        }
        if(op != NE) break;
        block = leafHead.rblock;
        slot = 0;
    };
    return RecId{-1,-1};
}

int BPlusTree::createNewRoot(int relId, char attrName, attrVal, int lChild, int rChild) {
    // initialize new root
    /*
        set lchild and rchild
        set pblock
        set the rootblock in the attrcache
    */
    IndInteranal newRootBlock;
    int newRootBlockNum = newRootBlock.getBlockNum();

    blockHeader;
    blockHeader.numEntries = 1;
    setHeader(&blockHeader); 

    InternalEntry internalEntry;
    internalEntry.lChild = lChild;
    internalEntry.rChild = rChild;
    internalEntry.attrVal = attrVal;

    leftChildBlock.pblock = newRootBlockNum;
    rightchildBlock.pblock = newRootBlockNum;

    setHeader;
}

splitLeaf(int leafBlockNum, Index indices[]) {
    IndLeaf rightBlock;
    IndLeaf leafBlock(leaftBlockNum);

    rightBlockNum.numEntries = 32;
    rightBlockNum.pblock = leftBlockNum.pblock;
    rightBlockNum.rblock = leftBlockNum.right;
    rightBlockNum.lblock = leftBlockNum;

    leftBlockHeader.numEntries = 32;
    leftBlockHeader.rblock = rightBlockNum;

    // set the values from the indices
}

insertIntoLeaf(int relId, char attrName, int leafBlockNum, Index indexEntry) {
    IndLeaf leafBlock(leafBlockNum);
    leafBlock.getHeader(&blockHeader);

    Index indices[blockHeader.numEntries + 1]; 
    // insert into indices
    if(blockHeader.numEntries < MAX_KEYS_LEAF) {
        blockHeader.numEntries++;
        for(int i = 0; i < numEntries; i++) {
            leafBlock.setEntry(&indices[i], i);
        }
    }

    int rightBlock = splitLeaf(leafBlock, indices);

    if(blockHeader.pblock != -1) {
        InternalEntry middleVal;
        return insertIntoInternal(relId, attrName, blockHeader.pblock, middleEntry);
    } else {
        createNewRoot(relId, attrName, indices[MIDDLE])
    }
}

In bPlusInsert, if E_DISKFULL, rootblock is set to -1
splitInternal has reassigning of parents from MIDDLE_INDEX_INTENAL+1.lchild to the rightblock