void Dbtup::scanProcedure(Signal* signal,
Operationrec* regOperPtr,
Uint32 lenAttrInfo)
{
//--------------------------------------------------------
// We introduce the maxCheck so that there is always one
// stored procedure entry free for copy procedures. Thus
// no amount of scanning can cause problems for the node
// recovery functionality.
//--------------------------------------------------------
StoredProcPtr storedPtr;
c_storedProcPool.seize(storedPtr);
ndbrequire(storedPtr.i != RNIL);
storedPtr.p->storedCode = ZSCAN_PROCEDURE;
storedPtr.p->storedCounter = 0;
storedPtr.p->storedProcLength = lenAttrInfo;
storedPtr.p->storedLinkFirst = RNIL;
storedPtr.p->storedLinkLast = RNIL;
set_trans_state(regOperPtr, TRANS_WAIT_STORED_PROCEDURE_ATTR_INFO);
regOperPtr->attrinbufLen = lenAttrInfo;
regOperPtr->currentAttrinbufLen = 0;
regOperPtr->storedProcPtr = storedPtr.i;
if (lenAttrInfo >= ZATTR_BUFFER_SIZE) { // yes ">="
jam();
// send REF and change state to ignore the ATTRINFO to come
storedSeizeAttrinbufrecErrorLab(signal, regOperPtr, ZSTORED_TOO_MUCH_ATTRINFO_ERROR);
}
}//Dbtup::scanProcedure()
void Dbtup::deleteScanProcedure(Signal* signal,
Operationrec* regOperPtr)
{
StoredProcPtr storedPtr;
Uint32 storedProcId = signal->theData[4];
c_storedProcPool.getPtr(storedPtr, storedProcId);
ndbrequire(storedPtr.p->storedCode != ZSTORED_PROCEDURE_FREE);
if (unlikely(storedPtr.p->storedCode == ZCOPY_PROCEDURE))
{
releaseCopyProcedure();
}
else
{
/* ZSCAN_PROCEDURE */
releaseSection(storedPtr.p->storedProcIVal);
}
storedPtr.p->storedCode = ZSTORED_PROCEDURE_FREE;
storedPtr.p->storedProcIVal= RNIL;
c_storedProcPool.release(storedPtr);
set_trans_state(regOperPtr, TRANS_IDLE);
signal->theData[0] = regOperPtr->userpointer;
signal->theData[1] = storedProcId;
BlockReference lqhRef = calcInstanceBlockRef(DBLQH);
sendSignal(lqhRef, GSN_STORED_PROCCONF, signal, 2, JBB);
}//Dbtup::deleteScanProcedure()
/* ---------------------------------------------------------------- */
void Dbtup::initOpConnection(Operationrec* regOperPtr)
{
set_tuple_state(regOperPtr, TUPLE_ALREADY_ABORTED);
set_trans_state(regOperPtr, TRANS_IDLE);
regOperPtr->op_type= ZREAD;
regOperPtr->op_struct.bit_field.m_disk_preallocated= 0;
regOperPtr->op_struct.bit_field.m_load_diskpage_on_commit= 0;
regOperPtr->op_struct.bit_field.m_wait_log_buffer= 0;
regOperPtr->op_struct.bit_field.in_active_list = false;
regOperPtr->m_undo_buffer_space= 0;
}
void Dbtup::storedProcBufferSeizeErrorLab(Signal* signal,
Operationrec* regOperPtr,
Uint32 storedProcPtr,
Uint32 errorCode)
{
regOperPtr->m_any_value = 0;
set_trans_state(regOperPtr, TRANS_ERROR_WAIT_STORED_PROCREQ);
signal->theData[0] = regOperPtr->userpointer;
signal->theData[1] = errorCode;
signal->theData[2] = storedProcPtr;
BlockReference lqhRef = calcInstanceBlockRef(DBLQH);
sendSignal(lqhRef, GSN_STORED_PROCREF, signal, 3, JBB);
}//Dbtup::storedSeizeAttrinbufrecErrorLab()
void Dbtup::storedSeizeAttrinbufrecErrorLab(Signal* signal,
Operationrec* regOperPtr,
Uint32 errorCode)
{
StoredProcPtr storedPtr;
c_storedProcPool.getPtr(storedPtr, regOperPtr->storedProcPtr);
ndbrequire(storedPtr.p->storedCode == ZSCAN_PROCEDURE);
storedPtr.p->storedLinkFirst = regOperPtr->firstAttrinbufrec;
regOperPtr->firstAttrinbufrec = RNIL;
regOperPtr->lastAttrinbufrec = RNIL;
regOperPtr->m_any_value = 0;
set_trans_state(regOperPtr, TRANS_ERROR_WAIT_STORED_PROCREQ);
signal->theData[0] = regOperPtr->userpointer;
signal->theData[1] = errorCode;
signal->theData[2] = regOperPtr->storedProcPtr;
sendSignal(DBLQH_REF, GSN_STORED_PROCREF, signal, 3, JBB);
}//Dbtup::storedSeizeAttrinbufrecErrorLab()
void Dbtup::deleteScanProcedure(Signal* signal,
Operationrec* regOperPtr)
{
StoredProcPtr storedPtr;
Uint32 storedProcId = signal->theData[4];
c_storedProcPool.getPtr(storedPtr, storedProcId);
ndbrequire(storedPtr.p->storedCode == ZSCAN_PROCEDURE);
ndbrequire(storedPtr.p->storedCounter == 0);
Uint32 firstAttrinbuf = storedPtr.p->storedLinkFirst;
storedPtr.p->storedCode = ZSTORED_PROCEDURE_FREE;
storedPtr.p->storedLinkFirst = RNIL;
storedPtr.p->storedLinkLast = RNIL;
storedPtr.p->storedProcLength = 0;
c_storedProcPool.release(storedPtr);
freeAttrinbufrec(firstAttrinbuf);
regOperPtr->currentAttrinbufLen = 0;
set_trans_state(regOperPtr, TRANS_IDLE);
signal->theData[0] = regOperPtr->userpointer;
signal->theData[1] = storedProcId;
sendSignal(DBLQH_REF, GSN_STORED_PROCCONF, signal, 2, JBB);
}//Dbtup::deleteScanProcedure()
void Dbtup::scanProcedure(Signal* signal,
Operationrec* regOperPtr,
SectionHandle* handle,
bool isCopy)
{
/* Size a stored procedure record, and link the
* stored procedure AttrInfo section from it
*/
ndbrequire( handle->m_cnt == 1 );
ndbrequire( handle->m_ptr[0].p->m_sz > 0 );
StoredProcPtr storedPtr;
c_storedProcPool.seize(storedPtr);
ndbrequire(storedPtr.i != RNIL);
storedPtr.p->storedCode = (isCopy)? ZCOPY_PROCEDURE : ZSCAN_PROCEDURE;
Uint32 lenAttrInfo= handle->m_ptr[0].p->m_sz;
storedPtr.p->storedProcIVal= handle->m_ptr[0].i;
handle->clear();
set_trans_state(regOperPtr, TRANS_IDLE);
if (lenAttrInfo >= ZATTR_BUFFER_SIZE) { // yes ">="
jam();
// send REF and change state
storedProcBufferSeizeErrorLab(signal,
regOperPtr,
storedPtr.i,
ZSTORED_TOO_MUCH_ATTRINFO_ERROR);
return;
}
signal->theData[0] = regOperPtr->userpointer;
signal->theData[1] = storedPtr.i;
BlockReference lqhRef = calcInstanceBlockRef(DBLQH);
sendSignal(lqhRef, GSN_STORED_PROCCONF, signal, 2, JBB);
}//Dbtup::scanProcedure()
bool Dbtup::storedProcedureAttrInfo(Signal* signal,
Operationrec* regOperPtr,
const Uint32 *data,
Uint32 length,
bool copyProcedure)
{
AttrbufrecPtr regAttrPtr;
Uint32 RnoFree = cnoFreeAttrbufrec;
if (ERROR_INSERTED(4004) && !copyProcedure) {
CLEAR_ERROR_INSERT_VALUE;
storedSeizeAttrinbufrecErrorLab(signal, regOperPtr, ZSTORED_SEIZE_ATTRINBUFREC_ERROR);
return false;
}//if
regOperPtr->currentAttrinbufLen += length;
ndbrequire(regOperPtr->currentAttrinbufLen <= regOperPtr->attrinbufLen);
if ((RnoFree > MIN_ATTRBUF) ||
(copyProcedure)) {
jam();
regAttrPtr.i = cfirstfreeAttrbufrec;
ptrCheckGuard(regAttrPtr, cnoOfAttrbufrec, attrbufrec);
regAttrPtr.p->attrbuf[ZBUF_DATA_LEN] = 0;
cfirstfreeAttrbufrec = regAttrPtr.p->attrbuf[ZBUF_NEXT];
cnoFreeAttrbufrec = RnoFree - 1;
regAttrPtr.p->attrbuf[ZBUF_NEXT] = RNIL;
} else {
jam();
storedSeizeAttrinbufrecErrorLab(signal, regOperPtr, ZSTORED_SEIZE_ATTRINBUFREC_ERROR);
return false;
}//if
if (regOperPtr->firstAttrinbufrec == RNIL) {
jam();
regOperPtr->firstAttrinbufrec = regAttrPtr.i;
}//if
regAttrPtr.p->attrbuf[ZBUF_NEXT] = RNIL;
if (regOperPtr->lastAttrinbufrec != RNIL) {
AttrbufrecPtr tempAttrinbufptr;
jam();
tempAttrinbufptr.i = regOperPtr->lastAttrinbufrec;
ptrCheckGuard(tempAttrinbufptr, cnoOfAttrbufrec, attrbufrec);
tempAttrinbufptr.p->attrbuf[ZBUF_NEXT] = regAttrPtr.i;
}//if
regOperPtr->lastAttrinbufrec = regAttrPtr.i;
regAttrPtr.p->attrbuf[ZBUF_DATA_LEN] = length;
MEMCOPY_NO_WORDS(®AttrPtr.p->attrbuf[0],
data,
length);
if (regOperPtr->currentAttrinbufLen < regOperPtr->attrinbufLen) {
jam();
return true;
}//if
if (ERROR_INSERTED(4005) && !copyProcedure) {
CLEAR_ERROR_INSERT_VALUE;
storedSeizeAttrinbufrecErrorLab(signal, regOperPtr, ZSTORED_SEIZE_ATTRINBUFREC_ERROR);
return false;
}//if
StoredProcPtr storedPtr;
c_storedProcPool.getPtr(storedPtr, (Uint32)regOperPtr->storedProcPtr);
ndbrequire(storedPtr.p->storedCode == ZSCAN_PROCEDURE);
regOperPtr->currentAttrinbufLen = 0;
storedPtr.p->storedLinkFirst = regOperPtr->firstAttrinbufrec;
storedPtr.p->storedLinkLast = regOperPtr->lastAttrinbufrec;
regOperPtr->firstAttrinbufrec = RNIL;
regOperPtr->lastAttrinbufrec = RNIL;
regOperPtr->m_any_value = 0;
set_trans_state(regOperPtr, TRANS_IDLE);
signal->theData[0] = regOperPtr->userpointer;
signal->theData[1] = storedPtr.i;
sendSignal(DBLQH_REF, GSN_STORED_PROCCONF, signal, 2, JBB);
return true;
}//Dbtup::storedProcedureAttrInfo()
