这一块是在助教给的参考代码的基础上进行了一些小范围的修改。
感觉最麻烦的是一个是文件的管理。一开始认定一定要（读一行表示一块），发现这样的话要循环调用getline这个函数，感觉并没有达到好的一个效率。后来查找了蛮多资料然后才熟悉了具体的存储方法……因为写的文件会用txt打开，无法显示的内容都会以为丢失了。
这一块我和写record的同学协商之后打算用强制类型转换的方法来读写，就是，比如int和float都是4个字节，就用四个字节的char来表示，相当于256进制。然后在后期拼合代码的时候……发现如果用这种方法来记录的话，字符串什么的类型都没法用了因为，默认0是字符串的结尾。所以后来扩充了那个类型，为了代码的容易理解最后是，用5个字节来表示int（所以int没法完全表达，比如负数和五位以上的正数）和8个字节表示float（128进制，这样可以避开之前让我们困扰的0的问题而且让大部分落在’可见’也就是能显示的区域）。
有些问题还是集中在个人的水平上，比如，因为内存分配什么的出过很多问题……
还是需要协调……比如说，我的buffer这一块需要建立的文件节点的链表，在队友写的时候是有一个头节点，而我是直接用第一个文件的节点，这样的话在释放的时候可能会有未考虑到的部分。（所以总觉得该用C++啊摔）。而且好像我写的两块独立测试都比较麻烦……而且测试看不出来……
一、BufferManager负责缓冲区的管理，主要功能有：
1. 根据需要，读取指定的数据到系统缓冲区或将缓冲区中的数据写出到文件；
2. 实现缓冲区的替换算法，当缓冲区满时选择合适的页进行替换；
3. 记录缓冲区中各页的状态，如是否被修改过等；
4. 提供缓冲区页的pin功能，及锁定缓冲区的页，不允许替换出去。
为提高磁盘I/O操作的效率，缓冲区与文件系统交互的单位是块，块的大小应为文件系统与磁盘交互单位的整数倍，一般可定为4KB或8KB。
二、模块总体设计思路
记录管理模块（RecordManager）和索引管理模块（IndexManager）向缓冲区管理申请所要的数据，缓冲区管理器首先在缓冲区中查看数据是否存在，若存在，直接返回，否则，从磁盘中将数据读入缓冲区，然后返回。
最近最少使用(LRU)算法：每次访问一个块的时候，如果是重新读取的话把该块的iTime置为1，如果是已经有的话把它的使用次数加一。采用这种方式记录主要是因为对于Index部分，比如根节点的使用率一直保持非常高。
换出脏块时需要写出块。
三、具体实现
1、宏
#defineBLOCK_LEN 4096 // the size of one block
#defineMAX_BLOCK 40 // the max number of the blocks
2、结构体
1）、文件头结构体(structfileInfo) ：
包含文件的基本信息：类型（数据文件或索引文件）、文件名、记录数、空块号、记录长度、指向下一个文件的指针、文件所指向的第一个块。
structfileInfo {
int type; //0-> data file， 1 -> index file
CString fileName; // the name of the file
int recordAmount; // the number of record in the file
int freeNum; // the free block number which could be used for thefile
int recordLength; // the length of the record in the file
fileInfo *next; // the pointer points to the next file
blockInfo *firstBlock; // point to the first block within the file
};
2）、块信息结构体(struct blockInfo)：
包含块的基本信息：块号、脏位、指向下一个块的指针、块中的字符数、存放信息的字符型数组、年龄（用于LRU算法）、锁。
struct blockInfo {
intblockNum; // the block number of theblock,
// which indicate itwhen it be newed
booldirtyBit; // 0 -> flase， 1 -> indicate dirty, write back
blockInfo*next; //the pointer point to next block
fileInfo*file; // the pointer point to the file, which the block belongs to
intcharNum; // the number of chars in theblock
char*cBlock; // the array space for storingthe records in the block in buffer
intiTime; // it indicate the ageof the block in use
intlock; // prevent the blockfrom replacing
};
3)、主要函数及其功能描述如下：
1. fileInfo *findFileInfo(CStringDB_Name)
返回该数据库对应的头节点。
2.fileInfo* get_file_info(CStringDB_Name,CString fileName, int m_fileType)
在内存中查找该文件，返回该文件头。
3. blockInfo*get_block_inbuffer(const fileInfo *file_temp, const int blockNum)
在该文件节点下所有的块节点中查找特定编号的块，没有返回NULL.
4. blockInfo*remove_block_inbuffer(blockInfo *m_blockInfo)
将块从文件节点下移除。
5. blockInfo *findBlock(CStringDB_Name)
函数实现获取用于替换的内存块。
首先遍历文件节点，判断每个文件节点下是否有dullNode，有的话返回。
其次如果块数未达到MAX_BLOCK，申请内存。
如没有可用块，遍历所有的块节点使用MRU算法找到没有使用的时间最长的块（itime最大），从文件节点下移去，itime置为1；并将该块返回。
6. void replace(fileInfo*m_fileInfo, blockInfo *m_blockInfo)
把block节点连到file节点下
7. blockInfo *get_file_block(CStringDB_Name, CString Table_Name, const int fileType, const int blockNum)
根据文件名，文件类型查找该文件
根据文件的块号，从内存中查询该块；
如该块已经在内存，并且不为空节点，判断是否加锁，未加锁则返回该块的指针，同时调用次数++；
如该块已经在内存，但是为空节点，调用readBlock读取内容，返回该块的指针，调用次数置为1；
如果该快没有存在内存，同样调用readBlock读取所需内容，返回。
8. blockInfo* readBlock(fileInfo*file_temp,CString DB_Name, const intm_blockNum, blockInfo *block_temp)
如果传入参数中块为NULL，则调用findBlock来申请一个可用的块。
申请空间，读取文件。
9. void writeBlock(CString DB_Name,blockInfo * block)
把block指针所指向的块的内容写回磁盘。
10. void closeDatabase(CString DB_Name,bool m_flag)
先调用closeFile释放块节点。
再逐个释放文件节点。
11. void closeFile(CStringDB_Name,struct fileInfo* file_temp)
释放该文件节点下所有的块节点
4)主要操作实现过程
关闭数据库：
调用closeDatabase。函数内部对于每个文件节点，调用closeFile逐个关闭block，判断如果是脏块，调用writeBlock写回文件。再通过一次循环释放掉file节点。
获得某个数据块：
调用get_file_block，先找对应文件get_file_info，再调用get_block_inbuffer找文件下的块。如果不为空块直接返回，如果这个块是空块调用readBlock，找不到也调用readBlock，这个函数会申请缓存，如果申请不到缓存的话，调用findBlock去找一块空的内存。
findBlock的工作机制是先遍历所有的文件，找有没有freeNum的，需要 get_block_inbuffer再判断是不是到了申请的上限，再考虑释放时间最久的块。这里需要用到removeBlockinBuffer这个函数。
初始化：
BlockInfo数据初始化在read里，读取的时候进行初始化。
由其他模块直接作用维持的结构：
当需要其他的模块对该页加锁时，get_file_block将输出错误并且返回NULL指针。
4、内存中维护的结构
1）、单个数据库结构
fileInfo代表一个数据库下所有文件名。在命令use database的时候由Catalog Manager建立。
每个文件记录自己的freeNum对应第几个文件的数据是空的（基本上由数据删除产生），多个freeBlock，每个freeBlock里value指向下一个空的文件。
四、代码参考
////////////////////////////////////////////////////////////
//------------------------------------------------------///
// Module: Index_Manager.cpp
// Produced by: Birdy & C
// Description: buffer
// date:2017/5/22-2017/6/16
//------------------------------------------------------///
///////////////////////////////////////////////////////////
#define MAX_BLOCK 500
//#include"MiniSQL.h"
#include"API_Module.h"
#include"Buffer_Manager.h"
#include"Catalog_Manager.h"
#include"Record_Manager.h"
#include"Index_Manager.h"
#include"Interpreter.h"
using namespace std;
//fileInfo *ptr_to_files;
//返回一个数据库的起始file的地址
fileInfo *findFileInfo(CString DB_Name)
{
if (head_of_files == NULL)
return NULL;
return head_of_files->next;
}
//返回fileInfo
fileInfo *get_file_info(const CString DB_Name, const CString fileName, const int m_fileType)
{
fileInfo* file_temp = findFileInfo(DB_Name);
while (NULL != file_temp) //遍历所有的file节点
{
if (file_temp->fileName == fileName && file_temp->type == m_fileType)
{
return file_temp;
}
file_temp = file_temp->next;
}
//没有找到这个文件
cout << "buffer::get_file_info::can't find the file" << endl;
return NULL;
}
//在内存中查找这个数据块
blockInfo *get_block_inbuffer(const fileInfo *file_temp, const int blockNum)
{
if (NULL == file_temp)
return NULL;
blockInfo *block_temp = file_temp->firstBlock;
//遍历该file节点下所有block
while (NULL != block_temp)
{
if (block_temp->blockNum == blockNum)
{
return block_temp;
}
block_temp = block_temp->next;
}
return NULL;
}
//将块从文件节点下移除
blockInfo *remove_block_inbuffer(blockInfo *m_blockInfo)
{
fileInfo *file_temp = m_blockInfo->fileName;
int blockNum = m_blockInfo->blockNum;
blockInfo *block_last = NULL;
blockInfo *block_temp = file_temp->firstBlock;
while (NULL != block_temp)
{
if (block_temp == m_blockInfo)
{
//find the node wanted
break;
}
block_last = block_temp;
block_temp = block_temp->next;
}
if (NULL != block_temp)
{
if (NULL == block_last)
{
file_temp->firstBlock = block_temp->next;//头节点
}
else
{
block_last->next = block_temp->next;//中间节点&叶节点
}
//返回前一个节点
return block_last;
}
//没找着
return NULL;
}
//返回可用的块
blockInfo *findBlock(CString DB_Name)
{
static int i = 0;//记录现有block数字
//搜索空块
fileInfo *ptr = findFileInfo(DB_Name);
blockInfo *newblock;
while (NULL != ptr)
{
int freeBlock = ptr->freeNum;
if (freeBlock > 0)
{
blockInfo *block_temp = get_block_inbuffer(ptr, freeBlock);
if (NULL != block_temp)
{
blockInfo *block_last = remove_block_inbuffer(block_temp);//从链表中移除
//更新freeNum
CString freeNum_rec(block_temp->cBlock);
ptr->freeNum = _ttoi(freeNum_rec.Left(3));
return block_temp;
}
//file记录了freeNUM 但是找不到这个block
cout << "WANING buffer::findBlock:the freeNum in record may be wrong" << endl;
}
ptr = ptr->next;
}
if (i < MAX_BLOCK)
{
//申请内存
newblock = new blockInfo;
i++;
if (NULL != newblock)
{
newblock->cBlock = new char[BLOCK_SIZE];
if (NULL != newblock->cBlock) return newblock;
}
}
//释放内存
//哇这里写的MRU
int time = -1;
blockInfo *temp = NULL;
ptr = findFileInfo(DB_Name);
while (NULL != ptr)
{
blockInfo *block_ptr = ptr->firstBlock;
while (NULL != block_ptr)
{
if (block_ptr->iTime > time)
{
time = block_ptr->iTime;
temp = block_ptr;
}
block_ptr = block_ptr->next;
}
ptr = ptr->next;
}
temp->iTime = 1;
remove_block_inbuffer(temp);
return temp;
}
//把block连到file下
void replace(fileInfo *m_fileInfo, blockInfo *m_blockInfo)
{
//加在最前面
m_blockInfo->fileName = m_fileInfo;
m_blockInfo->next = m_fileInfo->firstBlock;
m_fileInfo->firstBlock = m_blockInfo;
}
//返回数据
blockInfo *get_file_block(CString DB_Name, CString Table_Name, const int fileType, const int blockNum)
{
blockInfo *block_temp;
fileInfo *file_temp = get_file_info(DB_Name, Table_Name, fileType);
if (NULL != (block_temp = get_block_inbuffer(file_temp, fileType)))
{
if (1 == block_temp->lock)//判断这个块有没有被锁住
cout << "buffer::the block has been locked" << endl;
return block_temp;
}
if (NULL == file_temp)//找不到这个文件
{
cout << "buffer::get_file_block::wrong information" << endl;
return NULL;
}
block_temp = file_temp->firstBlock;
while (NULL != block_temp)
{
if (block_temp->blockNum == blockNum)
{
if (0 != block_temp->charNum) //如果不是空块
{
block_temp->iTime++; //调用次数++
return block_temp;
}
else
{
block_temp = readBlock(file_temp, DB_Name, blockNum, block_temp);
block_temp->iTime = 1; //调用次数初始化
return block_temp;
}
}
block_temp = block_temp->next;
}
cout << "buffer::get_file_block::can't find this block >>> begin read" << endl;
block_temp = readBlock(file_temp, DB_Name, blockNum, NULL);
replace(file_temp, block_temp); //将该block增加到头节点下
block_temp->iTime = 1; //调用次数初始化
return block_temp;
}
//已经判断内存中不存在这一个块、 读取数据
blockInfo* readBlock(fileInfo *file_temp, CString DB_Name, const int m_blockNum, blockInfo *block_temp)
{
//如果没有提供块，则需要自己找一个块
if (block_temp == NULL)
{
block_temp = findBlock(DB_Name);
block_temp->blockNum = m_blockNum;
block_temp->dirtyBit = 0;
}
//读取文件
CString fpath;
if (0 == file_temp->type)
{
fpath = "..\\" + DB_Name + "\\table\\" + file_temp->fileName + ".txt";
}
else
{
fpath = "..\\" + DB_Name + "\\index\\" + file_temp->fileName + ".txt";
}
fstream file(fpath, ios::in | ios::out);
if (!file.is_open()) //检查打开是否成功
{
cout << "buffer::readBlock::can't find the file" + fpath << endl;
return NULL;
}
int offset = (m_blockNum - 1) * BLOCK_SIZE; //计算偏移量
file.seekp(offset, ios::beg); //从起始位置开始
block_temp->cBlock = new char[BLOCK_SIZE]; //申请内存
file.read(block_temp->cBlock, BLOCK_SIZE); //读取文件
file.close();
return block_temp;
}
//把block指针所指向的块的内容写回磁盘。
void writeBlock(CString DB_Name, blockInfo * block)
{
if (!block->dirtyBit) return;
fileInfo *file_temp = block->fileName;
CString m_fileName = block->fileName->fileName;
int m_blockNum = block->blockNum;
CString fpath;
if (0 == file_temp->type)
{
fpath = "..\\" + DB_Name + "\\table\\" + m_fileName + ".txt";
}
else
{
fpath = "..\\" + DB_Name + "\\index\\" + m_fileName + ".txt";
}
fstream file(fpath, ios::in | ios::out);
if (!file.is_open()) //检查打开是否成功
{
cout << "buffer::writeBlock::can't find the file" + fpath << endl;
return;
}
int offset = (m_blockNum - 1) * BLOCK_SIZE;
file.seekp(offset, ios::beg);
CString temp = block->cBlock;
file.write(block->cBlock, temp.GetLength());
file.close();
}
//调用closeFile(DB_Name,filename,fileType,m_flag),逐个关闭文件。
void closeDatabase(CString DB_Name, bool m_flag)
{
//release Block_Info
fileInfo *ptr = findFileInfo(DB_Name);
while (NULL != ptr)
{
closeFile(DB_Name, ptr);
ptr = ptr->next;
}
//release File_info
ptr = findFileInfo(DB_Name);
while (NULL != ptr)
{
fileInfo *ptr_next = ptr->next;
delete ptr;
ptr = ptr_next;
}
}
//关闭文件
void closeFile(CString DB_Name, struct fileInfo* file_temp)
{
if (NULL == file_temp)
{
cout << "buffer::closeFile:can't find the file" << endl;
return;
}
blockInfo* block_temp = file_temp->firstBlock;
blockInfo * block_delete;
//依次删除该file下的block
while (NULL != block_temp)
{
writeBlock(DB_Name, block_temp);
block_delete = block_temp;
block_temp = block_temp->next;//指向下一个节点
delete[] block_delete->cBlock;//释放内存
delete block_delete;//删除节点
}
}