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());
return NDBT_FAILED;
}
}
}
return NDBT_OK;
}
int
HugoAsynchTransactions::executeAsynchOperation(Ndb* pNdb,
int records,
int batch,
int trans,
int operations,
NDB_OPERATION theOperation,
ExecType theType) {
int check = 0;
// int retryAttempt = 0; // Not used at the moment
// int retryMax = 5; // Not used at the moment
int cTrans = 0;
int cRecords = 0;
int cIndex = 0;
int a,t,r;
transactionsCompleted = 0;
allocTransactions(trans);
for (int i = 0; i < batch; i++) { // For each batch
while (cRecords < records*batch) {
cTrans = 0;
cIndex = 0;
for (t = 0; t < trans; t++) { // For each transaction
transactions[t] = pNdb->startTransaction();
if (transactions[t] == NULL) {
ERR(pNdb->getNdbError());
return NDBT_FAILED;
}
for (int k = 0; k < operations; k++) { // For each operation
NdbOperation* pOp = transactions[t]->getNdbOperation(tab.getName());
if (pOp == NULL) {
ERR(transactions[t]->getNdbError());
pNdb->closeTransaction(transactions[t]);
return NDBT_FAILED;
}
switch (theOperation) {
case NO_INSERT:
// Insert
check = pOp->insertTuple();
if (check == -1) {
ERR(transactions[t]->getNdbError());
pNdb->closeTransaction(transactions[t]);
return NDBT_FAILED;
}
// Set a calculated value for each attribute in this table
for (a = 0; a < tab.getNoOfColumns(); a++) {
if (setValueForAttr(pOp, a, cRecords, 0 ) != 0) {
ERR(transactions[t]->getNdbError());
pNdb->closeTransaction(transactions[t]);
return NDBT_FAILED;
}
} // For each attribute
break;
case NO_UPDATE:
// This is a special case and is handled in the calling client...
break;
break;
case NO_READ:
// Define primary keys
check = pOp->readTuple();
for (a = 0; a < tab.getNoOfColumns(); a++) {
if (tab.getColumn(a)->getPrimaryKey() == true) {
if (equalForAttr(pOp, a, cRecords) != 0){
ERR(transactions[t]->getNdbError());
pNdb->closeTransaction(transactions[t]);
return NDBT_FAILED;
}
}
}
// Define attributes to read
for (a = 0; a < tab.getNoOfColumns(); a++) {
if ((rows[cIndex]->attributeStore(a) =
pOp->getValue(tab.getColumn(a)->getName())) == 0) {
ERR(transactions[t]->getNdbError());
pNdb->closeTransaction(transactions[t]);
return NDBT_FAILED;
}
}
break;
case NO_DELETE:
// Delete
check = pOp->deleteTuple();
if (check == -1) {
ERR(transactions[t]->getNdbError());
pNdb->closeTransaction(transactions[t]);
return NDBT_FAILED;
}
// Define primary keys
for (a = 0; a < tab.getNoOfColumns(); a++) {
if (tab.getColumn(a)->getPrimaryKey() == true){
if (equalForAttr(pOp, a, cRecords) != 0) {
ERR(transactions[t]->getNdbError());
pNdb->closeTransaction(transactions[t]);
return NDBT_FAILED;
}
}
}
break;
default:
// Should not happen...
pNdb->closeTransaction(transactions[t]);
return NDBT_FAILED;
}
cIndex++;
cRecords++;
} // For each operation
// Let's prepare...
transactions[t]->executeAsynchPrepare(theType, &asynchCallback,
this);
cTrans++;
if (cRecords >= records) {
// No more transactions needed
break;
}
} // For each transaction
// Wait for all outstanding transactions
pNdb->sendPollNdb(3000, 0, 0);
// ugly... it's starts to resemble flexXXX ...:(
switch (theOperation) {
case NO_READ:
// Verify the data!
for (r = 0; r < trans*operations; r++) {
if (calc.verifyRowValues(rows[r]) != 0) {
g_info << "|- Verify failed..." << endl;
// Close all transactions
for (int t = 0; t < cTrans; t++) {
pNdb->closeTransaction(transactions[t]);
}
return NDBT_FAILED;
}
}
break;
case NO_INSERT:
case NO_UPDATE:
case NO_DELETE:
break;
}
// Close all transactions
for (t = 0; t < cTrans; t++) {
pNdb->closeTransaction(transactions[t]);
}
} // while (cRecords < records*batch)
} // For each batch
deallocTransactions();
return NDBT_OK;
}
int
HugoAsynchTransactions::pkUpdateRecordsAsynch(Ndb* pNdb,
int records,
int batch,
int trans,
int operations) {
g_info << "|- Updating records asynchronous..." << endl;
int check = 0;
int cTrans = 0;
int cReadRecords = 0;
int cReadIndex = 0;
int cRecords = 0;
int cIndex = 0;
transactionsCompleted = 0;
allocRows(trans*operations);
allocTransactions(trans);
int a, t, r;
for (int i = 0; i < batch; i++) { // For each batch
while (cRecords < records*batch) {
cTrans = 0;
cReadIndex = 0;
for (t = 0; t < trans; t++) { // For each transaction
transactions[t] = pNdb->startTransaction();
if (transactions[t] == NULL) {
ERR(pNdb->getNdbError());
return NDBT_FAILED;
}
for (int k = 0; k < operations; k++) { // For each operation
NdbOperation* pOp = transactions[t]->getNdbOperation(tab.getName());
if (pOp == NULL) {
ERR(transactions[t]->getNdbError());
pNdb->closeTransaction(transactions[t]);
return NDBT_FAILED;
}
// Read
// Define primary keys
check = pOp->readTupleExclusive();
for (a = 0; a < tab.getNoOfColumns(); a++) {
if (tab.getColumn(a)->getPrimaryKey() == true) {
if (equalForAttr(pOp, a, cReadRecords) != 0){
ERR(transactions[t]->getNdbError());
pNdb->closeTransaction(transactions[t]);
return NDBT_FAILED;
}
}
}
// Define attributes to read
for (a = 0; a < tab.getNoOfColumns(); a++) {
if ((rows[cReadIndex]->attributeStore(a) =
pOp->getValue(tab.getColumn(a)->getName())) == 0) {
ERR(transactions[t]->getNdbError());
pNdb->closeTransaction(transactions[t]);
return NDBT_FAILED;
}
}
cReadIndex++;
cReadRecords++;
} // For each operation
// Let's prepare...
transactions[t]->executeAsynchPrepare(NoCommit, &asynchCallback,
this);
cTrans++;
if (cReadRecords >= records) {
// No more transactions needed
break;
}
} // For each transaction
// Wait for all outstanding transactions
pNdb->sendPollNdb(3000, 0, 0);
// Verify the data!
for (r = 0; r < trans*operations; r++) {
if (calc.verifyRowValues(rows[r]) != 0) {
g_info << "|- Verify failed..." << endl;
// Close all transactions
for (int t = 0; t < cTrans; t++) {
pNdb->closeTransaction(transactions[t]);
}
return NDBT_FAILED;
}
}
// Update
cTrans = 0;
cIndex = 0;
for (t = 0; t < trans; t++) { // For each transaction
for (int k = 0; k < operations; k++) { // For each operation
NdbOperation* pOp = transactions[t]->getNdbOperation(tab.getName());
if (pOp == NULL) {
ERR(transactions[t]->getNdbError());
pNdb->closeTransaction(transactions[t]);
return NDBT_FAILED;
}
int updates = calc.getUpdatesValue(rows[cIndex]) + 1;
check = pOp->updateTuple();
if (check == -1) {
ERR(transactions[t]->getNdbError());
pNdb->closeTransaction(transactions[t]);
return NDBT_FAILED;
}
// Set search condition for the record
for (a = 0; a < tab.getNoOfColumns(); a++) {
if (tab.getColumn(a)->getPrimaryKey() == true) {
if (equalForAttr(pOp, a, cRecords) != 0) {
ERR(transactions[t]->getNdbError());
pNdb->closeTransaction(transactions[t]);
return NDBT_FAILED;
}
}
}
// Update the record
for (a = 0; a < tab.getNoOfColumns(); a++) {
if (tab.getColumn(a)->getPrimaryKey() == false) {
if (setValueForAttr(pOp, a, cRecords, updates) != 0) {
ERR(transactions[t]->getNdbError());
pNdb->closeTransaction(transactions[t]);
return NDBT_FAILED;
}
}
}
cIndex++;
cRecords++;
} // For each operation
// Let's prepare...
transactions[t]->executeAsynchPrepare(Commit, &asynchCallback,
this);
cTrans++;
if (cRecords >= records) {
// No more transactions needed
break;
}
} // For each transaction
// Wait for all outstanding transactions
pNdb->sendPollNdb(3000, 0, 0);
// Close all transactions
for (t = 0; t < cTrans; t++) {
pNdb->closeTransaction(transactions[t]);
}
} // while (cRecords < records*batch)
} // For each batch
deallocTransactions();
deallocRows();
g_info << "|- " << ((unsigned int)transactionsCompleted * operations)/2
<< " updated..." << endl;
return NDBT_OK;
}
