int runEventMixedLoad(NDBT_Context* ctx, NDBT_Step* step) { int loops = ctx->getNumLoops(); int records = ctx->getNumRecords(); HugoTransactions hugoTrans(*ctx->getTab()); sleep(5); if (hugoTrans.loadTable(GETNDB(step), 3*records, 1, true, 1) != 0){ return NDBT_FAILED; } if (hugoTrans.pkDelRecords(GETNDB(step), 3*records, 1, true, 1) != 0){ return NDBT_FAILED; } if (hugoTrans.loadTable(GETNDB(step), records, 1, true, 1) != 0){ return NDBT_FAILED; } if (hugoTrans.pkUpdateRecords(GETNDB(step), records, 1, 1) != 0){ return NDBT_FAILED; } if (hugoTrans.pkUpdateRecords(GETNDB(step), records, 1, 1) != 0){ return NDBT_FAILED; } if (hugoTrans.pkUpdateRecords(GETNDB(step), records, 1, 1) != 0){ return NDBT_FAILED; } return NDBT_OK; }
int runMiscUntilStopped(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); int i = 0; Ndb * ndb = GETNDB(step); HugoTransactions hugoTrans(*ctx->getTab()); while (ctx->isTestStopped() == false) { int r = 0; switch(i % 5) { case 0: // batch size = 2, random = 1 r = hugoTrans.pkReadRecords(ndb, records / 20, 2, NdbOperation::LM_Read, 1); break; case 1: r = hugoTrans.pkUpdateRecords(ndb, records / 20); break; case 2: r = hugoTrans.scanReadRecords(ndb, records); break; case 3: r = hugoTrans.scanUpdateRecords(ndb, records / 10); break; case 4: NdbSleep_MilliSleep(records); break; } if(r != 0) return NDBT_FAILED; i++; } ndbout << "V2 Test misc thread: " << i << " transactions" << endl; return NDBT_OK; }
int runVerifyOne(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); Ndb* pNdb = GETNDB(step); int result = NDBT_OK; int count = 0; const NdbDictionary::Table* tab = GETNDB(step)->getDictionary()->getTable(ctx->getTab()->getName()); if(tab == 0) return NDBT_FAILED; UtilTransactions utilTrans(* tab); HugoTransactions hugoTrans(* tab); do{ // Check that there are as many records as we expected CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0); g_err << "count = " << count; g_err << " records = " << records; g_err << endl; CHECK(count == records); // Read and verify every record CHECK(hugoTrans.pkReadRecords(pNdb, records) == 0); } while (false); return result; }
int runSetup(NDBT_Context* ctx, NDBT_Step* step, int waitGroupSize){ int records = ctx->getNumRecords(); int batchSize = ctx->getProperty("BatchSize", 1); int transactions = (records / 100) + 1; int operations = (records / transactions) + 1; Ndb* pNdb = GETNDB(step); HugoAsynchTransactions hugoTrans(*ctx->getTab()); if (hugoTrans.loadTableAsynch(pNdb, records, batchSize, transactions, operations) != 0){ return NDBT_FAILED; } Ndb_cluster_connection* conn = &pNdb->get_ndb_cluster_connection(); /* The first call to create_multi_ndb_wait_group() should succeed ... */ global_poll_group = conn->create_ndb_wait_group(waitGroupSize); if(global_poll_group == 0) { return NDBT_FAILED; } /* and subsequent calls should fail */ if(conn->create_ndb_wait_group(waitGroupSize) != 0) { return NDBT_FAILED; } return NDBT_OK; }
int runBug24717(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; int loops = ctx->getNumLoops(); int records = ctx->getNumRecords(); NdbRestarter restarter; Ndb* pNdb = GETNDB(step); HugoTransactions hugoTrans(*ctx->getTab()); int dump[] = { 9002, 0 } ; Uint32 ownNode = refToNode(pNdb->getReference()); dump[1] = ownNode; for (; loops; loops --) { int nodeId = restarter.getRandomNotMasterNodeId(rand()); restarter.restartOneDbNode(nodeId, false, true, true); restarter.waitNodesNoStart(&nodeId, 1); if (restarter.dumpStateOneNode(nodeId, dump, 2)) return NDBT_FAILED; restarter.startNodes(&nodeId, 1); do { for (Uint32 i = 0; i < 100; i++) { hugoTrans.pkReadRecords(pNdb, 100, 1, NdbOperation::LM_CommittedRead); } } while (restarter.waitClusterStarted(5) != 0); } return NDBT_OK; }
int runPkDelete(NDBT_Context* ctx, NDBT_Step* step){ int loops = ctx->getNumLoops(); int records = ctx->getNumRecords(); int batchSize = ctx->getProperty("BatchSize", 1); int transactions = (records / 100) + 1; int operations = (records / transactions) + 1; int i = 0; HugoAsynchTransactions hugoTrans(*ctx->getTab()); while (i<loops) { ndbout << i << ": "; if (hugoTrans.pkDelRecordsAsynch(GETNDB(step), records, batchSize, transactions, operations) != 0){ return NDBT_FAILED; } // Load table, don't allow any primary key violations if (hugoTrans.loadTableAsynch(GETNDB(step), records, batchSize, transactions, operations) != 0){ return NDBT_FAILED; } i++; } return NDBT_OK; }
int main(int argc, const char** argv){ ndb_init(); int _records = 0; const char* _tabname = NULL; int _help = 0; int _batch = 512; const char* db = "TEST_DB"; struct getargs args[] = { { "batch", 'b', arg_integer, &_batch, "Number of operations in each transaction", "batch" }, { "database", 'd', arg_string, &db, "Database", "" }, { "usage", '?', arg_flag, &_help, "Print help", "" } }; int num_args = sizeof(args) / sizeof(args[0]); int optind = 0; char desc[] = "tabname\n"\ "This program will load one table in Ndb with calculated data \n"\ "until the database is full. \n"; if(getarg(args, num_args, argc, argv, &optind) || argv[optind] == NULL || _help) { arg_printusage(args, num_args, argv[0], desc); return NDBT_ProgramExit(NDBT_WRONGARGS); } _tabname = argv[optind]; // Connect to Ndb Ndb_cluster_connection con; if(con.connect(12, 5, 1) != 0) { return NDBT_ProgramExit(NDBT_FAILED); } Ndb MyNdb(&con, db); if(MyNdb.init() != 0){ ERR(MyNdb.getNdbError()); return NDBT_ProgramExit(NDBT_FAILED); } // Connect to Ndb and wait for it to become ready while(MyNdb.waitUntilReady() != 0) ndbout << "Waiting for ndb to become ready..." << endl; // Check if table exists in db const NdbDictionary::Table* pTab = NDBT_Table::discoverTableFromDb(&MyNdb, _tabname); if(pTab == NULL){ ndbout << " Table " << _tabname << " does not exist!" << endl; return NDBT_ProgramExit(NDBT_WRONGARGS); } HugoTransactions hugoTrans(*pTab); if (hugoTrans.fillTable(&MyNdb, _batch) != 0){ return NDBT_ProgramExit(NDBT_FAILED); } return NDBT_ProgramExit(NDBT_OK); }
int runDDL(NDBT_Context* ctx, NDBT_Step* step){ Ndb* pNdb= GETNDB(step); NdbDictionary::Dictionary* pDict = pNdb->getDictionary(); const int tables = NDBT_Tables::getNumTables(); while(!ctx->isTestStopped()) { const int tab_no = rand() % (tables); NdbDictionary::Table tab = *NDBT_Tables::getTable(tab_no); BaseString name= tab.getName(); name.appfmt("-%d", step->getStepNo()); tab.setName(name.c_str()); if(pDict->createTable(tab) == 0) { HugoTransactions hugoTrans(* pDict->getTable(name.c_str())); if (hugoTrans.loadTable(pNdb, 10000) != 0){ return NDBT_FAILED; } while(pDict->dropTable(tab.getName()) != 0 && pDict->getNdbError().code != 4009) g_err << pDict->getNdbError() << endl; sleep(1); } } return NDBT_OK; }
int runScanJoin(NDBT_Context* ctx, NDBT_Step* step){ int loops = ctx->getNumLoops(); int joinlevel = ctx->getProperty("JoinLevel", 3); int until_stopped = ctx->getProperty("UntilStopped", (Uint32)0); Uint32 stepNo = step->getStepNo(); int i = 0; HugoQueryBuilder qb(GETNDB(step), ctx->getTab(), HugoQueryBuilder::O_SCAN); qb.setJoinLevel(joinlevel); const NdbQueryDef * query = qb.createQuery(GETNDB(step)); HugoQueries hugoTrans(* query); while ((i<loops || until_stopped) && !ctx->isTestStopped()) { g_info << i << ": "; if (hugoTrans.runScanQuery(GETNDB(step))) { g_info << endl; return NDBT_FAILED; } addMask(ctx, (1 << stepNo), "Running"); i++; } g_info << endl; return NDBT_OK; }
int runFillTable(NDBT_Context* ctx, NDBT_Step* step){ HugoTransactions hugoTrans(*ctx->getTab()); if (hugoTrans.fillTable(GETNDB(step)) != 0){ return NDBT_FAILED; } return NDBT_OK; }
int runCreateEvent(NDBT_Context* ctx, NDBT_Step* step) { HugoTransactions hugoTrans(*ctx->getTab()); if (hugoTrans.createEvent(GETNDB(step)) != 0){ return NDBT_FAILED; } return NDBT_OK; }
int runVerifyUndoData(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); Ndb* pNdb = GETNDB(step); int count = 0; int num = 5; if (records - 5 < 0) num = 1; const NdbDictionary::Table* tab = GETNDB(step)->getDictionary()->getTable(ctx->getTab()->getName()); if(tab == 0) { g_err << " Can't find table" << endl; return NDBT_FAILED; } UtilTransactions utilTrans(* tab); HugoTransactions hugoTrans(* tab); // Check that there are as many records as we expected if(utilTrans.selectCount(pNdb, 64, &count) != 0) { g_err << "Can't get records count" << endl; return NDBT_FAILED; } g_err << "count = " << count; g_err << " records = " << records; g_err << endl; if (count != records) { g_err << "The records count is not correct" << endl; return NDBT_FAILED; } // make sure all the update data is there NdbTransaction *pTransaction= pNdb->startTransaction(); if (pTransaction == NULL) { g_err << "Can't get transaction pointer" << endl; return NDBT_FAILED; } if(hugoTrans.setTransaction(pTransaction) != 0) { g_err << "Set transaction error" << endl; pNdb->closeTransaction(pTransaction); return NDBT_FAILED; } if(hugoTrans.pkReadRecord(pNdb, 0, records, NdbOperation::LM_Read) != 0) { g_err << "Can't read record" << endl; return NDBT_FAILED; } if(hugoTrans.verifyUpdatesValue(0, records) != 0) { g_err << "The records restored with undo log is not correct" << endl; return NDBT_FAILED; } hugoTrans.closeTransaction(pNdb); 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 runScanReadVerify(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); HugoTransactions hugoTrans(*ctx->getTab()); if (hugoTrans.scanReadRecords(GETNDB(step), records, 0, 64) != 0){ return NDBT_FAILED; } 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 runDropEvent(NDBT_Context* ctx, NDBT_Step* step) { HugoTransactions hugoTrans(*ctx->getTab()); theThreadIdCounter = 0; // if (hugoTrans.createEvent(GETNDB(step)) != 0){ // return NDBT_FAILED; // } return NDBT_OK; }
static int verify_copy(Ndb *ndb, Vector<const NdbDictionary::Table *> &tabs1, Vector<const NdbDictionary::Table *> &tabs2) { for (unsigned i= 0; i < tabs1.size(); i++) if (tabs1[i]) { HugoTransactions hugoTrans(*tabs1[i]); if (hugoTrans.compare(ndb, tabs2[i]->getName(), 0)) return -1; } return 0; }
int runClearTable(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); int batchSize = ctx->getProperty("BatchSize", 1); int transactions = (records / 100) + 1; int operations = (records / transactions) + 1; HugoAsynchTransactions hugoTrans(*ctx->getTab()); if (hugoTrans.pkDelRecordsAsynch(GETNDB(step), records, batchSize, transactions, operations) != 0){ return NDBT_FAILED; } return NDBT_OK; }
int load_table() { if(!g_paramters[P_LOAD].value) return 0; int rows = g_paramters[P_ROWS].value; HugoTransactions hugoTrans(* g_tab); if (hugoTrans.loadTable(g_ndb, rows)) { g_err.println("Failed to load %s with %d rows", g_tab->getName(), rows); return -1; } return 0; }
int runScanReadUntilStopped(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; int records = ctx->getNumRecords(); int i = 0; HugoTransactions hugoTrans(*ctx->getTab()); while (ctx->isTestStopped() == false) { g_info << i << ": "; if (hugoTrans.scanReadRecords(GETNDB(step), records) != 0){ return NDBT_FAILED; } i++; } return result; }
static int runInsertUpdate(NDBT_Context* ctx, NDBT_Step* step) { NDBT_Table* pTab = ctx->getTab(); Ndb* pNdb = GETNDB(step); int ret; g_info << "Insert: " << pTab->getName() << endl; HugoTransactions hugoTrans(*pTab); ret = hugoTrans.loadTable(pNdb, ctx->getNumRecords(), 100); if (ret != 0) { g_err << "ERR: " << step->getName() << "failed" << endl; return NDBT_FAILED; } return NDBT_OK; }
int create_table(){ NdbDictionary::Dictionary* dict = g_ndb->getDictionary(); assert(dict); if(g_paramters[P_CREATE].value){ g_ndb->getDictionary()->dropTable(g_tablename); const NdbDictionary::Table * pTab = NDBT_Tables::getTable(g_tablename); assert(pTab); NdbDictionary::Table copy = * pTab; copy.setLogging(false); if(dict->createTable(copy) != 0){ g_err << "Failed to create table: " << g_tablename << endl; return -1; } NdbDictionary::Index x(g_indexname); x.setTable(g_tablename); x.setType(NdbDictionary::Index::OrderedIndex); x.setLogging(false); for (unsigned k = 0; k < copy.getNoOfColumns(); k++){ if(copy.getColumn(k)->getPrimaryKey()){ x.addColumnName(copy.getColumn(k)->getName()); } } if(dict->createIndex(x) != 0){ g_err << "Failed to create index: " << endl; return -1; } } g_table = dict->getTable(g_tablename); g_index = dict->getIndex(g_indexname, g_tablename); assert(g_table); assert(g_index); if(g_paramters[P_CREATE].value) { int rows = g_paramters[P_ROWS].value; HugoTransactions hugoTrans(* g_table); if (hugoTrans.loadTable(g_ndb, rows)){ g_err.println("Failed to load %s with %d rows", g_table->getName(), rows); return -1; } } return 0; }
int runInsert(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); int batchSize = ctx->getProperty("BatchSize", 1); int transactions = (records / 100) + 1; int operations = (records / transactions) + 1; HugoAsynchTransactions hugoTrans(*ctx->getTab()); // Insert records, dont allow any // errors(except temporary) while inserting if (hugoTrans.loadTableAsynch(GETNDB(step), records, batchSize, transactions, operations) != 0){ return NDBT_FAILED; } return NDBT_OK; }
int runVerify(NDBT_Context* ctx, NDBT_Step* step) { int records = ctx->getNumRecords(); const NdbDictionary::Table * table= ctx->getTab(); char buf[1024]; sprintf(buf, "%s_SHADOW", table->getName()); HugoTransactions hugoTrans(*table); if (hugoTrans.compare(GETNDB(step), buf, 0)) { return NDBT_FAILED; } return NDBT_OK; }
int runPkUpdateUntilStopped(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; int records = ctx->getNumRecords(); int i = 0; HugoTransactions hugoTrans(*ctx->getTab()); while (ctx->isTestStopped() == false) { g_info << i << ": "; int rows = (rand()%records)+1; int batch = (rand()%rows)+1; if (hugoTrans.pkUpdateRecords(GETNDB(step), rows, batch) != 0){ return NDBT_FAILED; } i++; } return result; }
int runCleanup(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); int batchSize = ctx->getProperty("BatchSize", 1); int transactions = (records / 100) + 1; int operations = (records / transactions) + 1; Ndb* pNdb = GETNDB(step); HugoAsynchTransactions hugoTrans(*ctx->getTab()); if (hugoTrans.pkDelRecordsAsynch(pNdb, records, batchSize, transactions, operations) != 0){ return NDBT_FAILED; } pNdb->get_ndb_cluster_connection().release_ndb_wait_group(global_poll_group); return NDBT_OK; }
static void hugoPkRead(NDBT_Thread& thr) { const ThrInput* input = (const ThrInput*)thr.get_input(); ThrOutput* output = (ThrOutput*)thr.get_output(); HugoTransactions hugoTrans(*input->pTab); output->latency.reset(); if (input->stats) hugoTrans.setStatsLatency(&output->latency); int ret; ret = hugoTrans.pkReadRecords(thr.get_ndb(), input->records, input->batch); if (ret != 0) thr.set_err(ret); }
int runScanUpdateUntilStopped(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; int records = ctx->getNumRecords(); int parallelism = ctx->getProperty("Parallelism", 1); int abort = ctx->getProperty("AbortProb", (Uint32)0); int i = 0; HugoTransactions hugoTrans(*ctx->getTab()); while (ctx->isTestStopped() == false) { g_info << i << ": "; if (hugoTrans.scanUpdateRecords(GETNDB(step), records, abort, parallelism) == NDBT_FAILED){ return NDBT_FAILED; } i++; } return result; }
int runPkRead(NDBT_Context* ctx, NDBT_Step* step){ int loops = ctx->getNumLoops(); int records = ctx->getNumRecords(); int batchSize = ctx->getProperty("BatchSize", 1); int transactions = (records / 100) + 1; int operations = (records / transactions) + 1; int i = 0; HugoAsynchTransactions hugoTrans(*ctx->getTab()); while (i<loops) { ndbout << i << ": "; if (hugoTrans.pkReadRecordsAsynch(GETNDB(step), records, batchSize, transactions, operations) != NDBT_OK){ return NDBT_FAILED; } i++; } return NDBT_OK; }
int runPkReadUntilStopped(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; int records = ctx->getNumRecords(); NdbOperation::LockMode lm = (NdbOperation::LockMode)ctx->getProperty("ReadLockMode", (Uint32)NdbOperation::LM_Read); int i = 0; HugoTransactions hugoTrans(*ctx->getTab()); while (ctx->isTestStopped() == false) { g_info << i << ": "; int rows = (rand()%records)+1; int batch = (rand()%rows)+1; if (hugoTrans.pkReadRecords(GETNDB(step), rows, batch, lm) != 0){ return NDBT_FAILED; } i++; } return result; }