/* Copyright (C) 2003 MySQL AB This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include <NDBT_Test.hpp> #include <NDBT_ReturnCodes.h> #include <HugoTransactions.hpp> #include <UtilTransactions.hpp> #include <NdbRestarter.hpp> #define GETNDB(ps) ((NDBT_NdbApiStep*)ps)->getNdb() /** * TODO * dirtyWrite, write, dirtyUpdate * delete should be visible to same transaction * */ int runLoadTable2(NDBT_Context* ctx, NDBT_Step* step) { int records = ctx->getNumRecords(); HugoTransactions hugoTrans(*ctx->getTab()); if (hugoTrans.loadTable(GETNDB(step), records, 512, false, 0, true) != 0){ return NDBT_FAILED; } return NDBT_OK; } int runLoadTable(NDBT_Context* ctx, NDBT_Step* step) { int records = ctx->getNumRecords(); HugoTransactions hugoTrans(*ctx->getTab()); if (hugoTrans.loadTable(GETNDB(step), records) != 0){ return NDBT_FAILED; } return NDBT_OK; } int runInsert(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); HugoTransactions hugoTrans(*ctx->getTab()); // Insert records, dont allow any // errors(except temporary) while inserting if (hugoTrans.loadTable(GETNDB(step), records, 1, false) != 0){ return NDBT_FAILED; } return NDBT_OK; } int runInsertTwice(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); HugoTransactions hugoTrans(*ctx->getTab()); // Insert records, expect primary key violation 630 if (hugoTrans.loadTable(GETNDB(step), records, 1, false) != 630){ return NDBT_FAILED; } return NDBT_OK; } int runVerifyInsert(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); HugoTransactions hugoTrans(*ctx->getTab()); if (hugoTrans.pkDelRecords(GETNDB(step), records, 1, false) != 0){ return NDBT_FAILED; } return NDBT_OK; } int runInsertUntilStopped(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); int i = 0; HugoTransactions hugoTrans(*ctx->getTab()); while (ctx->isTestStopped() == false) { g_info << i << ": "; if (hugoTrans.loadTable(GETNDB(step), records) != 0){ g_info << endl; return NDBT_FAILED; } i++; } g_info << endl; return NDBT_OK; } int runClearTable(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); int batchSize = ctx->getProperty("BatchSize", 1); HugoTransactions hugoTrans(*ctx->getTab()); if (hugoTrans.pkDelRecords(GETNDB(step), records, batchSize) != 0){ return NDBT_FAILED; } return NDBT_OK; } int runPkDelete(NDBT_Context* ctx, NDBT_Step* step){ int loops = ctx->getNumLoops(); int records = ctx->getNumRecords(); int i = 0; HugoTransactions hugoTrans(*ctx->getTab()); while (i<loops) { g_info << i << ": "; if (hugoTrans.pkDelRecords(GETNDB(step), records) != 0){ g_info << endl; return NDBT_FAILED; } // Load table, don't allow any primary key violations if (hugoTrans.loadTable(GETNDB(step), records, 512, false) != 0){ g_info << endl; return NDBT_FAILED; } i++; } g_info << endl; return NDBT_OK; } int runPkRead(NDBT_Context* ctx, NDBT_Step* step){ int loops = ctx->getNumLoops(); int records = ctx->getNumRecords(); int batchSize = ctx->getProperty("BatchSize", 1); int i = 0; HugoTransactions hugoTrans(*ctx->getTab()); while (i<loops) { g_info << i << ": "; if (hugoTrans.pkReadRecords(GETNDB(step), records, batchSize) != NDBT_OK){ g_info << endl; return NDBT_FAILED; } i++; } g_info << endl; return NDBT_OK; } int runPkDirtyRead(NDBT_Context* ctx, NDBT_Step* step){ int loops = ctx->getNumLoops(); int records = ctx->getNumRecords(); int batchSize = ctx->getProperty("BatchSize", 1); int i = 0; bool dirty = true; HugoTransactions hugoTrans(*ctx->getTab()); while (i<loops) { g_info << i << ": "; if (hugoTrans.pkReadRecords(GETNDB(step), records, batchSize, NdbOperation::LM_CommittedRead) != NDBT_OK){ g_info << endl; return NDBT_FAILED; } i++; } g_info << endl; return NDBT_OK; } int runPkReadUntilStopped(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); int batchSize = ctx->getProperty("BatchSize", 1); int i = 0; HugoTransactions hugoTrans(*ctx->getTab()); while (ctx->isTestStopped() == false) { g_info << i << ": "; if (hugoTrans.pkReadRecords(GETNDB(step), records, batchSize) != 0){ g_info << endl; return NDBT_FAILED; } i++; } g_info << endl; return NDBT_OK; } int runPkUpdate(NDBT_Context* ctx, NDBT_Step* step){ int loops = ctx->getNumLoops(); int records = ctx->getNumRecords(); int batchSize = ctx->getProperty("BatchSize", 1); int i = 0; HugoTransactions hugoTrans(*ctx->getTab()); while (i<loops) { g_info << "|- " << i << ": "; if (hugoTrans.pkUpdateRecords(GETNDB(step), records, batchSize) != 0){ g_info << endl; return NDBT_FAILED; } i++; } g_info << endl; return NDBT_OK; } int runPkUpdateUntilStopped(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); int batchSize = ctx->getProperty("BatchSize", 1); int i = 0; HugoTransactions hugoTrans(*ctx->getTab()); while (ctx->isTestStopped()) { g_info << i << ": "; if (hugoTrans.pkUpdateRecords(GETNDB(step), records, batchSize) != 0){ g_info << endl; return NDBT_FAILED; } i++; } g_info << endl; return NDBT_OK; } int runLocker(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; int records = ctx->getNumRecords(); HugoTransactions hugoTrans(*ctx->getTab()); if (hugoTrans.lockRecords(GETNDB(step), records, 10, 500) != 0){ result = NDBT_FAILED; } ctx->stopTest(); return result; } int runInsertOne(NDBT_Context* ctx, NDBT_Step* step){ if(ctx->getProperty("InsertCommitted", (Uint32)0) != 0){ abort(); } while(ctx->getProperty("Read1Performed", (Uint32)0) == 0){ NdbSleep_MilliSleep(20); } HugoTransactions hugoTrans(*ctx->getTab()); if (hugoTrans.loadTable(GETNDB(step), 1, 1) != 0){ return NDBT_FAILED; } ctx->setProperty("InsertCommitted", 1); NdbSleep_SecSleep(2); return NDBT_OK; } static int readOneNoCommit(Ndb* pNdb, NdbConnection* pTrans, const NdbDictionary::Table* tab,NDBT_ResultRow * row){ int a; NdbOperation * pOp = pTrans->getNdbOperation(tab->getName()); if (pOp == NULL){ ERR(pTrans->getNdbError()); return NDBT_FAILED; } HugoTransactions tmp(*tab); int check = pOp->readTuple(); if( check == -1 ) { ERR(pTrans->getNdbError()); return NDBT_FAILED; } // Define primary keys for(a = 0; a<tab->getNoOfColumns(); a++){ if (tab->getColumn(a)->getPrimaryKey() == true){ if(tmp.equalForAttr(pOp, a, 0) != 0){ ERR(pTrans->getNdbError()); return NDBT_FAILED; } } } // Define attributes to read for(a = 0; a<tab->getNoOfColumns(); a++){ if((row->attributeStore(a) = pOp->getValue(tab->getColumn(a)->getName())) == 0) { ERR(pTrans->getNdbError()); return NDBT_FAILED; } } check = pTrans->execute(NoCommit); if( check == -1 ) { const NdbError err = pTrans->getNdbError(); ERR(err); return err.code; } return NDBT_OK; } int runReadOne(NDBT_Context* ctx, NDBT_Step* step){ Ndb* pNdb = GETNDB(step); const NdbDictionary::Table* tab = ctx->getTab(); NDBT_ResultRow row1(*tab); NDBT_ResultRow row2(*tab); if(ctx->getProperty("Read1Performed", (Uint32)0) != 0){ abort(); } if(ctx->getProperty("InsertCommitted", (Uint32)0) != 0){ abort(); } NdbConnection * pTrans = pNdb->startTransaction(); if (pTrans == NULL) { abort(); } // Read a record with NoCommit // Since the record isn't inserted yet it wil return 626 const int res1 = readOneNoCommit(pNdb, pTrans, tab, &row1); g_info << "|- res1 = " << res1 << endl; ctx->setProperty("Read1Performed", 1); while(ctx->getProperty("InsertCommitted", (Uint32)0) == 0 && !ctx->isTestStopped()){ g_info << "|- Waiting for insert" << endl; NdbSleep_MilliSleep(20); } if(ctx->isTestStopped()){ abort(); } // Now the record should have been inserted // Read it once again in the same transaction // Should also reutrn 626 if reads are consistent // NOTE! Currently it's not possible to start a new operation // on a transaction that has returned an error code // This is wat fail in this test // MASV 20030624 const int res2 = readOneNoCommit(pNdb, pTrans, tab, &row2); pTrans->execute(Commit); pNdb->closeTransaction(pTrans); g_info << "|- res2 = " << res2 << endl; if (res2 == 626 && res1 == res2) return NDBT_OK; else return NDBT_FAILED; } int runFillTable(NDBT_Context* ctx, NDBT_Step* step){ int batch = 512; //4096; HugoTransactions hugoTrans(*ctx->getTab()); if (hugoTrans.fillTable(GETNDB(step), batch ) != 0){ return NDBT_FAILED; } return NDBT_OK; } int runClearTable2(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); UtilTransactions utilTrans(*ctx->getTab()); if (utilTrans.clearTable2(GETNDB(step), records, 240) != 0){ return NDBT_FAILED; } return NDBT_OK; } #define CHECK(b) if (!(b)) { \ ndbout << "ERR: "<< step->getName() \ << " failed on line " << __LINE__ << endl; \ result = NDBT_FAILED; \ break; } int runNoCommitSleep(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); int sleepTime = 100; // ms for (int i = 2; i < 8; i++){ CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); ndbout << i <<": Sleeping for " << sleepTime << " ms" << endl; NdbSleep_MilliSleep(sleepTime); // Dont care about result of these ops hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive); hugoOps.closeTransaction(pNdb); sleepTime = sleepTime *i; } hugoOps.closeTransaction(pNdb); return result; } int runCommit626(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); do{ // Commit transaction CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_Commit(pNdb) == 626); CHECK(hugoOps.closeTransaction(pNdb) == 0); // Commit transaction // Multiple operations CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 2, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 3, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_Commit(pNdb) == 626); }while(false); hugoOps.closeTransaction(pNdb); return result; } int runCommit630(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); do{ // Commit transaction CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkInsertRecord(pNdb, 1) == 0); CHECK(hugoOps.execute_Commit(pNdb) == 630); }while(false); hugoOps.closeTransaction(pNdb); return result; } int runCommit_TryCommit626(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); do{ // Commit transaction, TryCommit CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_Commit(pNdb, TryCommit) == 626); CHECK(hugoOps.closeTransaction(pNdb) == 0); // Commit transaction, TryCommit // Several operations in one transaction // The insert is OK CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 2, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 3, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.pkInsertRecord(pNdb, 1) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 4, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_Commit(pNdb, TryCommit) == 626); }while(false); hugoOps.closeTransaction(pNdb); return result; } int runCommit_TryCommit630(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); do{ // Commit transaction, TryCommit CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkInsertRecord(pNdb, 1) == 0); CHECK(hugoOps.execute_Commit(pNdb, TryCommit) == 630); }while(false); hugoOps.closeTransaction(pNdb); return result; } int runCommit_CommitAsMuchAsPossible626(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); do{ // Commit transaction, CommitAsMuchAsPossible CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_Commit(pNdb, CommitAsMuchAsPossible) == 626); CHECK(hugoOps.closeTransaction(pNdb) == 0); // Commit transaction, CommitAsMuchAsPossible CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 2, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 3, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.pkInsertRecord(pNdb, 1) == 0); CHECK(hugoOps.execute_Commit(pNdb, CommitAsMuchAsPossible) == 626); CHECK(hugoOps.closeTransaction(pNdb) == 0); CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 1) == 0); CHECK(hugoOps.execute_Commit(pNdb) == 0); CHECK(hugoOps.closeTransaction(pNdb) == 0); } while(false); hugoOps.closeTransaction(pNdb); return result; } int runCommit_CommitAsMuchAsPossible630(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); do{ // Commit transaction, CommitAsMuchAsPossible CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkInsertRecord(pNdb, 1) == 0); CHECK(hugoOps.pkDeleteRecord(pNdb, 2) == 0); CHECK(hugoOps.execute_Commit(pNdb, CommitAsMuchAsPossible) == 630); CHECK(hugoOps.closeTransaction(pNdb) == 0); CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 2) == 0); CHECK(hugoOps.execute_Commit(pNdb) == 0); } while(false); hugoOps.closeTransaction(pNdb); return result; } int runNoCommit626(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); do{ // No commit transaction, readTuple CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Read) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 626); CHECK(hugoOps.closeTransaction(pNdb) == 0); // No commit transaction, readTupleExcluive CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 626); }while(false); hugoOps.closeTransaction(pNdb); return result; } int runNoCommit630(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); do{ // No commit transaction CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkInsertRecord(pNdb, 1) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 630); }while(false); hugoOps.closeTransaction(pNdb); return result; } int runNoCommitRollback626(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); do{ // No commit transaction, rollback CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 626); CHECK(hugoOps.execute_Rollback(pNdb) == 0); CHECK(hugoOps.closeTransaction(pNdb) == 0); // No commit transaction, rollback // Multiple operations CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 1, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 2, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 3, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 4, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 626); CHECK(hugoOps.execute_Rollback(pNdb) == 0); }while(false); hugoOps.closeTransaction(pNdb); return result; } int runNoCommitRollback630(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); do{ // No commit transaction, rollback CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkInsertRecord(pNdb, 1) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 630); CHECK(hugoOps.execute_Rollback(pNdb) == 0); }while(false); hugoOps.closeTransaction(pNdb); return result; } int runNoCommitAndClose(NDBT_Context* ctx, NDBT_Step* step){ int i, result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); do{ // Read CHECK(hugoOps.startTransaction(pNdb) == 0); for (i = 0; i < 10; i++) CHECK(hugoOps.pkReadRecord(pNdb, i, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); CHECK(hugoOps.closeTransaction(pNdb) == 0); // Update CHECK(hugoOps.startTransaction(pNdb) == 0); for (i = 0; i < 10; i++) CHECK(hugoOps.pkUpdateRecord(pNdb, i) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); CHECK(hugoOps.closeTransaction(pNdb) == 0); // Delete CHECK(hugoOps.startTransaction(pNdb) == 0); for (i = 0; i < 10; i++) CHECK(hugoOps.pkDeleteRecord(pNdb, i) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); CHECK(hugoOps.closeTransaction(pNdb) == 0); // Try to insert, record should already exist CHECK(hugoOps.startTransaction(pNdb) == 0); for (i = 0; i < 10; i++) CHECK(hugoOps.pkInsertRecord(pNdb, i) == 0); CHECK(hugoOps.execute_Commit(pNdb) == 630); CHECK(hugoOps.closeTransaction(pNdb) == 0); }while(false); hugoOps.closeTransaction(pNdb); return result; } int runCheckRollbackDelete(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); do{ // Read value and save it for later CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 5) == 0); CHECK(hugoOps.execute_Commit(pNdb) == 0); CHECK(hugoOps.saveCopyOfRecord() == NDBT_OK); CHECK(hugoOps.closeTransaction(pNdb) == 0); // Delete record 5 CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkDeleteRecord(pNdb, 5) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); // Check record is deleted CHECK(hugoOps.pkReadRecord(pNdb, 5, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 626); CHECK(hugoOps.execute_Rollback(pNdb) == 0); CHECK(hugoOps.closeTransaction(pNdb) == 0); // Check record is not deleted CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 5, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_Commit(pNdb) == 0); CHECK(hugoOps.closeTransaction(pNdb) == 0); // Check record is back to original value CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 5, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_Commit(pNdb) == 0); CHECK(hugoOps.compareRecordToCopy() == NDBT_OK); }while(false); hugoOps.closeTransaction(pNdb); return result; } int runCheckRollbackUpdate(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); int numRecords = 5; do{ // Read value and save it for later CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 1, numRecords) == 0); CHECK(hugoOps.execute_Commit(pNdb) == 0); CHECK(hugoOps.verifyUpdatesValue(0) == NDBT_OK); // Update value 0 CHECK(hugoOps.closeTransaction(pNdb) == 0); // Update record 5 CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkUpdateRecord(pNdb, 1, numRecords, 5) == 0);// Updates value 5 CHECK(hugoOps.execute_NoCommit(pNdb) == 0); // Check record is updated CHECK(hugoOps.pkReadRecord(pNdb, 1, numRecords, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); CHECK(hugoOps.verifyUpdatesValue(5) == NDBT_OK); // Updates value 5 CHECK(hugoOps.execute_Rollback(pNdb) == 0); CHECK(hugoOps.closeTransaction(pNdb) == 0); // Check record is back to original value CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 1, numRecords, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_Commit(pNdb) == 0); CHECK(hugoOps.verifyUpdatesValue(0) == NDBT_OK); // Updates value 0 }while(false); hugoOps.closeTransaction(pNdb); return result; } int runCheckRollbackDeleteMultiple(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); do{ // Read value and save it for later CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 5, 10) == 0); CHECK(hugoOps.execute_Commit(pNdb) == 0); CHECK(hugoOps.verifyUpdatesValue(0) == NDBT_OK); CHECK(hugoOps.closeTransaction(pNdb) == 0); Uint32 updatesValue = 0; Uint32 j; for(Uint32 i = 0; i<1; i++){ // Read record 5 - 10 CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 5, 10, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); for(j = 0; j<10; j++){ // Update record 5 - 10 updatesValue++; CHECK(hugoOps.pkUpdateRecord(pNdb, 5, 10, updatesValue) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 5, 10, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); CHECK(hugoOps.verifyUpdatesValue(updatesValue) == 0); } for(j = 0; j<10; j++){ // Delete record 5 - 10 times CHECK(hugoOps.pkDeleteRecord(pNdb, 5, 10) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); #if 0 // Check records are deleted CHECK(hugoOps.pkReadRecord(pNdb, 5, 10, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 626); #endif updatesValue++; CHECK(hugoOps.pkInsertRecord(pNdb, 5, 10, updatesValue) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 5, 10, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); CHECK(hugoOps.verifyUpdatesValue(updatesValue) == 0); } CHECK(hugoOps.pkDeleteRecord(pNdb, 5, 10) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); // Check records are deleted CHECK(hugoOps.pkReadRecord(pNdb, 5, 10, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 626); CHECK(hugoOps.execute_Rollback(pNdb) == 0); CHECK(hugoOps.closeTransaction(pNdb) == 0); } // Check records are not deleted // after rollback CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 5, 10, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_Commit(pNdb) == 0); CHECK(hugoOps.verifyUpdatesValue(0) == NDBT_OK); }while(false); hugoOps.closeTransaction(pNdb); return result; } int runCheckImplicitRollbackDelete(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); do{ // Read record 5 CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 5, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); CHECK(hugoOps.closeTransaction(pNdb) == 0); // Update record 5 CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkUpdateRecord(pNdb, 5) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); CHECK(hugoOps.closeTransaction(pNdb) == 0); // Delete record 5 CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkDeleteRecord(pNdb, 5) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); CHECK(hugoOps.closeTransaction(pNdb) == 0); // Check record is not deleted // Close transaction should have rollbacked CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 5, 1, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_Commit(pNdb) == 0); }while(false); hugoOps.closeTransaction(pNdb); return result; } int runCheckCommitDelete(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); do{ // Read 10 records CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 5, 10, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); // Update 10 records CHECK(hugoOps.pkUpdateRecord(pNdb, 5, 10) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); // Delete 10 records CHECK(hugoOps.pkDeleteRecord(pNdb, 5, 10) == 0); CHECK(hugoOps.execute_NoCommit(pNdb) == 0); CHECK(hugoOps.execute_Commit(pNdb) == 0); CHECK(hugoOps.closeTransaction(pNdb) == 0); // Check record's are deleted CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 5, 10, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_Commit(pNdb) == 626); }while(false); hugoOps.closeTransaction(pNdb); return result; } int runRollbackNothing(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); do{ // Delete record 5 - 15 CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkDeleteRecord(pNdb, 5, 10) == 0); // Rollback CHECK(hugoOps.execute_Rollback(pNdb) == 0); CHECK(hugoOps.closeTransaction(pNdb) == 0); // Check records are not deleted CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.pkReadRecord(pNdb, 5, 10, NdbOperation::LM_Exclusive) == 0); CHECK(hugoOps.execute_Commit(pNdb) == 0); CHECK(hugoOps.closeTransaction(pNdb) == 0); CHECK(hugoOps.startTransaction(pNdb) == 0); CHECK(hugoOps.execute_Rollback(pNdb) == 0); }while(false); hugoOps.closeTransaction(pNdb); return result; } int runMassiveRollback(NDBT_Context* ctx, NDBT_Step* step){ NdbRestarter restarter; const int records = 4 * restarter.getNumDbNodes(); HugoTransactions hugoTrans(*ctx->getTab()); if (hugoTrans.loadTable(GETNDB(step), records) != 0){ return NDBT_FAILED; } int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); const Uint32 OPS_PER_TRANS = 256; const Uint32 OPS_TOTAL = 4096; for(int row = 0; row < records; row++){ int res; CHECK(hugoOps.startTransaction(pNdb) == 0); for(Uint32 i = 0; i<OPS_TOTAL; i += OPS_PER_TRANS){ for(Uint32 j = 0; j<OPS_PER_TRANS; j++){ CHECK(hugoOps.pkUpdateRecord(pNdb, row, 1, i) == 0); } g_info << "Performed " << (i+OPS_PER_TRANS) << " updates on row: " << row << endl; if(result != NDBT_OK){ break; } res = hugoOps.execute_NoCommit(pNdb); if(res != 0){ NdbError err = pNdb->getNdbError(res); CHECK(err.classification == NdbError::TimeoutExpired); break; } } if(result != NDBT_OK){ break; } g_info << "executeRollback" << endl; CHECK(hugoOps.execute_Rollback(pNdb) == 0); CHECK(hugoOps.closeTransaction(pNdb) == 0); } hugoOps.closeTransaction(pNdb); return result; } int runMassiveRollback2(NDBT_Context* ctx, NDBT_Step* step){ HugoTransactions hugoTrans(*ctx->getTab()); if (hugoTrans.loadTable(GETNDB(step), 1) != 0){ return NDBT_FAILED; } int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); const Uint32 OPS_TOTAL = 4096; const Uint32 LOOPS = 10; for(Uint32 loop = 0; loop<LOOPS; loop++){ CHECK(hugoOps.startTransaction(pNdb) == 0); for(Uint32 i = 0; i<OPS_TOTAL-1; i ++){ if((i & 1) == 0){ CHECK(hugoOps.pkUpdateRecord(pNdb, 0, 1, loop) == 0); } else { CHECK(hugoOps.pkUpdateRecord(pNdb, 1, 1, loop) == 0); } } CHECK(hugoOps.execute_Commit(pNdb) == 626); CHECK(hugoOps.execute_Rollback(pNdb) == 0); CHECK(hugoOps.closeTransaction(pNdb) == 0); } hugoOps.closeTransaction(pNdb); return result; } int runMassiveRollback3(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); const Uint32 BATCH = 10; const Uint32 OPS_TOTAL = 20; const Uint32 LOOPS = 100; for(Uint32 loop = 0; loop<LOOPS; loop++) { CHECK(hugoOps.startTransaction(pNdb) == 0); bool ok = true; for (Uint32 i = 0; i<OPS_TOTAL; i+= BATCH) { CHECK(hugoOps.pkInsertRecord(pNdb, i, BATCH, 0) == 0); if (hugoOps.execute_NoCommit(pNdb) != 0) { ok = false; break; } } hugoOps.execute_Rollback(pNdb); CHECK(hugoOps.closeTransaction(pNdb) == 0); } hugoOps.closeTransaction(pNdb); return result; } /** * TUP errors */ struct TupError { enum Bits { TE_VARSIZE = 0x1, TE_MULTI_OP = 0x2, TE_DISK = 0x4, TE_REPLICA = 0x8 }; int op; int error; int bits; }; static TupError f_tup_errors[] = { { NdbOperation::InsertRequest, 4014, 0 }, // Out of undo buffer { NdbOperation::InsertRequest, 4015, TupError::TE_DISK }, // Out of log space { NdbOperation::InsertRequest, 4016, 0 }, // AI Inconsistency { NdbOperation::InsertRequest, 4017, 0 }, // Out of memory { NdbOperation::InsertRequest, 4018, 0 }, // Null check error { NdbOperation::InsertRequest, 4019, TupError::TE_REPLICA }, //Alloc rowid error { NdbOperation::InsertRequest, 4020, TupError::TE_MULTI_OP }, // Size change error { NdbOperation::InsertRequest, 4021, TupError::TE_DISK }, // Out of disk space { -1, 0, 0 } }; int runTupErrors(NDBT_Context* ctx, NDBT_Step* step){ NdbRestarter restarter; HugoTransactions hugoTrans(*ctx->getTab()); HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); const NdbDictionary::Table * tab = ctx->getTab(); Uint32 i; int bits = TupError::TE_MULTI_OP; for(i = 0; i<tab->getNoOfColumns(); i++) { if (tab->getColumn(i)->getArrayType() != NdbDictionary::Column::ArrayTypeFixed) bits |= TupError::TE_VARSIZE; if (tab->getColumn(i)->getStorageType()!= NdbDictionary::Column::StorageTypeMemory) bits |= TupError::TE_DISK; } if (restarter.getNumDbNodes() >= 2) { bits |= TupError::TE_REPLICA; } /** * Insert */ for(i = 0; f_tup_errors[i].op != -1; i++) { if (f_tup_errors[i].op != NdbOperation::InsertRequest) { g_info << "Skipping " << f_tup_errors[i].error << " - not insert" << endl; continue; } if ((f_tup_errors[i].bits & bits) != f_tup_errors[i].bits) { g_info << "Skipping " << f_tup_errors[i].error << " - req bits: " << hex << f_tup_errors[i].bits << " bits: " << hex << bits << endl; continue; } g_info << "Testing error insert: " << f_tup_errors[i].error << endl; restarter.insertErrorInAllNodes(f_tup_errors[i].error); if (f_tup_errors[i].bits & TupError::TE_MULTI_OP) { } else { hugoTrans.loadTable(pNdb, 5); } restarter.insertErrorInAllNodes(0); if (hugoTrans.clearTable(pNdb, 5) != 0) { return NDBT_FAILED; } } return NDBT_OK; } NDBT_TESTSUITE(testBasic); TESTCASE("PkInsert", "Verify that we can insert and delete from this table using PK" "NOTE! No errors are allowed!" ){ INITIALIZER(runInsert); VERIFIER(runVerifyInsert); } TESTCASE("PkRead", "Verify that we can insert, read and delete from this table using PK"){ INITIALIZER(runLoadTable); STEP(runPkRead); FINALIZER(runClearTable); } TESTCASE("PkDirtyRead", "Verify that we can insert, dirty read and delete from this table using PK"){ INITIALIZER(runLoadTable); STEP(runPkDirtyRead); FINALIZER(runClearTable); } TESTCASE("PkUpdate", "Verify that we can insert, update and delete from this table using PK"){ INITIALIZER(runLoadTable); STEP(runPkUpdate); FINALIZER(runClearTable); } TESTCASE("PkDelete", "Verify that we can delete from this table using PK"){ INITIALIZER(runLoadTable); STEP(runPkDelete); FINALIZER(runClearTable); } TESTCASE("UpdateAndRead", "Verify that we can read and update at the same time"){ INITIALIZER(runLoadTable); STEP(runPkRead); STEP(runPkRead); STEP(runPkRead); STEP(runPkUpdate); STEP(runPkUpdate); STEP(runPkUpdate); FINALIZER(runClearTable); } TESTCASE("PkReadAndLocker", "Verify that we can read although there are "\ " a number of 1 second locks in the table"){ INITIALIZER(runLoadTable); STEP(runPkReadUntilStopped); STEP(runLocker); FINALIZER(runClearTable); } TESTCASE("PkReadAndLocker2", "Verify that we can read and update although there are "\ " a number of 1 second locks in the table"){ INITIALIZER(runLoadTable); STEP(runPkReadUntilStopped); STEP(runPkReadUntilStopped); STEP(runPkReadUntilStopped); STEP(runPkReadUntilStopped); STEP(runPkReadUntilStopped); STEP(runPkReadUntilStopped); STEP(runLocker); FINALIZER(runClearTable); } TESTCASE("PkReadUpdateAndLocker", "Verify that we can read and update although there are "\ " a number of 1 second locks in the table"){ INITIALIZER(runLoadTable); STEP(runPkReadUntilStopped); STEP(runPkReadUntilStopped); STEP(runPkUpdateUntilStopped); STEP(runPkUpdateUntilStopped); STEP(runLocker); FINALIZER(runClearTable); } TESTCASE("ReadWithLocksAndInserts", "TR457: This test is added to verify that an insert of a records "\ "that is already in the database does not delete the record"){ INITIALIZER(runLoadTable); STEP(runPkReadUntilStopped); STEP(runPkReadUntilStopped); STEP(runLocker); STEP(runInsertUntilStopped); FINALIZER(runClearTable); } TESTCASE("PkInsertTwice", "Verify that we can't insert an already inserted record." "Error should be returned" ){ INITIALIZER(runLoadTable); STEP(runInsertTwice); FINALIZER(runClearTable); } TESTCASE("NoCommitSleep", "Verify what happens when a NoCommit transaction is aborted by " "NDB because the application is sleeping" ){ INITIALIZER(runLoadTable); INITIALIZER(runNoCommitSleep); FINALIZER(runClearTable2); } TESTCASE("Commit626", "Verify what happens when a Commit transaction is aborted by " "NDB because the record does no exist" ){ INITIALIZER(runClearTable2); INITIALIZER(runCommit626); FINALIZER(runClearTable2); } TESTCASE("CommitTry626", "Verify what happens when a Commit(TryCommit) \n" "transaction is aborted by " "NDB because the record does no exist" ){ INITIALIZER(runClearTable2); INITIALIZER(runCommit_TryCommit626); FINALIZER(runClearTable2); } TESTCASE("CommitAsMuch626", "Verify what happens when a Commit(CommitAsMuchAsPossible) \n" "transaction is aborted by\n" "NDB because the record does no exist" ){ INITIALIZER(runClearTable2); INITIALIZER(runCommit_CommitAsMuchAsPossible626); FINALIZER(runClearTable2); } TESTCASE("NoCommit626", "Verify what happens when a NoCommit transaction is aborted by " "NDB because the record does no exist" ){ INITIALIZER(runClearTable2); INITIALIZER(runNoCommit626); FINALIZER(runClearTable2); } TESTCASE("NoCommitRollback626", "Verify what happens when a NoCommit transaction is aborted by " "NDB because the record does no exist and then we try to rollback\n" "the transaction" ){ INITIALIZER(runClearTable2); INITIALIZER(runNoCommitRollback626); FINALIZER(runClearTable2); } TESTCASE("Commit630", "Verify what happens when a Commit transaction is aborted by " "NDB because the record already exist" ){ INITIALIZER(runLoadTable); INITIALIZER(runCommit630); FINALIZER(runClearTable2); } TESTCASE("CommitTry630", "Verify what happens when a Commit(TryCommit) \n" "transaction is aborted by " "NDB because the record already exist" ){ INITIALIZER(runLoadTable); INITIALIZER(runCommit_TryCommit630); FINALIZER(runClearTable2); } TESTCASE("CommitAsMuch630", "Verify what happens when a Commit(CommitAsMuchAsPossible) \n" "transaction is aborted by\n" "NDB because the record already exist" ){ INITIALIZER(runLoadTable); INITIALIZER(runCommit_CommitAsMuchAsPossible630); FINALIZER(runClearTable2); } TESTCASE("NoCommit630", "Verify what happens when a NoCommit transaction is aborted by " "NDB because the record already exist" ){ INITIALIZER(runLoadTable); INITIALIZER(runNoCommit630); FINALIZER(runClearTable2); } TESTCASE("NoCommitRollback630", "Verify what happens when a NoCommit transaction is aborted by " "NDB because the record already exist and then we try to rollback\n" "the transaction" ){ INITIALIZER(runLoadTable); INITIALIZER(runNoCommitRollback630); FINALIZER(runClearTable2); } TESTCASE("NoCommitAndClose", "Verify what happens when a NoCommit transaction is closed " "without rolling back the transaction " ){ INITIALIZER(runLoadTable); INITIALIZER(runNoCommitAndClose); FINALIZER(runClearTable2); } TESTCASE("RollbackDelete", "Test rollback of a no committed delete"){ INITIALIZER(runLoadTable); INITIALIZER(runCheckRollbackDelete); FINALIZER(runClearTable2); } TESTCASE("RollbackUpdate", "Test rollback of a no committed update"){ INITIALIZER(runLoadTable); INITIALIZER(runCheckRollbackUpdate); FINALIZER(runClearTable2); } TESTCASE("RollbackDeleteMultiple", "Test rollback of 10 non committed delete"){ INITIALIZER(runLoadTable); INITIALIZER(runCheckRollbackDeleteMultiple); FINALIZER(runClearTable2); } TESTCASE("ImplicitRollbackDelete", "Test close transaction after a no commited delete\n" "this would give an implicit rollback of the delete\n"){ INITIALIZER(runLoadTable); INITIALIZER(runCheckImplicitRollbackDelete); FINALIZER(runClearTable2); } TESTCASE("CommitDelete", "Test close transaction after a no commited delete\n" "this would give an implicit rollback of the delete\n"){ INITIALIZER(runLoadTable); INITIALIZER(runCheckCommitDelete); FINALIZER(runClearTable2); } TESTCASE("RollbackNothing", "Test rollback of nothing"){ INITIALIZER(runLoadTable); INITIALIZER(runRollbackNothing); FINALIZER(runClearTable2); } TESTCASE("MassiveRollback", "Test rollback of 4096 operations"){ INITIALIZER(runClearTable2); INITIALIZER(runMassiveRollback); FINALIZER(runClearTable2); } TESTCASE("MassiveRollback2", "Test rollback of 4096 operations"){ INITIALIZER(runClearTable2); INITIALIZER(runMassiveRollback2); FINALIZER(runClearTable2); } TESTCASE("MassiveRollback3", "Test rollback of 4096 operations"){ INITIALIZER(runClearTable2); STEP(runMassiveRollback3); STEP(runMassiveRollback3); FINALIZER(runClearTable2); } TESTCASE("MassiveTransaction", "Test very large insert transaction"){ INITIALIZER(runLoadTable2); FINALIZER(runClearTable2); } TESTCASE("Fill", "Verify what happens when we fill the db" ){ INITIALIZER(runFillTable); INITIALIZER(runPkRead); FINALIZER(runClearTable2); } TESTCASE("TupError", "Verify what happens when we fill the db" ){ INITIALIZER(runTupErrors); } NDBT_TESTSUITE_END(testBasic); #if 0 TESTCASE("ReadConsistency", "Check that a read within a transaction returns the " \ "same result no matter"){ STEP(runInsertOne); STEP(runReadOne); FINALIZER(runClearTable2); } #endif int main(int argc, const char** argv){ ndb_init(); return testBasic.execute(argc, argv); }