void BANDB::openDB(char* dbName, char* logName) {
// Start buffer and log managers
bm->start(dbName);
lm->start(logName);
// Now the log manager has done all txnTable rebuilding and
// all redo work, so we can rollback incomplete Txns
for (int i = 0; i < 255; i++) {
TxnRecord rec = lm->txnTable.records[i];
if (rec.transID != 0) {
// For all the transactions
if (rec.state == 3) {
// If it is committed but not ended, write the end record
lm->writeEndRecord(rec.transID);
}
else if (rec.state != 5) {
// Otherwise, if it is not an ended Txn, its a looser
rollbackWork(rec.transID);
lm->writeEndRecord(rec.transID);
}
}
}
// Harden All Pages
bm->pageOut(0);
bm->pageOut(1);
}
string CatalogManager::indexLocation(string indexName)
{
BufferManager buffer;
IndexCatalogPage indexPage;
int n,i,k,x;
string s,ans;
ans="";
indexPage.pageIndex=1;
buffer.readPage(indexPage);
n=*(int*)indexPage.pageData;
i=1;
k=0;
while (i<=n) //开始逐条检查，看看这个索引名有没有
{
x=indexPage.readPrevDel(i);
if (x==0) //如果当前条未被删除
{
s=indexPage.readIndexName(i);
if (s==indexName) //如果找到了
{
ans=indexPage.readTableName(i)+" "+indexPage.readAttrName(i);
return ans;
}
}
else //如果当前条已被删除，则最后一条位置后移
n++;
i++;
}
return "";
}
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);
}
MergeJoin::~MergeJoin()
{
bool enable = false;
BufferManager * bm = BufferManager::getInstance();
Settings::get("partition-materialization", enable);
for (int i = 0; i < N_BRANCHES; i++)
{
delete m_layout[i];
delete m_child[i];
delete m_tsr[i];
bm->deallocate(m_inBuffer[i]);
}
for (int i = 0; i < NCHILD_TUPLES; i++)
{
delete [] m_tuple[i].m_data;
if (enable)
delete m_tuple[i].schema();
}
bm->deallocate(m_buffer);
delete [] m_data;
delete m_tsw;
std::for_each(m_merge_stack.begin(), m_merge_stack.end(), free);
}
int CatalogManager::attrType(string tableName, string attrName)
{
int i,j,num;
string s="";
CatalogPage page;
BufferManager buffer;
page.tableName = tableName;
buffer.readPage(page);
num = (int)page.pageData[0];
for (i=0; i<num; i++)
if (page.readAttrName(i) == attrName)
s = page.readAttrType(i);
if (s == "")
return 0;
else
if (s == "int")
return 1;
else
if (s == "float")
return 2;
else
{
j=0;
for (i=5; s[i]!=')'; i++)
j = j*10+s[i]-'0';
return j+2;
}
}
bool RenderDevice::bindBuffers(RenderBatch* renderable)
{
BufferManager* buffers = activeContext->bufferManager;
GeometryBuffer* gb = renderable->getGeometryBuffer().get();
VertexBuffer* vb = buffers->getVertexBuffer(gb).get();
IndexBuffer* ib = buffers->getIndexBuffer(gb).get();
if( !vb ) return false;
if( !vb->isBuilt() || gb->needsRebuild )
{
// If the vertex buffer is not built yet, then we build it.
renderBackend->buildVertexBuffer(vb);
}
renderBackend->bindVertexBuffer(vb);
// If there is no index buffer associated with the geometry, we are done.
if( !ib ) goto done;
renderBackend->bindIndexBuffer(ib);
if( !ib->isBuilt || gb->needsRebuild )
{
// If the index buffer is not built, we also need to build it.
renderBackend->buildIndexBuffer(ib);
}
done:
gb->needsRebuild = false;
return true;
}
// Buffering methods
Buffer * AtomRenderableManager::getBuffer(unsigned int renderFormat, unsigned int tag, unsigned int mode, unsigned int verticesRequired)
{
if (bufferManagers[renderFormat][tag].find(mode) == bufferManagers[renderFormat][tag].end())
bufferManagers[renderFormat][tag][mode] = new BufferManager();
BufferManager * bufferManager = bufferManagers[renderFormat][tag][mode];
return bufferManager->getBuffer(verticesRequired);
}
char* BANDB::read(int transID, int key) {
int pageIndex = bm->findKey(key);
if (pageIndex == -1) { return ""; }
Record* rec = bm->locateRecord(pageIndex, key);
return rec->readData();
}
BufferMapper* DisplayPlane::mapBuffer(DataBuffer *buffer)
{
BufferManager *bm = Hwcomposer::getInstance().getBufferManager();
// invalidate buffer cache if cache is full
if ((int)mDataBuffers.size() >= mCacheCapacity) {
invalidateBufferCache();
}
BufferMapper *mapper = bm->map(*buffer);
if (!mapper) {
ELOGTRACE("failed to map buffer");
return NULL;
}
// add it to data buffers
ssize_t index = mDataBuffers.add(buffer->getKey(), mapper);
if (index < 0) {
ELOGTRACE("failed to add mapper");
bm->unmap(mapper);
return NULL;
}
return mapper;
}
Block::Block(WickyFile* wf, int index){
this->wf = wf;
this->index = index;
this->start = index * BLOCK_SIZE;
this->mem = new unsigned char[BLOCK_SIZE];
BufferManager* bm = BufferManager::getInstance();
bm->readDisk(wf, start, BLOCK_SIZE, mem);
}
bool CatalogManager::tableExisted(string tableName)
{
BufferManager buffer;
if (buffer.tableCatalogFileIsExist(tableName))
return 1;
else
return 0;
}
//--------------------------------------------------------------------------------------------------------------
SkyBox::~SkyBox()
{
BufferManager* pBufMgr = BufferManager::GetSingletonPtr();
//释放顶点声明及顶点缓存
pBufMgr->DelVertexDeclaration( mpVD );
pBufMgr->DelVertexBuffer( mpPositionVB );
pBufMgr->DelVertexBuffer( mpTexcoordVB );
}
Table::~Table()
{
RecordPage page;
page.pageIndex = 1;
page.tableName = TableName;
bm.readPage(page);
page.writenext(head);
bm.writePage(page);
}
Index::Index(std::string name, std::string type, int keyLen){
this->debug = false;
this->d = false;
this->name = name;
this->type = type;
this->keyLen = keyLen;
this->maxKeyNum = (Block::BLOCK_SIZE - 12) / (keyLen + 4) - 3;
this->fileName = "index-" + name + ".wk";
BufferManager* bm = BufferManager::getInstance();
if (bm->isFileExists(fileName)){
bm->read(fileName, 0, &(this->last));//last block
int m, x;
bm->read(fileName, &m); //root
if (m != -1) {
this->root = new Node(this, m);
} else
this->root = NULL;
bm->read(fileName, 8, &m);
for (int i=0; i<m; i++){
bm->read(fileName, &x);
(this->holes).push_back(x);
}
} else {
this->last = 0;
this->root = NULL;
bm->write(fileName, 0, this->last);
bm->write(fileName, -1);
bm->write(fileName, (int)holes.size());
}
}
void CatalogManager::insertTable(TableInfo table)
{
CatalogPage page;
BufferManager buffer;
int i,j;
string s;
if (tableExisted(table.tableName))
{
printf("Failed to create table %s. Table already existed.\n",table.tableName.c_str());
return;
}
for (i=0; i<table.attrNum-1; i++)
for (j=i+1; j<table.attrNum; j++)
if (table.attrName[i]==table.attrName[j])
{
printf("Failed to create table %s. Attributes with the same name have been found.\n",table.tableName.c_str());
return;
}
if (table.primaryKey=="")
table.primaryKeyLoc=-1;
else
{
for (i=0; i<table.attrNum; i++)
if (table.attrName[i]==table.primaryKey)
{
table.primaryKeyLoc=i;
table.attrUnique[i]='Y';
}
}
page.tableName = table.tableName;
page.pageData[0] = (char)table.attrNum;
page.pageData[1] = (char)table.primaryKeyLoc;
for (i=0; i<table.attrNum; i++)
{
page.writeAttr(i*100+2, table.attrName[i]);
page.writeAttr(i*100+22, table.attrType[i]);
// page.writeAttr(i*100+42, table.attrIndex[i]);
page.pageData[i*100+62] = table.attrUnique[i];
*(int*)(page.pageData+(i*100+82)) = 0; //该属性上的索引总数，初始为0
}
buffer.writePage(page);
printf("Created table %s successfully!\n",table.tableName.c_str());
if (table.primaryKeyLoc>=0)
{
printf("Trying to build index on primary key automatelly...\n");
insertIndex(table.tableName, table.attrName[table.primaryKeyLoc], table.tableName+table.attrName[table.primaryKeyLoc]);
}
}
string CatalogManager::primaryKey(string tableName)
{
CatalogPage page;
BufferManager buffer;
page.tableName = tableName;
buffer.readPage(page);
if ((int)page.pageData[1]==-1)
return "";
else
return page.readAttrName((int)page.pageData[1]);
}
int
CatalogManager::new_table_def(Node* node)
{
Node *tablePtr = cm_catNodeMgr.newCopyDataNode(node);
tablePtr->leftSon = cm_catRoot->leftSon;
cm_catRoot->leftSon = tablePtr;
++cm_catRoot->numval;
Node *insertPtr = node->leftSon;
Node *columnPtr = nullptr;
int columnCount = 0;
while (insertPtr != nullptr)
{
columnPtr = cm_catNodeMgr.newCopyDataNode(insertPtr);
if (insertPtr->rightSon != nullptr)
{
columnPtr->rightSon = cm_catNodeMgr.newCopyDataNode(insertPtr->rightSon);
}
columnPtr->leftSon = tablePtr->rightSon;
tablePtr->rightSon = columnPtr;
insertPtr = insertPtr->leftSon;
++columnCount;
}
// build file
string tmpStr(node->strval);
tmpStr += ".db";
BufferManager* bufmgr = BufferManager::getInstance();
bufmgr->createFile(tmpStr.c_str());
Pager* page = bufmgr->getPager(tmpStr.c_str());
unsigned char* block = bufmgr->newblock(page, BUFFER_FLAG_DIRTY);
int* blockData = (int*)(block+16*sizeof(char));
int* blockVarType = blockData + 5;
int* blockVarLen = blockVarType + columnCount;
strncpy((char*)block, "MINISQL v0.01", 16*sizeof(char));
blockData[0] = 1;
blockData[1] = 0;
blockData[2] = 0;
blockData[3] = sizeof(char)*16+sizeof(int)*(5+2*columnCount);
blockData[4] = columnCount;
insertPtr = node->leftSon;
for (int i = columnCount-1; i >=0 ; --i)
{
blockVarType[i] = insertPtr->operation;
blockVarLen[i] = (insertPtr->operation == VAL_CHAR)? insertPtr->numval: 4;
insertPtr = insertPtr->leftSon;
}
return 0;
}
void CatalogManager::dropTable(string tableName)
{
if (!tableExisted(tableName))
{
printf("Table does not exist!\n");
}
else
{
BufferManager buffer;
IndexCatalogPage indexPage;
int n,nn,i,x,k;
string s, attrName;
indexPage.pageIndex=1;
buffer.readPage(indexPage);
n=*(int*)indexPage.pageData;
nn=n;
i=1;
k=0;
while (i<=n) //开始逐条检查，删除这张表上所有的索引
{
x=indexPage.readPrevDel(i);
if (x==0) //如果当前条未被删除
{
s=indexPage.readTableName(i);
if (s==tableName) //如果是这张表的索引，删掉
{
k++; //k用来记录删除了多少条索引
indexPage.deleteIndex(i);
attrName=indexPage.readAttrName(i);
BufferManager bm;
string filePath=bm.indexFilePath(tableName, attrName);
if (bm.indexFileIsExist(tableName, attrName))
bm.deleteIndexFile(tableName, attrName);
}
}
else //如果当前条已被删除，则最后一条位置后移
n++;
i++;
}
indexPage.pageIndex=1; //记录索引信息首页的索引总数也需要改
buffer.readPage(indexPage);
*(int*)indexPage.pageData=nn-k;
buffer.writePage(indexPage);
buffer.deleteTableCatalogFile(tableName); //删除当前表的文件
buffer.deleteTableFile(tableName); //删除当前表的record文件
printf("Dropped table %s successfully!\n",tableName.c_str());
}
}
bool RenderDevice::unbindBuffers(RenderBatch* renderable)
{
BufferManager* buffers = activeContext->bufferManager;
const GeometryBuffer* gb = renderable->getGeometryBuffer().get();
VertexBuffer* vb = buffers->getVertexBuffer(gb).get();
if( !vb ) return false;
renderBackend->unbindVertexBuffer(vb);
IndexBuffer* ib = buffers->getIndexBuffer(gb).get();
if( ib ) renderBackend->unbindIndexBuffer(ib);
return true;
}
bool CatalogManager::insertIndex(string tableName, string attrName, string indexName)
{
IndexCatalogPage indexPage;
if (indexExisted(indexName))
{
printf("Failed to insert index %s. Index name already existed!\n", indexName.c_str());
return 0;
}
else
if (!tableExisted(tableName))
{
printf("Failed to insert index %s. Table %s does not exist!\n", indexName.c_str(),tableName.c_str());
return 0;
}
else
if (!attrExisted(tableName, attrName))
{
printf("Failed to insert index %s. Attribute %s on Table %s does not exist!\n", indexName.c_str(), attrName.c_str(),tableName.c_str());
return 0;
}
else
if (!attrUnique(tableName, attrName))
{
printf("Failed to insert index %s. Attribute %s on Table %s is not unique!\n", indexName.c_str(), attrName.c_str(),tableName.c_str());
return 0;
}
else
{
indexPage.writeIndex(tableName, attrName, indexName);
BufferManager buffer;
CatalogPage catalog;
int num,i;
catalog.tableName = tableName;
buffer.readPage(catalog);
num = (int)catalog.pageData[0];
for (i=0; i<num; i++)
if (catalog.readAttrName(i) == attrName)
{
catalog.modifyAttrIndexNum(i,1);
buffer.writePage(catalog);
break;
}
printf("Inserted index %s(Attribute %s on Table %s) successfully!\n", indexName.c_str(), attrName.c_str(),tableName.c_str());
return 1;
}
}
void BANDB::createDB(char* dbName, char* logName) {
// Create db and log files, start buffer and log managers
fm->create(dbName);
fm->create(logName);
bm->start(dbName);
lm->start(logName);
}
void DisplayPlane::invalidateBufferCache()
{
BufferManager *bm = Hwcomposer::getInstance().getBufferManager();
BufferMapper* mapper;
RETURN_VOID_IF_NOT_INIT();
for (size_t i = 0; i < mDataBuffers.size(); i++) {
mapper = mDataBuffers.valueAt(i);
bm->unmap(mapper);
}
mDataBuffers.clear();
// reset current buffer
mCurrentDataBuffer = 0;
}
bool BANDB::remove(int transID, int key) {
int pageIndex = bm->findKey(key);
if (pageIndex == -1) { return false; }
int pageNum = bm->getNumAtIndex(pageIndex);
Record* oldRecP = bm->locateRecord(pageIndex, key);
Record oldRec = *oldRecP;
char* oldData = (char*) &oldRec;
char empty[16] = {};
for (int i = 0; i < 16; i++) { empty[i] = 0; }
bool result = bm->removeRecord(pageIndex, key);
lm->writeWriteRecord(transID, pageNum, oldData, empty);
return result;
}
vector<pair<Attribute, PageIndexType>> Table::getAll(int attrnum)
{
vector<pair<Attribute, PageIndexType>> result;
PageIndexType i = head;
while(i != UNDEFINEED_PAGE_NUM)
{
RecordPage page;
page.tableName = TableName;
page.pageIndex = i;
bm.readPage(page);
Tuple tuple;
tuple.page = page;
tuple.createlist(TableName);
tuple.ParseFromRawData();
pair<Attribute, PageIndexType> p;
p.first = tuple.list[attrnum];
p.second = i;
result.push_back(p);
i = page.readnext();
}
return result;
}
vector<PageIndexType> Table::scanNotEqual(int attrnum, Attribute attribute)
{
vector<PageIndexType> result;
PageIndexType i = head;
while (i != UNDEFINEED_PAGE_NUM)
{
RecordPage page;
page.tableName = TableName;
page.pageIndex = i;
bm.readPage(page);
Tuple tuple;
tuple.page = page;
tuple.createlist(TableName);
tuple.ParseFromRawData();
if (tuple.list[attrnum] != attribute)
result.push_back(i);
i = page.readnext();
}
return result;
}
void DisplayPlane::updateActiveBuffers(BufferMapper *mapper)
{
BufferManager *bm = Hwcomposer::getInstance().getBufferManager();
// unmap the first entry (oldest buffer)
if (mActiveBuffers.size() >= MIN_DATA_BUFFER_COUNT) {
BufferMapper *oldest = mActiveBuffers.itemAt(0);
bm->unmap(oldest);
mActiveBuffers.removeAt(0);
}
// queue it to active buffers
if (!isActiveBuffer(mapper)) {
mapper->incRef();
mActiveBuffers.push_back(mapper);
}
}
bool BANDB::write(int transID, int key, char* data) {
int pageIndex = bm->findKey(key);
if (pageIndex == -1) { pageIndex = bm->findKey(0); }
if (pageIndex == -1) { return false; }
int pageNum = bm->getNumAtIndex(pageIndex);
Record* oldRecP = bm->locateRecord(pageIndex, key);
Record oldRec = *oldRecP;
char* oldData = (char*) &oldRec;
Record newRec = Record(key, data);
char* newData = (char*) &newRec;
bool result = bm->insertRecord(pageIndex, key, data);
lm->writeWriteRecord(transID, pageNum, oldData, newData);
return result;
}
int CatalogManager::indexNum(string tableName, string attrName)
{
CatalogPage catalog;
BufferManager buffer;
int num,i,x=-1;
catalog.tableName = tableName;
buffer.readPage(catalog);
num = (int)catalog.pageData[0];
for (i=0; i<num; i++)
if (catalog.readAttrName(i) == attrName)
{
x = catalog.readAttrIndexNum(i);
return x;
}
return x;
}
void DisplayPlane::invalidateActiveBuffers()
{
BufferManager *bm = Hwcomposer::getInstance().getBufferManager();
BufferMapper* mapper;
RETURN_VOID_IF_NOT_INIT();
VLOGTRACE("invalidating active buffers");
for (size_t i = 0; i < mActiveBuffers.size(); i++) {
mapper = mActiveBuffers.itemAt(i);
// unmap it
bm->unmap(mapper);
}
// clear recorded data buffers
mActiveBuffers.clear();
}
bool CatalogManager::attrUnique(string tableName, string attrName)
{
int i,num;
char c = '\0';
CatalogPage page;
BufferManager buffer;
page.tableName = tableName;
buffer.readPage(page);
num = (int)page.pageData[0];
for (i=0; i<num; i++)
if (page.readAttrName(i) == attrName)
c = page.readAttrUnique(i);
if (c=='Y')
return 1;
else
return 0;
}
