static void
usage (int ret)
{
arg_printusage (args,
sizeof(args)/sizeof(*args),
NULL,
"[principal]");
exit (ret);
}
static void
usage (int ret)
{
arg_printusage (args,
sizeof(args)/sizeof(*args),
NULL,
"filename.so");
exit (ret);
}
static void
usage (int ret)
{
arg_printusage (args,
sizeof(args)/sizeof(*args),
NULL,
"service");
exit (ret);
}
static void
usage (int ret)
{
arg_printusage (args,
sizeof(args)/sizeof(*args),
NULL,
"dns-record resource-record-type");
exit (ret);
}
static int parse_args(int argc, char** argv)
{
size_t i;
char * ops= 0, *cases=0;
struct getargs args[] = {
{ "records", 0, arg_integer, &g_rows, "Number of records", "records" },
{ "operations", 'o', arg_string, &ops, "Operations [a-h]", 0 },
{ "1", '1', arg_flag, &g_one_op_at_a_time, "One op at a time", 0 },
{ "0", '0', arg_negative_flag, &g_one_op_at_a_time, "All ops at once", 0 },
{ "cases", 'c', arg_string, &cases, "Cases [a-c]", 0 },
{ 0, 't', arg_flag, &g_setup_tables, "Create table", 0 },
{ 0, 'u', arg_negative_flag, &g_setup_tables, "Dont create table", 0 }
};
int optind= 0;
const int num_args = sizeof(args)/sizeof(args[0]);
if(getarg(args, num_args, argc, (const char**)argv, &optind)) {
arg_printusage(args, num_args, argv[0], " tabname1\n");
ndbout_c("\n -- Operations [a-%c] = ", 'a'+OP_COUNT-1);
for(i = 0; i<OP_COUNT; i++){
ndbout_c("\t%c = %s %s",
'a'+i, g_op_types[i].op1,
g_op_types[i].op2 ? g_op_types[i].op2 : "");
}
return -1;
}
if(ops != 0){
g_use_ops = 0;
char * s = ops;
while(* s)
g_use_ops |= (1 << ((* s++) - 'a'));
}
if(cases != 0){
g_cases = 0;
char * s = cases;
while(* s)
g_cases |= (1 << ((* s++) - 'a'));
}
ndbout_c("table: %s", g_tablename);
printf("operations: ");
for(i = 0; i<OP_COUNT; i++)
if(g_use_ops & (1 << i))
printf("%c", 'a'+i);
printf("\n");
printf("test cases: ");
for(i = 0; i<3; i++)
if(g_cases & (1 << i))
printf("%c", '1'+i);
printf("\n");
printf("-------------\n");
return 0;
}
static void
usage (int ret)
{
arg_printusage (args,
sizeof(args) / sizeof(args[0]),
NULL,
"[[{po:username[@hostname] | hostname[:username]}] ...] "
"filename");
exit (ret);
}
int main(int argc, char **argv)
{
int optind = 0;
while(getarg(args, 5, argc, argv, &optind))
printf("Bad arg: %s\n", argv[optind]);
printf("flag1 = %d\n", flag1);
printf("flag2 = %d\n", flag2);
printf("foo_flag = %d\n", foo_flag);
printf("bar_int = %d\n", bar_int);
printf("baz_flag = %s\n", baz_string);
arg_printusage (args, 5, argv[0], "nothing here");
}
static void
usage (int ret)
{
if(isatty(STDIN_FILENO))
arg_printusage (args,
sizeof(args) / sizeof(args[0]),
NULL,
"");
else
syslog (LOG_ERR, "Usage: %s [-ikxlvPL] [-p port]", getprogname());
exit (ret);
}
int main(int argc, const char** argv){
ndb_init();
const char* _tabname = NULL;
int _help = 0;
struct getargs args[] = {
{ "usage", '?', arg_flag, &_help, "Print help", "" }
};
int num_args = sizeof(args) / sizeof(args[0]);
int optind = 0;
char desc[] =
"tabname\n"\
"This program will bulk copy data from a file to a table in Ndb.\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];
ndbout << "Tablename: " << _tabname << endl;
// Connect to Ndb
Ndb MyNdb( "TEST_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 = MyNdb.getDictionary()->getTable(_tabname);
if(pTab == NULL){
ndbout << " Table " << _tabname << " does not exist!" << endl;
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
char buf[255];
BaseString::snprintf(buf, sizeof(buf), "%s.data", (const char*)_tabname);
if (insertFile(&MyNdb, pTab, buf) != 0){
return NDBT_ProgramExit(NDBT_FAILED);
}
return NDBT_ProgramExit(NDBT_OK);
}
int main(int argc, const char** argv){
ndb_init();
int _temp = false;
int _help = 0;
struct getargs args[] = {
{ "temp", 't', arg_flag, &_temp, "Temporary table", "temp" },
{ "usage", '?', arg_flag, &_help, "Print help", "" }
};
int num_args = sizeof(args) / sizeof(args[0]);
int optind = 0;
char desc[] =
"This program will create all standard tables in Ndb.\n"\
"The tables is selected from a fixed list of tables\n"\
"defined in NDBT_Tables class\n";
if(getarg(args, num_args, argc, argv, &optind) || _help) {
arg_printusage(args, num_args, argv[0], desc);
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
// Connect to Ndb
Ndb_cluster_connection con;
if(con.connect(12, 5, 1) != 0)
{
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb(&con, "TEST_DB" );
if(MyNdb.init() != 0){
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
while(MyNdb.waitUntilReady() != 0)
ndbout << "Waiting for ndb to become ready..." << endl;
return NDBT_Tables::createAllTables(&MyNdb, _temp);
}
static void
usage(int code)
{
arg_printusage(args, num_args, NULL, "error-table");
exit(code);
}
static void
usage(int code)
{
arg_printusage(args, num_args, NULL, "[asn1-file [name]]");
exit(code);
}
int
main(int argc, const char** argv) {
ndb_init();
int verbose = 1;
int optind = 0;
struct getargs args[1+P_MAX] = {
{ "verbose", 'v', arg_flag, &verbose, "Print verbose status", "verbose" }
};
const int num_args = 1 + P_MAX;
int i;
for(i = 0; i<P_MAX; i++) {
args[i+1].long_name = g_paramters[i].name;
args[i+1].short_name = * g_paramters[i].name;
args[i+1].type = arg_integer;
args[i+1].value = &g_paramters[i].value;
BaseString tmp;
tmp.assfmt("min: %d max: %d", g_paramters[i].min, g_paramters[i].max);
args[i+1].help = strdup(tmp.c_str());
args[i+1].arg_help = 0;
}
if(getarg(args, num_args, argc, argv, &optind)) {
arg_printusage(args, num_args, argv[0], "tabname1 tabname2 ...");
return NDBT_WRONGARGS;
}
myRandom48Init(NdbTick_CurrentMillisecond());
memset(g_times, 0, sizeof(g_times));
Ndb_cluster_connection con;
if(con.connect(12, 5, 1))
{
return NDBT_ProgramExit(NDBT_FAILED);
}
g_ndb = new Ndb(&con, "TEST_DB");
if(g_ndb->init() != 0) {
g_err << "init() failed" << endl;
goto error;
}
if(g_ndb->waitUntilReady() != 0) {
g_err << "Wait until ready failed" << endl;
goto error;
}
for(i = optind; i<argc; i++) {
const char * T = argv[i];
g_info << "Testing " << T << endl;
BaseString::snprintf(g_table, sizeof(g_table), T);
BaseString::snprintf(g_ordered, sizeof(g_ordered), "IDX_O_%s", T);
BaseString::snprintf(g_unique, sizeof(g_unique), "IDX_U_%s", T);
if(create_table())
goto error;
if(load_table())
goto error;
for(int l = 0; l<g_paramters[P_LOOPS].value; l++) {
for(int j = 0; j<P_OP_TYPES; j++) {
g_paramters[P_OPER].value = j;
if(run_read())
goto error;
}
}
print_result();
}
if(g_ndb) delete g_ndb;
return NDBT_OK;
error:
if(g_ndb) delete g_ndb;
return NDBT_FAILED;
}
int main(int argc, const char** argv){
ndb_init();
int _records = 0;
int _loops = 1;
int _threads = 1;
int _stats = 0;
int _abort = 0;
int _batch = 1;
const char* _tabname = NULL, *db = 0;
int _help = 0;
struct getargs args[] = {
{ "aborts", 'a', arg_integer, &_abort, "percent of transactions that are aborted", "abort%" },
{ "loops", 'l', arg_integer, &_loops, "number of times to run this program(0=infinite loop)", "loops" },
{ "threads", 't', arg_integer, &_threads, "number of threads (default 1)", "threads" },
{ "stats", 's', arg_flag, &_stats, "report latency per batch", "stats" },
// { "batch", 'b', arg_integer, &_batch, "batch value", "batch" },
{ "records", 'r', arg_integer, &_records, "Number of records", "records" },
{ "usage", '?', arg_flag, &_help, "Print help", "" },
{ "database", 'd', arg_string, &db, "Database", "" }
};
int num_args = sizeof(args) / sizeof(args[0]);
int optind = 0;
char desc[] =
"tabname\n"\
"This program will update all records in a table using PK\n";
if(getarg(args, num_args, argc, argv, &optind) ||
argv[optind] == NULL || _records == 0 || _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);
}
if (con.wait_until_ready(30,0) < 0)
{
ndbout << "Cluster nodes not ready in 30 seconds." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb( &con, db ? db : "TEST_DB" );
if(MyNdb.init() != 0){
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
// 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);
}
// threads
NDBT_ThreadSet ths(_threads);
// create Ndb object for each thread
if (ths.connect(&con, db ? db : "TEST_DB") == -1) {
ndbout << "connect failed: err=" << ths.get_err() << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
// input is options
ThrInput input;
ths.set_input(&input);
input.pTab = pTab;
input.records = _records;
input.batch = _batch;
input.stats = _stats;
// output is stats
ThrOutput output;
ths.set_output<ThrOutput>();
int i = 0;
while (i < _loops || _loops == 0) {
ndbout << i << ": ";
ths.set_func(hugoPkUpdate);
ths.start();
ths.stop();
if (ths.get_err())
NDBT_ProgramExit(NDBT_FAILED);
if (_stats) {
NDBT_Stats latency;
// add stats from each thread
int n;
for (n = 0; n < ths.get_count(); n++) {
NDBT_Thread& thr = ths.get_thread(n);
ThrOutput* output = (ThrOutput*)thr.get_output();
latency += output->latency;
}
ndbout
<< "latency per batch (us): "
<< " samples=" << latency.getCount()
<< " min=" << (int)latency.getMin()
<< " max=" << (int)latency.getMax()
<< " mean=" << (int)latency.getMean()
<< " stddev=" << (int)latency.getStddev()
<< endl;
}
i++;
}
return NDBT_ProgramExit(NDBT_OK);
}
static void
usage (int status)
{
arg_printusage (args, num_args, NULL, "");
exit (status);
}
static void
usage(int ecode)
{
arg_printusage(getargs, num_args, NULL, "command [args...]");
exit(ecode);
}
int main(int argc, const char** argv){
ndb_init();
int _help = 0;
int _p = 0;
const char * db = "TEST_DB";
const char* _connectstr = NULL;
struct getargs args[] = {
{ "database", 'd', arg_string, &db, "database", 0 },
{ "connstr", 'c', arg_string, &_connectstr, "Connect string", "cs" },
{ "partitions", 'p', arg_integer, &_p, "New no of partitions", 0},
{ "usage", '?', arg_flag, &_help, "Print help", "" }
};
int num_args = sizeof(args) / sizeof(args[0]);
int optind = 0;
char desc[] =
"tabname\n" \
"This program will alter no of partitions of table in Ndb.\n";
if(getarg(args, num_args, argc, argv, &optind) || _help){
arg_printusage(args, num_args, argv[0], desc);
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
if(argv[optind] == NULL)
{
arg_printusage(args, num_args, argv[0], desc);
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
// Connect to Ndb
Ndb_cluster_connection con(_connectstr);
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);
}
while(MyNdb.waitUntilReady() != 0)
ndbout << "Waiting for ndb to become ready..." << endl;
NdbDictionary::Dictionary* MyDic = MyNdb.getDictionary();
for (int i = optind; i<argc; i++)
{
printf("altering %s/%s...", db, argv[i]);
const NdbDictionary::Table* oldTable = MyDic->getTable(argv[i]);
if (oldTable == 0)
{
ndbout << "Failed to retrieve table " << argv[i]
<< ": " << MyDic->getNdbError() << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
NdbDictionary::Table newTable = *oldTable;
newTable.setFragmentCount(_p);
if (MyDic->beginSchemaTrans() != 0)
goto err;
if (MyDic->prepareHashMap(*oldTable, newTable) != 0)
goto err;
if (MyDic->alterTable(*oldTable, newTable) != 0)
goto err;
if (MyDic->endSchemaTrans())
goto err;
ndbout_c("done");
}
return NDBT_ProgramExit(NDBT_OK);
err:
NdbError err = MyDic->getNdbError();
if (MyDic->hasSchemaTrans())
MyDic->endSchemaTrans(NdbDictionary::Dictionary::SchemaTransAbort);
ndbout << "Failed! "
<< err << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
int main(int argc, const char** argv){
ndb_init();
int _records = 0;
int _loops = 1;
int _abort = 0;
int _parallelism = 1;
const char* _tabname = NULL, *db = 0;
int _help = 0;
int lock = NdbOperation::LM_Read;
int sorted = 0;
struct getargs args[] = {
{ "aborts", 'a', arg_integer, &_abort, "percent of transactions that are aborted", "abort%" },
{ "loops", 'l', arg_integer, &_loops, "number of times to run this program(0=infinite loop)", "loops" },
{ "parallelism", 'p', arg_integer, &_parallelism, "parallelism(1-240)", "para" },
{ "records", 'r', arg_integer, &_records, "Number of records", "recs" },
{ "usage", '?', arg_flag, &_help, "Print help", "" },
{ "lock", 'm', arg_integer, &lock, "lock mode", "" },
{ "sorted", 's', arg_flag, &sorted, "sorted", "" },
{ "database", 'd', arg_string, &db, "Database", "" }
};
int num_args = sizeof(args) / sizeof(args[0]);
int optind = 0;
char desc[] =
" tabname\n"\
"This program will scan read all records in one table in Ndb.\n"\
"It will verify every column read by calculating the expected value.\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 ? db : "TEST_DB" );
if(MyNdb.init() != 0){
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
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);
}
const NdbDictionary::Index * pIdx = 0;
if(optind+1 < argc)
{
pIdx = MyNdb.getDictionary()->getIndex(argv[optind+1], _tabname);
if(!pIdx)
ndbout << " Index " << argv[optind+1] << " not found" << endl;
else
if(pIdx->getType() != NdbDictionary::Index::OrderedIndex)
{
ndbout << " Index " << argv[optind+1] << " is not scannable" << endl;
pIdx = 0;
}
}
HugoTransactions hugoTrans(*pTab);
int i = 0;
while (i<_loops || _loops==0) {
ndbout << i << ": ";
if(!pIdx)
{
if(hugoTrans.scanReadRecords(&MyNdb,
0,
_abort,
_parallelism,
(NdbOperation::LockMode)lock) != 0)
{
return NDBT_ProgramExit(NDBT_FAILED);
}
}
else
{
if(hugoTrans.scanReadRecords(&MyNdb, pIdx,
0,
_abort,
_parallelism,
(NdbOperation::LockMode)lock,
sorted) != 0)
{
return NDBT_ProgramExit(NDBT_FAILED);
}
}
i++;
}
return NDBT_ProgramExit(NDBT_OK);
}
static void
usage(int ret)
{
arg_printusage (args, sizeof(args)/sizeof(*args), NULL, "infile command..");
exit (ret);
}
static void
usage (int ret)
{
arg_printusage (args, sizeof(args)/sizeof(*args), NULL, "hostname ...");
exit (ret);
}
static void
usage(int code, struct getargs *inargs, int num_inargs)
{
arg_printusage(inargs, num_inargs, NULL, "hosts");
exit(code);
}
int main(int argc, const char** argv){
ndb_init();
int _temp = false;
int _help = 0;
int _all = 0;
int _print = 0;
const char* _connectstr = NULL;
int _diskbased = 0;
const char* _tsname = NULL;
int _trans = false;
struct getargs args[] = {
{ "all", 'a', arg_flag, &_all, "Create/print all tables", 0 },
{ "print", 'p', arg_flag, &_print, "Print table(s) instead of creating it", 0},
{ "temp", 't', arg_flag, &_temp, "Temporary table", 0 },
{ "trans", 'x', arg_flag, &_trans, "Use single schema trans", 0 },
{ "connstr", 'c', arg_string, &_connectstr, "Connect string", "cs" },
{ "diskbased", 0, arg_flag, &_diskbased, "Store attrs on disk if possible", 0 },
{ "tsname", 0, arg_string, &_tsname, "Tablespace name", "ts" },
{ "usage", '?', arg_flag, &_help, "Print help", "" }
};
int num_args = sizeof(args) / sizeof(args[0]);
int optind = 0;
char desc[] =
"tabname\n"\
"This program will create one table in Ndb.\n"\
"The tables may be selected from a fixed list of tables\n"\
"defined in NDBT_Tables class\n";
if(getarg(args, num_args, argc, argv, &optind) || _help){
arg_printusage(args, num_args, argv[0], desc);
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
if(argv[optind] == NULL && !_all){
arg_printusage(args, num_args, argv[0], desc);
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
g_diskbased = _diskbased;
g_tsname = _tsname;
int res = 0;
if(_print){
/**
* Print instead of creating
*/
if(optind < argc){
for(int i = optind; i<argc; i++){
NDBT_Tables::print(argv[i]);
}
} else {
NDBT_Tables::printAll();
}
} else {
/**
* Creating
*/
// Connect to Ndb
Ndb_cluster_connection con(_connectstr);
if(con.connect(12, 5, 1) != 0)
{
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb(&con, "TEST_DB" );
if(MyNdb.init() != 0){
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
while(MyNdb.waitUntilReady() != 0)
ndbout << "Waiting for ndb to become ready..." << endl;
NdbDictionary::Dictionary* MyDic = MyNdb.getDictionary();
if (_trans) {
if (MyDic->beginSchemaTrans() == -1) {
ERR(MyDic->getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
}
if(_all){
res = NDBT_Tables::createAllTables(&MyNdb, _temp);
} else {
int tmp;
for(int i = optind; i<argc; i++){
ndbout << "Trying to create " << argv[i] << endl;
if((tmp = NDBT_Tables::createTable(&MyNdb, argv[i], _temp, false,
g_create_hook)) != 0)
res = tmp;
}
}
if (_trans) {
if (MyDic->endSchemaTrans() == -1) {
ERR(MyDic->getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
}
}
if(res != 0)
return NDBT_ProgramExit(NDBT_FAILED);
else
return NDBT_ProgramExit(NDBT_OK);
}
static void
usage(int ret)
{
arg_printusage (args, num_args, NULL, "[host[:port]] ...");
exit (ret);
}
static void
server_usage(int code, struct getargs *largs, int lnum_args)
{
arg_printusage(largs, lnum_args, NULL, "");
exit(code);
}
static void
client_usage(int code, struct getargs *largs, int lnum_args)
{
arg_printusage(largs, lnum_args, NULL, "host");
exit(code);
}
int main(int argc, const char** argv){
ndb_init();
int _records = 0;
int _help = 0;
int _batch = 512;
int _loops = -1;
int _rand = 0;
int _onetrans = 0;
int _abort = 0;
const char* db = 0;
struct getargs args[] = {
{ "records", 'r', arg_integer, &_records, "Number of records", "recs" },
{ "batch", 'b', arg_integer, &_batch, "Number of operations in each transaction", "batch" },
{ "loops", 'l', arg_integer, &_loops, "Number of loops", "" },
{ "database", 'd', arg_string, &db, "Database", "" },
{ "usage", '?', arg_flag, &_help, "Print help", "" },
{ "rnd-rows", 0, arg_flag, &_rand, "Rand number of records", "recs" },
{ "one-trans", 0, arg_flag, &_onetrans, "Insert as 1 trans", "" },
{ "abort", 0, arg_integer, &_abort, "Abort probability", "" }
};
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"\
"This means that it is possible to check the validity of the data \n"\
"at a later time. The last column in each table is used as an update \n"\
"counter, it's initialised to zero and should be incremented for each \n"\
"update of the record. \n";
if(getarg(args, num_args, argc, argv, &optind) ||
argv[optind] == NULL || _records == 0 || _help) {
arg_printusage(args, num_args, argv[0], desc);
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
// Connect to Ndb
Ndb_cluster_connection con;
if(con.connect(12, 5, 1) != 0)
{
return NDBT_ProgramExit(NDBT_FAILED);
}
if (con.wait_until_ready(30,0) < 0)
{
ndbout << "Cluster nodes not ready in 30 seconds." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb( &con, db ? db : "TEST_DB" );
if(MyNdb.init() != 0){
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
for(Uint32 i = optind; i<argc; i++)
{
const char* _tabname = argv[i];
// 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);
loop:
int rows = (_rand ? rand() % _records : _records);
int abort = (rand() % 100) < _abort ? 1 : 0;
if (abort)
ndbout << "load+abort" << endl;
if (hugoTrans.loadTable(&MyNdb,
rows,
_batch,
true, 0, _onetrans, _loops, abort) != 0){
return NDBT_ProgramExit(NDBT_FAILED);
}
if(_loops > 0)
{
ndbout << "clearing..." << endl;
hugoTrans.clearTable(&MyNdb);
//hugoTrans.pkDelRecords(&MyNdb, _records);
_loops--;
goto loop;
}
}
return NDBT_ProgramExit(NDBT_OK);
}
static void
usage(int ret)
{
arg_printusage (args, num_args, NULL, "");
exit (ret);
}
int main(int argc, const char** argv){
ndb_init();
int _records = 0;
int _loops = 1;
int _abort = 0;
int _batch = 0;
const char* _tabname = NULL, *db = 0;
int _help = 0;
struct getargs args[] = {
{ "aborts", 'a', arg_integer, &_abort, "percent of transactions that are aborted", "abort%" },
{ "loops", 'l', arg_integer, &_loops, "number of times to run this program(0=infinite loop)", "loops" },
// { "batch", 'b', arg_integer, &_batch, "batch value", "batch" },
{ "records", 'r', arg_integer, &_records, "Number of records", "records" },
{ "usage", '?', arg_flag, &_help, "Print help", "" },
{ "database", 'd', arg_string, &db, "Database", "" }
};
int num_args = sizeof(args) / sizeof(args[0]);
int optind = 0;
char desc[] =
"tabname\n"\
"This program will update all records in a table using PK\n";
if(getarg(args, num_args, argc, argv, &optind) ||
argv[optind] == NULL || _records == 0 || _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 ? db : "TEST_DB" );
if(MyNdb.init() != 0){
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
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);
int i = 0;
while (i<_loops || _loops==0) {
ndbout << "loop " << i << ": ";
if (hugoTrans.pkUpdateRecords(&MyNdb,
_records) != 0){
return NDBT_ProgramExit(NDBT_FAILED);
}
i++;
}
return NDBT_ProgramExit(NDBT_OK);
}
static void
usage(int code)
{
arg_printusage(http_args, num_http_args, NULL, "host [page]");
exit(code);
}
static void
usage(int ret)
{
arg_printusage (args, num_args, NULL, "kdc-request-log-file");
exit (ret);
}
