opensci
/
gStore
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

update the length(to 1024) of char arrays which store the BTree file path. 

author: hanshuo
This commit is contained in:
Caesar11 2015-09-08 05:02:08 +00:00
parent c8efa0ee8b
commit 22668470e1
2 changed files with 247 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

342
KVstore/CBtreeFunc.cpp
View File

@ -15,7 +15,7 @@ string filePath_sID2s;
string filePath_o2sID;
string filePath_opID2sID;
FILE * _log_btree;
// 在中间结点中插入键
// 在中间结点中插入键
bool mItnlNode::Insert( mNode * pNode)
{
if(getCount() >= MAXNUM_KEY)
@ -32,7 +32,7 @@ bool mItnlNode::Insert( mNode * pNode)
printf("err in insert itnl\n");
system("pause"); exit(0);
}
// 在要插入的点是在最右端时要特殊处理, solved
// 在要插入的点是在最右端时要特殊处理, solved
for(int i = getCount() + 1; i > _ikey; i --)
{
this ->setElement(i, this ->getElement(i - 1) );
@ -50,13 +50,13 @@ bool mItnlNode::Insert( mNode * pNode)
return true;
}
// 在中间结点中删除键，以及该键后的指针
// 在中间结点中删除键，以及该键后的指针
int mItnlNode::Delete(const KeyType & _keytype)
{
int _index = -1;
int _ibegin = 1, _iend = getCount();
int _imiddle;
// 二分查找index
// 二分查找index
while(_ibegin < _iend)
{
_imiddle = (_ibegin + _iend) / 2;
@ -81,9 +81,9 @@ int mItnlNode::Delete(const KeyType & _keytype)
}
}
//任何一个不是根节点或不是叶子节点的节点必须保证包含至少两个元素
// 对于insert， index = 1 的时候一定是整棵树的最右边！！！
// delete则不同
//任何一个不是根节点或不是叶子节点的节点必须保证包含至少两个元素
// 对于insert， index = 1 的时候一定是整棵树的最右边！！！
// delete则不同
if(_index == 1 && this ->getFather() != NULL)
{
mItnlNode * itnl_father = (mItnlNode *)(this ->getFather() );
@ -91,7 +91,7 @@ int mItnlNode::Delete(const KeyType & _keytype)
KeyType & i_data = this ->getKey(2);
while(itnl_father != NULL)
{
// 此处同insert不同，审慎其不同之处
// 此处同insert不同，审慎其不同之处
int tmp_key = itnl_father ->iExist(f_data);
if(tmp_key < 1)
{
@ -142,7 +142,7 @@ KeyType & mItnlNode::Split(mItnlNode* pNode)
return (pNode ->getElement(1)).mKey;
}
// 结合结点，把指定中间结点的数据全部剪切到本中间结点
// 结合结点，把指定中间结点的数据全部剪切到本中间结点
bool mItnlNode::Combine(mItnlNode * pNode)
{
if(this ->getCount() + pNode ->getCount() > MAXNUM_KEY)
@ -156,7 +156,7 @@ bool mItnlNode::Combine(mItnlNode * pNode)
return true;
}
// 从另一结点移一个元素到本结点
// 从另一结点移一个元素到本结点
bool mItnlNode::MoveOneElement(mNode* pNode)
{
@ -164,9 +164,9 @@ bool mItnlNode::MoveOneElement(mNode* pNode)
return false;
}
// 清除叶子结点中的数据
// 清除叶子结点中的数据
// 在叶子结点中插入数据
// 在叶子结点中插入数据
bool mLeafNode::Insert(const mleafdata & _leafdata)
{
const KeyType & data = _leafdata.mData;
@ -179,9 +179,9 @@ bool mLeafNode::Insert(const mleafdata & _leafdata)
printf("err count too large\n");
return false;
}
// 返回i， data 介于i - 1 与 i 之间, 要放在i 上
// 返回i， data 介于i - 1 与 i 之间, 要放在i 上
int _i_insert = this ->iInsert(data);
// 还要考虑仅根节点是叶子节点的情况， 需要再加个条件
// 还要考虑仅根节点是叶子节点的情况， 需要再加个条件
if(_i_insert == 1 && this ->getFather() != NULL)
{
mItnlNode * _pFather = (mItnlNode *)(this ->getFather());
@ -196,7 +196,7 @@ bool mLeafNode::Insert(const mleafdata & _leafdata)
system("pause");
exit(0);
}
//同步使得内存位等其它位失效， 策略失策， 弥补之。。
//同步使得内存位等其它位失效， 策略失策， 弥补之。。
_pFather ->setKey(_ikey, _leafdata.mData);
_pFather ->setMemory(_ikey);
_pFather ->setModify();
@ -216,10 +216,10 @@ bool mLeafNode::Insert(const mleafdata & _leafdata)
}
/*
* 删除成功返回删除的key的下标， 失败则返回-1
* 设置修改位
* 若是最左端的元素则向上修改对应需要修改的父节点， 此处与insert不同
* insert若出现最左端必然是整棵树的最左端
* 删除成功返回删除的key的下标， 失败则返回-1
* 设置修改位
* 若是最左端的元素则向上修改对应需要修改的父节点， 此处与insert不同
* insert若出现最左端必然是整棵树的最左端
*/
int mLeafNode::Delete(KeyType & _keytype)
{
@ -249,9 +249,9 @@ int mLeafNode::Delete(KeyType & _keytype)
_ibegin = _imiddle;
}
}
//任何一个不是根节点或不是叶子节点的节点必须保证包含至少两个元素
// 对于insert， index = 1 的时候一定是整棵树的最右边！！！
// delete则不同
//任何一个不是根节点或不是叶子节点的节点必须保证包含至少两个元素
// 对于insert， index = 1 的时候一定是整棵树的最右边！！！
// delete则不同
if(_index == 1 && this ->getFather() != NULL)
{
mItnlNode * itnl_father = (mItnlNode *)(this ->getFather() );
@ -259,7 +259,7 @@ int mLeafNode::Delete(KeyType & _keytype)
KeyType & i_data = this ->getKey(2);
while(itnl_father != NULL)
{
// 此处同insert不同，审慎其不同之处
// 此处同insert不同，审慎其不同之处
int tmp_key = itnl_father ->iExist(f_data);
if(tmp_key < 1)
{
@ -292,7 +292,7 @@ int mLeafNode::Delete(KeyType & _keytype)
}
return -1;
}
//重载delete of leaf
//重载delete of leaf
int mLeafNode::Delete(KeyType & _keytype, char partval[], int & pvFlag)
{
int _index = -1;
@ -334,12 +334,12 @@ int mLeafNode::Delete(KeyType & _keytype, char partval[], int & pvFlag)
if(pvFlag == FLAG_NO_ZERO)
return _index;
//如果删除成功并且元素变为空， 则继续删除对应的key
//如果删除成功并且元素变为空， 则继续删除对应的key
//任何一个不是根节点或不是叶子节点的节点必须保证包含至少两个元素
// 对于insert， index = 1 的时候一定是整棵树的最右边！！！
// delete则不同
//任何一个不是根节点或不是叶子节点的节点必须保证包含至少两个元素
// 对于insert， index = 1 的时候一定是整棵树的最右边！！！
// delete则不同
if(_index == 1 && this ->getFather() != NULL)
{
mItnlNode * itnl_father = (mItnlNode *)(this ->getFather() );
@ -347,7 +347,7 @@ int mLeafNode::Delete(KeyType & _keytype, char partval[], int & pvFlag)
KeyType & i_data = this ->getKey(2);
while(itnl_father != NULL)
{
// 此处同insert不同，审慎其不同之处
// 此处同insert不同，审慎其不同之处
int tmp_key = itnl_father ->iExist(f_data);
if(tmp_key < 1)
{
@ -379,7 +379,7 @@ int mLeafNode::Delete(KeyType & _keytype, char partval[], int & pvFlag)
// 分裂叶子结点，把本叶子结点的后一半数据剪切到指定的叶子结点中
// 分裂叶子结点，把本叶子结点的后一半数据剪切到指定的叶子结点中
KeyType & mLeafNode::Split(mLeafNode * pNode)
{
for(int i = ORDER_V + 1; i <= MAXNUM_KEY; i ++)
@ -393,7 +393,7 @@ KeyType & mLeafNode::Split(mLeafNode * pNode)
return (pNode ->getElement(1)).mData;
}
// 结合结点，把指定叶子结点的数据全部剪切到本叶子结点
// 结合结点，把指定叶子结点的数据全部剪切到本叶子结点
bool mLeafNode::Combine(mLeafNode * pNode)
{
int this_count = this ->getCount();
@ -405,7 +405,7 @@ bool mLeafNode::Combine(mLeafNode * pNode)
}
return false;
}
// 查找对应的叶子结点
// 查找对应的叶子结点
mLeafNode* BPlusTree::SearchLeafNode(const KeyType & data)const
{
mNode * pNode = mRoot;
@ -415,15 +415,15 @@ mLeafNode* BPlusTree::SearchLeafNode(const KeyType & data)const
}
else// no check
{
/*
* while 循环
* 当前还是中间节点
* 找到下层入口下标
* 判断是否超出左边界， 是的话直接到底， pNode 指向叶子节点， break
* 总之， 最后肯定是pNode指向叶子节点
* 所以， 插入时还要判断是否超过左边界， 是的话要修改上层父节点的左边界
* Search 的时候都要注意边界的率先判断, 还有当前叶节点可能是根节点
*/
/*
* while 循环
* 当前还是中间节点
* 找到下层入口下标
* 判断是否超出左边界， 是的话直接到底， pNode 指向叶子节点， break
* 总之， 最后肯定是pNode指向叶子节点
* 所以， 插入时还要判断是否超过左边界， 是的话要修改上层父节点的左边界
* Search 的时候都要注意边界的率先判断, 还有当前叶节点可能是根节点
*/
// int _floor = 1;
while(pNode ->getType() == NODE_TYPE_INTERNAL)
{
@ -461,8 +461,8 @@ mLeafNode* BPlusTree::SearchLeafNode(const KeyType & data)const
}
return NULL;
}
// 在树中查找数据
bool BPlusTree::Search(KeyType & data, mleafdata & _ret)//增加一参数， 用于接收查找过程中进入的叶子节点
// 在树中查找数据
bool BPlusTree::Search(KeyType & data, mleafdata & _ret)//增加一参数， 用于接收查找过程中进入的叶子节点
{
mLeafNode * _pLeaf = SearchLeafNode(data);
int _ikey = _pLeaf ->iExist(data);
@ -521,7 +521,7 @@ bool BPlusTree::Insert(const mleafdata & _leafdata)
long long int _addr_newleaf = mblockQueue.Pop();
_pNewLeaf ->setAddrFB(_addr_newleaf);
// _key_tmp 也就将是_pnewleaf的第一个元素的key
// _key_tmp 也就将是_pnewleaf的第一个元素的key
// set modified in split;
if(! _pOldLeaf ->getModify())
{
@ -535,8 +535,8 @@ bool BPlusTree::Insert(const mleafdata & _leafdata)
if(_pFather == NULL)
{
// _pOldLeaf以前是根节点，要把offset = 0 让出来
// 还存在占用外存链的情况下则需要释放外存链
// _pOldLeaf以前是根节点，要把offset = 0 让出来
// 还存在占用外存链的情况下则需要释放外存链
// if(!preModified)
// {
// DelDisk(mfp, 0l, mblockQueue);
@ -545,7 +545,7 @@ bool BPlusTree::Insert(const mleafdata & _leafdata)
_pOldLeaf ->setAddrFB(_addr_new);
// setmodified in initial;
mItnlNode * _pItnl = new mItnlNode;
// 分配新的首地址
// 分配新的首地址ַ
long long int _addr_root = 0;
long long int _addr_2 = _pNewLeaf ->getAddrFB();
long long int _addr_1 = _pOldLeaf ->getAddrFB();
@ -587,15 +587,15 @@ bool mLeafNode :: dupInsert(const mleafdata & _mleafdata, int _index_insert)
return true;
}
/* 删除某数据
* 涉及删除节点时注意回收外存~~
/* 删除某数据
* 涉及删除节点时注意回收外存~~
*/
bool BPlusTree::Delete(KeyType & data)
{
mLeafNode * _pOldLeaf = SearchLeafNode(data);
// for when _ikey = 1
//if ok , return the index of the deleted
//如果idelete是1的话则函数里会是否进行向上删除 考虑
//如果idelete是1的话则函数里会是否进行向上删除 考虑
int _idelete = _pOldLeaf ->Delete(data);
if(_idelete < 0) return false;
@ -607,13 +607,13 @@ bool BPlusTree::Delete(KeyType & data)
if(_pOldLeaf ->getCount() >= ORDER_V)
{
//如果idelete = 1 向上删除 不需要
//如果idelete = 1 向上删除 不需要
return true;
}
// count < 50%
int flag = FLAG_LEFT;
// 右兄弟优先
// 右兄弟优先
mLeafNode * _pBrother = (mLeafNode*)(_pOldLeaf ->getBrother(flag));
//brother > 50%
@ -661,13 +661,13 @@ bool BPlusTree::Delete(KeyType & data)
cout << "bug run" << endl;
return false;
}
//重载删除函数
//重载删除函数
bool BPlusTree :: Delete(KeyType & data, char PartVal[])
{
mLeafNode * _pOldLeaf = SearchLeafNode(data);
// for when _ikey = 1
//if ok , return the index of the deleted
//如果idelete是1的话则函数里会是否进行向上删除 考虑
// for when _ikey = 1
//if ok , return the index of the deleted
//如果idelete是1的话则函数里会是否进行向上删除 考虑
int pvFlag = FLAG_ZERO;
int _idelete = _pOldLeaf ->Delete(data, PartVal, pvFlag);
if(_idelete < 0) return false;
@ -681,13 +681,13 @@ bool BPlusTree :: Delete(KeyType & data, char PartVal[])
if(_pOldLeaf ->getCount() >= ORDER_V)
{
//如果idelete = 1 向上删除 不需要
//如果idelete = 1 向上删除 不需要
return true;
}
// count < 50%
int flag = FLAG_LEFT;
// 右兄弟优先
// <EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
mLeafNode * _pBrother = (mLeafNode*)(_pOldLeaf ->getBrother(flag));
//brother > 50%
@ -740,7 +740,7 @@ void BPlusTree::Flush(){
this ->StoreTree();
this ->ClearTree();
}
// 清除整个树，删除所有结点
// 清除整个树，删除所有结点
void BPlusTree :: ClearTree()
{
queue<mNode *> pQueue[100];
@ -799,26 +799,26 @@ void BPlusTree :: ClearTree()
return;
}
// 检查树是否满足B+树的定义
// 检查树是否满足B+树的定义
//bool BPlusTree::CheckTree()
//{}
// 递归检查结点及其子树是否满足B+树的定义
// 递归检查结点及其子树是否满足B+树的定义
//bool BPlusTree::CheckNode(mNode* pNode)
//{}
// 打印整个树
// 打印整个树
//void BPlusTree::PrintTree(FILE * ifp)
//{}
// 打印某结点
// 打印某结点
//void BPlusTree::PrintNode(mNode* pNode, FILE * ifp)
//{}
//递归函数：插入键到中间结点
//key即为pNode中的首个key
//递归函数：插入键到中间结点
//key即为pNode中的首个key
bool BPlusTree::InsertItnlNode(mItnlNode* pNode, mNode* pSon)
{
if(pNode == NULL || pNode ->getType() == NODE_TYPE_LEAF)
@ -878,8 +878,8 @@ bool BPlusTree::InsertItnlNode(mItnlNode* pNode, mNode* pSon)
if(_pFather == NULL)
{
// 原offset = 0处块以及相应后续链接块先清除
// 判断是否需要删除的外存链
// 原offset = 0处块以及相应后续链接块先清除
// 判断是否需要删除的外存链
// if(!preModified)
// {
// DelDisk(mfp, 0l, mblockQueue);
@ -890,7 +890,7 @@ bool BPlusTree::InsertItnlNode(mItnlNode* pNode, mNode* pSon)
_pOldItnl ->setAddrFB(_addr_new);
// setmodified in mnode_initial;
mItnlNode * _pItnl = new mItnlNode;
// 分配新的首地址
//分配新的首地址
long long int _addr_root = 0l;
long long int _addr_1 = _pOldItnl ->getAddrFB();
long long int _addr_2 = _pNewItnl ->getAddrFB();
@ -921,11 +921,11 @@ bool BPlusTree::InsertItnlNode(mItnlNode* pNode, mNode* pSon)
return false;
}
/*
* 删除key对应的元素并在delete函数中完成对父节点的修改， 注意内存位的同步修改
* 若节点 > 50% 或为根节点， 则结束
* 删除key对应的元素并在delete函数中完成对父节点的修改， 注意内存位的同步修改
* 若节点 > 50% 或为根节点， 则结束
*
*/
// 递归函数：在中间结点中删除键
// 递归函数：在中间结点中删除键
bool BPlusTree::DeleteItnlNode(mItnlNode* pItnl, KeyType & key)
{
int _idelete = pItnl ->Delete(key);
@ -984,11 +984,11 @@ bool BPlusTree::DeleteItnlNode(mItnlNode* pItnl, KeyType & key)
cout << "run bug" << endl;
return false;
}
//保存树结构
//保存树结构
/*
* 保证两点：
* 1、内存位标记都正确
* 2、修改位标记都正确
* 保证两点：
* 1、内存位标记都正确
* 2、修改位标记都正确
*/
void BPlusTree :: StoreTree()
{
@ -1004,7 +1004,7 @@ void BPlusTree :: StoreTree()
{
pNode = pQueue.front();
pQueue.pop();
// 内有unmodify
// 内有unmodify
if(pNode->getModify()){
any = true;
}
@ -1026,7 +1026,7 @@ void BPlusTree :: StoreTree()
}
}
cout << endl;
char _queuefile[50];
char _queuefile[1024];
strcpy(_queuefile, mTreeName);
strcat(_queuefile, "_queue.btree");
this ->mblockQueue.WriteQueue(_queuefile);
@ -1039,7 +1039,7 @@ void BPlusTree :: StoreTree()
}
//
//打印树
//打印树
void BPlusTree :: PrintTree()
{
queue<mNode *> pQueue[100];
@ -1083,18 +1083,18 @@ void BPlusTree :: PrintTree()
}
/*
* 新建节点需要提供的信息：
* 节点的首块地址
* 读出type int
* 读出count int
* 读出count_block int
* 读出blocklink mBlockLink
* 新建节点需要提供的信息：
* 节点的首块地址
* 读出type int
* 读出count int
* 读出count_block int
* 读出blocklink mBlockLink
*
* 读出各元素后， 通过下块地址转移， 转以后读入块元素个数， 再读入块链接
* 读出各元素后， 通过下块地址转移， 转以后读入块元素个数， 再读入块链接
*
*/
mNode * ReadNode(FILE * fp, long long _addrfb)//每个新建的节点都有分配的或上层节点给予的首块存储区地址
mNode * ReadNode(FILE * fp, long long _addrfb)//每个新建的节点都有分配的或上层节点给予的首块存储区地址
{
fseek(fp, _addrfb, SEEK_SET);
int _type_tmp;
@ -1118,25 +1118,25 @@ mNode * ReadNode(FILE * fp, long long _addrfb)//ÿ
_pLeaf ->unModify();
_pLeaf ->setAddrFB(_addrfb);
fread(&(_pLeaf ->leafLink), sizeof(_pLeaf ->leafLink), 1, fp);
/*
* while cycle里
* for cycle
* 通过块内元素个数读入
*/
/*
* while cycle里
* for cycle
* 通过块内元素个数读入
*/
/*
* 读完后， 先记录当前独到节点的第几个元素
* 文件指针偏移至指示的下一块
* 再读入块内元素个数及上下块结构体变量
* 继续读入， 直到元素个数达到count值
*/
/*
* 先把块的剩余空间写入 -1， 再写入len（便于准确申请空间）， sizeleft 减去三个4（12字节， “-1”“len”“sizeleft自身”），
* 写入sizeleft：　到时需要分段读入　　然后申请块，　在将块链接写入之前位置
* 写完剩余的空间后， 调整buffer及其size
* 然后每多申请一块则先跳过一个整型以及快链接结构体的大小，　以备写入当前块存放的长度buffer(考虑最后一块好处理)，以及块链接
* 写入剩余的buffer后回写长度及块链接， 若是最后一块， 要注意整理： fp指针 & sizeleft；
*/
/*
* 读完后， 先记录当前独到节点的第几个元素
* 文件指针偏移至指示的下一块
* 再读入块内元素个数及上下块结构体变量
* 继续读入， 直到元素个数达到count值
*/
/*
* 先把块的剩余空间写入 -1， 再写入len（便于准确申请空间）， sizeleft 减去三个4（12字节， “-1”“len”“sizeleft自身”），
* 写入sizeleft：　到时需要分段读入　　然后申请块，　在将块链接写入之前位置
* 写完剩余的空间后， 调整buffer及其size
* 然后每多申请一块则先跳过一个整型以及快链接结构体的大小，　以备写入当前块存放的长度buffer(考虑最后一块好处理)，以及块链接
* 写入剩余的buffer后回写长度及块链接， 若是最后一块， 要注意整理： fp指针 & sizeleft；
*/
bool ReadIn = true;
while(_i_tmp <= _count_tmp)
{
@ -1199,7 +1199,7 @@ mNode * ReadNode(FILE * fp, long long _addrfb)//ÿ
mItnlNode * _pItnl = new mItnlNode;
_pItnl ->setCount(_count_tmp);
_pItnl ->unModify();
// 后加， 未知之前没有设地址的原因
// <EFBFBD><EFBFBD>ӣ<EFBFBD> δ֪֮ǰû<C7B0><C3BB><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7>ԭ<EFBFBD><D4AD>
_pItnl ->setAddrFB(_addrfb);
while(_i_tmp <= _count_tmp)
{
@ -1262,7 +1262,7 @@ void WriteNode(mNode * pNode, FILE * fp, mQueue & _mqueue)
fwrite(&(_count_tmp), size_count, 1, fp);
_size_left -= size_count;//--------------------------------int
long long int _addr_blocklink = ftell(fp); // 可能产生问题
long long int _addr_blocklink = ftell(fp); // 可能产生问题
fseek(fp, size_int + size_blocklink, SEEK_CUR);
_size_left -= size_int + size_blocklink;//------------------int + long_long_int*2
@ -1284,20 +1284,20 @@ void WriteNode(mNode * pNode, FILE * fp, mQueue & _mqueue)
mBlockLink _blocklink;
for(; _i_tmp <= _count; _i_tmp ++)
{
/*
* 传入剩余块大小， 若当前元素能够继续写入则写入并返回true， 否则不写入并返回false;
* 如果返回false则先返写块容元素个数 及上下块的联系_ _addr_blocklink，
* 再申请新块并继续写入： 恢复_size_left, 写入mblocklink
* 修改上下块链接
* 改成块内元素个数更好
* 调整文件指针, 块内元素归零
*/
/*
* 传入剩余块大小， 若当前元素能够继续写入则写入并返回true， 否则不写入并返回false;
* 如果返回false则先返写块容元素个数 及上下块的联系_ _addr_blocklink，
* 再申请新块并继续写入： 恢复_size_left, 写入mblocklink
* 修改上下块链接
* 改成块内元素个数更好
* 调整文件指针, 块内元素归零
*/
int size_key = -1;
int size_val = -1;
int _tmp_i = -1;
bool_WriteIn = _pLeaf ->LeafData[_i_tmp].Write_mleafdata(fp, _size_left, size_key, size_val);
if(!bool_WriteIn) //确定不可能有单一元素超过4K， 可能产生问题
if(!bool_WriteIn) //确定不可能有单一元素超过4K， 可能产生问题
{
if(size_key + size_val > BLOCKSIZE - size_int*3 - size_lli*4
&& _size_left > size_key + size_int * 3 + 1)
@ -1324,9 +1324,9 @@ void WriteNode(mNode * pNode, FILE * fp, mQueue & _mqueue)
// _curblockaddr = _mqueue.Pop();
_blocklink.mBlockLink_Initial();
_blocklink.preBlockAddr = _preblockaddr;
_preblockaddr = _curblockaddr; // 新块的上一块就是当前块（首块指向-1）
_curblockaddr = _mqueue.Pop(); //当前块变量再调整为指向新块
_blocklink.nextBlockAddr = _curblockaddr; // 上一块的下一块即为新块
_preblockaddr = _curblockaddr; // 新块的上一块就是当前块（首块指向-1）
_curblockaddr = _mqueue.Pop(); //当前块变量再调整为指向新块
_blocklink.nextBlockAddr = _curblockaddr; // 上一块的下一块即为新块
fseek(fp, _addr_blocklink, SEEK_SET);
nEle_inBlock ++;
@ -1335,7 +1335,7 @@ void WriteNode(mNode * pNode, FILE * fp, mQueue & _mqueue)
fwrite(&_blocklink, size_blocklink, 1, fp);
fseek(fp, _curblockaddr, SEEK_SET);
_addr_blocklink = _curblockaddr;//调整回写偏移
_addr_blocklink = _curblockaddr;//调整回写偏移
fseek(fp, size_blocklink + size_int, SEEK_CUR);
//write back blocklink
@ -1349,16 +1349,16 @@ void WriteNode(mNode * pNode, FILE * fp, mQueue & _mqueue)
_blocklink.mBlockLink_Initial();
_blocklink.preBlockAddr = _preblockaddr;
_preblockaddr = _curblockaddr; // 新块的上一块就是当前块（首块指向-1）
_curblockaddr = _mqueue.Pop(); //当前块变量再调整为指向新块
_blocklink.nextBlockAddr = _curblockaddr; // 上一块的下一块即为新块
_preblockaddr = _curblockaddr; // 新块的上一块就是当前块（首块指向-1）
_curblockaddr = _mqueue.Pop(); //当前块变量再调整为指向新块
_blocklink.nextBlockAddr = _curblockaddr; // 上一块的下一块即为新块
fseek(fp, _addr_blocklink, SEEK_SET);
fwrite(&_block_hold, size_int, 1, fp);
fwrite(&_blocklink, size_blocklink, 1, fp);
fseek(fp, _curblockaddr, SEEK_SET);
_addr_blocklink = _curblockaddr;//调整回写偏移
_addr_blocklink = _curblockaddr;//调整回写偏移
fseek(fp, size_blocklink + size_int, SEEK_CUR);
}
@ -1372,36 +1372,36 @@ void WriteNode(mNode * pNode, FILE * fp, mQueue & _mqueue)
// _size_left = BLOCKSIZE - _size_buffer - size_int - size_blocklink;
_size_left = -1;
first_int = _size_buffer;
/*
* 先把块的剩余空间写入 -1， 再写入len（便于准确申请空间）， sizeleft 减去三个4（12字节， “-1”“len”“sizeleft自身”），
* 写入sizeleft：　到时需要分段读入　　然后申请块，　在将块链接写入之前位置
* 写完剩余的空间后， 调整buffer及其size
* 然后每多申请一块则先跳过一个整型以及快链接结构体的大小，　以备写入当前块存放的长度buffer(考虑最后一块好处理)，以及块链接
* 写入剩余的buffer后回写长度及块链接， 若是最后一块， 要注意整理： fp指针 & sizeleft；
*/
/*
* 先把块的剩余空间写入 -1， 再写入len（便于准确申请空间）， sizeleft 减去三个4（12字节， “-1”“len”“sizeleft自身”），
* 写入sizeleft：　到时需要分段读入　　然后申请块，　在将块链接写入之前位置
* 写完剩余的空间后， 调整buffer及其size
* 然后每多申请一块则先跳过一个整型以及快链接结构体的大小，　以备写入当前块存放的长度buffer(考虑最后一块好处理)，以及块链接
* 写入剩余的buffer后回写长度及块链接， 若是最后一块， 要注意整理： fp指针 & sizeleft；
*/
}
else
{
_i_tmp --;
_size_left = BLOCKSIZE; //回复块内容量
_size_left = BLOCKSIZE; //<EFBFBD>ظ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
_blocklink.mBlockLink_Initial();
_blocklink.preBlockAddr = _preblockaddr;
_preblockaddr = _curblockaddr; // 新块的上一块就是当前块（首块指向-1）
_curblockaddr = _mqueue.Pop(); //当前块变量再调整为指向新块
_blocklink.nextBlockAddr = _curblockaddr; // 上一块的下一块即为新块
/*
* 写回块内元素个数以及快链接
*/
_preblockaddr = _curblockaddr; // 新块的上一块就是当前块（首块指向-1）
_curblockaddr = _mqueue.Pop(); //当前块变量再调整为指向新块
_blocklink.nextBlockAddr = _curblockaddr; // 上一块的下一块即为新块
/*
* 写回块内元素个数以及快链接
*/
fseek(fp, _addr_blocklink, SEEK_SET);
int size_ele_inblock = sizeof(nEle_inBlock);
fwrite(&first_int, size_ele_inblock, 1, fp);
fwrite(&_blocklink, size_blocklink, 1, fp);
fseek(fp, _curblockaddr, SEEK_SET);
_addr_blocklink = _curblockaddr;//调整回写偏移
_addr_blocklink = _curblockaddr;//调整回写偏移
fseek(fp, size_ele_inblock + size_blocklink, SEEK_CUR);
_size_left -= size_ele_inblock + size_blocklink;//===========int + lli * 2
@ -1415,13 +1415,13 @@ void WriteNode(mNode * pNode, FILE * fp, mQueue & _mqueue)
}// if write_in
}// for count
/*
* 最后一块的处理
*/
/*
* 最后一块的处理
*/
_blocklink.mBlockLink_Initial();
_blocklink.preBlockAddr = _preblockaddr;
_blocklink.nextBlockAddr = -1; // 上一块的下一块即为新块
_blocklink.nextBlockAddr = -1; // 上一块的下一块即为新块
fseek(fp, _addr_blocklink, SEEK_SET);
fwrite(&first_int, size_int, 1, fp);
fwrite(&_blocklink, size_blocklink, 1, fp);
@ -1440,37 +1440,37 @@ void WriteNode(mNode * pNode, FILE * fp, mQueue & _mqueue)
mBlockLink _blocklink;
for(; _i_tmp <= _count; _i_tmp ++)
{
/*
* 传入剩余块大小， 若当前元素能够继续写入则写入并返回true， 否则不写入并返回false;
* 如果返回false则先返写块容元素个数 及上下块的联系_ _addr_blocklink，
* 再申请新块并继续写入： 恢复_size_left, 写入mblocklink
* 修改上下块链接
* 改成块内元素个数更好
* 调整文件指针, 块内元素归零
*/
/*
* 传入剩余块大小， 若当前元素能够继续写入则写入并返回true， 否则不写入并返回false;
* 如果返回false则先返写块容元素个数 及上下块的联系_ _addr_blocklink，
* 再申请新块并继续写入： 恢复_size_left, 写入mblocklink
* 修改上下块链接
* 改成块内元素个数更好
* 调整文件指针, 块内元素归零
*/
bool_WriteIn = _pItnl ->ItnlData[_i_tmp].Write_mitnldata(fp, _size_left);
if(!bool_WriteIn) //确定不可能有单一元素超过4K， 可能产生问题
if(!bool_WriteIn) //确定不可能有单一元素超过4K， 可能产生问题
{
_i_tmp --;
_size_left = BLOCKSIZE; //回复块内容量
_size_left = BLOCKSIZE; //回复块内容量
_blocklink.mBlockLink_Initial();
_blocklink.preBlockAddr = _preblockaddr;
_preblockaddr = _curblockaddr; // 新块的上一块就是当前块（首块指向-1）
_curblockaddr = _mqueue.Pop(); //当前块变量再调整为指向新块
_blocklink.nextBlockAddr = _curblockaddr; // 上一块的下一块即为新块
/*
* 写回块内元素个数以及块链接
*/
_preblockaddr = _curblockaddr; // 新块的上一块就是当前块（首块指向-1）
_curblockaddr = _mqueue.Pop(); //当前块变量再调整为指向新块
_blocklink.nextBlockAddr = _curblockaddr; // 上一块的下一块即为新块
/*
* 写回块内元素个数以及块链接
*/
fseek(fp, _addr_blocklink, SEEK_SET);
int size_ele_inblock = sizeof(nEle_inBlock);
fwrite(&nEle_inBlock, size_ele_inblock, 1, fp);
fwrite(&_blocklink, size_blocklink, 1, fp);
fseek(fp, _curblockaddr, SEEK_SET);
_addr_blocklink = _curblockaddr;//调整回写偏移
_addr_blocklink = _curblockaddr;//调整回写偏移
fseek(fp, size_ele_inblock + size_blocklink, SEEK_CUR);
_size_left -= size_ele_inblock + size_blocklink;
@ -1481,13 +1481,13 @@ void WriteNode(mNode * pNode, FILE * fp, mQueue & _mqueue)
nEle_inBlock ++;
}
}
/*
* 最后一块的处理
*/
/*
* 最后一块的处理
*/
_blocklink.mBlockLink_Initial();
_blocklink.preBlockAddr = _preblockaddr;
_blocklink.nextBlockAddr = -1; // 上一块的下一块即为新块
_blocklink.nextBlockAddr = -1; // 上一块的下一块即为新块
fseek(fp, _addr_blocklink, SEEK_SET);
int size_ele_inblock = sizeof(nEle_inBlock);
fwrite(&nEle_inBlock, size_ele_inblock, 1, fp);
@ -1517,7 +1517,7 @@ void DelDisk(FILE * fp, long long int _addrfb, mQueue & _mqueue)
long long int BackAddr[1000] = {};
vector<long long int> BackVec;
// BackAddr[_i_tmp] = _addrfb;
// _i_tmp ++; 首块地址绝非要一起回收， 在delete实现之后首块地址在适时push的！！
// _i_tmp ++; 首块地址绝非要一起回收， 在delete实现之后首块地址在适时push的！！
while(_curblocklink.nextBlockAddr != -1)
{
{
@ -1582,7 +1582,7 @@ bool Delete_Key_PartVal(char keyStr[], int keyLen, char partVal[], BPlusTree * _
return dRet;
}
// 以下为四个对应的删除实现， 调用了上面两个函数；
// 以下为四个对应的删除实现， 调用了上面两个函数；
bool Delete_sID2sub(int _sID, BPlusTree * _p_sID2sub)
{
char * sid2str = new char[5];
@ -1741,9 +1741,9 @@ void mitnldata::Read_mitnldata(FILE * fp)
}
bool mitnldata::Write_mitnldata( FILE * fp, int & _size_left )
{
/*
* KeyType 需要由函数返回写入的空间大小
*/
/*
* KeyType 需要由函数返回写入的空间大小
*/
int size_lli = sizeof(long long int);
int size_mKey = mKey.WriteSize();
if(_size_left < size_lli + size_mKey) return false;
@ -1815,7 +1815,7 @@ BPlusTree::BPlusTree(const char * const_tree_name, const char * _build_or_open)
}
this ->Initial();
insert_count = 0;
char _tree_name[1000];
char _tree_name[1024];
memcpy(_tree_name, const_tree_name, (int)strlen(const_tree_name));
_tree_name[(int)strlen(const_tree_name)] = '\0';
int _key_chose;
@ -1843,7 +1843,7 @@ BPlusTree::BPlusTree(const char * const_tree_name, const char * _build_or_open)
mRoot = new mLeafNode;
mRoot ->setAddrFB( 0 );
printf("the tree called: %s\n", mTreeName);
char _treefile[500];
char _treefile[1024];
strcpy(_treefile, mTreeName);
strcat(_treefile, ".btree");
if((mfp = fopen(_treefile, "wb+")) == NULL)
@ -1874,7 +1874,7 @@ BPlusTree::BPlusTree(const char * const_tree_name, const char * _build_or_open)
break;
}
}
char _queuefile[500];
char _queuefile[1024];
strcpy(_queuefile, mTreeName);
strcat(_queuefile, "_queue.btree");
mblockQueue.ReadQueue(_queuefile);

151
KVstore/CBtreeH.h
View File

@ -25,10 +25,10 @@
#include<set>
#define BLOCKSIZE (1 << 14)/* 16K */
#define ORDER_V 128 /* 为简单起见，把v固定为2，实际的B+树v值应该是可配的 */
#define MAXNUM_KEY (ORDER_V * 2) /* 内部结点中最多键个数，为2v ( 1~2v )*/
#define MAXNUM_POINTER (ORDER_V * 2 + 1) /* 内部结点中最多指向子树的指针个数，为2v ( 1~2v )*/
#define MAXNUM_DATA (ORDER_V * 2 + 1) /* 结点中用作定义，为2v ( 1~2v )*/
#define ORDER_V 128 /* 为简单起见，把v固定为2，实际的B+树v值应该是可配的 */
#define MAXNUM_KEY (ORDER_V * 2) /* 内部结点中最多键个数，为2v ( 1~2v )*/
#define MAXNUM_POINTER (ORDER_V * 2 + 1) /* 内部结点中最多指向子树的指针个数，为2v ( 1~2v )*/
#define MAXNUM_DATA (ORDER_V * 2 + 1) /* 结点中用作定义，为2v ( 1~2v )*/
#define TERM_NUMBER 1
#define FLAG_LEFT 5
@ -49,8 +49,8 @@ using namespace std;
enum NODE_TYPE
{
NODE_TYPE_INTERNAL = 2, // 内部结点
NODE_TYPE_LEAF = 3, // 叶子结点
NODE_TYPE_INTERNAL = 2, // 内部结点
NODE_TYPE_LEAF = 3, // 叶子结点
};
enum eletype
{
@ -73,7 +73,7 @@ public:
bool is_AtMem;
char* sKey;
int iKey;
int mLenKey; //关于是否读入\n的试验
int mLenKey; //关于是否读入\n的试验
KeyType()
{
KeyType_Initial();
@ -179,9 +179,9 @@ public:
void ReadKey(FILE * fp);
void WriteKey(FILE * fp);
/*
* 合适的功能函数
*/
/*
* 合适的功能函数
*/
int WriteSize()
{
int size_mLenKey = sizeof(mLenKey);
@ -524,7 +524,7 @@ public:
{
Term[0][_tag] = '\0';
lenTerm[0] -= sizeof(int) + sizeof(char);
//只有一个元素时很特殊， 长度是减少4， 其余减少5
//只有一个元素时很特殊， 长度是减少4， 其余减少5
if(lenTerm[0] <= 0) flag = FLAG_ZERO;
else flag = FLAG_NO_ZERO;
return true;
@ -630,9 +630,10 @@ public:
class mQueue
{
public:
static const int qLenth = 5243005;
// static const int qLenth = 5243005; /* 5*1024*1024 */
static const int qLenth = 20971520; /* 20*1024*1024 */
int qUsed;
bool qAvailable[mQueue::qLenth];/* 5*1024*1024 */
bool qAvailable[mQueue::qLenth];
public:
mQueue()
@ -787,7 +788,7 @@ public:
mNode * _pBrother = NULL;
for(int i = 1; i <= _pFather ->getCount(); i ++)
{
//指针匹配
//ָ<EFBFBD><EFBFBD>ƥ<EFBFBD><EFBFBD>
if(_pFather ->getPointer(i) == this)
{
if(i == (_pFather ->getCount()) + 1)
@ -973,7 +974,7 @@ public:
}
}
//此函数需仔细考虑~~！！
//此函数需仔细考虑~~！！
int iExist(const KeyType &_keytype)
{
int _ibegin = 1, _iend = getCount();
@ -991,7 +992,7 @@ public:
}
if(_ibegin == _iend - 1) return -1;
// 后加可能有风险
// 后加可能有风险
if(ItnlData[_imiddle].mKey > _keytype)
{
@ -1129,17 +1130,17 @@ public:
printf(" == ");
}
// 插入键
// 最左端递归向上
bool Insert(mNode* _pmnode);
// 删除键
int Delete(const KeyType & _keytype);
// 分裂结点
KeyType & Split(mItnlNode* _mitnlnode);
// 结合结点
bool Combine(mItnlNode * _pmnode);
// 从另一结点移一个元素到本结点
bool MoveOneElement(mNode * _pmnode);
// 插入键
// 最左端递归向上
bool Insert(mNode* _pmnode);
// 删除键
int Delete(const KeyType & _keytype);
// 分裂结点
KeyType & Split(mItnlNode* _mitnlnode);
// 结合结点
bool Combine(mItnlNode * _pmnode);
// 从另一结点移一个元素到本结点
bool MoveOneElement(mNode * _pmnode);
};
@ -1433,7 +1434,7 @@ public:
}
}
// 此两个函数对叶节点无意义
// 此两个函数对叶节点无意义
mNode * getPointer(int _i)
{
return NULL;
@ -1479,7 +1480,7 @@ public:
}
return -1;
}
// 考虑cout = 0的情况
// 考虑cout = 0的情况
int iInsert(const KeyType & _keytype)
{
int _ibegin = 1, _iend = getCount();
@ -1554,19 +1555,19 @@ public:
// 插入数据
// 最左端递归向上
bool Insert(const mleafdata & _leafdata);
// 删除数据
int Delete(KeyType & _keytype);
//重载delete partval
int Delete(KeyType & _keytype, char partval[], int & pvFlag);
// 分裂结点
KeyType & Split(mLeafNode* _mpnode);
// 结合结点
bool Combine(mLeafNode* _mpnode);
// 重复插入
bool dupInsert(const mleafdata & _leafdata, int _index_insert);
// 插入数据
// 最左端递归向上
bool Insert(const mleafdata & _leafdata);
// 删除数据
int Delete(KeyType & _keytype);
//重载delete partval
int Delete(KeyType & _keytype, char partval[], int & pvFlag);
// 分裂结点
KeyType & Split(mLeafNode* _mpnode);
// 结合结点
bool Combine(mLeafNode* _mpnode);
// 重复插入
bool dupInsert(const mleafdata & _leafdata, int _index_insert);
};
extern mNode* ReadNode(FILE * fp, long long int _addr);
@ -1583,19 +1584,19 @@ extern bool Delete_obj2sID(char _obj_str[], int _del_sID, BPlusTree * _p_obj2sID
extern bool Delete_objpID2sID(char _obj_str[], int _pID, int _del_sID, BPlusTree * _p_objpID2sID);
/* B+树数据结构 */
/* B+树数据结构 */
class BPlusTree
{
public:
// 以下两个变量用于实现双向链表
mLeafNode* pmLeafHead; // 头结点
mLeafNode* pmLeafTail; // 尾结点
mNode * mRoot; // 根结点
// 以下两个变量用于实现双向链表
mLeafNode* pmLeafHead; // 头结点
mLeafNode* pmLeafTail; // 尾结点
mNode * mRoot; // 根结点
mQueue mblockQueue;
FILE * mfp;
char mTreeName[55];
int mDepth; // 树的深度
char mTreeName[1024];
int mDepth; // 树的深度
int insert_count;
void Initial();
@ -1605,33 +1606,33 @@ public:
void log(const char* _log)const;
void forcheck();
// 获取和设置根结点
mNode * getRoot() { return mRoot; }
// 获取和设置根结点
mNode * getRoot() { return mRoot; }
void setRoot(mNode * root) { mRoot = root; }
void Flush();
// 为插入而查找叶子结点
mLeafNode * SearchLeafNode(const KeyType & data)const;
//插入键到中间结点
bool InsertItnlNode(mItnlNode * pNode, mNode * pSon);
// 在中间结点中删除键
bool DeleteItnlNode(mItnlNode * pNode, KeyType & key);
// 查找指定的数据
bool Search(KeyType & data, mleafdata & _ret);
// 插入指定的数据
bool Insert(const mleafdata & _mleafdata);
// 删除指定的数据
bool Delete(KeyType & data);
// 重载删除函数
bool Delete(KeyType & data, char PartVal[]);
// 清除树
void ClearTree();
// 打印树
void PrintTree();
//读出根节点
void ReadRoot();
//保存树结构
void StoreTree();
void setRoot(mNode * root) { mRoot = root; }
void Flush();
// 为插入而查找叶子结点
mLeafNode * SearchLeafNode(const KeyType & data)const;
//插入键到中间结点
bool InsertItnlNode(mItnlNode * pNode, mNode * pSon);
// 在中间结点中删除键
bool DeleteItnlNode(mItnlNode * pNode, KeyType & key);
// 查找指定的数据
bool Search(KeyType & data, mleafdata & _ret);
// 插入指定的数据
bool Insert(const mleafdata & _mleafdata);
// 删除指定的数据
bool Delete(KeyType & data);
// 重载删除函数
bool Delete(KeyType & data, char PartVal[]);
// 清除树
void ClearTree();
// 打印树
void PrintTree();
//读出根节点
void ReadRoot();
//保存树结构
void StoreTree();
};
#endif /* CBTREE_H_ */