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; }