Int32 ExpHbaseInterface_JNI::deleteColumns(
HbaseStr &tblName,
HbaseStr& column)
{
Int32 retcode = 0;
LIST(HbaseStr) columns(heap_);
columns.insert(column);
htc_ = client_->getHTableClient((NAHeap *)heap_, tblName.val, useTRex_, hbs_);
if (htc_ == NULL)
{
retCode_ = HBC_ERROR_GET_HTC_EXCEPTION;
return HBASE_OPEN_ERROR;
}
Int64 transID = getTransactionIDFromContext();
int numReqRows = 100;
retcode = htc_->startScan(transID, "", "", columns, -1, FALSE, numReqRows, FALSE,
NULL, NULL, NULL, NULL);
if (retcode != HTC_OK)
return retcode;
NABoolean done = FALSE;
HbaseStr rowID;
do {
// Added the for loop to consider using deleteRows
// to delete the column for all rows in the batch
for (int rowNo = 0; rowNo < numReqRows; rowNo++)
{
retcode = htc_->nextRow();
if (retcode != HTC_OK)
{
done = TRUE;
break;
}
retcode = htc_->getRowID(rowID);
if (retcode != HBASE_ACCESS_SUCCESS)
{
done = TRUE;
break;
}
retcode = htc_->deleteRow(transID, rowID, columns, -1);
if (retcode != HTC_OK)
{
done = TRUE;
break;
}
}
} while (!(done || isParentQueryCanceled()));
scanClose();
if (retcode == HTC_DONE)
return HBASE_ACCESS_SUCCESS;
return HBASE_ACCESS_ERROR;
}
/*
* Received when scan is closing. This signal arrives after any
* ACCKEYCON or ACCKEYREF which may have been in job buffer.
*/
void
Dbtup::execACC_ABORTCONF(Signal* signal)
{
jamEntry();
ScanOpPtr scanPtr;
scanPtr.i = signal->theData[0];
c_scanOpPool.getPtr(scanPtr);
ScanOp& scan = *scanPtr.p;
ndbrequire(scan.m_state == ScanOp::Aborting);
// most likely we are still in lock wait
if (scan.m_bits & ScanOp::SCAN_LOCK_WAIT) {
jam();
scan.m_bits &= ~ ScanOp::SCAN_LOCK_WAIT;
scan.m_accLockOp = RNIL;
}
scanClose(signal, scanPtr);
}
void
Dbtup::execNEXT_SCANREQ(Signal* signal)
{
jamEntry();
const NextScanReq reqCopy = *(const NextScanReq*)signal->getDataPtr();
const NextScanReq* const req = &reqCopy;
ScanOpPtr scanPtr;
c_scanOpPool.getPtr(scanPtr, req->accPtr);
ScanOp& scan = *scanPtr.p;
switch (req->scanFlag) {
case NextScanReq::ZSCAN_NEXT:
jam();
break;
case NextScanReq::ZSCAN_NEXT_COMMIT:
jam();
case NextScanReq::ZSCAN_COMMIT:
jam();
if ((scan.m_bits & ScanOp::SCAN_LOCK) != 0) {
jam();
AccLockReq* const lockReq = (AccLockReq*)signal->getDataPtrSend();
lockReq->returnCode = RNIL;
lockReq->requestInfo = AccLockReq::Unlock;
lockReq->accOpPtr = req->accOperationPtr;
EXECUTE_DIRECT(DBACC, GSN_ACC_LOCKREQ,
signal, AccLockReq::UndoSignalLength);
jamEntry();
ndbrequire(lockReq->returnCode == AccLockReq::Success);
removeAccLockOp(scan, req->accOperationPtr);
}
if (req->scanFlag == NextScanReq::ZSCAN_COMMIT) {
NextScanConf* const conf = (NextScanConf*)signal->getDataPtrSend();
conf->scanPtr = scan.m_userPtr;
unsigned signalLength = 1;
sendSignal(scanPtr.p->m_userRef, GSN_NEXT_SCANCONF,
signal, signalLength, JBB);
return;
}
break;
case NextScanReq::ZSCAN_CLOSE:
jam();
if (scan.m_bits & ScanOp::SCAN_LOCK_WAIT) {
jam();
ndbrequire(scan.m_accLockOp != RNIL);
// use ACC_ABORTCONF to flush out any reply in job buffer
AccLockReq* const lockReq = (AccLockReq*)signal->getDataPtrSend();
lockReq->returnCode = RNIL;
lockReq->requestInfo = AccLockReq::AbortWithConf;
lockReq->accOpPtr = scan.m_accLockOp;
EXECUTE_DIRECT(DBACC, GSN_ACC_LOCKREQ,
signal, AccLockReq::UndoSignalLength);
jamEntry();
ndbrequire(lockReq->returnCode == AccLockReq::Success);
scan.m_state = ScanOp::Aborting;
return;
}
if (scan.m_state == ScanOp::Locked) {
jam();
ndbrequire(scan.m_accLockOp != RNIL);
AccLockReq* const lockReq = (AccLockReq*)signal->getDataPtrSend();
lockReq->returnCode = RNIL;
lockReq->requestInfo = AccLockReq::Abort;
lockReq->accOpPtr = scan.m_accLockOp;
EXECUTE_DIRECT(DBACC, GSN_ACC_LOCKREQ,
signal, AccLockReq::UndoSignalLength);
jamEntry();
ndbrequire(lockReq->returnCode == AccLockReq::Success);
scan.m_accLockOp = RNIL;
}
scan.m_state = ScanOp::Aborting;
scanClose(signal, scanPtr);
return;
case NextScanReq::ZSCAN_NEXT_ABORT:
jam();
default:
jam();
ndbrequire(false);
break;
}
// start looking for next scan result
AccCheckScan* checkReq = (AccCheckScan*)signal->getDataPtrSend();
checkReq->accPtr = scanPtr.i;
checkReq->checkLcpStop = AccCheckScan::ZNOT_CHECK_LCP_STOP;
EXECUTE_DIRECT(DBTUP, GSN_ACC_CHECK_SCAN, signal, AccCheckScan::SignalLength);
jamEntry();
}
ExpORCinterface::~ExpORCinterface()
{
// close. Ignore errors.
scanClose();
}
