Ndb_cluster_connection* JniNdbEventStreamingImp::connect_to_cluster(const char *connection_string) {
Ndb_cluster_connection* c;
if (ndb_init())
exit(EXIT_FAILURE);
c = new Ndb_cluster_connection(connection_string);
if (c->connect(RETRIES, DELAY_BETWEEN_RETRIES, VERBOSE)) {
fprintf(stderr, "Unable to connect to cluster.\n\n");
exit(EXIT_FAILURE);
}
if (c->wait_until_ready(WAIT_UNTIL_READY, WAIT_UNTIL_READY) < 0) {
fprintf(stderr, "Cluster was not ready.\n\n");
exit(EXIT_FAILURE);
}
return c;
}
// Init the connection to an NDB cluster.
Ndb_cluster_connection* connect_to_cluster(char* conn_string)
{
Ndb_cluster_connection* c;
if(ndb_init())
exit(EXIT_FAILURE);
c= new Ndb_cluster_connection(conn_string);
if(c->connect(4, 5, 1))
{
fprintf(stderr, "Unable to connect to cluster within 30 seconds.\n\n");
exit(EXIT_FAILURE);
}
if(c->wait_until_ready(30, 0) < 0)
{
fprintf(stderr, "Cluster was not ready within 30 seconds.\n\n");
exit(EXIT_FAILURE);
}
return c;
}
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);
}
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);
}
int main(int argc, char ** argv)
{
ndb_init();
/**
* define a connect string to the management server
*/
memset( ndbconnectstring,0,255);
memset( database,0,255);
memset( tablename,0,255);
strcpy(ndbconnectstring, "localhost:1186");
strcpy(database, "");
option(argc,argv);
if(strcmp(tablename,"")==0)
{
g_analyze_all=true;
}
char * db;
if(strcmp(database,"")==0)
db=0;
else
db=database;
char * table = tablename;
/**
* Create a Ndb_cluster_connection object using the connectstring
*/
Ndb_cluster_connection * conn = new Ndb_cluster_connection(ndbconnectstring);
/**
* Connect to the management server
* try 12 times, wait 5 seconds between each retry,
* and be verbose (1), if connection attempt failes
*/
if(conn->connect(12, 5, 1) != 0)
{
printf( "Unable to connect to management server." );
return -1;
}
/**
* Join the cluster
* wait for 30 seconds for first node to be alive, and 0 seconds
* for the rest.
*/
if (conn->wait_until_ready(30,0) <0)
{
printf( "Cluster nodes not ready in 30 seconds." );
return -1;
}
/**
* The first thing we have to do is to instantiate an Ndb object.
* The Ndb object represents a connection to a database.
* It is important to note that the Ndb object is not thread safe!!
* Thus, if it is a multi-threaded application, then typically each thread
* uses its own Ndb object.
*
* Now we create an Ndb object that connects to the test database.
*/
Ndb * ndb = new Ndb(conn);
if (ndb->init() != 0)
{
/**
* just exit if we can't initialize the Ndb object
*/
return -1;
}
if(ftScan)
{
if(g_analyze_all)
printf("Analyzing all tables. This may take a while.\n");
else
printf("Analyzing entire table. This may take a while.\n");
}
if (ignoreData)
{
printf("record in database will be ignored.\n");
}
memset(g_all_tables,0,sizeof(g_all_tables));
memset(g_all_dbs,0,sizeof(g_all_dbs));
char filename[255];
if(g_analyze_all)
{
if(db!=0)
sprintf(filename,"%s.csv",db);
else
{
strcpy(filename,"all_databases.csv");
g_multi_db=true;
}
list_tables(ndb,db);
}
else
{
if(db==0)
{
printf("You must specify the database when analyzing only one table\n");
exit(1);
}
g_count=1;
sprintf(filename,"%s_%s.csv",db,table);
strcpy(g_all_tables[0], table);
}
FILE * fh = fopen(filename,"w+");
fclose(fh);
for(int i=0;i<g_count;i++)
{
if(db!=0)
{
if (supersizeme(ndb, db, g_all_tables[i], ftScan,ignoreData ) <0)
return -1;
}else
{
if (supersizeme(ndb, g_all_dbs[i], g_all_tables[i], ftScan,ignoreData) <0)
return -1;
}
printf("----------------------------------------------------\n");
}
return 0;
}
int main(int argc, const char** argv){
ndb_init();
int _records = 0;
int _loops = 1;
int _parallelism = 1;
int _ver2 = 0;
const char* _tabname = NULL, *db = 0;
int _help = 0;
int abort= 0;
struct getargs args[] = {
{ "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" },
{ "ver2", '2', arg_flag, &_ver2, "Use version 2 of scanUpdateRecords", "" },
{ "ver2", '1', arg_negative_flag, &_ver2, "Use version 1 of scanUpdateRecords (default)", "" },
{ "abort", 'a', arg_integer, &abort, "Abort probability", "" },
{ "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 scan update all records in one 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];
// 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);
}
HugoTransactions hugoTrans(*pTab);
int i = 0;
int res = NDBT_FAILED;
while (i<_loops || _loops==0) {
ndbout << i << ": ";
if (_ver2 == 0){
res = hugoTrans.scanUpdateRecords(&MyNdb,
_records,
abort % 101,
_parallelism);
} else{
res = hugoTrans.scanUpdateRecords2(&MyNdb,
_records,
abort % 101,
_parallelism);
}
if (res != NDBT_OK ){
return NDBT_ProgramExit(NDBT_FAILED);
}
i++;
//NdbSleep_MilliSleep(300);
}
return NDBT_ProgramExit(NDBT_OK);
}
int main(int argc, char** argv){
NDB_INIT(argv[0]);
ndb_opt_set_usage_funcs(short_usage_sub, usage);
ndb_load_defaults(NULL, load_default_groups, &argc, &argv);
int ho_error;
if ((ho_error=handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option)))
return -1;
// 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);
if(MyNdb.init() != 0)
{
NDB_ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
Vector<const NdbDictionary::Table*> tables;
for(int i = 0; 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);
}
else
{
ndbout << " Discovered " << _tabname << endl;
}
tables.push_back(pTab);
}
tables.push_back(0);
HugoQueryBuilder::OptionMask mask = 0;
struct { const char * name; HugoQueryBuilder::QueryOption option; }
_ops[] = {
{ "lookup", HugoQueryBuilder::O_LOOKUP },
{ "scan", HugoQueryBuilder::O_SCAN },
{ "pk", HugoQueryBuilder::O_PK_INDEX },
{ "uk", HugoQueryBuilder::O_UNIQUE_INDEX },
{ "oi", HugoQueryBuilder::O_ORDERED_INDEX },
{ "ts", HugoQueryBuilder::O_TABLE_SCAN },
// end-marker
{ 0, HugoQueryBuilder::O_LOOKUP }
};
Vector<BaseString> list;
BaseString tmp(_options);
tmp.split(list, ",");
for (unsigned i = 0; i<list.size(); i++)
{
bool found = false;
for (int o = 0; _ops[o].name != 0; o++)
{
if (strcasecmp(list[i].c_str(), _ops[o].name) == 0)
{
found = true;
mask |= _ops[o].option;
break;
}
}
if (!found)
{
ndbout << "Unknown option " << list[i].c_str() << ", ignoring" << endl;
}
}
if (_seed == 0)
{
_seed = (unsigned)NdbTick_CurrentMillisecond();
}
ndbout << "--seed=" << _seed << endl;
srand(_seed);
for (int i = 0; (_loops == 0) || (i < _loops);)
{
if (_verbose >= 1)
{
ndbout << "******\tbuilding new query (mask: 0x" << hex
<< (Uint64)mask << ")" << endl;
}
HugoQueryBuilder builder(&MyNdb, tables.getBase(), mask);
builder.setJoinLevel(_depth);
const NdbQueryDef * q = builder.createQuery();
if (_verbose >= 2)
{
q->print(); ndbout << endl;
}
for (int j = 0; j < _loops_per_query && ((_loops == 0) || (i < _loops));
i++, j++)
{
int res = 0;
HugoQueries hq(* q);
if (q->isScanQuery())
{
res = hq.runScanQuery(&MyNdb);
}
else
{
res = hq.runLookupQuery(&MyNdb, _records/_depth, _batch);
}
if (res != 0)
{
return NDBT_ProgramExit(NDBT_FAILED);
}
if (hq.m_rows_found.size() != 0)
{
printf("\tfound: [ ");
for (unsigned i = 0; i<hq.m_rows_found.size(); i++)
{
printf("%u ", (Uint32)hq.m_rows_found[i]);
}
ndbout_c("]");
}
}
}
return NDBT_ProgramExit(NDBT_OK);
}
