/***************************************************************** * Update the second attribute in half of the tuples (adding 10) * *****************************************************************/ static void do_update(Ndb &myNdb, const char* table) { const NdbDictionary::Dictionary* myDict= myNdb.getDictionary(); const NdbDictionary::Table *myTable= myDict->getTable(table); if (myTable == NULL) APIERROR(myDict->getNdbError()); for (int i = 0; i < 10; i+=2) { NdbTransaction *myTransaction= myNdb.startTransaction(); if (myTransaction == NULL) APIERROR(myNdb.getNdbError()); NdbOperation *myOperation= myTransaction->getNdbOperation(myTable); if (myOperation == NULL) APIERROR(myTransaction->getNdbError()); myOperation->updateTuple(); myOperation->equal( "ATTR1", i ); myOperation->setValue( "ATTR2", i+10); if( myTransaction->execute( NdbTransaction::Commit ) == -1 ) APIERROR(myTransaction->getNdbError()); myNdb.closeTransaction(myTransaction); } }
static int createDropEvent(NDBT_Context* ctx, NDBT_Step* step) { Ndb* pNdb = GETNDB(step); NdbDictionary::Dictionary *myDict = pNdb->getDictionary(); if (ctx->getProperty("NoDDL", Uint32(0)) == 0) { for (unsigned i = 0; i<table_list.size(); i++) { int res = NDBT_OK; const NdbDictionary::Table* tab = myDict->getTable(table_list[i].c_str()); if (tab == 0) { continue; } if ((res = createEvent(pNdb, *tab) != NDBT_OK)) { return res; } if ((res = dropEvent(pNdb, *tab)) != NDBT_OK) { return res; } } } return NDBT_OK; }
int dropTable(NDBT_Context* ctx, NDBT_Step* step, Uint32 num) { Ndb* pNdb = GETNDB(step); const NdbDictionary::Table* pTab= ctx->getTab(); /* Run as a 'T1' testcase - do nothing for other tables */ if (strcmp(pTab->getName(), "T1") != 0) return NDBT_OK; char tabnameBuff[10]; snprintf(tabnameBuff, sizeof(tabnameBuff), "TAB%u", num); if (pNdb->getDictionary()->dropTable(tabnameBuff) != 0) { ndbout << "Drop table failed with error : " << pNdb->getDictionary()->getNdbError().code << " " << pNdb->getDictionary()->getNdbError().message << endl; } else { ndbout << "Dropped table " << tabnameBuff << endl; } return NDBT_OK; }
int runRestartGciControl(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); Ndb* pNdb = GETNDB(step); UtilTransactions utilTrans(*ctx->getTab()); NdbRestarter restarter; // Wait until we have enough records in db int count = 0; while (count < records){ if (utilTrans.selectCount(pNdb, 64, &count) != 0){ ctx->stopTest(); return NDBT_FAILED; } } // Restart cluster with abort if (restarter.restartAll(false, false, true) != 0){ ctx->stopTest(); return NDBT_FAILED; } // Stop the other thread ctx->stopTest(); if (restarter.waitClusterStarted(300) != 0){ return NDBT_FAILED; } if (pNdb->waitUntilReady() != 0){ return NDBT_FAILED; } return NDBT_OK; }
int runBug24717(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; int loops = ctx->getNumLoops(); int records = ctx->getNumRecords(); NdbRestarter restarter; Ndb* pNdb = GETNDB(step); HugoTransactions hugoTrans(*ctx->getTab()); int dump[] = { 9002, 0 } ; Uint32 ownNode = refToNode(pNdb->getReference()); dump[1] = ownNode; for (; loops; loops --) { int nodeId = restarter.getRandomNotMasterNodeId(rand()); restarter.restartOneDbNode(nodeId, false, true, true); restarter.waitNodesNoStart(&nodeId, 1); if (restarter.dumpStateOneNode(nodeId, dump, 2)) return NDBT_FAILED; restarter.startNodes(&nodeId, 1); do { for (Uint32 i = 0; i < 100; i++) { hugoTrans.pkReadRecords(pNdb, 100, 1, NdbOperation::LM_CommittedRead); } } while (restarter.waitClusterStarted(5) != 0); } return NDBT_OK; }
int runCreateIndexT1(NDBT_Context* ctx, NDBT_Step* step) { Ndb* pNdb = GETNDB(step); NdbDictionary::Dictionary* pDict = pNdb->getDictionary(); const NdbDictionary::Table* pTab = pDict->getTable("T1"); if (pTab == 0) { g_err << "getTable(T1) error: " << pDict->getNdbError() << endl; return NDBT_FAILED; } NdbDictionary::Index ind; ind.setName("T1X1"); ind.setTable("T1"); ind.setType(NdbDictionary::Index::OrderedIndex); ind.setLogging(false); ind.addColumn("KOL2"); ind.addColumn("KOL3"); ind.addColumn("KOL4"); if (pDict->createIndex(ind, *pTab) != 0) { g_err << "createIndex(T1X1) error: " << pDict->getNdbError() << endl; return NDBT_FAILED; } return NDBT_OK; }
int runSetup(NDBT_Context* ctx, NDBT_Step* step, int waitGroupSize){ int records = ctx->getNumRecords(); int batchSize = ctx->getProperty("BatchSize", 1); int transactions = (records / 100) + 1; int operations = (records / transactions) + 1; Ndb* pNdb = GETNDB(step); HugoAsynchTransactions hugoTrans(*ctx->getTab()); if (hugoTrans.loadTableAsynch(pNdb, records, batchSize, transactions, operations) != 0){ return NDBT_FAILED; } Ndb_cluster_connection* conn = &pNdb->get_ndb_cluster_connection(); /* The first call to create_multi_ndb_wait_group() should succeed ... */ global_poll_group = conn->create_ndb_wait_group(waitGroupSize); if(global_poll_group == 0) { return NDBT_FAILED; } /* and subsequent calls should fail */ if(conn->create_ndb_wait_group(waitGroupSize) != 0) { return NDBT_FAILED; } return NDBT_OK; }
/************************************************************************** * Using 5 transactions, insert 10 tuples in table: (0,0),(1,1),...,(9,9) * **************************************************************************/ static void do_insert(Ndb &myNdb) { const NdbDictionary::Dictionary* myDict= myNdb.getDictionary(); const NdbDictionary::Table *myTable= myDict->getTable("MYTABLENAME"); if (myTable == NULL) APIERROR(myDict->getNdbError()); for (int i = 0; i < 5; i++) { NdbTransaction *myTransaction= myNdb.startTransaction(); if (myTransaction == NULL) APIERROR(myNdb.getNdbError()); NdbOperation *myOperation= myTransaction->getNdbOperation(myTable); if (myOperation == NULL) APIERROR(myTransaction->getNdbError()); myOperation->insertTuple(); myOperation->equal("ATTR1", i); myOperation->setValue("ATTR2", i); myOperation= myTransaction->getNdbOperation(myTable); if (myOperation == NULL) APIERROR(myTransaction->getNdbError()); myOperation->insertTuple(); myOperation->equal("ATTR1", i+5); myOperation->setValue("ATTR2", i+5); if (myTransaction->execute( NdbTransaction::Commit ) == -1) APIERROR(myTransaction->getNdbError()); myNdb.closeTransaction(myTransaction); } }
/** * 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; }
Ndb* JniNdbEventStreamingImp::create_ndb_connection(const char* database) { Ndb* ndb = new Ndb(mClusterConnection, database); if (ndb->init() == -1) { LOG_NDB_API_ERROR(ndb->getNdbError()); } return ndb; }
int runVerifyUndoData(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); Ndb* pNdb = GETNDB(step); int count = 0; int num = 5; if (records - 5 < 0) num = 1; const NdbDictionary::Table* tab = GETNDB(step)->getDictionary()->getTable(ctx->getTab()->getName()); if(tab == 0) { g_err << " Can't find table" << endl; return NDBT_FAILED; } UtilTransactions utilTrans(* tab); HugoTransactions hugoTrans(* tab); // Check that there are as many records as we expected if(utilTrans.selectCount(pNdb, 64, &count) != 0) { g_err << "Can't get records count" << endl; return NDBT_FAILED; } g_err << "count = " << count; g_err << " records = " << records; g_err << endl; if (count != records) { g_err << "The records count is not correct" << endl; return NDBT_FAILED; } // make sure all the update data is there NdbTransaction *pTransaction= pNdb->startTransaction(); if (pTransaction == NULL) { g_err << "Can't get transaction pointer" << endl; return NDBT_FAILED; } if(hugoTrans.setTransaction(pTransaction) != 0) { g_err << "Set transaction error" << endl; pNdb->closeTransaction(pTransaction); return NDBT_FAILED; } if(hugoTrans.pkReadRecord(pNdb, 0, records, NdbOperation::LM_Read) != 0) { g_err << "Can't read record" << endl; return NDBT_FAILED; } if(hugoTrans.verifyUpdatesValue(0, records) != 0) { g_err << "The records restored with undo log is not correct" << endl; return NDBT_FAILED; } hugoTrans.closeTransaction(pNdb); return NDBT_OK; }
void NdbPool::closeAll() { lock(); while(list) { Ndb *n = list; list = (Ndb *) n->getCustomData(); delete n; } size = 0; unlock(); }
Handle<Value> getStatistics(const Arguments &args) { HandleScope scope; Ndb *ndb = unwrapPointer<Ndb *>(args.Holder()); Local<Object> stats = Object::New(); for(int i = 0 ; i < Ndb::NumClientStatistics ; i ++) { stats->Set(String::NewSymbol(ndb->getClientStatName(i)), Number::New(ndb->getClientStat(i)), ReadOnly); } return scope.Close(stats); }
void getStatistics(const Arguments &args) { EscapableHandleScope scope(args.GetIsolate()); Ndb *ndb = unwrapPointer<Ndb *>(args.Holder()); Local<Object> stats = Object::New(args.GetIsolate()); for(int i = 0 ; i < Ndb::NumClientStatistics ; i ++) { stats->Set(String::NewFromUtf8(args.GetIsolate(), ndb->getClientStatName(i)), Number::New(args.GetIsolate(), ndb->getClientStat(i))); } args.GetReturnValue().Set(scope.Escape(stats)); }
/* Producer thread */ int runV2MultiWait_Producer(NDBT_Context* ctx, NDBT_Step* step, int thd_id, int nthreads) { int records = ctx->getNumRecords(); HugoOperations hugoOps(*ctx->getTab()); /* For three threads (2 producers + 1 consumer) we loop 0-7. producer 0 is slow if (loop & 1) producer 1 is slow if (loop & 2) consumer is slow if (loop & 4) */ for (int loop = 0; loop < V2_NLOOPS; loop++) { ctx->getPropertyWait("LOOP", loop+1); bool slow = loop & (thd_id+1); for (int j=0; j < records; j++) { if(j % nthreads == thd_id) { Ndb* ndb = global_ndb_pool->getNdb(); NdbTransaction* trans = ndb->startTransaction(); check(trans != NULL, (*ndb)); ndb->setCustomData(trans); NdbOperation* readOp = trans->getNdbOperation(ctx->getTab()); check(readOp != NULL, (*trans)); check(readOp->readTuple() == 0, (*readOp)); check(hugoOps.equalForRow(readOp, j) == 0, hugoOps); /* Read all other cols */ for (int k=0; k < ctx->getTab()->getNoOfColumns(); k++) { check(readOp->getValue(ctx->getTab()->getColumn(k)) != NULL, (*readOp)); } trans->executeAsynchPrepare(NdbTransaction::Commit, NULL, NULL, NdbOperation::AbortOnError); ndb->sendPreparedTransactions(); global_poll_group->push(ndb); if(slow) { int tm = myRandom48(3) * myRandom48(3); if(tm) NdbSleep_MilliSleep(tm); } } } } return NDBT_OK; }
Ndb* asyncDbConnect(int parallellism){ NdbMutex_Lock(startupMutex); Ndb * pNDB = new Ndb(""); pNDB->init(parallellism + 1); while(pNDB->waitUntilReady() != 0){ } NdbMutex_Unlock(startupMutex); return pNDB; }
int runPkReadMultiWakeupT2(NDBT_Context* ctx, NDBT_Step* step) { ndbout << "Thread 2 : Waiting for phase 1 notification from Thread 1" << endl; ctx->getPropertyWait("PHASE", 1); /* Ok, now thread 1 has locked row 1, we'll attempt to read * it, using the multi_ndb_wait Api to block */ HugoOperations hugoOps(*ctx->getTab()); Ndb* ndb = GETNDB(step); ndbout << "Thread 2 : Starting async transaction to read row" << endl; check(hugoOps.startTransaction(ndb) == 0, hugoOps); check(hugoOps.pkReadRecord(ndb, 0, 1, NdbOperation::LM_Exclusive) == 0, hugoOps); /* Prepare, Send */ check(hugoOps.execute_async(ndb, NdbTransaction::Commit, NdbOperation::AbortOnError) == 0, hugoOps); global_poll_group->addNdb(ndb); Ndb ** ready_ndbs; int wait_rc = 0; int acknowledged = 0; do { ndbout << "Thread 2 : Calling NdbWaitGroup::wait()" << endl; wait_rc = global_poll_group->wait(ready_ndbs, 10000); ndbout << " Result : " << wait_rc << endl; if (wait_rc == 0) { if (!acknowledged) { ndbout << "Thread 2 : Woken up, moving to phase 2" << endl; ctx->incProperty("PHASE"); acknowledged = 1; } } else if (wait_rc > 0) { ndbout << "Thread 2 : Transaction completed" << endl; ndb->pollNdb(1,0); hugoOps.closeTransaction(ndb); } } while (wait_rc == 0); return (wait_rc == 1 ? NDBT_OK : NDBT_FAILED); }
int runInterpretedUKLookup(NDBT_Context* ctx, NDBT_Step* step) { const NdbDictionary::Table * pTab = ctx->getTab(); Ndb* pNdb = GETNDB(step); NdbDictionary::Dictionary * dict = pNdb->getDictionary(); const NdbDictionary::Index* pIdx= dict->getIndex(pkIdxName, pTab->getName()); CHK_RET_FAILED(pIdx != 0); const NdbRecord * pRowRecord = pTab->getDefaultRecord(); CHK_RET_FAILED(pRowRecord != 0); const NdbRecord * pIdxRecord = pIdx->getDefaultRecord(); CHK_RET_FAILED(pIdxRecord != 0); const Uint32 len = NdbDictionary::getRecordRowLength(pRowRecord); Uint8 * pRow = new Uint8[len]; bzero(pRow, len); HugoCalculator calc(* pTab); calc.equalForRow(pRow, pRowRecord, 0); NdbTransaction* pTrans = pNdb->startTransaction(); CHK_RET_FAILED(pTrans != 0); NdbInterpretedCode code; code.interpret_exit_ok(); code.finalise(); NdbOperation::OperationOptions opts; bzero(&opts, sizeof(opts)); opts.optionsPresent = NdbOperation::OperationOptions::OO_INTERPRETED; opts.interpretedCode = &code; const NdbOperation * pOp = pTrans->readTuple(pIdxRecord, (char*)pRow, pRowRecord, (char*)pRow, NdbOperation::LM_Read, 0, &opts, sizeof(opts)); CHK_RET_FAILED(pOp); int res = pTrans->execute(Commit, AbortOnError); CHK_RET_FAILED(res == 0); delete [] pRow; return NDBT_OK; }
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 runBackupBank(NDBT_Context* ctx, NDBT_Step* step){ int loops = ctx->getNumLoops(); int l = 0; int maxSleep = 30; // Max seconds between each backup Ndb* pNdb = GETNDB(step); NdbBackup backup(GETNDB(step)->getNodeId()+1); unsigned minBackupId = ~0; unsigned maxBackupId = 0; unsigned backupId = 0; int result = NDBT_OK; while (l < loops && result != NDBT_FAILED){ if (pNdb->waitUntilReady() != 0){ result = NDBT_FAILED; continue; } // Sleep for a while NdbSleep_SecSleep(maxSleep); // Perform backup if (backup.start(backupId) != 0){ ndbout << "backup.start failed" << endl; result = NDBT_FAILED; continue; } ndbout << "Started backup " << backupId << endl; // Remember min and max backupid if (backupId < minBackupId) minBackupId = backupId; if (backupId > maxBackupId) maxBackupId = backupId; ndbout << " maxBackupId = " << maxBackupId << ", minBackupId = " << minBackupId << endl; ctx->setProperty("MinBackupId", minBackupId); ctx->setProperty("MaxBackupId", maxBackupId); l++; } ctx->stopTest(); return result; }
static void createIndex(Ndb &myNdb, bool includePrimary, unsigned int noOfIndexes) { Uint64 before, after; NdbDictionary::Dictionary* dict = myNdb.getDictionary(); char indexName[] = "PNUMINDEX0000"; int res; for(unsigned int indexNum = 0; indexNum < noOfIndexes; indexNum++) { sprintf(indexName, "PNUMINDEX%.4u", indexNum); NdbDictionary::Index index(indexName); index.setTable("PERSON"); index.setType(NdbDictionary::Index::UniqueHashIndex); if (includePrimary) { const char* attr_arr[] = {"NAME", "PNUM1", "PNUM3"}; index.addIndexColumns(3, attr_arr); } else { const char* attr_arr[] = {"PNUM1", "PNUM3"}; index.addIndexColumns(2, attr_arr); } before = NdbTick_CurrentMillisecond(); if ((res = dict->createIndex(index)) == -1) { error_handler(dict->getNdbError()); } after = NdbTick_CurrentMillisecond(); ndbout << "Created index " << indexName << ", " << after - before << " msec" << endl; } }
int runDropTablesRestart(NDBT_Context* ctx, NDBT_Step* step){ NdbRestarter restarter; Ndb* pNdb = GETNDB(step); const NdbDictionary::Table *tab = ctx->getTab(); pNdb->getDictionary()->dropTable(tab->getName()); if (restarter.restartAll(false) != 0) return NDBT_FAILED; if (restarter.waitClusterStarted() != 0) return NDBT_FAILED; return NDBT_OK; }
bool ChartElemNavaids::addNdb(const Ndb& ndb, QDomElement& element, QDomDocument& dom_doc, QString& err_msg) { QString leaf_id = getLeafID(ndb); // check for double entries if (containsLeaf(leaf_id)) { err_msg = QString("Double NDB entry detected: (%1)").arg(ndb.getId()); return false; } // process the NDB ChartElemNdb* chart_elem_ndb = new ChartElemNdb(this, m_chart_model, ndb); MYASSERT(chart_elem_ndb != 0); if (!chart_elem_ndb->loadFromDomElement(element, dom_doc, err_msg)) { delete chart_elem_ndb; return false; } addLeaf(leaf_id, chart_elem_ndb); return true; }
Ndb * NdbPool::getNdb() { Ndb * n; lock(); if(list) { n = list; list = (Ndb *) n->getCustomData(); size--; } else { n = new Ndb(conn); n->init(); created++; } unlock(); return n; }
int runCleanup(NDBT_Context* ctx, NDBT_Step* step){ int records = ctx->getNumRecords(); int batchSize = ctx->getProperty("BatchSize", 1); int transactions = (records / 100) + 1; int operations = (records / transactions) + 1; Ndb* pNdb = GETNDB(step); HugoAsynchTransactions hugoTrans(*ctx->getTab()); if (hugoTrans.pkDelRecordsAsynch(pNdb, records, batchSize, transactions, operations) != 0){ return NDBT_FAILED; } pNdb->get_ndb_cluster_connection().release_ndb_wait_group(global_poll_group); return NDBT_OK; }
void getConnectionStatistics(const Arguments &args) { EscapableHandleScope scope(args.GetIsolate()); Uint64 ndb_stats[Ndb::NumClientStatistics]; Ndb *ndb = unwrapPointer<Ndb *>(args.Holder()); Ndb_cluster_connection & c = ndb->get_ndb_cluster_connection(); c.collect_client_stats(ndb_stats, Ndb::NumClientStatistics); Local<Object> stats = Object::New(args.GetIsolate()); for(int i = 0 ; i < Ndb::NumClientStatistics ; i ++) { stats->Set(String::NewFromUtf8(args.GetIsolate(), ndb->getClientStatName(i)), Number::New(args.GetIsolate(), ndb_stats[i])); } args.GetReturnValue().Set(scope.Escape(stats)); }
Handle<Value> getConnectionStatistics(const Arguments &args) { HandleScope scope; Uint64 ndb_stats[Ndb::NumClientStatistics]; Ndb *ndb = unwrapPointer<Ndb *>(args.Holder()); Ndb_cluster_connection & c = ndb->get_ndb_cluster_connection(); c.collect_client_stats(ndb_stats, Ndb::NumClientStatistics); Local<Object> stats = Object::New(); for(int i = 0 ; i < Ndb::NumClientStatistics ; i ++) { stats->Set(String::NewSymbol(ndb->getClientStatName(i)), Number::New(ndb_stats[i]), ReadOnly); } return scope.Close(stats); }
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; }
static void dropIndex(Ndb &myNdb, unsigned int noOfIndexes) { for(unsigned int indexNum = 0; indexNum < noOfIndexes; indexNum++) { char indexName[255]; sprintf(indexName, "PNUMINDEX%.4u", indexNum); const Uint64 before = NdbTick_CurrentMillisecond(); const int retVal = myNdb.getDictionary()->dropIndex(indexName, "PERSON"); const Uint64 after = NdbTick_CurrentMillisecond(); if(retVal == 0){ ndbout << "Dropped index " << indexName << ", " << after - before << " msec" << endl; } else { ndbout << "Failed to drop index " << indexName << endl; ndbout << myNdb.getDictionary()->getNdbError() << endl; } } }
/* arg0: TableMetadata wrapping NdbDictionary::Table * arg1: Ndb * arg2: number of columns arg3: array of NdbDictionary::Column * */ Handle<Value> getRecordForMapping(const Arguments &args) { DEBUG_MARKER(UDEB_DEBUG); HandleScope scope; const NdbDictionary::Table *table = unwrapPointer<const NdbDictionary::Table *>(args[0]->ToObject()); Ndb * ndb = unwrapPointer<Ndb *>(args[1]->ToObject()); unsigned int nColumns = args[2]->Int32Value(); Record * record = new Record(ndb->getDictionary(), nColumns); for(unsigned int i = 0 ; i < nColumns ; i++) { const NdbDictionary::Column * col = unwrapPointer<const NdbDictionary::Column *> (args[3]->ToObject()->Get(i)->ToObject()); record->addColumn(col); } record->completeTableRecord(table); return scope.Close(Record_Wrapper(record)); }