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(); }
/** * Transaction 1 - T1 * * Update location and changed by/time on a subscriber * * Input: * SubscriberNumber, * Location, * ChangedBy, * ChangedTime * * Output: */ void start_T1(Ndb * pNDB, ThreadData * td){ DEBUG2("T1(%.*s): - Starting\n", SUBSCRIBER_NUMBER_LENGTH, td->transactionData.number); int check; NdbConnection * pCON = pNDB->startTransaction(); if (pCON != NULL) { NdbOperation *MyOp = pCON->getNdbOperation(SUBSCRIBER_TABLE); if (MyOp != NULL) { MyOp->updateTuple(); MyOp->equal(IND_SUBSCRIBER_NUMBER, td->transactionData.number); MyOp->setValue(IND_SUBSCRIBER_LOCATION, (char *)&td->transactionData.location); MyOp->setValue(IND_SUBSCRIBER_CHANGED_BY, td->transactionData.changed_by); MyOp->setValue(IND_SUBSCRIBER_CHANGED_TIME, td->transactionData.changed_time); pCON->executeAsynchPrepare( Commit , T1_Callback, td); } else { CHECK_NULL(MyOp, "T1: getNdbOperation", pCON); }//if } else { error_handler("T1-1: startTranscation", pNDB->getNdbErrorString(), pNDB->getNdbError()); }//if }
/** * Transaction 2 - T2 * * Read from Subscriber: * * Input: * SubscriberNumber * * Output: * Location * Changed by * Changed Timestamp * Name */ void start_T2(Ndb * pNDB, ThreadData * td){ DEBUG3("T2(%.*s, %p): - Starting\n", SUBSCRIBER_NUMBER_LENGTH, td->transactionData.number, td->transactionData.location); int check; NdbRecAttr * check2; NdbConnection * pCON = pNDB->startTransaction(); if (pCON == NULL) error_handler("T2-1: startTransaction", pNDB->getNdbErrorString(), pNDB->getNdbError()); NdbOperation *MyOp= pCON->getNdbOperation(SUBSCRIBER_TABLE); CHECK_NULL(MyOp, "T2: getNdbOperation", pCON); MyOp->readTuple(); MyOp->equal(IND_SUBSCRIBER_NUMBER, td->transactionData.number); MyOp->getValue(IND_SUBSCRIBER_LOCATION, (char *)&td->transactionData.location); MyOp->getValue(IND_SUBSCRIBER_CHANGED_BY, td->transactionData.changed_by); MyOp->getValue(IND_SUBSCRIBER_CHANGED_TIME, td->transactionData.changed_time); MyOp->getValue(IND_SUBSCRIBER_NAME, td->transactionData.name); pCON->executeAsynchPrepare( Commit, T2_Callback, td ); }
int DeleteTransaction(Ndb* pNdb, long iContextId, NdbError& err) { int iRes = -1; NdbConnection* pNdbConnection = pNdb->startTransaction(0, (const char*)&iContextId, 4); if(pNdbConnection) { NdbOperation* pNdbOperation = pNdbConnection->getNdbOperation(g_szTableName); if(pNdbOperation) { if(!pNdbOperation->deleteTuple() && !pNdbOperation->equal(c_szContextId, (Int32)iContextId)) { if(pNdbConnection->execute(Commit) == 0) iRes = 0; else err = pNdbConnection->getNdbError(); } else err = pNdbOperation->getNdbError(); } else err = pNdbConnection->getNdbError(); pNdb->closeTransaction(pNdbConnection); } else err = pNdb->getNdbError(); return iRes; }
int UpdateTransaction(Ndb* pNdb, long iContextId, NdbError& err) { int iRes = -1; NdbConnection* pNdbConnection = pNdb->startTransaction(0, (const char*)&iContextId, 4); if(pNdbConnection) { NdbOperation* pNdbOperation = pNdbConnection->getNdbOperation(g_szTableName); if(pNdbOperation) { if(!pNdbOperation->updateTuple() && !pNdbOperation->equal(c_szContextId, (Int32)iContextId) && !pNdbOperation->setValue(c_szContextData, STATUS_DATA, g_nStatusDataSize)) { if(!pNdbConnection->execute(Commit)) iRes = 0; else err = pNdbConnection->getNdbError(); } else err = pNdbOperation->getNdbError(); } else err = pNdbConnection->getNdbError(); pNdb->closeTransaction(pNdbConnection); } else err = pNdb->getNdbError(); return iRes; }
void start_T1(Ndb * pNDB, ThreadData * td, int async){ DEBUG2("T1(%.*s): - Starting", SUBSCRIBER_NUMBER_LENGTH, td->transactionData.number); NdbConnection * pCON = 0; while((pCON = startTransaction(pNDB, td)) == 0){ CHECK_ALLOWED_ERROR("T1: startTransaction", td, pNDB->getNdbError()); NdbSleep_MilliSleep(10); } NdbOperation *MyOp = pCON->getNdbOperation(SUBSCRIBER_TABLE); if (MyOp != NULL) { MyOp->updateTuple(); MyOp->equal(IND_SUBSCRIBER_NUMBER, td->transactionData.number); MyOp->setValue(IND_SUBSCRIBER_LOCATION, (char *)&td->transactionData.location); MyOp->setValue(IND_SUBSCRIBER_CHANGED_BY, td->transactionData.changed_by); MyOp->setValue(IND_SUBSCRIBER_CHANGED_TIME, td->transactionData.changed_time); if (async == 1) { pCON->executeAsynchPrepare( Commit , T1_Callback, td); } else { int result = pCON->execute(Commit); T1_Callback(result, pCON, (void*)td); return; }//if } else { CHECK_NULL(MyOp, "T1: getNdbOperation", td, pCON->getNdbError()); }//if }
/** * Transaction 1 - T1 * * Update location and changed by/time on a subscriber * * Input: * SubscriberNumber, * Location, * ChangedBy, * ChangedTime * * Output: */ int T1(void * obj, const SubscriberNumber number, const Location new_location, const ChangedBy changed_by, const ChangedTime changed_time, BenchmarkTime * transaction_time){ Ndb * pNDB = (Ndb *) obj; DEBUG2("T1(%.*s):\n", SUBSCRIBER_NUMBER_LENGTH, number); BenchmarkTime start; get_time(&start); int check; NdbRecAttr * check2; NdbConnection * MyTransaction = pNDB->startTransaction(); if (MyTransaction == NULL) error_handler("T1-1: startTranscation", pNDB->getNdbErrorString(), 0); NdbOperation *MyOperation = MyTransaction->getNdbOperation(SUBSCRIBER_TABLE); CHECK_NULL(MyOperation, "T1: getNdbOperation", MyTransaction); check = MyOperation->updateTuple(); CHECK_MINUS_ONE(check, "T1: updateTuple", MyTransaction); check = MyOperation->equal(IND_SUBSCRIBER_NUMBER, number); CHECK_MINUS_ONE(check, "T1: equal subscriber", MyTransaction); check = MyOperation->setValue(IND_SUBSCRIBER_LOCATION, (char *)&new_location); CHECK_MINUS_ONE(check, "T1: setValue location", MyTransaction); check = MyOperation->setValue(IND_SUBSCRIBER_CHANGED_BY, changed_by); CHECK_MINUS_ONE(check, "T1: setValue changed_by", MyTransaction); check = MyOperation->setValue(IND_SUBSCRIBER_CHANGED_TIME, changed_time); CHECK_MINUS_ONE(check, "T1: setValue changed_time", MyTransaction); check = MyTransaction->execute( Commit ); CHECK_MINUS_ONE(check, "T1: Commit", MyTransaction); pNDB->closeTransaction(MyTransaction); get_time(transaction_time); time_diff(transaction_time, &start); return 0; }
void read_and_verify_rows(Ndb* pMyNdb, bool pre) { int check = -1 ; int loop_count_ops = nRecords; char expectedCOL1[NUMBEROFRECORDS] = {0} ; char expectedCOL2[NUMBEROFRECORDS] = {0} ; NdbConnection *pMyTransaction = NULL ; NdbOperation *MyOp = NULL ; NdbRecAttr* tTmp = NULL ; int readValue[MAXATTR] = {0} ; ndbout << "Verifying records...\n"<< endl; for (int count=0 ; count < loop_count_ops ; count++) { pMyTransaction = pMyNdb->startTransaction(); if (!pMyTransaction) error_handler(pMyNdb->getNdbError(), NO_FAIL); MyOp = pMyTransaction->getNdbOperation(tableName); if (!MyOp) error_handler( pMyTransaction->getNdbError(), NO_FAIL); check = MyOp->readTuple(); if( check == -1 ) error_handler( MyOp->getNdbError(), NO_FAIL); check = MyOp->equal( attrName[0],(char*)&pkValue[count] ); if( check == -1 ) error_handler( MyOp->getNdbError(), NO_FAIL); for (int count_attributes = 1; count_attributes < MAXATTR; count_attributes++) { tTmp = MyOp->getValue( (char*)attrName[count_attributes], (char*)&readValue[count_attributes] ); if(!tTmp) error_handler( MyOp->getNdbError(), NO_FAIL); } if( pMyTransaction->execute( Commit ) == -1 ) { error_handler(pMyTransaction->getNdbError(), NO_FAIL); } else { if (pre) { expectedCOL1[count] = readValue[1]; expectedCOL2[count] = readValue[2]; } ndbout << attrName[1] << "\t " << readValue[1] << "\t " << attrName[2] << "\t " << readValue[2] << endl; } pMyNdb->closeTransaction(pMyTransaction); } ndbout << "\nOK\n" << endl; return; };
int runPkReadPkUpdateUntilStopped(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; int records = ctx->getNumRecords(); Ndb* pNdb = GETNDB(step); int i = 0; HugoOperations hugoOps(*ctx->getTab()); while (ctx->isTestStopped() == false) { g_info << i++ << ": "; int rows = (rand()%records)+1; int batch = (rand()%rows)+1; int row = (records - rows) ? rand() % (records - rows) : 0; int j,k; for(j = 0; j<rows; j += batch) { k = batch; if(j+k > rows) k = rows - j; if(hugoOps.startTransaction(pNdb) != 0) goto err; if(hugoOps.pkReadRecord(pNdb, row+j, k, NdbOperation::LM_Exclusive) != 0) goto err; if(hugoOps.execute_NoCommit(pNdb) != 0) goto err; if(hugoOps.pkUpdateRecord(pNdb, row+j, k, rand()) != 0) goto err; if(hugoOps.execute_Commit(pNdb) != 0) goto err; if(hugoOps.closeTransaction(pNdb) != 0) return NDBT_FAILED; } continue; err: NdbConnection* pCon = hugoOps.getTransaction(); if(pCon == 0) continue; NdbError error = pCon->getNdbError(); hugoOps.closeTransaction(pNdb); if (error.status == NdbError::TemporaryError){ NdbSleep_MilliSleep(50); continue; } return NDBT_FAILED; } return NDBT_OK; }
extern "C" void* NdbThreadFuncUpdate(void* pArg) { myRandom48Init((long int)NdbTick_CurrentMillisecond()); unsigned nSucc = 0; unsigned nFail = 0; Ndb* pNdb = NULL ; pNdb = new Ndb("TEST_DB"); VerifyMethodInt(pNdb, init()); VerifyMethodInt(pNdb, waitUntilReady()); while(NdbMutex_Trylock(g_pNdbMutex)) { Uint32 nWarehouse = myRandom48(g_nWarehouseCount); NdbConnection* pNdbConnection = NULL ; VerifyMethodPtr(pNdbConnection, pNdb, startTransaction()); CHK_TR(pNdbConnection) ; // epaulsa NdbOperation* pNdbOperationW = NULL ; VerifyMethodPtr(pNdbOperationW, pNdbConnection, getNdbOperation(c_szWarehouse)); VerifyMethodInt(pNdbOperationW, interpretedUpdateTuple()); VerifyMethodInt(pNdbOperationW, equal(c_szWarehouseNumber, nWarehouse)); VerifyMethodInt(pNdbOperationW, incValue(c_szWarehouseCount, Uint32(1))); Uint32 nWarehouseSum = 0; for(Uint32 nDistrict=0; nDistrict<g_nDistrictPerWarehouse; ++nDistrict) { NdbOperation* pNdbOperationD = NULL ; VerifyMethodPtr(pNdbOperationD, pNdbConnection, getNdbOperation(c_szDistrict)); VerifyMethodInt(pNdbOperationD, interpretedUpdateTuple()); VerifyMethodInt(pNdbOperationD, equal(c_szDistrictWarehouseNumber, nWarehouse)); VerifyMethodInt(pNdbOperationD, equal(c_szDistrictNumber, nDistrict)); VerifyMethodInt(pNdbOperationD, incValue(c_szDistrictCount, Uint32(1))); Uint32 nDistrictSum = myRandom48(100); nWarehouseSum += nDistrictSum; VerifyMethodInt(pNdbOperationD, setValue(c_szDistrictSum, nDistrictSum)); } VerifyMethodInt(pNdbOperationW, setValue(c_szWarehouseSum, nWarehouseSum)); int iExec = pNdbConnection->execute(Commit); int iError = pNdbConnection->getNdbError().code; if(iExec<0 && iError!=0 && iError!=266 && iError!=626) { ReportMethodInt(iExec, pNdbConnection, "pNdbConnection", "execute(Commit)", __FILE__, __LINE__); } if(iExec==0) { ++nSucc; } else { ++nFail; } VerifyMethodVoid(pNdb, closeTransaction(pNdbConnection)); } ndbout << "update: " << nSucc << " succeeded, " << nFail << " failed " << endl; NdbMutex_Unlock(g_pNdbMutex); delete pNdb; pNdb = NULL ; return NULL; }
int userDbInsertSubscriber(UserHandle *uh, SubscriberNumber number, uint32 groupId, SubscriberName name) { int check; uint32 activeSessions = 0; Location l = 0; ChangedBy changedBy; ChangedTime changedTime; BaseString::snprintf(changedBy, sizeof(changedBy), "ChangedBy"); BaseString::snprintf(changedTime, sizeof(changedTime), "ChangedTime"); NdbConnection * MyTransaction = 0; if(uh->pCurrTrans != 0){ MyTransaction = uh->pCurrTrans; } else { uh->pCurrTrans = MyTransaction = uh->pNDB->startTransaction(); } if (MyTransaction == NULL) error_handler("startTranscation", uh->pNDB->getNdbError(), 0); NdbOperation *MyOperation = MyTransaction->getNdbOperation(SUBSCRIBER_TABLE); CHECK_NULL(MyOperation, "getNdbOperation", MyTransaction); check = MyOperation->insertTuple(); CHECK_MINUS_ONE(check, "insertTuple", MyTransaction); check = MyOperation->equal(SUBSCRIBER_NUMBER, number); CHECK_MINUS_ONE(check, "equal", MyTransaction); check = MyOperation->setValue(SUBSCRIBER_NAME, name); CHECK_MINUS_ONE(check, "setValue name", MyTransaction); check = MyOperation->setValue(SUBSCRIBER_GROUP, (char*)&groupId); CHECK_MINUS_ONE(check, "setValue group", MyTransaction); check = MyOperation->setValue(SUBSCRIBER_LOCATION, (char*)&l); CHECK_MINUS_ONE(check, "setValue location", MyTransaction); check = MyOperation->setValue(SUBSCRIBER_SESSIONS, (char*)&activeSessions); CHECK_MINUS_ONE(check, "setValue sessions", MyTransaction); check = MyOperation->setValue(SUBSCRIBER_CHANGED_BY, changedBy); CHECK_MINUS_ONE(check, "setValue changedBy", MyTransaction); check = MyOperation->setValue(SUBSCRIBER_CHANGED_TIME, changedTime); CHECK_MINUS_ONE(check, "setValue changedTime", MyTransaction); return 0; }
int insert_subscriber(void * obj, SubscriberNumber number, SubscriberName name, GroupId groupId, Location l, ActiveSessions activeSessions, ChangedBy changedBy, ChangedTime changedTime){ Ndb * pNDB = (Ndb *)obj; int check; NdbConnection * MyTransaction = pNDB->startTransaction(); if (MyTransaction == NULL) error_handler("startTranscation", pNDB->getNdbErrorString(), 0); NdbOperation *MyOperation = MyTransaction->getNdbOperation(SUBSCRIBER_TABLE); CHECK_NULL(MyOperation, "getNdbOperation", MyTransaction); check = MyOperation->insertTuple(); CHECK_MINUS_ONE(check, "insertTuple", MyTransaction); check = MyOperation->equal(SUBSCRIBER_NUMBER, number); CHECK_MINUS_ONE(check, "equal", MyTransaction); check = MyOperation->setValue(SUBSCRIBER_NAME, name); CHECK_MINUS_ONE(check, "setValue name", MyTransaction); check = MyOperation->setValue(SUBSCRIBER_GROUP, (char*)&groupId); CHECK_MINUS_ONE(check, "setValue group", MyTransaction); check = MyOperation->setValue(SUBSCRIBER_LOCATION, (char*)&l); CHECK_MINUS_ONE(check, "setValue location", MyTransaction); check = MyOperation->setValue(SUBSCRIBER_SESSIONS, (char*)&activeSessions); CHECK_MINUS_ONE(check, "setValue sessions", MyTransaction); check = MyOperation->setValue(SUBSCRIBER_CHANGED_BY, changedBy); CHECK_MINUS_ONE(check, "setValue changedBy", MyTransaction); check = MyOperation->setValue(SUBSCRIBER_CHANGED_TIME, changedTime); CHECK_MINUS_ONE(check, "setValue changedTime", MyTransaction); check = MyTransaction->execute( Commit ); CHECK_MINUS_ONE(check, "commit", MyTransaction); pNDB->closeTransaction(MyTransaction); return 0; }
int QueryTransaction(Ndb* pNdb, long iContextId, long* piVersion, long* piLockFlag, long* piLockTime, long* piLockTimeUSec, char* pchContextData, NdbError& err) { int iRes = -1; NdbConnection* pNdbConnection = pNdb->startTransaction(0, (const char*)&iContextId, 4); if(pNdbConnection) { NdbOperation* pNdbOperation = pNdbConnection->getNdbOperation(g_szTableName); if(pNdbOperation) { NdbRecAttr* pNdbRecAttrVersion; NdbRecAttr* pNdbRecAttrLockFlag; NdbRecAttr* pNdbRecAttrLockTime; NdbRecAttr* pNdbRecAttrLockTimeUSec; NdbRecAttr* pNdbRecAttrContextData; if(!pNdbOperation->readTuple() && !pNdbOperation->equal(c_szContextId, (Int32)iContextId) && (pNdbRecAttrVersion=pNdbOperation->getValue(c_szVersion, (char*)piVersion)) && (pNdbRecAttrLockFlag=pNdbOperation->getValue(c_szLockFlag, (char*)piLockFlag)) && (pNdbRecAttrLockTime=pNdbOperation->getValue(c_szLockTime, (char*)piLockTime)) && (pNdbRecAttrLockTimeUSec=pNdbOperation->getValue(c_szLockTimeUSec, (char*)piLockTimeUSec)) && (pNdbRecAttrContextData=pNdbOperation->getValue(c_szContextData, pchContextData))) { if(!pNdbConnection->execute(Commit)) iRes = 0; else err = pNdbConnection->getNdbError(); } else err = pNdbOperation->getNdbError(); } else err = pNdbConnection->getNdbError(); pNdb->closeTransaction(pNdbConnection); } else err = pNdb->getNdbError(); return iRes; }
int userDbInsertServer(UserHandle *uh, ServerId serverId, SubscriberSuffix suffix, ServerName name) { int check; uint32 noOfRead = 0; uint32 noOfInsert = 0; uint32 noOfDelete = 0; NdbConnection * MyTransaction = 0; if(uh->pCurrTrans != 0){ MyTransaction = uh->pCurrTrans; } else { uh->pCurrTrans = MyTransaction = uh->pNDB->startTransaction(); } if (MyTransaction == NULL) error_handler("startTranscation", uh->pNDB->getNdbError(), 0); NdbOperation *MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE); CHECK_NULL(MyOperation, "getNdbOperation", MyTransaction); check = MyOperation->insertTuple(); CHECK_MINUS_ONE(check, "insert tuple", MyTransaction); check = MyOperation->equal(SERVER_ID, (char*)&serverId); CHECK_MINUS_ONE(check, "setValue id", MyTransaction); check = MyOperation->setValue(SERVER_SUBSCRIBER_SUFFIX, suffix); CHECK_MINUS_ONE(check, "setValue suffix", MyTransaction); check = MyOperation->setValue(SERVER_NAME, name); CHECK_MINUS_ONE(check, "setValue name", MyTransaction); check = MyOperation->setValue(SERVER_READS, (char*)&noOfRead); CHECK_MINUS_ONE(check, "setValue reads", MyTransaction); check = MyOperation->setValue(SERVER_INSERTS, (char*)&noOfInsert); CHECK_MINUS_ONE(check, "setValue inserts", MyTransaction); check = MyOperation->setValue(SERVER_DELETES, (char*)&noOfDelete); CHECK_MINUS_ONE(check, "setValue deletes", MyTransaction); return 0; }
int insert_server(void * obj, ServerId serverId, SubscriberSuffix suffix, ServerName name, Counter noOfRead, Counter noOfInsert, Counter noOfDelete){ Ndb * pNDB = (Ndb *)obj; int check; NdbConnection * MyTransaction = pNDB->startTransaction(); if (MyTransaction == NULL) error_handler("startTranscation", pNDB->getNdbErrorString(), 0); NdbOperation *MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE); CHECK_NULL(MyOperation, "getNdbOperation", MyTransaction); check = MyOperation->insertTuple(); CHECK_MINUS_ONE(check, "insert tuple", MyTransaction); check = MyOperation->equal(SERVER_ID, (char*)&serverId); CHECK_MINUS_ONE(check, "setValue id", MyTransaction); check = MyOperation->setValue(SERVER_SUBSCRIBER_SUFFIX, suffix); CHECK_MINUS_ONE(check, "setValue suffix", MyTransaction); check = MyOperation->setValue(SERVER_NAME, name); CHECK_MINUS_ONE(check, "setValue name", MyTransaction); check = MyOperation->setValue(SERVER_READS, (char*)&noOfRead); CHECK_MINUS_ONE(check, "setValue reads", MyTransaction); check = MyOperation->setValue(SERVER_INSERTS, (char*)&noOfInsert); CHECK_MINUS_ONE(check, "setValue inserts", MyTransaction); check = MyOperation->setValue(SERVER_DELETES, (char*)&noOfDelete); CHECK_MINUS_ONE(check, "setValue deletes", MyTransaction); check = MyTransaction->execute( Commit ); CHECK_MINUS_ONE(check, "commit", MyTransaction); pNDB->closeTransaction(MyTransaction); return 0; }
/** * Transaction 2 - T2 * * Read from Subscriber: * * Input: * SubscriberNumber * * Output: * Location * Changed by * Changed Timestamp * Name */ void start_T2(Ndb * pNDB, ThreadData * td, int async) { DEBUG3("T2(%.*s, %d): - Starting", SUBSCRIBER_NUMBER_LENGTH, td->transactionData.number, td->transactionData.location); NdbConnection * pCON = 0; while((pCON = startTransaction(pNDB, td)) == 0) { CHECK_ALLOWED_ERROR("T2-1: startTransaction", td, pNDB->getNdbError()); NdbSleep_MilliSleep(10); } if (td->ndbRecordSharedData) { char* rowPtr= (char*) &td->transactionData; const NdbRecord* record= td->ndbRecordSharedData-> subscriberTableNdbRecord; Uint32 m=0; unsigned char* mask= (unsigned char*) &m; SET_MASK(mask, IND_SUBSCRIBER_LOCATION); SET_MASK(mask, IND_SUBSCRIBER_CHANGED_BY); SET_MASK(mask, IND_SUBSCRIBER_CHANGED_TIME); SET_MASK(mask, IND_SUBSCRIBER_NAME); const NdbOperation* MyOp= pCON->readTuple(record, rowPtr, record, rowPtr, NdbOperation::LM_Read, mask); CHECK_NULL((void*) MyOp, "T2: readTuple", td, pCON->getNdbError()); } else { NdbOperation *MyOp= pCON->getNdbOperation(SUBSCRIBER_TABLE); CHECK_NULL(MyOp, "T2: getNdbOperation", td, pCON->getNdbError()); MyOp->readTuple(); MyOp->equal(IND_SUBSCRIBER_NUMBER, td->transactionData.number); MyOp->getValue(IND_SUBSCRIBER_LOCATION, (char *)&td->transactionData.location); MyOp->getValue(IND_SUBSCRIBER_CHANGED_BY, td->transactionData.changed_by); MyOp->getValue(IND_SUBSCRIBER_CHANGED_TIME, td->transactionData.changed_time); MyOp->getValue(IND_SUBSCRIBER_NAME, td->transactionData.name); } if (async == 1) { pCON->executeAsynchPrepare( Commit , T2_Callback, td); } else { int result = pCON->execute(Commit); T2_Callback(result, pCON, (void*)td); return; }//if }
int InsertTransaction(Ndb* pNdb, long iContextID, long iVersion, long iLockFlag, long iLockTime, long iLockTimeUSec, const char* pchContextData, NdbError& err) { int iRes = -1; NdbConnection* pNdbConnection = pNdb->startTransaction(0, (const char*)&iContextID, 4); if(pNdbConnection) { NdbOperation* pNdbOperation = pNdbConnection->getNdbOperation(g_szTableName); if(pNdbOperation) { if(!(g_bWriteTuple ? pNdbOperation->writeTuple() : pNdbOperation->insertTuple()) && !pNdbOperation->equal(c_szContextId, (Int32)iContextID) && !pNdbOperation->setValue(c_szVersion, (Int32)iVersion) && !pNdbOperation->setValue(c_szLockFlag, (Int32)iLockFlag) && !pNdbOperation->setValue(c_szLockTime, (Int32)iLockTime) && !pNdbOperation->setValue(c_szLockTimeUSec, (Int32)iLockTimeUSec) && !pNdbOperation->setValue(c_szContextData, pchContextData, g_nStatusDataSize)) { if(!pNdbConnection->execute(Commit)) iRes = 0; else err = pNdbConnection->getNdbError(); } else err = pNdbOperation->getNdbError(); } else err = pNdbConnection->getNdbError(); pNdb->closeTransaction(pNdbConnection); } else err = pNdb->getNdbError(); return iRes; }
static int runFullScan(NDBT_Context* ctx, NDBT_Step* step) { NDBT_Table* pTab = ctx->getTab(); Ndb* pNdb = GETNDB(step); unsigned cntIndex = getTableProperty(ctx, pTab, "numIndex"); for (unsigned numIndex = 0; numIndex < cntIndex; numIndex++) { char buf[200]; sprintf(buf, "%s_X%03d", pTab->getName(), numIndex); NDBT_Index* pInd = NDBT_Index::discoverIndexFromDb(pNdb, buf, pTab->getName()); assert(pInd != 0); g_info << "Scan index:" << pInd->getName() << endl << *pInd; NdbConnection* pCon = pNdb->startTransaction(); if (pCon == 0) { ERR(pNdb->getNdbError()); return NDBT_FAILED; } NdbOperation* pOp = pCon->getNdbOperation(pInd->getName(), pTab->getName()); if (pOp == 0) { ERR(pCon->getNdbError()); pNdb->closeTransaction(pCon); return NDBT_FAILED; } if (pOp->openScanRead() != 0) { ERR(pCon->getNdbError()); pNdb->closeTransaction(pCon); return NDBT_FAILED; } if (pCon->executeScan() != 0) { ERR(pCon->getNdbError()); pNdb->closeTransaction(pCon); return NDBT_FAILED; } unsigned rows = 0; while (1) { int ret = pCon->nextScanResult(); if (ret == 0) { rows++; } else if (ret == 1) { break; } else { ERR(pCon->getNdbError()); pNdb->closeTransaction(pCon); return NDBT_FAILED; } } pNdb->closeTransaction(pCon); g_info << "Scanned " << rows << " rows" << endl; } return NDBT_OK; }
int insert_group(void * obj, GroupId groupId, GroupName name, Permission allowRead, Permission allowInsert, Permission allowDelete){ Ndb * pNDB = (Ndb *)obj; int check; NdbConnection * MyTransaction = pNDB->startTransaction(); if (MyTransaction == NULL) error_handler("startTranscation", pNDB->getNdbErrorString(), 0); NdbOperation *MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE); CHECK_NULL(MyOperation, "getNdbOperation", MyTransaction); check = MyOperation->insertTuple(); CHECK_MINUS_ONE(check, "insertTuple", MyTransaction); check = MyOperation->equal(GROUP_ID, (char*)&groupId); CHECK_MINUS_ONE(check, "equal", MyTransaction); check = MyOperation->setValue(GROUP_NAME, name); CHECK_MINUS_ONE(check, "setValue name", MyTransaction); check = MyOperation->setValue(GROUP_ALLOW_READ, (char*)&allowRead); CHECK_MINUS_ONE(check, "setValue allowRead", MyTransaction); check = MyOperation->setValue(GROUP_ALLOW_INSERT, (char*)&allowInsert); CHECK_MINUS_ONE(check, "setValue allowInsert", MyTransaction); check = MyOperation->setValue(GROUP_ALLOW_DELETE, (char*)&allowDelete); CHECK_MINUS_ONE(check, "setValue allowDelete", MyTransaction); check = MyTransaction->execute( Commit ); CHECK_MINUS_ONE(check, "commit", MyTransaction); pNDB->closeTransaction(MyTransaction); return 0; }
/** * Transaction 1 - T1 * * Update location and changed by/time on a subscriber * * Input: * SubscriberNumber, * Location, * ChangedBy, * ChangedTime * * Output: */ void userTransaction_T1(UserHandle * uh, SubscriberNumber number, Location new_location, ChangedBy changed_by, ChangedTime changed_time){ Ndb * pNDB = uh->pNDB; DEBUG2("T1(%.*s):\n", SUBSCRIBER_NUMBER_LENGTH, number); int check; NdbRecAttr * check2; NdbConnection * MyTransaction = pNDB->startTransaction(); if (MyTransaction != NULL) { NdbOperation *MyOperation = MyTransaction->getNdbOperation(SUBSCRIBER_TABLE); if (MyOperation != NULL) { MyOperation->updateTuple(); MyOperation->equal(IND_SUBSCRIBER_NUMBER, number); MyOperation->setValue(IND_SUBSCRIBER_LOCATION, (char *)&new_location); MyOperation->setValue(IND_SUBSCRIBER_CHANGED_BY, changed_by); MyOperation->setValue(IND_SUBSCRIBER_CHANGED_TIME, changed_time); check = MyTransaction->execute( Commit ); if (check != -1) { pNDB->closeTransaction(MyTransaction); return; } else { CHECK_MINUS_ONE(check, "T1: Commit", MyTransaction); }//if } else { CHECK_NULL(MyOperation, "T1: getNdbOperation", MyTransaction); }//if } else { error_handler("T1-1: startTranscation", pNDB->getNdbErrorString(), pNDB->getNdbError()); }//if }
int userDbInsertGroup(UserHandle *uh, GroupId groupId, GroupName name, Permission allowRead, Permission allowInsert, Permission allowDelete) { int check; NdbConnection * MyTransaction = 0; if(uh->pCurrTrans != 0){ MyTransaction = uh->pCurrTrans; } else { uh->pCurrTrans = MyTransaction = uh->pNDB->startTransaction(); } if (MyTransaction == NULL) error_handler("startTranscation", uh->pNDB->getNdbError(), 0); NdbOperation *MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE); CHECK_NULL(MyOperation, "getNdbOperation", MyTransaction); check = MyOperation->insertTuple(); CHECK_MINUS_ONE(check, "insertTuple", MyTransaction); check = MyOperation->equal(GROUP_ID, (char*)&groupId); CHECK_MINUS_ONE(check, "equal", MyTransaction); check = MyOperation->setValue(NDB_GROUP_NAME, name); CHECK_MINUS_ONE(check, "setValue name", MyTransaction); check = MyOperation->setValue(GROUP_ALLOW_READ, (char*)&allowRead); CHECK_MINUS_ONE(check, "setValue allowRead", MyTransaction); check = MyOperation->setValue(GROUP_ALLOW_INSERT, (char*)&allowInsert); CHECK_MINUS_ONE(check, "setValue allowInsert", MyTransaction); check = MyOperation->setValue(GROUP_ALLOW_DELETE, (char*)&allowDelete); CHECK_MINUS_ONE(check, "setValue allowDelete", MyTransaction); return 0; }
/** * Transaction 5 - T5 * * Delete session * * Input: * SubscriberNumber * ServerId * ServerBit * DoRollback * Output: * ChangedBy * ChangedTime * Location * BranchExecuted */ void start_T5(Ndb * pNDB, ThreadData * td, int async){ DEBUG3("T5(%.*s, %.2d): - Starting", SUBSCRIBER_NUMBER_LENGTH, td->transactionData.number, td->transactionData.server_id); NdbConnection * pCON = 0; while((pCON = startTransaction(pNDB, td)) == 0){ CHECK_ALLOWED_ERROR("T5-1: startTransaction", td, pNDB->getNdbError()); NdbSleep_MilliSleep(10); } NdbOperation * MyOp= pCON->getNdbOperation(SUBSCRIBER_TABLE); CHECK_NULL(MyOp, "T5-1: getNdbOperation", td, pCON->getNdbError()); MyOp->interpretedUpdateTuple(); MyOp->equal(IND_SUBSCRIBER_NUMBER, td->transactionData.number); MyOp->getValue(IND_SUBSCRIBER_LOCATION, (char *)&td->transactionData.location); MyOp->getValue(IND_SUBSCRIBER_CHANGED_BY, td->transactionData.changed_by); MyOp->getValue(IND_SUBSCRIBER_CHANGED_TIME, td->transactionData.changed_time); MyOp->getValue(IND_SUBSCRIBER_GROUP, (char *)&td->transactionData.group_id); MyOp->getValue(IND_SUBSCRIBER_SESSIONS, (char *)&td->transactionData.sessions); MyOp->subValue(IND_SUBSCRIBER_SESSIONS, (uint32)td->transactionData.server_bit); stat_async = async; if (async == 1) { pCON->executeAsynchPrepare( NoCommit , T5_Callback_1, td); } else { int result = pCON->execute( NoCommit ); T5_Callback_1(result, pCON, (void*)td); return; }//if }
/** * Transaction 4 - T4 * * Create session * * Input: * SubscriberNumber * ServerId * ServerBit * SessionDetails, * DoRollback * Output: * ChangedBy * ChangedTime * Location * BranchExecuted */ void start_T4(Ndb * pNDB, ThreadData * td){ DEBUG3("T4(%.*s, %.2d): - Starting\n", SUBSCRIBER_NUMBER_LENGTH, td->transactionData.number, td->transactionData.server_id); int check; NdbRecAttr * check2; NdbConnection * pCON = startTransaction(pNDB, td->transactionData.server_id, td->transactionData.number); if (pCON == NULL) error_handler("T4-1: startTranscation", pNDB->getNdbErrorString(), pNDB->getNdbError()); NdbOperation *MyOp= pCON->getNdbOperation(SUBSCRIBER_TABLE); CHECK_NULL(MyOp, "T4-1: getNdbOperation", pCON); MyOp->interpretedUpdateTuple(); MyOp->equal(IND_SUBSCRIBER_NUMBER, td->transactionData.number); MyOp->getValue(IND_SUBSCRIBER_LOCATION, (char *)&td->transactionData.location); MyOp->getValue(IND_SUBSCRIBER_CHANGED_BY, td->transactionData.changed_by); MyOp->getValue(IND_SUBSCRIBER_CHANGED_TIME, td->transactionData.changed_time); MyOp->getValue(IND_SUBSCRIBER_GROUP, (char *)&td->transactionData.group_id); MyOp->getValue(IND_SUBSCRIBER_SESSIONS, (char *)&td->transactionData.sessions); MyOp->incValue(IND_SUBSCRIBER_SESSIONS, (uint32)td->transactionData.server_bit); pCON->executeAsynchPrepare( NoCommit , T4_Callback_1, td); }
/** * Transaction 2 - T2 * * Read from Subscriber: * * Input: * SubscriberNumber * * Output: * Location * Changed by * Changed Timestamp * Name */ void userTransaction_T2(UserHandle * uh, SubscriberNumber number, Location * readLocation, ChangedBy changed_by, ChangedTime changed_time, SubscriberName subscriberName){ Ndb * pNDB = uh->pNDB; DEBUG2("T2(%.*s):\n", SUBSCRIBER_NUMBER_LENGTH, number); int check; NdbRecAttr * check2; NdbConnection * MyTransaction = pNDB->startTransaction(); if (MyTransaction == NULL) error_handler("T2-1: startTransaction", pNDB->getNdbErrorString(), pNDB->getNdbError()); NdbOperation *MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE); CHECK_NULL(MyOperation, "T2: getNdbOperation", MyTransaction); MyOperation->readTuple(); MyOperation->equal(IND_SUBSCRIBER_NUMBER, number); MyOperation->getValue(IND_SUBSCRIBER_LOCATION, (char *)readLocation); MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, changed_by); MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, changed_time); MyOperation->getValue(IND_SUBSCRIBER_NAME, subscriberName); check = MyTransaction->execute( Commit ); CHECK_MINUS_ONE(check, "T2: Commit", MyTransaction); pNDB->closeTransaction(MyTransaction); }
void write_rows (Ndb* pMyNdb) { /**************************************************************** * Insert rows into SimpleTable * ***************************************************************/ int check = -1 ; int loop_count_ops = nRecords ; NdbOperation *MyOperation = NULL ; NdbConnection *MyTransaction = NULL ; ndbout << endl << "Writing records ..." << flush; for (int count=0 ; count < loop_count_ops ; count++) { MyTransaction = pMyNdb->startTransaction(); if (!MyTransaction) { error_handler(pMyNdb->getNdbError(), NO_FAIL); }//if MyOperation = MyTransaction->getNdbOperation(tableName); if (!MyOperation) { error_handler(pMyNdb->getNdbError(), NO_FAIL); }//if check = MyOperation->writeTuple(); if( check == -1 ) error_handler(MyTransaction->getNdbError(), NO_FAIL); check = MyOperation->equal( attrName[0],(char*)&pkValue[count] ); if( check == -1 ) error_handler(MyTransaction->getNdbError(), NO_FAIL); // Update the columns, index column already ok. for (int i = 1 ; i < MAXATTR; i++) { if ((i == 2) && (count > 4)) { check = MyOperation->setValue(attrName[i], (char*)&attrValue[count + 1]); } else { check = MyOperation->setValue(attrName[i], (char*)&attrValue[count]); } if( check == -1 ) error_handler(MyTransaction->getNdbError(), NO_FAIL); } check = MyTransaction->execute( Commit ); if(check == -1 ) error_handler(MyTransaction->getNdbError(), NO_FAIL); pMyNdb->closeTransaction(MyTransaction); } ndbout <<" \tOK" << endl; return; }
void verify_deleted(Ndb* pMyNdb) { int check = -1 ; int loop_count_ops = nRecords; NdbOperation* pMyOperation = NULL ; ndbout << "Verifying deleted records..."<< flush; for (int count=0 ; count < loop_count_ops ; count++) { NdbConnection* pMyTransaction = pMyNdb->startTransaction(); if (!pMyTransaction) error_handler(pMyNdb->getNdbError(), NO_FAIL); pMyOperation = pMyTransaction->getNdbOperation(tableName); if (!pMyOperation) error_handler(pMyNdb->getNdbError(), NO_FAIL); check = pMyOperation->readTuple(); if( check == -1 ) error_handler( pMyTransaction->getNdbError(), NO_FAIL); check = pMyOperation->equal( attrName[0],(char*)&pkValue[count] ); if( check == -1 ) error_handler( pMyTransaction->getNdbError(), NO_FAIL); // Exepect to receive an error if(pMyTransaction->execute(Commit) != -1) if( 626 == pMyTransaction->getNdbError().code) { ndbout << pMyTransaction->getNdbError() << endl ; ndbout << "OK" << endl ; } else { error_handler(pMyTransaction->getNdbError(), NO_FAIL) ; } pMyNdb->closeTransaction(pMyTransaction); } ndbout << "OK" << endl; return; };
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; }
int insertLine(Ndb* pNdb, const NdbDictionary::Table* pTab, char* line){ int check; int retryAttempt = 0; int retryMax = 5; NdbConnection *pTrans; NdbOperation *pOp; while (retryAttempt < retryMax){ pTrans = pNdb->startTransaction(); if (pTrans == NULL) { ERR(pNdb->getNdbError()); NdbSleep_MilliSleep(50); retryAttempt++; continue; } pOp = pTrans->getNdbOperation(pTab->getName()); if (pOp == NULL) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return -1; } check = pOp->insertTuple(); if( check == -1 ) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return -1; } check = setValuesFromLine(pOp, pTab, line); if (check == -2){ pNdb->closeTransaction(pTrans); return -2; } if( check == -1 ) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return -1; } // Execute the transaction and insert the record check = pTrans->execute( Commit ); if(check == -1 ) { const NdbError err = pTrans->getNdbError(); pNdb->closeTransaction(pTrans); switch(err.status){ case NdbError::Success: ERR(err); ndbout << "ERROR: NdbError reports success when transcaction failed" << endl; return -1; break; case NdbError::TemporaryError: ERR(err); NdbSleep_MilliSleep(50); retryAttempt++; continue; break; case NdbError::UnknownResult: ERR(err); return -1; break; case NdbError::PermanentError: switch (err.classification){ case NdbError::ConstraintViolation: // Tuple already existed, OK in this application, but should be reported ndbout << err.code << " " << err.message << endl; break; default: ERR(err); return -1; break; } break; } } else{ pNdb->closeTransaction(pTrans); } return 0; } return check; }
/** * Transaction 5 - T5 * * Delete session * * Input: * SubscriberNumber * ServerId * ServerBit * DoRollback * Output: * ChangedBy * ChangedTime * Location * BranchExecuted */ int T5(void * obj, const SubscriberNumber inNumber, const SubscriberSuffix inSuffix, const ServerId inServerId, const ServerBit inServerBit, ChangedBy outChangedBy, ChangedTime outChangedTime, Location * outLocation, DoRollback inDoRollback, BranchExecuted * outBranchExecuted, BenchmarkTime * outTransactionTime) { Ndb * pNDB = (Ndb *) obj; NdbConnection * MyTransaction = 0; NdbOperation * MyOperation = 0; GroupId groupId; ActiveSessions sessions; Permission permission; BenchmarkTime start; get_time(&start); int check; NdbRecAttr * check2; MyTransaction = pNDB->startTransaction(); if (MyTransaction == NULL) error_handler("T5-1: startTranscation", pNDB->getNdbErrorString(), 0); MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE); CHECK_NULL(MyOperation, "T5-1: getNdbOperation", MyTransaction); check = MyOperation->readTupleExclusive(); CHECK_MINUS_ONE(check, "T5-1: readTuple", MyTransaction); check = MyOperation->equal(IND_SUBSCRIBER_NUMBER, inNumber); CHECK_MINUS_ONE(check, "T5-1: equal subscriber", MyTransaction); check2 = MyOperation->getValue(IND_SUBSCRIBER_LOCATION, (char *)outLocation); CHECK_NULL(check2, "T5-1: getValue location", MyTransaction); check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, outChangedBy); CHECK_NULL(check2, "T5-1: getValue changed_by", MyTransaction); check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, outChangedTime); CHECK_NULL(check2, "T5-1: getValue changed_time", MyTransaction); check2 = MyOperation->getValue(IND_SUBSCRIBER_GROUP, (char *)&groupId); CHECK_NULL(check2, "T5-1: getValue group", MyTransaction); check2 = MyOperation->getValue(IND_SUBSCRIBER_SESSIONS, (char *)&sessions); CHECK_NULL(check2, "T5-1: getValue sessions", MyTransaction); check = MyTransaction->execute( NoCommit ); CHECK_MINUS_ONE(check, "T5-1: NoCommit", MyTransaction); /* Operation 2 */ MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE); CHECK_NULL(MyOperation, "T5-2: getNdbOperation", MyTransaction); check = MyOperation->readTuple(); CHECK_MINUS_ONE(check, "T5-2: readTuple", MyTransaction); check = MyOperation->equal(IND_GROUP_ID, (char*)&groupId); CHECK_MINUS_ONE(check, "T5-2: equal group", MyTransaction); check2 = MyOperation->getValue(IND_GROUP_ALLOW_DELETE, (char *)&permission); CHECK_NULL(check2, "T5-2: getValue allow_delete", MyTransaction); check = MyTransaction->execute( NoCommit ); CHECK_MINUS_ONE(check, "T5-2: NoCommit", MyTransaction); DEBUG3("T5(%.*s, %.2d): ", SUBSCRIBER_NUMBER_LENGTH, inNumber, inServerId); if(((permission & inServerBit) == inServerBit) && ((sessions & inServerBit) == inServerBit)) { DEBUG("deleting - "); /* Operation 3 */ MyOperation = MyTransaction->getNdbOperation(SESSION_TABLE); CHECK_NULL(MyOperation, "T5-3: getNdbOperation", MyTransaction); check = MyOperation->deleteTuple(); CHECK_MINUS_ONE(check, "T5-3: deleteTuple", MyTransaction); check = MyOperation->equal(IND_SESSION_SUBSCRIBER, (char*)inNumber); CHECK_MINUS_ONE(check, "T5-3: equal number", MyTransaction); check = MyOperation->equal(IND_SESSION_SERVER, (char*)&inServerId); CHECK_MINUS_ONE(check, "T5-3: equal server id", MyTransaction); check = MyTransaction->execute( NoCommit ); CHECK_MINUS_ONE(check, "T5-3: NoCommit", MyTransaction); /* Operation 4 */ MyOperation = MyTransaction->getNdbOperation(SUBSCRIBER_TABLE); CHECK_NULL(MyOperation, "T5-4: getNdbOperation", MyTransaction); check = MyOperation->interpretedUpdateTuple(); CHECK_MINUS_ONE(check, "T5-4: interpretedUpdateTuple", MyTransaction); check = MyOperation->equal(IND_SUBSCRIBER_NUMBER, (char*)inNumber); CHECK_MINUS_ONE(check, "T5-4: equal number", MyTransaction); check = MyOperation->subValue(IND_SUBSCRIBER_SESSIONS, (uint32)inServerBit); CHECK_MINUS_ONE(check, "T5-4: dec value", MyTransaction); check = MyTransaction->execute( NoCommit ); CHECK_MINUS_ONE(check, "T5-4: NoCommit", MyTransaction); /* Operation 5 */ MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE); CHECK_NULL(MyOperation, "T5-5: getNdbOperation", MyTransaction); check = MyOperation->interpretedUpdateTuple(); CHECK_MINUS_ONE(check, "T5-5: interpretedUpdateTuple", MyTransaction); check = MyOperation->equal(IND_SERVER_ID, (char*)&inServerId); CHECK_MINUS_ONE(check, "T5-5: equal serverId", MyTransaction); check = MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX, (char*)inSuffix); CHECK_MINUS_ONE(check, "T5-5: equal suffix", MyTransaction); check = MyOperation->incValue(IND_SERVER_DELETES, (uint32)1); CHECK_MINUS_ONE(check, "T5-5: inc value", MyTransaction); check = MyTransaction->execute( NoCommit ); CHECK_MINUS_ONE(check, "T5-5: NoCommit", MyTransaction); (* outBranchExecuted) = 1; } else { DEBUG1("%s", ((permission & inServerBit) ? "permission - " : "no permission - ")); DEBUG1("%s", ((sessions & inServerBit) ? "in session - " : "no in session - ")); (* outBranchExecuted) = 0; } if(!inDoRollback) { DEBUG("commit\n"); check = MyTransaction->execute( Commit ); CHECK_MINUS_ONE(check, "T5: Commit", MyTransaction); } else { DEBUG("rollback\n"); check = MyTransaction->execute(Rollback); CHECK_MINUS_ONE(check, "T5:Rollback", MyTransaction); } pNDB->closeTransaction(MyTransaction); get_time(outTransactionTime); time_diff(outTransactionTime, &start); return 0; }
/** * Transaction 3 - T3 * * Read session details * * Input: * SubscriberNumber * ServerId * ServerBit * * Output: * BranchExecuted * SessionDetails * ChangedBy * ChangedTime * Location */ int T3(void * obj, const SubscriberNumber inNumber, const SubscriberSuffix inSuffix, const ServerId inServerId, const ServerBit inServerBit, SessionDetails outSessionDetails, ChangedBy outChangedBy, ChangedTime outChangedTime, Location * outLocation, BranchExecuted * outBranchExecuted, BenchmarkTime * outTransactionTime) { Ndb * pNDB = (Ndb *) obj; GroupId groupId; ActiveSessions sessions; Permission permission; BenchmarkTime start; get_time(&start); int check; NdbRecAttr * check2; NdbConnection * MyTransaction = pNDB->startTransaction(); if (MyTransaction == NULL) error_handler("T3-1: startTranscation", pNDB->getNdbErrorString(), 0); NdbOperation *MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE); CHECK_NULL(MyOperation, "T3-1: getNdbOperation", MyTransaction); check = MyOperation->readTuple(); CHECK_MINUS_ONE(check, "T3-1: readTuple", MyTransaction); check = MyOperation->equal(IND_SUBSCRIBER_NUMBER, inNumber); CHECK_MINUS_ONE(check, "T3-1: equal subscriber", MyTransaction); check2 = MyOperation->getValue(IND_SUBSCRIBER_LOCATION, (char *)outLocation); CHECK_NULL(check2, "T3-1: getValue location", MyTransaction); check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, outChangedBy); CHECK_NULL(check2, "T3-1: getValue changed_by", MyTransaction); check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, outChangedTime); CHECK_NULL(check2, "T3-1: getValue changed_time", MyTransaction); check2 = MyOperation->getValue(IND_SUBSCRIBER_GROUP, (char *)&groupId); CHECK_NULL(check2, "T3-1: getValue group", MyTransaction); check2 = MyOperation->getValue(IND_SUBSCRIBER_SESSIONS, (char *)&sessions); CHECK_NULL(check2, "T3-1: getValue sessions", MyTransaction); check = MyTransaction->execute( NoCommit ); CHECK_MINUS_ONE(check, "T3-1: NoCommit", MyTransaction); /* Operation 2 */ MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE); CHECK_NULL(MyOperation, "T3-2: getNdbOperation", MyTransaction); check = MyOperation->readTuple(); CHECK_MINUS_ONE(check, "T3-2: readTuple", MyTransaction); check = MyOperation->equal(IND_GROUP_ID, (char*)&groupId); CHECK_MINUS_ONE(check, "T3-2: equal group", MyTransaction); check2 = MyOperation->getValue(IND_GROUP_ALLOW_READ, (char *)&permission); CHECK_NULL(check2, "T3-2: getValue allow_read", MyTransaction); check = MyTransaction->execute( NoCommit ); CHECK_MINUS_ONE(check, "T3-2: NoCommit", MyTransaction); DEBUG3("T3(%.*s, %.2d): ", SUBSCRIBER_NUMBER_LENGTH, inNumber, inServerId); if(((permission & inServerBit) == inServerBit) && ((sessions & inServerBit) == inServerBit)) { DEBUG("reading - "); /* Operation 3 */ MyOperation = MyTransaction->getNdbOperation(SESSION_TABLE); CHECK_NULL(MyOperation, "T3-3: getNdbOperation", MyTransaction); check = MyOperation->readTuple(); CHECK_MINUS_ONE(check, "T3-3: readTuple", MyTransaction); check = MyOperation->equal(IND_SESSION_SUBSCRIBER, (char*)inNumber); CHECK_MINUS_ONE(check, "T3-3: equal number", MyTransaction); check = MyOperation->equal(IND_SESSION_SERVER, (char*)&inServerId); CHECK_MINUS_ONE(check, "T3-3: equal server id", MyTransaction); check2 = MyOperation->getValue(IND_SESSION_DATA, (char *)outSessionDetails); CHECK_NULL(check2, "T3-3: getValue session details", MyTransaction); check = MyTransaction->execute( NoCommit ); CHECK_MINUS_ONE(check, "T3-3: NoCommit", MyTransaction); /* Operation 4 */ MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE); CHECK_NULL(MyOperation, "T3-4: getNdbOperation", MyTransaction); check = MyOperation->interpretedUpdateTuple(); CHECK_MINUS_ONE(check, "T3-4: interpretedUpdateTuple", MyTransaction); check = MyOperation->equal(IND_SERVER_ID, (char*)&inServerId); CHECK_MINUS_ONE(check, "T3-4: equal serverId", MyTransaction); check = MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX, (char*)inSuffix); CHECK_MINUS_ONE(check, "T3-4: equal suffix", MyTransaction); check = MyOperation->incValue(IND_SERVER_READS, (uint32)1); CHECK_MINUS_ONE(check, "T3-4: inc value", MyTransaction); check = MyTransaction->execute( NoCommit ); CHECK_MINUS_ONE(check, "T3-4: NoCommit", MyTransaction); (* outBranchExecuted) = 1; } else { (* outBranchExecuted) = 0; } DEBUG("commit\n"); check = MyTransaction->execute( Commit ); CHECK_MINUS_ONE(check, "T3: Commit", MyTransaction); pNDB->closeTransaction(MyTransaction); get_time(outTransactionTime); time_diff(outTransactionTime, &start); return 0; }