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; }
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; }
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; }
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; }
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 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 }
/** * 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 }
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 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); }
/** * 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); } 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 }
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; };
static void readTable(Ndb &myNdb, unsigned int noOfTuples, unsigned int noOfOperations, bool oneTrans, bool twoKey, bool longKey) { Uint64 tbefore, tafter, before, after; NdbConnection *myTrans; NdbOperation *myOp; char name[] = "Kalle0000000"; NdbRecAttr* myRecAttrArr[MAX_NO_PARALLEL_OPERATIONS]; tbefore = NdbTick_CurrentMillisecond(); if (oneTrans) myTrans = myNdb.startTransaction(); for (unsigned int i = 0; i<noOfTuples; i++) { if (!oneTrans) myTrans = myNdb.startTransaction(); for(unsigned int j = 1; ((j<=noOfOperations)&&(i<noOfTuples)); (++j<=noOfOperations)?i++:i) { if (myTrans == NULL) error_handler4(__LINE__, myNdb.getNdbError()); myOp = myTrans->getNdbOperation("PERSON"); if (myOp == NULL) error_handler4(__LINE__, myTrans->getNdbError()); myOp->readTuple(); sprintf(name, "Kalle%.7i", i); if (longKey) memcpy(longName, name, strlen(name)); if (myOp->equal("NAME", (longKey)?longName:name) == -1) { error_handler4(__LINE__, myTrans->getNdbError()); myNdb.closeTransaction(myTrans); break; } if (twoKey) if (myOp->equal("KEY2", i) == -1) { error_handler4(__LINE__, myTrans->getNdbError()); myNdb.closeTransaction(myTrans); break; } myRecAttrArr[j-1] = myOp->getValue("PNUM2", NULL); } if (noOfOperations == 1) printf("Trying to read person %s\n", name); else printf("Trying to read %u persons\n", noOfOperations); before = NdbTick_CurrentMillisecond(); if (myTrans->execute( (oneTrans) ? NoCommit : Commit ) == -1) { error_handler4(__LINE__, myTrans->getNdbError()); myNdb.closeTransaction(myTrans); break; } after = NdbTick_CurrentMillisecond(); if (noOfOperations == 1) printf("Read person %s, %u msec\n", name, (Uint32) after - before); else printf("Read %u persons, %u msec\n", noOfOperations, (Uint32) after - before); for(unsigned int j = 0; j<noOfOperations; j++) printf("PNUM2 = %u\n", myRecAttrArr[j]->u_32_value()); if (!oneTrans) myNdb.closeTransaction(myTrans); } if (oneTrans) { if (myTrans->execute( Commit ) == -1) { error_handler4(__LINE__, myTrans->getNdbError()); } myNdb.closeTransaction(myTrans); } tafter = NdbTick_CurrentMillisecond(); ndbout << "Read "<< noOfTuples << " tuples in " << ((oneTrans) ? 1 : noOfTuples) << " transaction(s), " << tafter - tbefore << " msec" << endl; }
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; }
/** * Transaction 2 - T2 * * Read from Subscriber: * * Input: * SubscriberNumber * * Output: * Location * Changed by * Changed Timestamp * Name */ int T2(void * obj, const SubscriberNumber number, Location * readLocation, ChangedBy changed_by, ChangedTime changed_time, SubscriberName subscriberName, BenchmarkTime * transaction_time) { Ndb * pNDB = (Ndb *) obj; BenchmarkTime start; get_time(&start); int check; NdbRecAttr * check2; NdbConnection * MyTransaction = pNDB->startTransaction(); if (MyTransaction == NULL) error_handler("T2: startTranscation", pNDB->getNdbErrorString(), 0); NdbOperation *MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE); CHECK_NULL(MyOperation, "T2: getNdbOperation", MyTransaction); check = MyOperation->readTuple(); CHECK_MINUS_ONE(check, "T2: readTuple", MyTransaction); check = MyOperation->equal(IND_SUBSCRIBER_NUMBER, number); CHECK_MINUS_ONE(check, "T2: equal subscriber", MyTransaction); check2 = MyOperation->getValue(IND_SUBSCRIBER_LOCATION, (char *)readLocation); CHECK_NULL(check2, "T2: getValue location", MyTransaction); check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, changed_by); CHECK_NULL(check2, "T2: getValue changed_by", MyTransaction); check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, changed_time); CHECK_NULL(check2, "T2: getValue changed_time", MyTransaction); check2 = MyOperation->getValue(IND_SUBSCRIBER_NAME, subscriberName); CHECK_NULL(check2, "T2: getValue name", MyTransaction); check = MyTransaction->execute( Commit ); CHECK_MINUS_ONE(check, "T2: Commit", MyTransaction); pNDB->closeTransaction(MyTransaction); get_time(transaction_time); time_diff(transaction_time, &start); 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); } 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_GROUP); SET_MASK(mask, IND_SUBSCRIBER_SESSIONS); const NdbOperation* MyOp= pCON->readTuple(record, rowPtr, record, rowPtr, NdbOperation::LM_Read, mask); CHECK_NULL((void*)MyOp, "T5-1: readTuple", td, pCON->getNdbError()); m= 0; /* Create program to subtract something from the * subscriber sessions column */ Uint32 codeBuf[20]; NdbInterpretedCode program(pNDB->getDictionary()-> getTable(SUBSCRIBER_TABLE), codeBuf, 20); if (program.sub_val(IND_SUBSCRIBER_SESSIONS, (uint32)td->transactionData.server_bit) || program.interpret_exit_ok() || program.finalise()) { CHECK_NULL(NULL , "T5: Program create failed", td, program.getNdbError()); } NdbOperation::OperationOptions opts; opts.optionsPresent= NdbOperation::OperationOptions::OO_INTERPRETED; opts.interpretedCode= &program; MyOp= pCON->updateTuple(record, rowPtr, record, rowPtr, mask, &opts, sizeof(opts)); CHECK_NULL((void*)MyOp, "T5-1: updateTuple", td, pCON->getNdbError()); } else { /* Use old Api */ if (td->useCombinedUpdate) { 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); } else { /* Use separate read and update operations * This relies on execution ordering between operations on * the same row */ NdbOperation * MyOp= pCON->getNdbOperation(SUBSCRIBER_TABLE); CHECK_NULL(MyOp, "T5-1: getNdbOperation (readTuple)", 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_GROUP, (char *)&td->transactionData.group_id); MyOp->getValue(IND_SUBSCRIBER_SESSIONS, (char *)&td->transactionData.sessions); MyOp= pCON->getNdbOperation(SUBSCRIBER_TABLE); CHECK_NULL(MyOp, "T5-1: getNdbOperation (updateTuple)", td, pCON->getNdbError()); MyOp->interpretedUpdateTuple(); MyOp->equal(IND_SUBSCRIBER_NUMBER, td->transactionData.number); 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 3 - T3 * * Read session details * * Input: * SubscriberNumber * ServerId * ServerBit * * Output: * BranchExecuted * SessionDetails * ChangedBy * ChangedTime * Location */ void userTransaction_T3(UserHandle * uh, SubscriberNumber inNumber, ServerId inServerId, ServerBit inServerBit, SessionDetails outSessionDetails, BranchExecuted * outBranchExecuted){ Ndb * pNDB = uh->pNDB; char outChangedBy [sizeof(ChangedBy) +(4-(sizeof(ChangedBy) & 3))]; char outChangedTime [sizeof(ChangedTime)+(4-(sizeof(ChangedTime) & 3))]; Location outLocation; GroupId groupId; ActiveSessions sessions; Permission permission; SubscriberSuffix inSuffix; DEBUG3("T3(%.*s, %.2d): ", SUBSCRIBER_NUMBER_LENGTH, inNumber, inServerId); int check; NdbRecAttr * check2; NdbConnection * MyTransaction = startTransaction(pNDB, inServerId, inNumber); if (MyTransaction == NULL) error_handler("T3-1: startTranscation", pNDB->getNdbErrorString(), pNDB->getNdbError()); NdbOperation *MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE); CHECK_NULL(MyOperation, "T3-1: getNdbOperation", MyTransaction); MyOperation->readTuple(); MyOperation->equal(IND_SUBSCRIBER_NUMBER, inNumber); MyOperation->getValue(IND_SUBSCRIBER_LOCATION, (char *)&outLocation); MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, outChangedBy); MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, outChangedTime); MyOperation->getValue(IND_SUBSCRIBER_GROUP, (char *)&groupId); MyOperation->getValue(IND_SUBSCRIBER_SESSIONS, (char *)&sessions); 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); MyOperation->readTuple(); MyOperation->equal(IND_GROUP_ID, (char*)&groupId); MyOperation->getValue(IND_GROUP_ALLOW_READ, (char *)&permission); check = MyTransaction->execute( NoCommit ); CHECK_MINUS_ONE(check, "T3-2: NoCommit", MyTransaction); if(((permission & inServerBit) == inServerBit) && ((sessions & inServerBit) == inServerBit)){ memcpy(inSuffix, &inNumber[SUBSCRIBER_NUMBER_LENGTH-SUBSCRIBER_NUMBER_SUFFIX_LENGTH], SUBSCRIBER_NUMBER_SUFFIX_LENGTH); DEBUG2("reading(%.*s) - ", SUBSCRIBER_NUMBER_SUFFIX_LENGTH, inSuffix); /* Operation 3 */ MyOperation = MyTransaction->getNdbOperation(SESSION_TABLE); CHECK_NULL(MyOperation, "T3-3: getNdbOperation", MyTransaction); MyOperation->simpleRead(); MyOperation->equal(IND_SESSION_SUBSCRIBER, (char*)inNumber); MyOperation->equal(IND_SESSION_SERVER, (char*)&inServerId); MyOperation->getValue(IND_SESSION_DATA, (char *)outSessionDetails); /* Operation 4 */ MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE); CHECK_NULL(MyOperation, "T3-4: getNdbOperation", MyTransaction); MyOperation->interpretedUpdateTuple(); MyOperation->equal(IND_SERVER_ID, (char*)&inServerId); MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX, (char*)inSuffix); MyOperation->incValue(IND_SERVER_READS, (uint32)1); (* outBranchExecuted) = 1; } else { (* outBranchExecuted) = 0; } DEBUG("commit..."); check = MyTransaction->execute( Commit ); CHECK_MINUS_ONE(check, "T3: Commit", MyTransaction); pNDB->closeTransaction(MyTransaction); DEBUG("done\n"); }
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); } const NdbOperation* op= NULL; 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_NUMBER); SET_MASK(mask, IND_SUBSCRIBER_LOCATION); SET_MASK(mask, IND_SUBSCRIBER_CHANGED_BY); SET_MASK(mask, IND_SUBSCRIBER_CHANGED_TIME); op= pCON->updateTuple(record, rowPtr, record, rowPtr, mask); } else { NdbOperation *MyOp = pCON->getNdbOperation(SUBSCRIBER_TABLE); op= MyOp; 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 (op != NULL) { 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(NULL, "T1: getNdbOperation", td, pCON->getNdbError()); }//if }
int runTestBug19537(NDBT_Context* ctx, NDBT_Step* step){ const NdbDictionary::Table * pTab = ctx->getTab(); Ndb* pNdb = GETNDB(step); if (strcmp(pTab->getName(), "T1") != 0) { g_err << "runTestBug19537: skip, table != T1" << endl; return NDBT_OK; } NdbConnection* pTrans = pNdb->startTransaction(); if (pTrans == NULL){ ERR(pNdb->getNdbError()); return NDBT_FAILED; } NdbOperation* pOp = pTrans->getNdbOperation(pTab->getName()); if (pOp == NULL) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } if (pOp->interpretedUpdateTuple() == -1) { ERR(pOp->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } // Primary keys const Uint32 pkVal = 1; if (pOp->equal("KOL1", pkVal) == -1) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } // Load 64-bit constant into register 1 and // write from register 1 to 32-bit column KOL2 const Uint64 reg_val = 0x0102030405060708ULL; #if 0 Uint32 reg_ptr32[2]; memcpy(&(reg_ptr32[0]), (Uint8*)®_val, sizeof(Uint32)); memcpy(&(reg_ptr32[1]), ((Uint8*)®_val)+4, sizeof(Uint32)); if (reg_ptr32[0] == 0x05060708 && reg_ptr32[1] == 0x01020304) { g_err << "runTestBug19537: platform is LITTLE endian" << endl; } else if (reg_ptr32[0] == 0x01020304 && reg_ptr32[1] == 0x05060708) { g_err << "runTestBug19537: platform is BIG endian" << endl; } else { g_err << "runTestBug19537: impossible platform" << hex << " [0]=" << reg_ptr32[0] << " [1]=" <<reg_ptr32[1] << endl; pNdb->closeTransaction(pTrans); return NDBT_FAILED; } #endif if (pOp->load_const_u64(1, reg_val) == -1 || pOp->write_attr("KOL2", 1) == -1) { ERR(pOp->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } if (pTrans->execute(Commit) == -1) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } // Read value via a new transaction pTrans = pNdb->startTransaction(); if (pTrans == NULL){ ERR(pNdb->getNdbError()); return NDBT_FAILED; } pOp = pTrans->getNdbOperation(pTab->getName()); if (pOp == NULL) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } Uint32 kol2 = 0x09090909; if (pOp->readTuple() == -1 || pOp->equal("KOL1", pkVal) == -1 || pOp->getValue("KOL2", (char*)&kol2) == 0) { ERR(pOp->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } if (pTrans->execute(Commit) == -1) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } // Expected conversion as in C - truncate to lower (logical) word if (kol2 == 0x01020304) { g_err << "runTestBug19537: the bug manifests itself !" << endl; pNdb->closeTransaction(pTrans); return NDBT_FAILED; } if (kol2 != 0x05060708) { g_err << "runTestBug19537: impossible KOL2 " << hex << kol2 << endl; pNdb->closeTransaction(pTrans); return NDBT_FAILED; } pNdb->closeTransaction(pTrans); return NDBT_OK; }
int runTestIncValue32(NDBT_Context* ctx, NDBT_Step* step){ const NdbDictionary::Table * pTab = ctx->getTab(); Ndb* pNdb = GETNDB(step); if (strcmp(pTab->getName(), "T1") != 0) { g_err << "runTestBug19537: skip, table != T1" << endl; return NDBT_OK; } NdbConnection* pTrans = pNdb->startTransaction(); if (pTrans == NULL){ ERR(pNdb->getNdbError()); return NDBT_FAILED; } NdbOperation* pOp = pTrans->getNdbOperation(pTab->getName()); if (pOp == NULL) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } int check = pOp->interpretedUpdateTuple(); if( check == -1 ) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } // Primary keys Uint32 pkVal = 1; check = pOp->equal("KOL1", pkVal ); if( check == -1 ) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } // Attributes // Perform initial read of column start value NdbRecAttr* initialVal = pOp->getValue("KOL2"); if( initialVal == NULL ) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } // Update the column Uint32 valToIncWith = 1; check = pOp->incValue("KOL2", valToIncWith); if( check == -1 ) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } // Perform final read of column after value NdbRecAttr* afterVal = pOp->getValue("KOL2"); if( afterVal == NULL ) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } check = pTrans->execute(Commit); if( check == -1 ) { ERR(pTrans->getNdbError()); pNdb->closeTransaction(pTrans); return NDBT_FAILED; } Uint32 oldValue = initialVal->u_32_value(); Uint32 newValue = afterVal->u_32_value(); Uint32 expectedValue = oldValue + valToIncWith; if (newValue != expectedValue) { g_err << "Failed : Expected " << oldValue << "+" << valToIncWith << "=" << expectedValue << " but received " << newValue << endl; pNdb->closeTransaction(pTrans); return NDBT_FAILED; } pNdb->closeTransaction(pTrans); return NDBT_OK; }
int main(int argc, const char** argv) { ndb_init(); int _row = 0; int _hex = 0; int _primaryKey = 0; const char* _tableName = NULL; struct getargs args[] = { { "row", 'r', arg_integer, &_row, "The row number", "row" }, { "primarykey", 'p', arg_integer, &_primaryKey, "The primary key", "primarykey" }, { "hex", 'h', arg_flag, &_hex, "Print hex", "hex" } }; int num_args = sizeof(args) / sizeof(args[0]); int optind = 0, i; if(getarg(args, num_args, argc, argv, &optind) || argv[optind] == NULL) { arg_printusage(args, num_args, argv[0], "table name\n"); return NDBT_WRONGARGS; } // Check if table name is supplied if (argv[optind] != NULL) _tableName = argv[optind]; const NdbDictionary::Table* table = NDBT_Tables::getTable(_tableName); // const NDBT_Attribute* attribute = table->getAttribute(_column); g_info << "Table " << _tableName << endl << "Row: " << _row << ", PrimaryKey: " << _primaryKey << endl; Ndb_cluster_connection con; if(con.connect(12, 5, 1) != 0) { return NDBT_ProgramExit(NDBT_FAILED); } Ndb* ndb = new Ndb(&con, "TEST_DB"); if (ndb->init() == 0 && ndb->waitUntilReady(30) == 0) { NdbConnection* conn = ndb->startTransaction(); if (conn == NULL) { g_info << "ERROR: " << ndb->getNdbError() << endl; delete ndb; return -1; } NdbOperation* op = conn->getNdbOperation(_tableName); if (op == NULL) { g_info << "ERROR: " << conn->getNdbError() << endl; delete ndb; return -1; } op->readTuple(); NdbRecAttr** data = new NdbRecAttr*[table->getNoOfColumns()]; for (i = 0; i < table->getNoOfColumns(); i++) { const NdbDictionary::Column* c = table->getColumn(i); if (c->getPrimaryKey()) { op->equal(c->getName(), _primaryKey); data[i] = op->getValue(c->getName(), NULL); } else { data[i] = op->getValue(c->getName(), NULL); } } if (conn->execute(Commit) == 0) { // Print column names for (i = 0; i < table->getNoOfColumns(); i++) { const NdbDictionary::Column* c = table->getColumn(i); g_info << c->getName() << "[" << c->getType() << "] "; } g_info << endl; if (_hex) { g_info << hex; } for (i = 0; i < table->getNoOfColumns(); i++) { NdbRecAttr* a = data[i]; ndbout << (* a) << " "; } // for g_info << endl; } // if (conn else { g_info << "Failed to commit read transaction... " << conn->getNdbError() << ", commitStatus = " << conn->commitStatus() << endl; } delete[] data; ndb->closeTransaction(conn); } // if (ndb.init else { g_info << "ERROR: Unable to connect to NDB, " << ndb->getNdbError() << endl; } delete ndb; return 0; }
/** * Transaction 5 - T5 * * Delete session * * Input: * SubscriberNumber * ServerId * ServerBit * DoRollback * Output: * ChangedBy * ChangedTime * Location * BranchExecuted */ void userTransaction_T5(UserHandle * uh, SubscriberNumber inNumber, ServerId inServerId, ServerBit inServerBit, DoRollback inDoRollback, BranchExecuted * outBranchExecuted){ Ndb * pNDB = uh->pNDB; DEBUG3("T5(%.*s, %.2d): ", SUBSCRIBER_NUMBER_LENGTH, inNumber, inServerId); NdbConnection * MyTransaction = 0; NdbOperation * MyOperation = 0; char outChangedBy [sizeof(ChangedBy) +(4-(sizeof(ChangedBy) & 3))]; char outChangedTime [sizeof(ChangedTime)+(4-(sizeof(ChangedTime) & 3))]; Location outLocation; GroupId groupId; ActiveSessions sessions; Permission permission; SubscriberSuffix inSuffix; int check; NdbRecAttr * check2; MyTransaction = pNDB->startTransaction(); if (MyTransaction == NULL) error_handler("T5-1: startTranscation", pNDB->getNdbErrorString(), pNDB->getNdbError()); MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE); CHECK_NULL(MyOperation, "T5-1: getNdbOperation", MyTransaction); MyOperation->interpretedUpdateTuple(); MyOperation->equal(IND_SUBSCRIBER_NUMBER, inNumber); MyOperation->getValue(IND_SUBSCRIBER_LOCATION, (char *)&outLocation); MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, &outChangedBy[0]); MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, &outChangedTime[0]); MyOperation->getValue(IND_SUBSCRIBER_GROUP, (char *)&groupId); MyOperation->getValue(IND_SUBSCRIBER_SESSIONS, (char *)&sessions); MyOperation->subValue(IND_SUBSCRIBER_SESSIONS, (uint32)inServerBit); MyTransaction->execute( NoCommit ); /* Operation 2 */ MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE); CHECK_NULL(MyOperation, "T5-2: getNdbOperation", MyTransaction); MyOperation->readTuple(); MyOperation->equal(IND_GROUP_ID, (char*)&groupId); MyOperation->getValue(IND_GROUP_ALLOW_DELETE, (char *)&permission); check = MyTransaction->execute( NoCommit ); CHECK_MINUS_ONE(check, "T5-2: NoCommit", MyTransaction); if(((permission & inServerBit) == inServerBit) && ((sessions & inServerBit) == inServerBit)){ memcpy(inSuffix, &inNumber[SUBSCRIBER_NUMBER_LENGTH-SUBSCRIBER_NUMBER_SUFFIX_LENGTH], SUBSCRIBER_NUMBER_SUFFIX_LENGTH); DEBUG2("deleting(%.*s) - ", SUBSCRIBER_NUMBER_SUFFIX_LENGTH, inSuffix); /* Operation 3 */ MyOperation = MyTransaction->getNdbOperation(SESSION_TABLE); CHECK_NULL(MyOperation, "T5-3: getNdbOperation", MyTransaction); MyOperation->deleteTuple(); MyOperation->equal(IND_SESSION_SUBSCRIBER, (char*)inNumber); MyOperation->equal(IND_SESSION_SERVER, (char*)&inServerId); /* Operation 4 */ /* Operation 5 */ MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE); CHECK_NULL(MyOperation, "T5-5: getNdbOperation", MyTransaction); MyOperation->interpretedUpdateTuple(); MyOperation->equal(IND_SERVER_ID, (char*)&inServerId); MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX, (char*)inSuffix); MyOperation->incValue(IND_SERVER_DELETES, (uint32)1); (* outBranchExecuted) = 1; } else { (* outBranchExecuted) = 0; DEBUG1("%s", ((permission & inServerBit) ? "permission - " : "no permission - ")); DEBUG1("%s", ((sessions & inServerBit) ? "in session - " : "no in session - ")); } if(!inDoRollback && (* outBranchExecuted)){ 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); }
static void updateTable(Ndb &myNdb, unsigned int noOfTuples, unsigned int noOfOperations, bool oneTrans, bool twoKey, bool longKey) { Uint64 tbefore, tafter, before, after; NdbConnection *myTrans; NdbOperation *myOp; char name[] = "Kalle0000000"; tbefore = NdbTick_CurrentMillisecond(); if (oneTrans) myTrans = myNdb.startTransaction(); for (unsigned int i = 0; i<noOfTuples; i++) { if (!oneTrans) myTrans = myNdb.startTransaction(); for(unsigned int j = 1; ((j<=noOfOperations)&&(i<noOfTuples)); (++j<=noOfOperations)?i++:i) { if (myTrans == NULL) error_handler4(__LINE__, myNdb.getNdbError()); myOp = myTrans->getNdbOperation("PERSON"); if (myOp == NULL) error_handler4(__LINE__, myTrans->getNdbError()); myOp->updateTuple(); sprintf(name, "Kalle%.7i", i); if (longKey) memcpy(longName, name, strlen(name)); if (myOp->equal("NAME", (longKey)?longName:name) == -1) { error_handler4(__LINE__, myTrans->getNdbError()); myNdb.closeTransaction(myTrans); break; } if (twoKey) if (myOp->equal("KEY2", i) == -1) { error_handler4(__LINE__, myTrans->getNdbError()); myNdb.closeTransaction(myTrans); break; } if (myOp->setValue("PNUM1", 77) == -1) { error_handler4(__LINE__, myTrans->getNdbError()); myNdb.closeTransaction(myTrans); break; } if (myOp->setValue("PNUM2", 88)) { error_handler4(__LINE__, myTrans->getNdbError()); myNdb.closeTransaction(myTrans); break; } if (myOp->setValue("PNUM4", 99)) { error_handler4(__LINE__, myTrans->getNdbError()); myNdb.closeTransaction(myTrans); break; } if (myOp->setValue("AGE", 100) == -1) { error_handler4(__LINE__, myTrans->getNdbError()); myNdb.closeTransaction(myTrans); break; } if (myOp->setValue("STRING_AGE", hundred) == -1) { error_handler4(__LINE__, myTrans->getNdbError()); myNdb.closeTransaction(myTrans); break; } } if (noOfOperations == 1) printf("Trying to update person %s\n", name); else printf("Trying to update %u persons\n", noOfOperations); before = NdbTick_CurrentMillisecond(); if (myTrans->execute( (oneTrans) ? NoCommit : Commit ) == -1) { error_handler4(__LINE__, myTrans->getNdbError()); myNdb.closeTransaction(myTrans); break; } after = NdbTick_CurrentMillisecond(); if (noOfOperations == 1) printf("Updated person %s, %u msec\n", name, (Uint32) after - before); else printf("Update %u persons, %u msec\n", noOfOperations, (Uint32) after - before); if (!oneTrans) myNdb.closeTransaction(myTrans); } if (oneTrans) { if (myTrans->execute( Commit ) == -1) { error_handler4(__LINE__, myTrans->getNdbError()); } myNdb.closeTransaction(myTrans); } tafter = NdbTick_CurrentMillisecond(); ndbout << "Updated "<< noOfTuples << " tuples in " << ((oneTrans) ? 1 : noOfTuples) << " transaction(s), " << tafter - tbefore << " msec" << endl; }
/** * Transaction 3 - T3 * * Read session details * * Input: * SubscriberNumber * ServerId * ServerBit * * Output: * BranchExecuted * SessionDetails * ChangedBy * ChangedTime * Location */ void start_T3(Ndb * pNDB, ThreadData * td, int async) { DEBUG3("T3(%.*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("T3-1: startTransaction", td, pNDB->getNdbError()); NdbSleep_MilliSleep(10); } const NdbOperation* op; 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_GROUP); SET_MASK(mask, IND_SUBSCRIBER_SESSIONS); op= pCON->readTuple(record, rowPtr, record, rowPtr, NdbOperation::LM_Read, mask); } else { NdbOperation *MyOp= pCON->getNdbOperation(SUBSCRIBER_TABLE); op= MyOp; CHECK_NULL(MyOp, "T3-1: 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_GROUP, (char *)&td->transactionData.group_id); MyOp->getValue(IND_SUBSCRIBER_SESSIONS, (char *)&td->transactionData.sessions); } stat_async = async; if (async == 1) { pCON->executeAsynchPrepare( NoCommit , T3_Callback_1, td); } else { int result = pCON->execute( NoCommit ); T3_Callback_1(result, pCON, (void*)td); return; }//if }