void
Dbtup::execLCP_FRAG_ORD(Signal* signal)
{
LcpFragOrd* req= (LcpFragOrd*)signal->getDataPtr();
TablerecPtr tablePtr;
tablePtr.i = req->tableId;
ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
if (tablePtr.p->m_no_of_disk_attributes)
{
jam();
FragrecordPtr fragPtr;
Uint32 fragId = req->fragmentId;
fragPtr.i = RNIL;
getFragmentrec(fragPtr, fragId, tablePtr.p);
ndbrequire(fragPtr.i != RNIL);
Fragrecord& frag = *fragPtr.p;
ndbrequire(frag.m_lcp_scan_op == RNIL && c_lcp_scan_op != RNIL);
frag.m_lcp_scan_op = c_lcp_scan_op;
ScanOpPtr scanPtr;
c_scanOpPool.getPtr(scanPtr, frag.m_lcp_scan_op);
ndbrequire(scanPtr.p->m_fragPtrI == RNIL);
scanPtr.p->m_fragPtrI = fragPtr.i;
scanFirst(signal, scanPtr);
scanPtr.p->m_state = ScanOp::First;
}
}
int
Dbtup::accReadPk(Uint32 tableId, Uint32 fragId, Uint32 fragPageId, Uint32 pageIndex, Uint32* dataOut, bool xfrmFlag)
{
jamEntry();
// get table
TablerecPtr tablePtr;
tablePtr.i = tableId;
ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
// get fragment
FragrecordPtr fragPtr;
getFragmentrec(fragPtr, fragId, tablePtr.p);
// get real page id and tuple offset
Uint32 pageId = getRealpid(fragPtr.p, fragPageId);
// use TUX routine - optimize later
int ret = tuxReadPk(fragPtr.i, pageId, pageIndex, dataOut, xfrmFlag);
return ret;
}
void Dbtup::execTUP_DEALLOCREQ(Signal* signal)
{
TablerecPtr regTabPtr;
FragrecordPtr regFragPtr;
Uint32 frag_page_id, frag_id;
jamEntry();
frag_id= signal->theData[0];
regTabPtr.i= signal->theData[1];
frag_page_id= signal->theData[2];
Uint32 page_index= signal->theData[3];
ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec);
getFragmentrec(regFragPtr, frag_id, regTabPtr.p);
ndbassert(regFragPtr.p != NULL);
if (! Local_key::isInvalid(frag_page_id, page_index))
{
Local_key tmp;
tmp.m_page_no= getRealpid(regFragPtr.p, frag_page_id);
tmp.m_page_idx= page_index;
PagePtr pagePtr;
Tuple_header* ptr= (Tuple_header*)get_ptr(&pagePtr, &tmp, regTabPtr.p);
ndbrequire(ptr->m_header_bits & Tuple_header::FREED);
if (regTabPtr.p->m_attributes[MM].m_no_of_varsize +
regTabPtr.p->m_attributes[MM].m_no_of_dynamic)
{
jam();
free_var_rec(regFragPtr.p, regTabPtr.p, &tmp, pagePtr);
} else {
free_fix_rec(regFragPtr.p, regTabPtr.p, &tmp, (Fix_page*)pagePtr.p);
}
}
}
void
Dbtup::execACC_SCANREQ(Signal* signal)
{
jamEntry();
const AccScanReq reqCopy = *(const AccScanReq*)signal->getDataPtr();
const AccScanReq* const req = &reqCopy;
ScanOpPtr scanPtr;
scanPtr.i = RNIL;
do {
// find table and fragment
TablerecPtr tablePtr;
tablePtr.i = req->tableId;
ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
FragrecordPtr fragPtr;
Uint32 fragId = req->fragmentNo;
fragPtr.i = RNIL;
getFragmentrec(fragPtr, fragId, tablePtr.p);
ndbrequire(fragPtr.i != RNIL);
Fragrecord& frag = *fragPtr.p;
// flags
Uint32 bits = 0;
if (AccScanReq::getLcpScanFlag(req->requestInfo))
{
jam();
bits |= ScanOp::SCAN_LCP;
c_scanOpPool.getPtr(scanPtr, c_lcp_scan_op);
}
else
{
// seize from pool and link to per-fragment list
LocalDLList<ScanOp> list(c_scanOpPool, frag.m_scanList);
if (! list.seize(scanPtr)) {
jam();
break;
}
}
if (!AccScanReq::getNoDiskScanFlag(req->requestInfo)
&& tablePtr.p->m_no_of_disk_attributes)
{
bits |= ScanOp::SCAN_DD;
}
bool mm = (bits & ScanOp::SCAN_DD);
if (tablePtr.p->m_attributes[mm].m_no_of_varsize > 0) {
bits |= ScanOp::SCAN_VS;
// disk pages have fixed page format
ndbrequire(! (bits & ScanOp::SCAN_DD));
}
if (! AccScanReq::getReadCommittedFlag(req->requestInfo)) {
if (AccScanReq::getLockMode(req->requestInfo) == 0)
bits |= ScanOp::SCAN_LOCK_SH;
else
bits |= ScanOp::SCAN_LOCK_EX;
}
if (AccScanReq::getNRScanFlag(req->requestInfo))
{
jam();
bits |= ScanOp::SCAN_NR;
scanPtr.p->m_endPage = req->maxPage;
if (req->maxPage != RNIL && req->maxPage > frag.noOfPages)
{
ndbout_c("%u %u endPage: %u (noOfPages: %u)",
tablePtr.i, fragId,
req->maxPage, fragPtr.p->noOfPages);
}
}
else
{
jam();
scanPtr.p->m_endPage = RNIL;
}
if (AccScanReq::getLcpScanFlag(req->requestInfo))
{
jam();
ndbrequire((bits & ScanOp::SCAN_DD) == 0);
ndbrequire((bits & ScanOp::SCAN_LOCK) == 0);
}
// set up scan op
new (scanPtr.p) ScanOp();
ScanOp& scan = *scanPtr.p;
scan.m_state = ScanOp::First;
scan.m_bits = bits;
scan.m_userPtr = req->senderData;
scan.m_userRef = req->senderRef;
scan.m_tableId = tablePtr.i;
scan.m_fragId = frag.fragmentId;
scan.m_fragPtrI = fragPtr.i;
scan.m_transId1 = req->transId1;
scan.m_transId2 = req->transId2;
scan.m_savePointId = req->savePointId;
// conf
AccScanConf* const conf = (AccScanConf*)signal->getDataPtrSend();
conf->scanPtr = req->senderData;
conf->accPtr = scanPtr.i;
conf->flag = AccScanConf::ZNOT_EMPTY_FRAGMENT;
sendSignal(req->senderRef, GSN_ACC_SCANCONF,
signal, AccScanConf::SignalLength, JBB);
return;
} while (0);
if (scanPtr.i != RNIL) {
jam();
releaseScanOp(scanPtr);
}
// LQH does not handle REF
signal->theData[0] = 0x313;
sendSignal(req->senderRef, GSN_ACC_SCANREF, signal, 1, JBB);
}
/* ---------------------------------------------------------------- */
void Dbtup::execTUP_PREPLCPREQ(Signal* signal)
{
CheckpointInfoPtr ciPtr;
DiskBufferSegmentInfoPtr dbsiPtr;
FragrecordPtr regFragPtr;
LocalLogInfoPtr lliPtr;
TablerecPtr regTabPtr;
ljamEntry();
Uint32 userptr = signal->theData[0];
BlockReference userblockref = signal->theData[1];
regTabPtr.i = signal->theData[2];
ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec);
Uint32 fragId = signal->theData[3];
Uint32 checkpointNumber = signal->theData[4];
cundoFileVersion = signal->theData[5];
getFragmentrec(regFragPtr, fragId, regTabPtr.p);
ndbrequire(regTabPtr.i != RNIL);
seizeCheckpointInfoRecord(ciPtr);
lliPtr.i = (cundoFileVersion << 2) + (regTabPtr.i & 0x3);
ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
cnoOfDataPagesToDiskWithoutSynch = 0;
ciPtr.p->lcpDataFileHandle = RNIL;
ciPtr.p->lcpCheckpointVersion = checkpointNumber;
ciPtr.p->lcpLocalLogInfoP = lliPtr.i;
ciPtr.p->lcpFragmentP = regFragPtr.i; /* SET THE FRAGMENT */
ciPtr.p->lcpFragmentId = fragId; /* SAVE THE FRAGMENT IDENTITY */
ciPtr.p->lcpTabPtr = regTabPtr.i; /* SET THE TABLE POINTER */
ciPtr.p->lcpBlockref = userblockref; /* SET THE BLOCK REFERENCE */
ciPtr.p->lcpUserptr = userptr; /* SET THE USERPOINTER */
/***************************************************************/
/* OPEN THE UNDO FILE FOR WRITE */
/* UPON FSOPENCONF */
/***************************************************************/
if (lliPtr.p->lliActiveLcp == 0) { /* IS THE UNDO LOG FILE OPEN? */
PendingFileOpenInfoPtr undoPfoiPtr;
UndoPagePtr regUndoPagePtr;
ljam();
lliPtr.p->lliPrevRecordId = 0;
lliPtr.p->lliLogFilePage = 0;
lliPtr.p->lliUndoPagesToDiskWithoutSynch = 0;
lliPtr.p->lliUndoWord = ZUNDO_PAGE_HEADER_SIZE;
seizeUndoBufferSegment(signal, regUndoPagePtr);
seizeDiskBufferSegmentRecord(dbsiPtr);
dbsiPtr.p->pdxBuffertype = UNDO_PAGES;
for (Uint32 i = 0; i < ZUB_SEGMENT_SIZE; i++) {
dbsiPtr.p->pdxDataPage[i] = regUndoPagePtr.i + i;
}//for
dbsiPtr.p->pdxFilePage = lliPtr.p->lliLogFilePage;
lliPtr.p->lliUndoPage = regUndoPagePtr.i;
lliPtr.p->lliUndoBufferSegmentP = dbsiPtr.i;
/* F LEVEL NOT USED */
Uint32 fileType = 1; /* VERSION */
fileType = (fileType << 8) | 2; /* .LOCLOG */
fileType = (fileType << 8) | 6; /* D6 */
fileType = (fileType << 8) | 0xff; /* DON'T USE P DIRECTORY LEVEL */
Uint32 fileFlag = 0x301; /* CREATE, WRITE ONLY, TRUNCATE */
seizePendingFileOpenInfoRecord(undoPfoiPtr);
undoPfoiPtr.p->pfoOpenType = LCP_UNDO_FILE_WRITE;
undoPfoiPtr.p->pfoCheckpointInfoP = ciPtr.i;
signal->theData[0] = cownref;
signal->theData[1] = undoPfoiPtr.i;
signal->theData[2] = lliPtr.i;
signal->theData[3] = 0xFFFFFFFF;
signal->theData[4] = cundoFileVersion;
signal->theData[5] = fileType;
signal->theData[6] = fileFlag;
sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA);
}//if
/***************************************************************/
/* OPEN THE DATA FILE FOR WRITE */
/* THE FILE HANDLE WILL BE SET IN THE CHECKPOINT_INFO_RECORD */
/* UPON FSOPENCONF */
/***************************************************************/
/* OPEN THE DATA FILE IN THE FOLLOWING FORM */
/* D5/DBTUP/T<TABID>/F<FRAGID>/S<CHECKPOINT_NUMBER>.DATA */
PendingFileOpenInfoPtr dataPfoiPtr;
Uint32 fileType = 1; /* VERSION */
fileType = (fileType << 8) | 0; /* .DATA */
fileType = (fileType << 8) | 5; /* D5 */
fileType = (fileType << 8) | 0xff; /* DON'T USE P DIRECTORY LEVEL */
Uint32 fileFlag = 0x301; /* CREATE, WRITE ONLY, TRUNCATE */
seizePendingFileOpenInfoRecord(dataPfoiPtr); /* SEIZE A NEW FILE OPEN INFO */
if (lliPtr.p->lliActiveLcp == 0) {
ljam();
dataPfoiPtr.p->pfoOpenType = LCP_DATA_FILE_WRITE_WITH_UNDO;
} else {
ljam();
dataPfoiPtr.p->pfoOpenType = LCP_DATA_FILE_WRITE;
}//if
dataPfoiPtr.p->pfoCheckpointInfoP = ciPtr.i;
/* LET'S OPEN THE DATA FILE FOR WRITE */
/* INCREASE NUMBER OF ACTIVE CHECKPOINTS */
lliPtr.p->lliActiveLcp = 1;
signal->theData[0] = cownref;
signal->theData[1] = dataPfoiPtr.i;
signal->theData[2] = ciPtr.p->lcpTabPtr;
signal->theData[3] = ciPtr.p->lcpFragmentId;
signal->theData[4] = ciPtr.p->lcpCheckpointVersion;
signal->theData[5] = fileType;
signal->theData[6] = fileFlag;
sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA);
return;
}//Dbtup::execTUP_PREPLCPREQ()
