/************************************************ * No Change * RETURN: * success - successfully created the index list header * failure - it did not create the index list header ***********************************************************/ const int IndexList::updateLastPtr(const int lastCount) { int rc; if (m_curBlock.state == BLK_INIT) readCurBlk(); if (m_useNarray) { rc = setCurBlkNextPtr(m_nextLbid, lastCount); rc = writeCurBlk(); } else { ((IdxEmptyListEntry*)&m_lastIdxRidListPtr)->fbo = m_nextLbid; ((IdxEmptyListEntry*)&m_lastIdxRidListPtr)->sbid = 0; ((IdxEmptyListEntry*)&m_lastIdxRidListPtr)->entry= 0; m_lastIdxRidListPtr.type= LIST_BLOCK_TYPE; m_lastIdxRidListPtr.spare=0x0; m_lastIdxRidListPtr.count = lastCount; setSubBlockEntry( m_curBlock.data, m_sbid, LIST_BLOCK_LLP_POS, LIST_ENTRY_WIDTH , &m_lastIdxRidListPtr ); m_curBlock.state = BLK_WRITE; rc = writeCurBlk(); } return rc; }
/************************************************ * No Change * RETURN: * success - successfully created the index list header * failure - it did not create the index list header ***********************************************************/ const int IndexList::insertRid(const RID& newRid, int& pos) { int rc = NO_ERROR; IdxRidListEntry idxRidListEntry; if (m_curType == LIST_BLOCK_TYPE) { m_sbid = 0; m_entry = 0; } memset(&idxRidListEntry, 0, LIST_ENTRY_WIDTH) ; idxRidListEntry.type =LIST_RID_TYPE; idxRidListEntry.spare =0; //cout << "line 910:newRid->" << newRid << endl; idxRidListEntry.rid =newRid; if (m_lbid != m_hdrLbid) { rc = readCurBlk(); setSubBlockEntry( m_curBlock.data, m_sbid, pos, LIST_ENTRY_WIDTH, &idxRidListEntry ); m_curBlock.state = BLK_WRITE; } else { setSubBlockEntry( m_hdrBlock.data, m_sbid, pos, LIST_ENTRY_WIDTH, &idxRidListEntry ); m_hdrBlock.state = BLK_WRITE; } return rc; }
/*********************************************************** * DESCRIPTION: * RETURN: * success NO_ERROR * fail ***********************************************************/ const int IndexList::moveRidsToNewSub(FILE* pFile, const RID& oldRid, const RID& newRid, IdxEmptyListEntry* newIdxListEntryPtr) { int rc; //Write everything out in getSegment m_segType = LIST_SUBBLOCK_TYPE; rc =getSegment( m_pFile, ENTRY_32, newIdxListEntryPtr ); if (rc != NO_ERROR) return rc; //This is the new segment m_curType = LIST_SUBBLOCK_TYPE; m_lbid = newIdxListEntryPtr->fbo; m_sbid = newIdxListEntryPtr->sbid; m_entry = newIdxListEntryPtr->entry; if (m_lbid !=m_hdrLbid) rc = readCurBlk(); rc = insertRid(oldRid, m_entry); m_entry++; rc = insertRid(newRid, m_entry); rc = updateCurCount(2); return rc; }
/************************************************ * No Change * RETURN: * success - successfully created the index list header * failure - it did not create the index list header ***********************************************************/ const int IndexList::addRidInBlk( const RID& newRid) { int maxCount, count=0; int rc = NO_ERROR; CommBlock cb; cb.file.oid = m_oid; cb.file.pFile = m_pFile; if (m_useNarray) maxCount = MAX_BLK_NARRAY_RID_CNT; else maxCount = MAX_BLK_RID_CNT; //Find the last block that has a space or //No next block linked rc = findLastBlk(count); if ((count ==maxCount) && (m_nextType==LIST_SIZE_TYPE)) {//Full, also need a new segment IdxEmptyListEntry newIdxListEntryPtr; m_segType = LIST_BLOCK_TYPE; rc = getSegment( m_pFile, ENTRY_BLK, &newIdxListEntryPtr); m_nextLbid = ((IdxEmptyListEntry*)&newIdxListEntryPtr)->fbo; m_nextType = m_segType; m_lastIdxRidListPtr.llp=((IdxRidListPtr*)&newIdxListEntryPtr)->llp; rc = updateLastPtrAndParent(count); //the new block for insertion and count record m_lbid = m_nextLbid; m_sbid = 0; m_entry = 0; m_curType = m_nextType; rc = readCurBlk(); //free manager puts bad entry type at the last entry for new block //clean it up! IdxRidListPtr idxRidListPtr; memset(&idxRidListPtr, 0, sizeof(idxRidListPtr)); rc = setNextInfoFromBlk( idxRidListPtr); if (m_useNarray) { rc = initCurBlock(); } //Set the count to the beginning count = 0; }//end if FULL get new segment // insert in the current block at the location if (m_lastLbid != m_lbid) { rc = setLastLbid(m_lbid); } rc = insertRid(newRid, count); rc = updateCurCount(); rc = updateHdrCount(); return rc; }
/************************************************ * No Change * RETURN: * success - successfully created the index list header * failure - it did not create the index list header ***********************************************************/ const int IndexList::findLastBlk(int& count) { int maxCount; int rc ; if (m_useNarray) maxCount = MAX_BLK_NARRAY_RID_CNT; else maxCount = MAX_BLK_RID_CNT; rc = readCurBlk(); rc = getNextInfo(count); while ((count == maxCount) &&(m_nextType==LIST_BLOCK_TYPE)) { //current is a Full link, No space to insert, go to the next one m_lbid = m_nextLbid; m_sbid = 0; m_entry =0; rc = readCurBlk(); rc = getNextInfo(count); }//end of while return rc; }
/************************************************ * Description: * Find a entry for the given rowId and Key * Converted * input * pFile -- File Handler * rowId -- row id * key -- value * curIdxRidListHdrPtr - point to the header * output * lbid -- File block id * sbid -- Sub Block id * entry -- Entry id * * * return value * true --found * false--not found ************************************************/ const int IndexList::findFirstBlk(FILE* pFile, const uint64_t& key, IdxEmptyListEntry* curIdxRidListHdrPtr, uint64_t& lbid) { int rc; CommBlock cb; int count; cb.file.oid = m_oid; cb.file.pFile = pFile; m_pFile = pFile; rc = getHdrInfo(curIdxRidListHdrPtr); if (key!= m_curIdxRidListHdr.key) { return ERR_IDX_LIST_INVALID_KEY;; } int type = m_curIdxRidListHdr.nextIdxRidListPtr.type; switch (type) { case LIST_NOT_USED_TYPE://Header is not full, no sub-block linked lbid = INVALID_LBID; return NO_ERROR; //not found case LIST_RID_TYPE:// There is a row id here, Check! lbid = INVALID_LBID; return NO_ERROR; //not found case LIST_SUBBLOCK_TYPE://Not found in header //get the lbid sbid and entry out from the header last entry rc = getSubBlk(m_lbid, m_sbid, m_entry ); m_curType = type; if (m_lbid != m_hdrLbid) rc =readCurBlk(); rc = getNextInfoFromBlk(m_lastIdxRidListPtr); count = m_lastIdxRidListPtr.count; //current count type = m_lastIdxRidListPtr.type; //block type if (type==LIST_BLOCK_TYPE) lbid = ((IdxEmptyListEntry*)&m_lastIdxRidListPtr)->fbo; else lbid = INVALID_LBID; return NO_ERROR; break; default: //printf ("FIND FIRST BLOCK got no where, error out !! \n"); break; }; //end switch lbid =INVALID_LBID; return NO_ERROR; } //end function
/**************************************************************** * DESCRIPTION: * Private Function for setting the last Fbo on header * ***************************************************************/ const int IndexList::setNextInfoFromBlk( IdxRidListPtr& idxRidListPtr) { int rc = NO_ERROR; CommBlock cb; cb.file.oid = m_oid; cb.file.pFile = m_pFile; int pos = 0; if (m_curType == LIST_SUBBLOCK_TYPE) pos = LIST_SUB_LLP_POS; else if (m_curType == LIST_BLOCK_TYPE) pos = LIST_BLOCK_LLP_POS; if (m_lbid==m_hdrLbid) {//when sub == hdr setSubBlockEntry( m_hdrBlock.data, m_sbid, pos, LIST_ENTRY_WIDTH, &idxRidListPtr ); m_hdrBlock.state =BLK_WRITE; } else { readCurBlk(); if (m_lbid == m_curBlock.lbid) { setSubBlockEntry( m_curBlock.data, m_sbid, pos, LIST_ENTRY_WIDTH, &idxRidListPtr ); rc = writeDBFile(cb, m_curBlock.data, m_lbid ); m_curBlock.state =BLK_READ; } else return ERR_IDX_LIST_WRONG_LBID_WRITE; } return rc; }
/**************************************************************** * DESCRIPTION: * RETURN: * success - successfully created the index list header * failure - it did not create the index list header ***********************************************************/ const int IndexList::updateHdrSub(const RID& newRid, const uint64_t &key) { int rc = ERR_IDX_LIST_INVALID_UP_HDR; CommBlock cb; cb.file.oid = m_oid; cb.file.pFile = m_pFile; if (m_curIdxRidListHdr.firstIdxRidListEntry.type == (int)LIST_NOT_USED_TYPE) { m_curIdxRidListHdr.firstIdxRidListEntry.type =LIST_RID_TYPE; m_curIdxRidListHdr.firstIdxRidListEntry.rid = newRid; m_curIdxRidListHdr.idxRidListSize.size++; if (m_hdrBlock.lbid == m_hdrLbid) rc = writeSubBlockEntry( cb, &m_hdrBlock, m_hdrLbid, m_hdrSbid, m_hdrEntry, LIST_HDR_SIZE, &m_curIdxRidListHdr ); else return ERR_IDX_LIST_WRONG_LBID_WRITE; m_hdrBlock.state = BLK_READ; return rc; };//Done //Check Header last entry's type and go to different next step m_nextType = m_curIdxRidListHdr.nextIdxRidListPtr.type; switch (m_nextType) { case LIST_NOT_USED_TYPE://Header is not full //insert row id into header last enty m_curIdxRidListHdr.nextIdxRidListPtr.type=LIST_RID_TYPE; m_curIdxRidListHdr.nextIdxRidListPtr.llp= newRid; m_curIdxRidListHdr.idxRidListSize.size++; if (m_hdrBlock.lbid == m_hdrLbid) rc =writeSubBlockEntry( cb, &m_hdrBlock,m_hdrLbid, m_hdrSbid, m_hdrEntry, LIST_HDR_SIZE, &m_curIdxRidListHdr); else return ERR_IDX_LIST_WRONG_LBID_WRITE; m_hdrBlock.state = BLK_READ; m_lastLbid = INVALID_LBID; break; case LIST_RID_TYPE://Header is full, need a new sub-block RID oldRid ; IdxEmptyListEntry newIdxListEntry; oldRid = m_curIdxRidListHdr.nextIdxRidListPtr.llp; //need a sub block m_segType = LIST_SUBBLOCK_TYPE; rc= moveRidsToNewSub(m_pFile, oldRid,newRid,&newIdxListEntry); if (rc!=NO_ERROR) return rc; //update header count twice m_curIdxRidListHdr.nextIdxRidListPtr.type = m_segType; m_curIdxRidListHdr.nextIdxRidListPtr.llp = ((IdxRidListHdrPtr*)&newIdxListEntry)->llp; m_curIdxRidListHdr.nextIdxRidListPtr.spare= 0; m_curIdxRidListHdr.idxRidListSize.size++; setSubBlockEntry(m_hdrBlock.data, m_hdrSbid, m_hdrEntry, LIST_HDR_SIZE, &m_curIdxRidListHdr ); rc = writeDBFile( cb, m_hdrBlock.data, m_hdrLbid ); if (rc!=NO_ERROR) return rc; m_hdrBlock.state = BLK_READ; m_lastLbid = INVALID_LBID; if (m_curBlock.state==BLK_WRITE) { rc = writeDBFile( cb, m_curBlock.data, m_lbid ); m_curBlock.state = BLK_READ; } break; case LIST_SUBBLOCK_TYPE: //first one is a sub block m_lbid= ((IdxEmptyListEntry*) &(m_curIdxRidListHdr.nextIdxRidListPtr))->fbo; m_sbid=((IdxEmptyListEntry*) &(m_curIdxRidListHdr.nextIdxRidListPtr))->sbid; m_entry=((IdxEmptyListEntry*) &(m_curIdxRidListHdr.nextIdxRidListPtr))->entry; m_curType = m_nextType; m_segType = LIST_BLOCK_TYPE; rc =readCurBlk(); rc = getNextInfoFromBlk(m_lastIdxRidListPtr); rc = addRidInSub(newRid, m_lastIdxRidListPtr); break; default: rc=ERR_IDX_LIST_INVALID_UP_HDR; break; } //end of switch return rc; }
/************************************************ * No Change * RETURN: * success - successfully created the index list header * failure - it did not create the index list header ***********************************************************/ const int IndexList::addRidInSub(const RID& newRid, IdxRidListPtr& lastIdxRidListPtr) { int rc = NO_ERROR; int maxCount; int count; CommBlock cb; cb.file.oid = m_oid; cb.file.pFile = m_pFile; m_curType = LIST_SUBBLOCK_TYPE; m_segType = LIST_BLOCK_TYPE; m_nextType = lastIdxRidListPtr.type; maxCount = MAX_SUB_RID_CNT; count = lastIdxRidListPtr.count; //For n-array m_curLevel =0; m_curLevelPos = 0; m_curBlkPos = 0; m_parentLbid = INVALID_LBID; if ((count ==maxCount) && (m_nextType==LIST_SIZE_TYPE)) {//Full, need a new segment IdxEmptyListEntry newIdxListEntryPtr; memset(&newIdxListEntryPtr, 0, sizeof(newIdxListEntryPtr)); rc = getSegment( m_pFile, ENTRY_BLK, &newIdxListEntryPtr); if (rc!=NO_ERROR) return rc; lastIdxRidListPtr.type = LIST_BLOCK_TYPE; lastIdxRidListPtr.llp=((IdxRidListPtr*)&newIdxListEntryPtr)->llp; lastIdxRidListPtr.spare=0x0; rc = setNextInfoFromBlk( lastIdxRidListPtr); //New Block initialization m_lbid = newIdxListEntryPtr.fbo; m_sbid = 0; m_entry = 0; m_curType = m_segType; rc = readCurBlk(); //make sure no garbage in the new block last entry IdxRidListPtr idxRidListPtr; memset(&idxRidListPtr, 0, sizeof(idxRidListPtr)); rc = setNextInfoFromBlk( idxRidListPtr); count = 0; if (m_useNarray) rc = initCurBlock(); if (m_lastLbid != m_lbid) { rc = setLastLbid(m_lbid); } }//end if FULL else if (count <maxCount)// if less than maxCount either type =7 or 0 { if (m_lastLbid != INVALID_LBID) { uint64_t zlbid = INVALID_LBID; rc = setLastLbid(zlbid); } } //endif count else if ((count ==maxCount) && (m_nextType==LIST_BLOCK_TYPE)) { m_lbid = ((IdxEmptyListEntry*)&lastIdxRidListPtr)->fbo; m_sbid = 0; m_entry = 0; m_curType = LIST_BLOCK_TYPE; rc = addRidInBlk(newRid); return rc; } rc = insertRid(newRid, count);// count is the position rc = updateCurCount(); rc = updateHdrCount(); return rc; }