int HugoOperations::pkUpdateRecord(Ndb* pNdb,
int recordNo,
int numRecords,
int updatesValue){
allocRows(numRecords);
int check;
for(int r=0; r < numRecords; r++){
NdbOperation* pOp = getOperation(pTrans, NdbOperation::UpdateRequest);
if (pOp == NULL) {
ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
check = pOp->updateTuple();
if( check == -1 ) {
ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
if(setValues(pOp, r+recordNo, updatesValue) != NDBT_OK)
{
return NDBT_FAILED;
}
Uint32 partId;
if(getPartIdForRow(pOp, r+recordNo, partId))
pOp->setPartitionId(partId);
pOp->setAnyValue(getAnyValueForRowUpd(r+recordNo, updatesValue));
}
return NDBT_OK;
}
int HugoOperations::pkDeleteRecord(Ndb* pNdb,
int recordNo,
int numRecords){
int check;
for(int r=0; r < numRecords; r++){
NdbOperation* pOp = getOperation(pTrans, NdbOperation::DeleteRequest);
if (pOp == NULL) {
ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
check = pOp->deleteTuple();
if( check == -1 ) {
ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
// Define primary keys
if (equalForRow(pOp, r+recordNo) != 0)
return NDBT_FAILED;
Uint32 partId;
if(getPartIdForRow(pOp, r+recordNo, partId))
pOp->setPartitionId(partId);
}
return NDBT_OK;
}
int HugoOperations::pkInsertRecord(Ndb* pNdb,
int recordNo,
int numRecords,
int updatesValue){
int check;
for(int r=0; r < numRecords; r++){
NdbOperation* pOp = getOperation(pTrans, NdbOperation::InsertRequest);
if (pOp == NULL) {
ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
check = pOp->insertTuple();
if( check == -1 ) {
ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
if(setValues(pOp, r+recordNo, updatesValue) != NDBT_OK)
{
m_error.code = pTrans->getNdbError().code;
return NDBT_FAILED;
}
Uint32 partId;
if(getPartIdForRow(pOp, r+recordNo, partId))
pOp->setPartitionId(partId);
}
return NDBT_OK;
}
int HugoOperations::pkWritePartialRecord(Ndb* pNdb,
int recordNo,
int numRecords){
int check;
for(int r=0; r < numRecords; r++){
NdbOperation* pOp = pTrans->getNdbOperation(tab.getName());
if (pOp == NULL) {
NDB_ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
check = pOp->writeTuple();
if( check == -1 ) {
NDB_ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
// Define primary keys
if (equalForRow(pOp, r+recordNo) != 0)
{
g_err << __LINE__ << " equal for row failed" << endl;
return NDBT_FAILED;
}
Uint32 partId;
if(getPartIdForRow(pOp, r+recordNo, partId))
pOp->setPartitionId(partId);
}
return NDBT_OK;
}
int HugoOperations::execute_NoCommit(Ndb* pNdb, AbortOption eao){
int check;
check = pTrans->execute(NoCommit, eao);
const NdbError err = pTrans->getNdbError();
if( check == -1 || err.code) {
NDB_ERR(err);
setNdbError(err);
const NdbOperation* pOp = pTrans->getNdbErrorOperation();
while (pOp != NULL)
{
const NdbError err2 = pOp->getNdbError();
if (err2.code)
{
NDB_ERR(err2);
setNdbError(err2);
}
pOp = pTrans->getNextCompletedOperation(pOp);
}
if (err.code == 0)
{
g_err << __LINE__ << " equal for row failed" << endl;
return NDBT_FAILED;
}
return err.code;
}
for(unsigned int i = 0; i<m_result_sets.size(); i++){
m_executed_result_sets.push_back(m_result_sets[i]);
int rows = m_result_sets[i].records;
NdbScanOperation* rs = m_result_sets[i].m_result_set;
int res = rs->nextResult();
switch(res){
case 1:
return 626;
case -1:
const NdbError err = pTrans->getNdbError();
NDB_ERR(err);
setNdbError(err);
return (err.code > 0 ? err.code : NDBT_FAILED);
}
// A row found
switch(rows){
case 0:
return 4000;
default:
case 1:
break;
}
}
m_result_sets.clear();
return NDBT_OK;
}
int HugoOperations::execute_Commit(Ndb* pNdb,
AbortOption eao){
int check = 0;
check = pTrans->execute(Commit, eao);
const NdbError err = pTrans->getNdbError();
if( check == -1 || err.code) {
ERR(err);
setNdbError(err);
NdbOperation* pOp = pTrans->getNdbErrorOperation();
if (pOp != NULL){
const NdbError err2 = pOp->getNdbError();
ERR(err2);
setNdbError(err2);
}
if (err.code == 0)
return NDBT_FAILED;
return err.code;
}
for(unsigned int i = 0; i<m_result_sets.size(); i++){
m_executed_result_sets.push_back(m_result_sets[i]);
int rows = m_result_sets[i].records;
NdbScanOperation* rs = m_result_sets[i].m_result_set;
int res = rs->nextResult();
switch(res){
case 1:
return 626;
case -1:
const NdbError err = pTrans->getNdbError();
ERR(err);
setNdbError(err);
return (err.code > 0 ? err.code : NDBT_FAILED);
}
// A row found
switch(rows){
case 0:
return 4000;
default:
m_result_sets[i].records--;
break;
}
}
m_result_sets.clear();
return NDBT_OK;
}
int
HugoOperations::scanReadRecords(Ndb* pNdb, NdbScanOperation::LockMode lm,
int records){
allocRows(records);
NdbScanOperation * pOp = pTrans->getNdbScanOperation(tab.getName());
if(!pOp)
return -1;
if(pOp->readTuples(lm, 0, 1)){
return -1;
}
for(int a = 0; a<tab.getNoOfColumns(); a++){
if((rows[0]->attributeStore(a) =
pOp->getValue(tab.getColumn(a)->getName())) == 0) {
ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
}
RsPair p = {pOp, records};
m_result_sets.push_back(p);
return 0;
}
int HugoOperations::pkReadRecordLockHandle(Ndb* pNdb,
Vector<const NdbLockHandle*>& lockHandles,
int recordNo,
int numRecords,
NdbOperation::LockMode lm,
NdbOperation::LockMode *lmused){
if (idx)
{
g_err << "ERROR : Cannot call pkReadRecordLockHandle on an index"
<< endl;
return NDBT_FAILED;
}
/* If something other than LM_Read or LM_Exclusive is
* passed in then we'll choose, and PkReadRecord
* will update lm_used
*/
while (lm != NdbOperation::LM_Read &&
lm != NdbOperation::LM_Exclusive)
{
lm = (NdbOperation::LockMode)((rand() >> 16) & 1);
}
const NdbOperation* prevOp = pTrans->getLastDefinedOperation();
int readRc = pkReadRecord(pNdb,
recordNo,
numRecords,
lm,
lmused);
if (readRc == NDBT_OK)
{
/* Now traverse operations added, requesting
* LockHandles
*/
const NdbOperation* definedOp = (prevOp)? prevOp->next() :
pTrans->getFirstDefinedOperation();
while (definedOp)
{
/* Look away now */
const NdbLockHandle* lh =
(const_cast<NdbOperation*>(definedOp))->getLockHandle();
if (lh == NULL)
{
ERR(definedOp->getNdbError());
setNdbError(definedOp->getNdbError());
return NDBT_FAILED;
}
lockHandles.push_back(lh);
definedOp = definedOp->next();
}
}
return readRc;
}
int HugoOperations::pkWriteRecord(Ndb* pNdb,
int recordNo,
int numRecords,
int updatesValue){
int a, check;
for(int r=0; r < numRecords; r++){
NdbOperation* pOp = pTrans->getNdbOperation(tab.getName());
if (pOp == NULL) {
NDB_ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
check = pOp->writeTuple();
if( check == -1 ) {
NDB_ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
// Define primary keys
if (equalForRow(pOp, r+recordNo) != 0)
{
g_err << __LINE__ << " equal for row failed" << endl;
return NDBT_FAILED;
}
Uint32 partId;
if(getPartIdForRow(pOp, r+recordNo, partId))
pOp->setPartitionId(partId);
// Define attributes to update
for(a = 0; a<tab.getNoOfColumns(); a++){
if (tab.getColumn(a)->getPrimaryKey() == false){
if(setValueForAttr(pOp, a, recordNo+r, updatesValue ) != 0){
NDB_ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
}
}
}
return NDBT_OK;
}
int
HugoOperations::indexUpdateRecord(Ndb*,
const char * idxName,
int recordNo,
int numRecords,
int updatesValue){
int a;
allocRows(numRecords);
int check;
for(int r=0; r < numRecords; r++){
NdbOperation* pOp = pTrans->getNdbIndexOperation(idxName, tab.getName());
if (pOp == NULL) {
NDB_ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
check = pOp->updateTuple();
if( check == -1 ) {
NDB_ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
// Define primary keys
if (equalForRow(pOp, r+recordNo) != 0)
{
g_err << __LINE__ << " equal for row failed" << endl;
return NDBT_FAILED;
}
// Define attributes to update
for(a = 0; a<tab.getNoOfColumns(); a++){
if (tab.getColumn(a)->getPrimaryKey() == false){
if(setValueForAttr(pOp, a, recordNo+r, updatesValue ) != 0){
NDB_ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
}
}
}
return NDBT_OK;
}
int HugoOperations::indexReadRecords(Ndb*, const char * idxName, int recordNo,
bool exclusive,
int numRecords){
int a;
allocRows(numRecords);
int check;
for(int r=0; r < numRecords; r++){
NdbOperation* pOp = pTrans->getNdbIndexOperation(idxName, tab.getName());
if (pOp == NULL) {
NDB_ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
if (exclusive == true)
check = pOp->readTupleExclusive();
else
check = pOp->readTuple();
if( check == -1 ) {
NDB_ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
// Define primary keys
if (equalForRow(pOp, r+recordNo) != 0)
{
g_err << __LINE__ << " equal for row failed" << endl;
return NDBT_FAILED;
}
// Define attributes to read
for(a = 0; a<tab.getNoOfColumns(); a++){
if((rows[r]->attributeStore(a) =
pOp->getValue(tab.getColumn(a))) == 0) {
NDB_ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
}
}
return NDBT_OK;
}
int HugoOperations::execute_Rollback(Ndb* pNdb){
int check;
check = pTrans->execute(Rollback);
if( check == -1 ) {
const NdbError err = pTrans->getNdbError();
ERR(err);
setNdbError(err);
return NDBT_FAILED;
}
return NDBT_OK;
}
int
HugoOperations::releaseLockHandles(Ndb* pNdb,
Vector<const NdbLockHandle*>& lockHandles,
int offset,
int numRecords)
{
int totalSize = lockHandles.size();
if (numRecords == ~(0))
{
numRecords = totalSize - offset;
}
if (totalSize < (offset + numRecords))
{
g_err << "ERROR : LockHandles size is "
<< lockHandles.size()
<< " offset ("
<< offset
<< ") and/or numRecords ("
<< numRecords
<< ") too large." << endl;
return NDBT_FAILED;
}
for (int i = 0; i < numRecords; i++)
{
const NdbLockHandle* lh = lockHandles[offset + i];
if (lh != NULL)
{
if (pTrans->releaseLockHandle(lh) != 0)
{
ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
const NdbLockHandle* nullPtr = NULL;
(void)nullPtr; // ??
//lockHandles.set(nullPtr, offset + i, nullPtr);
}
else
{
g_err << "ERROR : LockHandle number "
<< i+offset << " is NULL. "
<< " offset is " << offset << endl;
return NDBT_FAILED;
}
}
return NDBT_OK;
}
int HugoOperations::pkUnlockRecord(Ndb* pNdb,
Vector<const NdbLockHandle*>& lockHandles,
int offset,
int numRecords,
NdbOperation::AbortOption ao)
{
if (numRecords == ~(0))
{
numRecords = lockHandles.size() - offset;
}
if (lockHandles.size() < (unsigned)(offset + numRecords))
{
g_err << "ERROR : LockHandles size is "
<< lockHandles.size()
<< " offset ("
<< offset
<< ") and/or numRecords ("
<< numRecords
<< ") too large." << endl;
return NDBT_FAILED;
}
for (int i = 0; i < numRecords; i++)
{
const NdbLockHandle* lh = lockHandles[offset + i];
if (lh != NULL)
{
const NdbOperation* unlockOp = pTrans->unlock(lh, ao);
if (unlockOp == NULL)
{
ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
}
else
{
g_err << "ERROR : LockHandle number "
<< i+offset << " is NULL. "
<< " offset is " << offset << endl;
return NDBT_FAILED;
}
}
return NDBT_OK;
}
int
HugoOperations::equalForRow(NdbOperation* pOp, int row)
{
for(int a = 0; a<tab.getNoOfColumns(); a++)
{
if (tab.getColumn(a)->getPrimaryKey() == true)
{
if(equalForAttr(pOp, a, row) != 0)
{
ERR(pOp->getNdbError());
setNdbError(pOp->getNdbError());
return NDBT_FAILED;
}
}
}
return NDBT_OK;
}
int
HugoOperations::setNonPkValues(NdbOperation* pOp, int rowId, int updateId)
{
for(int a = 0; a<tab.getNoOfColumns(); a++)
{
if (tab.getColumn(a)->getPrimaryKey() == false)
{
if(setValueForAttr(pOp, a, rowId, updateId ) != 0)
{
ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
}
}
return NDBT_OK;
}
int HugoOperations::startTransaction(Ndb* pNdb,
const NdbDictionary::Table *table,
const char *keyData, Uint32 keyLen){
if (pTrans != NULL){
ndbout << "HugoOperations::startTransaction, pTrans != NULL" << endl;
return NDBT_FAILED;
}
pTrans = pNdb->startTransaction(table, keyData, keyLen);
if (pTrans == NULL) {
const NdbError err = pNdb->getNdbError();
ERR(err);
setNdbError(err);
return NDBT_FAILED;
}
return NDBT_OK;
}
int HugoOperations::startTransaction(Ndb* pNdb,
Uint32 node_id,
Uint32 instance_id)
{
if (pTrans != NULL)
{
ndbout << "HugoOperations::startTransaction, pTrans != NULL" << endl;
return NDBT_FAILED;
}
pTrans = pNdb->startTransaction(node_id, instance_id);
if (pTrans == NULL) {
const NdbError err = pNdb->getNdbError();
NDB_ERR(err);
setNdbError(err);
return NDBT_FAILED;
}
return NDBT_OK;
}
int HugoOperations::pkRefreshRecord(Ndb* pNdb,
int recordNo,
int numRecords,
int anyValueInfo){
char buffer[NDB_MAX_TUPLE_SIZE];
const NdbDictionary::Table * pTab =
pNdb->getDictionary()->getTable(tab.getName());
if (pTab == 0)
{
g_err << __LINE__ << " pTab == 0" << endl;
return NDBT_FAILED;
}
const NdbRecord * record = pTab->getDefaultRecord();
NdbOperation::OperationOptions opts;
opts.optionsPresent = NdbOperation::OperationOptions::OO_ANYVALUE;
for(int r=0; r < numRecords; r++)
{
bzero(buffer, sizeof(buffer));
if (calc.equalForRow((Uint8*)buffer, record, r + recordNo))
{
g_err << __LINE__ << " equal for row failed" << endl;
return NDBT_FAILED;
}
opts.anyValue = anyValueInfo?
(anyValueInfo << 16) | (r+recordNo) :
0;
const NdbOperation* pOp = pTrans->refreshTuple(record, buffer,
&opts, sizeof(opts));
if (pOp == NULL)
{
NDB_ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
}
return NDBT_OK;
}
int HugoOperations::pkReadRecord(Ndb* pNdb,
int recordNo,
int numRecords,
NdbOperation::LockMode lm,
NdbOperation::LockMode *lmused){
int a;
allocRows(numRecords);
indexScans.clear();
int check;
NdbOperation* pOp = 0;
pIndexScanOp = 0;
for(int r=0; r < numRecords; r++){
if(pOp == 0)
{
pOp = getOperation(pTrans, NdbOperation::ReadRequest);
}
if (pOp == NULL) {
ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
rand_lock_mode:
switch(lm){
case NdbOperation::LM_Read:
case NdbOperation::LM_Exclusive:
case NdbOperation::LM_CommittedRead:
case NdbOperation::LM_SimpleRead:
if (lmused)
* lmused = lm;
if(idx && idx->getType() == NdbDictionary::Index::OrderedIndex)
{
if (pIndexScanOp == 0)
{
pIndexScanOp = ((NdbIndexScanOperation*)pOp);
bool mrrScan= (numRecords > 1);
Uint32 flags= mrrScan? NdbScanOperation::SF_MultiRange : 0;
check = pIndexScanOp->readTuples(lm, flags);
/* Record NdbIndexScanOperation ptr for later... */
indexScans.push_back(pIndexScanOp);
}
}
else
check = pOp->readTuple(lm);
break;
default:
lm = (NdbOperation::LockMode)((rand() >> 16) & 3);
goto rand_lock_mode;
}
if( check == -1 ) {
ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
// Define primary keys
if (equalForRow(pOp, r+recordNo) != 0)
return NDBT_FAILED;
Uint32 partId;
/* Do we need to set the partitionId for this operation? */
if (getPartIdForRow(pOp, r+recordNo, partId))
{
g_info << "Setting operation partition Id" << endl;
pOp->setPartitionId(partId);
}
if(pIndexScanOp)
pIndexScanOp->end_of_bound(r);
if(r == 0 || pIndexScanOp == 0)
{
// Define attributes to read
for(a = 0; a<tab.getNoOfColumns(); a++){
if((rows[r]->attributeStore(a) =
pOp->getValue(tab.getColumn(a)->getName())) == 0) {
ERR(pTrans->getNdbError());
setNdbError(pTrans->getNdbError());
return NDBT_FAILED;
}
}
}
/* Note pIndexScanOp will point to the 'last' index scan op
* we used. The full list is in the indexScans vector
*/
pOp = pIndexScanOp;
}
return NDBT_OK;
}
