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