static void print_part_info(Ndb* pNdb, NDBT_Table* pTab) { InfoInfo g_part_info[] = { { "Partition", 0, NdbDictionary::Column::FRAGMENT }, { "Row count", 0, NdbDictionary::Column::ROW_COUNT }, { "Commit count", 0, NdbDictionary::Column::COMMIT_COUNT }, { "Frag fixed memory", 0, NdbDictionary::Column::FRAGMENT_FIXED_MEMORY }, { "Frag varsized memory", 0, NdbDictionary::Column::FRAGMENT_VARSIZED_MEMORY }, { 0, 0, 0 } }; ndbout << "-- Per partition info -- " << endl; NdbConnection* pTrans = pNdb->startTransaction(); if (pTrans == 0) return; do { NdbScanOperation* pOp= pTrans->getNdbScanOperation(pTab->getName()); if (pOp == NULL) break; int rs = pOp->readTuples(NdbOperation::LM_CommittedRead); if (rs != 0) break; if (pOp->interpret_exit_last_row() != 0) break; Uint32 i = 0; for(i = 0; g_part_info[i].m_title != 0; i++) { if ((g_part_info[i].m_rec_attr = pOp->getValue(g_part_info[i].m_column)) == 0) break; } if (g_part_info[i].m_title != 0) break; if (pTrans->execute(NoCommit) != 0) break; for (i = 0; g_part_info[i].m_title != 0; i++) ndbout << g_part_info[i].m_title << "\t"; ndbout << endl; while(pOp->nextResult() == 0) { for(i = 0; g_part_info[i].m_title != 0; i++) { ndbout << *g_part_info[i].m_rec_attr << "\t"; } ndbout << endl; } } while(0); pTrans->close(); }
int run_read() { int iter = g_paramters[P_LOOPS].value; NDB_TICKS start1, stop; int sum_time= 0; const Uint32 rows = g_paramters[P_ROWS].value; const Uint32 range = g_paramters[P_RANGE].value; start1 = NdbTick_CurrentMillisecond(); NdbConnection * pTrans = g_ndb->startTransaction(); if(!pTrans) { g_err << "Failed to start transaction" << endl; err(g_ndb->getNdbError()); return -1; } NdbOperation * pOp; NdbScanOperation * pSp; NdbIndexOperation * pUp; NdbIndexScanOperation * pIp; Uint32 start_row = rand() % (rows - range); Uint32 stop_row = start_row + range; /** * 0 - serial pk * 1 - batch pk * 2 - serial uniq * 3 - batch uniq * 4 - index eq * 5 - range scan * 6 - interpreted scan */ int check = 0; void* res = (void*)~0; const Uint32 pk = 0; Uint32 cnt = 0; for(; start_row < stop_row; start_row++) { switch(g_paramters[P_OPER].value) { case 0: pOp = pTrans->getNdbOperation(g_table); check = pOp->readTuple(); check = pOp->equal(pk, start_row); break; case 1: for(; start_row<stop_row; start_row++) { pOp = pTrans->getNdbOperation(g_table); check = pOp->readTuple(); check = pOp->equal(pk, start_row); for(int j = 0; j<g_tab->getNoOfColumns(); j++) { res = pOp->getValue(j); assert(res); } } break; case 2: pOp = pTrans->getNdbIndexOperation(g_unique, g_table); check = pOp->readTuple(); check = pOp->equal(pk, start_row); break; case 3: for(; start_row<stop_row; start_row++) { pOp = pTrans->getNdbIndexOperation(g_unique, g_table); check = pOp->readTuple(); check = pOp->equal(pk, start_row); for(int j = 0; j<g_tab->getNoOfColumns(); j++) { res = pOp->getValue(j); assert(res); } } break; case 4: pOp = pSp = pIp = pTrans->getNdbIndexScanOperation(g_ordered,g_table); pIp->readTuples(NdbScanOperation::LM_CommittedRead, 0, 0); check = pIp->setBound(pk, NdbIndexScanOperation::BoundEQ, &start_row); break; case 5: pOp = pSp = pIp = pTrans->getNdbIndexScanOperation(g_ordered,g_table); pIp->readTuples(NdbScanOperation::LM_CommittedRead, 0, 0); check = pIp->setBound(pk, NdbIndexScanOperation::BoundLE, &start_row); check = pIp->setBound(pk, NdbIndexScanOperation::BoundGT, &stop_row); start_row = stop_row; break; case 6: pOp = pSp = pIp = pTrans->getNdbIndexScanOperation(g_ordered,g_table); pIp->readTuples(NdbScanOperation::LM_CommittedRead, 0, 0, true); check = pIp->setBound(pk, NdbIndexScanOperation::BoundLE, &start_row); check = pIp->setBound(pk, NdbIndexScanOperation::BoundGT, &stop_row); start_row = stop_row; break; case 7: pOp = pSp = pTrans->getNdbScanOperation(g_table); pSp->readTuples(NdbScanOperation::LM_CommittedRead, 0, 0); NdbScanFilter filter(pOp) ; filter.begin(NdbScanFilter::AND); filter.ge(pk, start_row); filter.lt(pk, stop_row); filter.end(); start_row = stop_row; break; } assert(res); if(check != 0) { ndbout << pOp->getNdbError() << endl; ndbout << pTrans->getNdbError() << endl; } assert(check == 0); for(int j = 0; j<g_tab->getNoOfColumns(); j++) { res = pOp->getValue(j); assert(res); } check = pTrans->execute(NoCommit); if(check != 0) { ndbout << pTrans->getNdbError() << endl; } assert(check == 0); if(g_paramters[P_OPER].value >= 4) { while((check = pSp->nextResult(true)) == 0) { cnt++; } if(check == -1) { err(pTrans->getNdbError()); return -1; } assert(check == 1); pSp->close(); } } assert(g_paramters[P_OPER].value < 4 || (cnt == range)); pTrans->close(); stop = NdbTick_CurrentMillisecond(); g_times[g_paramters[P_OPER].value] += (stop - start1); return 0; }
inline int ScanInterpretTest::scanReadVerify(Ndb* pNdb, int records, int parallelism, ScanFilter& filter){ int retryAttempt = 0; const int retryMax = 100; int check; NdbConnection *pTrans; NdbScanOperation *pOp; while (true){ if (retryAttempt >= retryMax){ ndbout << "ERROR: has retried this operation " << retryAttempt << " times, failing!" << endl; return NDBT_FAILED; } pTrans = pNdb->startTransaction(); if (pTrans == NULL) { const NdbError err = pNdb->getNdbError(); if (err.status == NdbError::TemporaryError){ ERR(err); NdbSleep_MilliSleep(50); retryAttempt++; continue; } ERR(err); return NDBT_FAILED; } pOp = pTrans->getNdbScanOperation(tab.getName()); if (pOp == NULL) { if (pOp->getValue("KOL2") == 0){ ERR(pNdb->getNdbError()); return NDBT_FAILED; } ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } if( pOp->readTuples(NdbScanOperation::LM_Read, 0, parallelism) ) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } check = pOp->interpret_exit_ok(); if (check == -1) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } // Read all attributes for(int a = 0; a<tab.getNoOfColumns(); a++){ if((row.attributeStore(a) = pOp->getValue(tab.getColumn(a)->getName())) == 0) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } } check = pTrans->execute(NoCommit); if( check == -1 ) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } int eof; int rows = 0; int rowsNoExist = 0; int rowsExist = 0; int existingRecordsNotFound = 0; int nonExistingRecordsFound = 0; NdbConnection* pExistTrans; NdbConnection* pNoExistTrans; while((eof = pOp->nextResult(true)) == 0){ pExistTrans = pNdb->startTransaction(); if (pExistTrans == NULL) { const NdbError err = pNdb->getNdbError(); ERR(err); return NDBT_FAILED; } pNoExistTrans = pNdb->startTransaction(); if (pNoExistTrans == NULL) { const NdbError err = pNdb->getNdbError(); ERR(err); return NDBT_FAILED; } do { rows++; if (filter.verifyRecord(row) == NDBT_OK){ rowsExist++; if (addRowToCheckTrans(pNdb, pExistTrans) != 0){ pNdb->closeTransaction(pTrans); pNdb->closeTransaction(pExistTrans); pNdb->closeTransaction(pNoExistTrans); return NDBT_FAILED; } }else{ rowsNoExist++; if (addRowToCheckTrans(pNdb, pNoExistTrans) != 0){ pNdb->closeTransaction(pTrans); pNdb->closeTransaction(pExistTrans); pNdb->closeTransaction(pNoExistTrans); return NDBT_FAILED; } } } while((eof = pOp->nextResult(false)) == 0); // Execute the transaction containing reads of // all the records that should be in the result table check = pExistTrans->execute(Commit); if( check == -1 ) { const NdbError err = pExistTrans->getNdbError(); ERR(err); if (err.code != 626){ pNdb->closeTransaction(pExistTrans); pNdb->closeTransaction(pNoExistTrans); pNdb->closeTransaction(pTrans); return NDBT_FAILED; }else{ // Some of the records expected to be found wasn't // there existingRecordsNotFound = 1; } } pNdb->closeTransaction(pExistTrans); // Execute the transaction containing reads of // all the records that should NOT be in the result table check = pNoExistTrans->execute(Commit, CommitAsMuchAsPossible); if( check == -1 ) { const NdbError err = pNoExistTrans->getNdbError(); // The transactions error code should be zero if (err.code != 626){ ERR(err); pNdb->closeTransaction(pNoExistTrans); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } // Loop through the no existing transaction and check that no // operations where successful const NdbOperation* pOp2 = NULL; while ((pOp2 = pNoExistTrans->getNextCompletedOperation(pOp2)) != NULL){ const NdbError err = pOp2->getNdbError(); if (err.code != 626){ ndbout << "err.code = " << err.code<< endl; nonExistingRecordsFound = 1; } } } pNdb->closeTransaction(pNoExistTrans); } if (eof == -1) { const NdbError err = pTrans->getNdbError(); if (err.status == NdbError::TemporaryError){ ERR(err); pNdb->closeTransaction(pTrans); NdbSleep_MilliSleep(50); retryAttempt++; continue; } ERR(err); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } int testResult = NDBT_OK; int rowsResult = 0; UtilTransactions utilTrans(restab); if (utilTrans.selectCount(pNdb, 240, &rowsResult) != 0){ return NDBT_FAILED; } if (existingRecordsNotFound == 1){ ndbout << "!!! Expected records not found" << endl; testResult = NDBT_FAILED; } if (nonExistingRecordsFound == 1){ ndbout << "!!! Unxpected records found" << endl; testResult = NDBT_FAILED; } ndbout << rows << " rows scanned(" << rowsExist << " found, " << rowsResult<<" expected)" << endl; if (rowsResult != rowsExist){ ndbout << "!!! Number of rows in result table different from expected" << endl; testResult = NDBT_FAILED; } return testResult; } return NDBT_FAILED; }
inline int ScanInterpretTest::scanRead(Ndb* pNdb, int records, int parallelism, ScanFilter& filter){ int retryAttempt = 0; int retryMax = 100; int check; NdbConnection *pTrans; NdbScanOperation *pOp; while (true){ if (retryAttempt >= retryMax){ ndbout << "ERROR: has retried this operation " << retryAttempt << " times, failing!" << endl; return NDBT_FAILED; } pTrans = pNdb->startTransaction(); if (pTrans == NULL) { const NdbError err = pNdb->getNdbError(); if (err.status == NdbError::TemporaryError){ ERR(err); NdbSleep_MilliSleep(50); retryAttempt++; continue; } ERR(err); return NDBT_FAILED; } pOp = pTrans->getNdbScanOperation(tab.getName()); if (pOp == NULL) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } if( pOp->readTuples(NdbScanOperation::LM_Read, 0, parallelism) ) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } if (filter.filterOp(pOp) != 0){ ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } // Read all attributes for(int a = 0; a<tab.getNoOfColumns(); a++){ if((row.attributeStore(a) = pOp->getValue(tab.getColumn(a)->getName())) == 0) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } } check = pTrans->execute(NoCommit); if( check == -1 ) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } int eof; int rows = 0; NdbConnection* pInsTrans; while((eof = pOp->nextResult(true)) == 0){ do { rows++; if (addRowToInsert(pNdb, pTrans) != 0){ pNdb->closeTransaction(pTrans); return NDBT_FAILED; } } while((eof = pOp->nextResult(false)) == 0); check = pTrans->execute(Commit); if( check == -1 ) { const NdbError err = pTrans->getNdbError(); ERR(err); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } } if (eof == -1) { const NdbError err = pTrans->getNdbError(); if (err.status == NdbError::TemporaryError){ ERR(err); pNdb->closeTransaction(pTrans); NdbSleep_MilliSleep(50); retryAttempt++; continue; } ERR(err); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } pNdb->closeTransaction(pTrans); g_info << rows << " rows have been scanned" << endl; return NDBT_OK; } return NDBT_FAILED; }
inline int ScanFunctions::scanReadFunctions(Ndb* pNdb, int records, int parallelism, ActionType action, bool exclusive){ int retryAttempt = 0; const int retryMax = 100; int sleepTime = 10; int check; NdbConnection *pTrans = 0; NdbScanOperation *pOp = 0; while (true){ if (retryAttempt >= retryMax){ g_err << "ERROR: has retried this operation " << retryAttempt << " times, failing!" << endl; return NDBT_FAILED; } pTrans = pNdb->startTransaction(); if (pTrans == NULL) { const NdbError err = pNdb->getNdbError(); if (err.status == NdbError::TemporaryError){ ERR(err); NdbSleep_MilliSleep(50); retryAttempt++; continue; } ERR(err); return NDBT_FAILED; } // Execute the scan without defining a scan operation pOp = pTrans->getNdbScanOperation(tab.getName()); if (pOp == NULL) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } if( pOp->readTuples(exclusive ? NdbScanOperation::LM_Exclusive : NdbScanOperation::LM_Read) ) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } if (action == OnlyOpenScanOnce){ // Call openScan one more time when it's already defined if( pOp->readTuples(NdbScanOperation::LM_Read) ) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } } if (action==EqualAfterOpenScan){ check = pOp->equal(tab.getColumn(0)->getName(), 10); if( check == -1 ) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } } check = pOp->interpret_exit_ok(); if( check == -1 ) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } for(int a = 0; a<tab.getNoOfColumns(); a++){ if(pOp->getValue(tab.getColumn(a)->getName()) == NULL) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } } check = pTrans->execute(NoCommit); if( check == -1 ) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } int abortCount = records / 10; bool abortTrans = (action==CloseWithoutStop); int eof; int rows = 0; eof = pOp->nextResult(); while(eof == 0){ rows++; if (abortCount == rows && abortTrans == true){ g_info << "Scan is aborted after "<<abortCount<<" rows" << endl; if (action != CloseWithoutStop){ // Test that we can closeTrans without stopScan pOp->close(); if( check == -1 ) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } } pNdb->closeTransaction(pTrans); return NDBT_OK; } if(action == CheckInactivityTimeOut){ if ((rows % (records / 10)) == 0){ // Sleep for a long time before calling nextScanResult if (sleepTime > 1) sleepTime--; g_info << "Sleeping "<<sleepTime<<" secs " << endl; NdbSleep_SecSleep(sleepTime); } } eof = pOp->nextResult(); } if (eof == -1) { const NdbError err = pTrans->getNdbError(); if (err.status == NdbError::TemporaryError){ ERR(err); // Be cruel, call nextScanResult after error for(int i=0; i<10; i++){ eof = pOp->nextResult(); if(eof == 0){ g_err << "nextScanResult returned eof = " << eof << endl << " That is an error when there are no more records" << endl; return NDBT_FAILED; } } // Be cruel end pNdb->closeTransaction(pTrans); NdbSleep_MilliSleep(50); retryAttempt++; g_info << "Starting over" << endl; // If test is CheckInactivityTimeOut // error 296 is expected if ((action == CheckInactivityTimeOut) && (err.code == 296)) return NDBT_OK; continue; } ERR(err); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } if (action == NextScanWhenNoMore){ g_info << "Calling nextScanresult when there are no more records" << endl; for(int i=0; i<10; i++){ eof = pOp->nextResult(); if(eof == 0){ g_err << "nextScanResult returned eof = " << eof << endl << " That is an error when there are no more records" << endl; return NDBT_FAILED; } } } if(action == CheckInactivityBeforeClose){ // Sleep for a long time before calling close g_info << "NdbSleep_SecSleep(5) before close transaction" << endl; NdbSleep_SecSleep(5); } if(action == NoCloseTransaction) g_info << "Forgetting to close transaction" << endl; else pNdb->closeTransaction(pTrans); g_info << rows << " rows have been read" << endl; if (records != 0 && rows != records){ g_err << "Check expected number of records failed" << endl << " expected=" << records <<", " << endl << " read=" << rows << endl; return NDBT_FAILED; } return NDBT_OK; } return NDBT_FAILED; }
int run_scan(){ int iter = g_paramters[P_LOOPS].value; NDB_TICKS start1, stop; int sum_time= 0; int sample_rows = 0; int tot_rows = 0; NDB_TICKS sample_start = NdbTick_CurrentMillisecond(); Uint32 tot = g_paramters[P_ROWS].value; if(g_paramters[P_BOUND].value >= 2 || g_paramters[P_FILT].value == 2) iter *= g_paramters[P_ROWS].value; NdbScanOperation * pOp = 0; NdbIndexScanOperation * pIOp = 0; NdbConnection * pTrans = 0; int check = 0; for(int i = 0; i<iter; i++){ start1 = NdbTick_CurrentMillisecond(); pTrans = pTrans ? pTrans : g_ndb->startTransaction(); if(!pTrans){ g_err << "Failed to start transaction" << endl; err(g_ndb->getNdbError()); return -1; } int par = g_paramters[P_PARRA].value; int bat = 0; // g_paramters[P_BATCH].value; NdbScanOperation::LockMode lm; switch(g_paramters[P_LOCK].value){ case 0: lm = NdbScanOperation::LM_CommittedRead; break; case 1: lm = NdbScanOperation::LM_Read; break; case 2: lm = NdbScanOperation::LM_Exclusive; break; default: abort(); } if(g_paramters[P_ACCESS].value == 0){ pOp = pTrans->getNdbScanOperation(g_tablename); assert(pOp); pOp->readTuples(lm, bat, par); } else { if(g_paramters[P_RESET].value == 0 || pIOp == 0) { pOp= pIOp= pTrans->getNdbIndexScanOperation(g_indexname, g_tablename); bool ord = g_paramters[P_ACCESS].value == 2; pIOp->readTuples(lm, bat, par, ord); } else { pIOp->reset_bounds(); } switch(g_paramters[P_BOUND].value){ case 0: // All break; case 1: // None pIOp->setBound((Uint32)0, NdbIndexScanOperation::BoundEQ, 0); break; case 2: { // 1 row default: assert(g_table->getNoOfPrimaryKeys() == 1); // only impl. so far int tot = g_paramters[P_ROWS].value; int row = rand() % tot; #if 0 fix_eq_bound(pIOp, row); #else pIOp->setBound((Uint32)0, NdbIndexScanOperation::BoundEQ, &row); #endif if(g_paramters[P_RESET].value == 2) goto execute; break; } case 3: { // read multi int multi = g_paramters[P_MULTI].value; int tot = g_paramters[P_ROWS].value; for(; multi > 0 && i < iter; --multi, i++) { int row = rand() % tot; pIOp->setBound((Uint32)0, NdbIndexScanOperation::BoundEQ, &row); pIOp->end_of_bound(i); } if(g_paramters[P_RESET].value == 2) goto execute; break; } } } assert(pOp); switch(g_paramters[P_FILT].value){ case 0: // All check = pOp->interpret_exit_ok(); break; case 1: // None check = pOp->interpret_exit_nok(); break; case 2: { // 1 row default: assert(g_table->getNoOfPrimaryKeys() == 1); // only impl. so far abort(); #if 0 int tot = g_paramters[P_ROWS].value; int row = rand() % tot; NdbScanFilter filter(pOp) ; filter.begin(NdbScanFilter::AND); fix_eq(filter, pOp, row); filter.end(); break; #endif } } if(check != 0){ err(pOp->getNdbError()); return -1; } assert(check == 0); if(g_paramters[P_RESET].value == 1) g_paramters[P_RESET].value = 2; for(int i = 0; i<g_table->getNoOfColumns(); i++){ pOp->getValue(i); } if(g_paramters[P_RESET].value == 1) g_paramters[P_RESET].value = 2; execute: int rows = 0; check = pTrans->execute(NoCommit); assert(check == 0); int fetch = g_paramters[P_FETCH].value; while((check = pOp->nextResult(true)) == 0){ do { rows++; } while(!fetch && ((check = pOp->nextResult(false)) == 0)); if(check == -1){ err(pTrans->getNdbError()); return -1; } assert(check == 2); } if(check == -1){ err(pTrans->getNdbError()); return -1; } assert(check == 1); if(g_paramters[P_RESET].value == 0) { pTrans->close(); pTrans = 0; } stop = NdbTick_CurrentMillisecond(); int time_passed= (int)(stop - start1); sample_rows += rows; sum_time+= time_passed; tot_rows+= rows; if(sample_rows >= tot) { int sample_time = (int)(stop - sample_start); g_info << "Found " << sample_rows << " rows" << endl; g_err.println("Time: %d ms = %u rows/sec", sample_time, (1000*sample_rows)/sample_time); sample_rows = 0; sample_start = stop; } } g_err.println("Avg time: %d ms = %u rows/sec", sum_time/tot_rows, (1000*tot_rows)/sum_time); return 0; }
int runTestBug34107(NDBT_Context* ctx, NDBT_Step* step){ const NdbDictionary::Table * pTab = ctx->getTab(); Ndb* pNdb = GETNDB(step); const Uint32 okSize= 10000; const Uint32 tooBig= 30000; Uint32 codeBuff[tooBig]; int i; for (i = 0; i <= 1; i++) { g_info << "bug34107:" << (i == 0 ? " small" : " too big") << endl; NdbConnection* pTrans = pNdb->startTransaction(); if (pTrans == NULL){ ERR(pNdb->getNdbError()); return NDBT_FAILED; } NdbScanOperation* pOp = pTrans->getNdbScanOperation(pTab->getName()); if (pOp == NULL) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } if (pOp->readTuples() == -1) { ERR(pOp->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } /* Test kernel mechanism for dealing with too large program * We need to provide our own program buffer as default * NdbInterpretedCode buffer will not grow larger than * NDB_MAX_SCANFILTER_SIZE */ NdbInterpretedCode code(NULL, // Table is irrelevant codeBuff, tooBig); // Size of codeBuff int n = i == 0 ? okSize : tooBig; int k; for (k = 0; k < n; k++) { // inserts 1 word ATTRINFO if (code.interpret_exit_ok() == -1) { ERR(code.getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } } if (code.finalise() != 0) { ERR(code.getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } if (pOp->setInterpretedCode(&code) != 0) { ERR(pOp->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } if (pTrans->execute(NoCommit) == -1) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } int ret; while ((ret = pOp->nextResult()) == 0) ; g_info << "ret=" << ret << " err=" << pOp->getNdbError().code << endl; if (i == 0 && ret != 1) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } if (i == 1 && ret != -1) { g_err << "unexpected big filter success" << endl; pNdb->closeTransaction(pTrans); return NDBT_FAILED; } if (i == 1 && pOp->getNdbError().code != 874) { g_err << "unexpected big filter error code, wanted 874" << endl; ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } pNdb->closeTransaction(pTrans); } return NDBT_OK; }
static void print_part_info(Ndb* pNdb, NdbDictionary::Table const* pTab) { InfoInfo g_part_info[] = { { "Partition", 0, NdbDictionary::Column::FRAGMENT }, { "Row count", 0, NdbDictionary::Column::ROW_COUNT }, { "Commit count", 0, NdbDictionary::Column::COMMIT_COUNT }, { "Frag fixed memory", 0, NdbDictionary::Column::FRAGMENT_FIXED_MEMORY }, { "Frag varsized memory", 0, NdbDictionary::Column::FRAGMENT_VARSIZED_MEMORY }, { "Extent_space", 0, NdbDictionary::Column::FRAGMENT_EXTENT_SPACE }, { "Free extent_space", 0, NdbDictionary::Column::FRAGMENT_FREE_EXTENT_SPACE }, { 0, 0, 0 } }; const Uint32 FragmentIdOffset = 0; ndbout << "-- Per partition info"; if (_blobinfo && _partinfo) ndbout << " for " << pTab->getName(); ndbout << " -- " << endl; const Uint32 codeWords= 1; Uint32 codeSpace[ codeWords ]; NdbInterpretedCode code(NULL, // Table is irrelevant &codeSpace[0], codeWords); if ((code.interpret_exit_last_row() != 0) || (code.finalise() != 0)) { return; } NdbConnection* pTrans = pNdb->startTransaction(); if (pTrans == 0) return; do { NdbScanOperation* pOp= pTrans->getNdbScanOperation(pTab->getName()); if (pOp == NULL) break; int rs = pOp->readTuples(NdbOperation::LM_CommittedRead); if (rs != 0) break; if (pOp->setInterpretedCode(&code) != 0) break; Uint32 i = 0; for(i = 0; g_part_info[i].m_title != 0; i++) { if ((g_part_info[i].m_rec_attr = pOp->getValue(g_part_info[i].m_column)) == 0) break; } if (g_part_info[i].m_title != 0) break; if (pTrans->execute(NoCommit) != 0) break; for (i = 0; g_part_info[i].m_title != 0; i++) ndbout << g_part_info[i].m_title << "\t"; if (_nodeinfo) { ndbout << "Nodes\t"; } ndbout << endl; while(pOp->nextResult() == 0) { for(i = 0; g_part_info[i].m_title != 0; i++) { NdbRecAttr &r= *g_part_info[i].m_rec_attr; unsigned long long val; switch (r.getType()) { case NdbDictionary::Column::Bigunsigned: val= r.u_64_value(); break; case NdbDictionary::Column::Unsigned: val= r.u_32_value(); break; default: abort(); } if (val != 0) printf("%-*.llu\t", (int)strlen(g_part_info[i].m_title), val); else printf("0%*.s\t", (int)strlen(g_part_info[i].m_title), ""); } if (_nodeinfo) { Uint32 partId = g_part_info[ FragmentIdOffset ].m_rec_attr -> u_32_value(); const Uint32 MaxReplicas = 4; Uint32 nodeIds[ MaxReplicas ]; Uint32 nodeCnt = pTab->getFragmentNodes(partId, &nodeIds[0], MaxReplicas); if (nodeCnt) { for (Uint32 n = 0; n < nodeCnt; n++) { if (n > 0) printf(","); printf("%u", nodeIds[n]); } printf("\t"); } else { printf("-\t"); } } printf("\n"); } } while(0); pTrans->close(); }
int runTestBug34107(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; const NdbDictionary::Table * pTab = ctx->getTab(); Ndb* pNdb = GETNDB(step); int i; for (i = 0; i <= 1; i++) { g_info << "bug34107:" << (i == 0 ? " small" : " too big") << endl; NdbConnection* pTrans = pNdb->startTransaction(); if (pTrans == NULL){ ERR(pNdb->getNdbError()); return NDBT_FAILED; } NdbScanOperation* pOp = pTrans->getNdbScanOperation(pTab->getName()); if (pOp == NULL) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } if (pOp->readTuples() == -1) { ERR(pOp->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } int n = i == 0 ? 10000 : 30000; int k; for (k = 0; k < n; k++) { // inserts 1 word ATTRINFO if (pOp->interpret_exit_ok() == -1) { ERR(pOp->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } } if (pTrans->execute(NoCommit) == -1) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } int ret; while ((ret = pOp->nextResult()) == 0) ; g_info << "ret=" << ret << " err=" << pOp->getNdbError().code << endl; if (i == 0 && ret != 1) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } if (i == 1 && ret != -1) { g_err << "unexpected big filter success" << endl; pNdb->closeTransaction(pTrans); return NDBT_FAILED; } if (i == 1 && pOp->getNdbError().code != 874) { g_err << "unexpected big filter error code, wanted 874" << endl; ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } pNdb->closeTransaction(pTrans); } return NDBT_OK; }