CNdbInit::CNdbInit()
{
// ndb_init()이 호출되지 않으면 로그도 정상동작하지 못하기 때문에
// 이곳의 로그는 특별처리가 필요
// LOG_NDB_FUNCTION();
// ndb_init의 리턴값은 항상 0으로 고정이기 때문에 검증할 필요가 없다
ndb_init();
LOG_NDB_FUNCTION();
NDB_CALL_FUNCTION(ndb_init());
}
int main(int argc, const char** argv){
ndb_init();
int _help = 0;
char * _database = "BANK";
struct getargs args[] = {
{ "usage", '?', arg_flag, &_help, "Print help", "" },
{ "database", 'd', arg_string, &_database, "Database name", ""}
};
int num_args = sizeof(args) / sizeof(args[0]);
int optind = 0;
char desc[] =
"This program will make GL records in the bank\n";
if(getarg(args, num_args, argc, argv, &optind) || _help) {
arg_printusage(args, num_args, argv[0], desc);
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
Ndb_cluster_connection con;
if(con.connect(12, 5, 1) != 0)
{
return NDBT_ProgramExit(NDBT_FAILED);
}
Bank bank(con,_database);
if (bank.performMakeGLs() != 0)
return NDBT_ProgramExit(NDBT_FAILED);
return NDBT_ProgramExit(NDBT_OK);
}
int main(int argc, const char** argv){
ndb_init();
int _parallelism = 240;
const char* _tabname = NULL;
const char* _indexname = NULL;
int _help = 0;
struct getargs args[] = {
{ "parallelism", 's', arg_integer, &_parallelism, "parallelism", "parallelism" },
{ "usage", '?', arg_flag, &_help, "Print help", "" }
};
int num_args = sizeof(args) / sizeof(args[0]);
int optind = 0;
char desc[] =
"tabname indexname\n"\
"This program will verify the index [indexname] and compare it to data\n"
"in table [tablename]\n";
if(getarg(args, num_args, argc, argv, &optind) ||
argv[optind] == NULL || argv[optind+1] == NULL || _help) {
arg_printusage(args, num_args, argv[0], desc);
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
_tabname = argv[optind];
_indexname = argv[optind+1];
// 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);
}
// 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_FAILED);
}
int rows = 0;
UtilTransactions utilTrans(*pTab);
if (utilTrans.verifyIndex(&MyNdb,
_indexname,
_parallelism) != 0){
return NDBT_ProgramExit(NDBT_FAILED);
}
return NDBT_ProgramExit(NDBT_OK);
}
void Store::_initDB()
{
string connectionString = string(_ndbConnectString) + ":" + to_string(_ndbPort);
setenv("NDB_CONNECTSTRING", connectionString.c_str(), 1);
ndb_init();
//_mysql.reset(new MYSQL[_noExecutorThreads], ArrayDeleter<MYSQL>());
_clusterConnections.reset(new Ndb_cluster_connection[_totalClusterConnections], ArrayDeleter<Ndb_cluster_connection>());
for (int i = 0; i < _totalClusterConnections; i++)
{
if(_clusterConnections.get()[i].connect(12, 5, 1) != 0)
{
FILE_LOG(logERROR)<<"Failed to connect to ndb cluster connection no "<<i+1;
exit(EXIT_FAILURE);
}
}
FILE_LOG(logINFO)<<"Initialzing NDB ";
// _initNDB(_ndbDefiners, _noDefinerThread);
_initNDB(_ndbExecutors, _noExecutorThreads);
FILE_LOG(logINFO)<<"NDB Initialzed";
NDBMessageExecutor::initialize(_mysql.get(), _ndbExecutors.get(), &_tableInfoCache);
// NDBMessageProcessor::initialize(_ndbDefiners.get(), &_tableInfoCache);
}
int main(int argc, const char** argv){
ndb_init();
int _help = 0;
int _wait = 30;
char * _database="BANK";
struct getargs args[] = {
{ "wait", 'w', arg_integer, &_wait, "Max time to wait between days", "secs" },
{ "database", 'd', arg_string, &_database, "Database name", ""},
{ "usage", '?', arg_flag, &_help, "Print help", "" }
};
int num_args = sizeof(args) / sizeof(args[0]);
int optind = 0;
char desc[] =
"This program will increase time in the bank\n";
if(getarg(args, num_args, argc, argv, &optind) || _help) {
arg_printusage(args, num_args, argv[0], desc);
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
Ndb_cluster_connection con;
if(con.connect(12, 5, 1) != 0)
{
return NDBT_ProgramExit(NDBT_FAILED);
}
Bank bank(con,_database);
if (bank.performIncreaseTime(_wait) != 0)
return NDBT_ProgramExit(NDBT_FAILED);
return NDBT_ProgramExit(NDBT_OK);
}
Pool_context
test_context(Uint32 pages)
{
ndb_init();
Pool_context pc;
pc.m_block = █
Resource_limit rl;
for (Uint32 resid = 1; resid < RG_COUNT; resid++)
{
rl.m_min = 0;
rl.m_max = 0;
rl.m_resource_id = resid;
mm.set_resource_limit(rl);
}
rl.m_min = 0;
rl.m_max = pages;
rl.m_resource_id = 0;
mm.set_resource_limit(rl);
if (!mm.init(NULL /* watchCounter */))
{
abort();
}
mm.map(NULL /* watchCounter */, 0 /* memlock */); // Map all
return pc;
}
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 main(void)
{
ndb_init();
printf("cdrstruct=%d\n",sizeof(struct cdr_record));
printf("long int=%d\n",sizeof(long int));
printf("int=%d\n",sizeof(int));
printf("short int=%d\n",sizeof(short int));
return 0;
}
int main()
{
ndb_init();
Ndb_cluster_connection *cluster_connection=
new Ndb_cluster_connection(); // Object representing the cluster
int r= cluster_connection->connect(5 /* retries */,
3 /* delay between retries */,
1 /* verbose */);
if (r > 0)
{
std::cout
<< "Cluster connect failed, possibly resolved with more retries.\n";
exit(-1);
}
else if (r < 0)
{
std::cout
<< "Cluster connect failed.\n";
exit(-1);
}
if (cluster_connection->wait_until_ready(30,30))
{
std::cout << "Cluster was not ready within 30 secs." << std::endl;
exit(-1);
}
Ndb* myNdb= new Ndb( cluster_connection,
"TEST_DB_1" ); // Object representing the database
if (myNdb->init() == -1) {
APIERROR(myNdb->getNdbError());
exit(-1);
}
const NdbDictionary::Dictionary* myDict= myNdb->getDictionary();
const NdbDictionary::Table *myTable= myDict->getTable("MYTABLENAME");
if (myTable == NULL)
{
APIERROR(myDict->getNdbError());
return -1;
}
/************************************
* Execute some insert transactions *
************************************/
for (int i = 10000; i < 20000; i++) {
executeInsertTransaction(i, myNdb, myTable);
}
delete myNdb;
delete cluster_connection;
ndb_end(0);
return 0;
}
int main(int argc, char** argv)
{
if (argc != 3)
{
std::cout << "Arguments are <socket mysqld> <connect_string cluster>.\n";
exit(-1);
}
// ndb_init must be called first
ndb_init();
// connect to mysql server and cluster and run application
{
char * mysqld_sock = argv[1];
const char *connectstring = argv[2];
// Object representing the cluster
Ndb_cluster_connection cluster_connection(connectstring);
// Connect to cluster management server (ndb_mgmd)
if (cluster_connection.connect(4 /* retries */,
5 /* delay between retries */,
1 /* verbose */))
{
std::cout << "Cluster management server was not ready within 30 secs.\n";
exit(-1);
}
// Optionally connect and wait for the storage nodes (ndbd's)
if (cluster_connection.wait_until_ready(30,0) < 0)
{
std::cout << "Cluster was not ready within 30 secs.\n";
exit(-1);
}
// connect to mysql server
MYSQL mysql;
if ( !mysql_init(&mysql) ) {
std::cout << "mysql_init failed\n";
exit(-1);
}
if ( !mysql_real_connect(&mysql, "localhost", "root", "", "",
0, mysqld_sock, 0) )
MYSQLERROR(mysql);
// run the application code
run_application(mysql, cluster_connection);
}
ndb_end(0);
return 0;
}
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 av, char** ac)
{
ndb_init();
debug("start");
hostname = "ndb-srv7";
if (Ndb_getInAddr(&hostaddr.sin_addr, hostname) != 0) {
fatal("hostname %s lookup failed", hostname);
}
localcfgfile = "Ndb.cfg";
initcfgfile = "config.txt";
getcfg();
start();
debug("done");
return 0;
}
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);
}
int
main(int argc, char** argv)
{
my_progname = "ndb_pack_frm";
int ret;
ndb_init();
ndb_opt_set_usage_funcs(short_usage_sub, usage);
ret = handle_options(&argc, &argv, my_long_options, ndb_std_get_one_option);
if (ret != 0)
return NDBT_WRONGARGS;
for (int i = 0; i < argc; i++)
{
ret = dofile(argv[i]);
if (ret != 0)
return NDBT_FAILED;
}
return NDBT_OK;
}
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;
}
int
main(int argc, char **argv)
{
ndb_init();
if (argc > 1)
{
time_t seed = time(0);
srand(seed);
fprintf(stderr, "srand(%d)\n", seed);
}
// alloc, free, reorg, grow, shrink
int t1[] = { 10, 60, 70, 85, 100 };
int t2[] = { 30, 60, 70, 85, 100 };
int t3[] = { 50, 60, 70, 85, 100 };
do_test(10000, t1);
do_test(10000, t2);
do_test(10000, t3);
return 0;
}
int
main(int argc, char** argv)
{
my_progname = "ndb_index_stat";
int ret;
ndb_init();
ndb_opt_set_usage_funcs(short_usage_sub, usage);
ret = handle_options(&argc, &argv, my_long_options, ndb_std_get_one_option);
if (ret != 0 || checkopts(argc, argv) != 0)
return NDBT_ProgramExit(NDBT_WRONGARGS);
setOutputLevel(_verbose ? 2 : 0);
unsigned seed = (unsigned)time(0);
g_info << "random seed " << seed << endl;
ndb_srand(seed);
ret = doall();
if (ret == -1)
return NDBT_ProgramExit(NDBT_FAILED);
return NDBT_ProgramExit(NDBT_OK);
}
int main(int argc, char** argv)
{
if (argc != 8)
{
ndbout << "Arguments are <connect_string cluster 1> <connect_string cluster 2> <database> <table name> <primary key> <value of primary key> <attribute to update>.\n";
exit(-1);
}
// ndb_init must be called first
ndb_init();
{
const char *opt_connectstring1 = argv[1];
const char *opt_connectstring2 = argv[2];
const char *opt_db = argv[3];
const char *opt_table = argv[4];
const char *opt_pk = argv[5];
const Uint32 opt_pk_val = atoi(argv[6]);
const char *opt_col = argv[7];
// Object representing the cluster 1
Ndb_cluster_connection cluster1_connection(opt_connectstring1);
// Object representing the cluster 2
Ndb_cluster_connection cluster2_connection(opt_connectstring2);
// connect cluster 1 and run application
// Connect to cluster 1 management server (ndb_mgmd)
if (cluster1_connection.connect(4 /* retries */,
5 /* delay between retries */,
1 /* verbose */))
{
g_err << "Cluster 1 management server was not ready within 30 secs.\n";
exit(-1);
}
// Optionally connect and wait for the storage nodes (ndbd's)
if (cluster1_connection.wait_until_ready(30,0) < 0)
{
g_err << "Cluster 1 was not ready within 30 secs.\n";
exit(-1);
}
// connect cluster 2 and run application
// Connect to cluster management server (ndb_mgmd)
if (cluster2_connection.connect(4 /* retries */,
5 /* delay between retries */,
1 /* verbose */))
{
g_err << "Cluster 2 management server was not ready within 30 secs.\n";
exit(-1);
}
// Optionally connect and wait for the storage nodes (ndbd's)
if (cluster2_connection.wait_until_ready(30,0) < 0)
{
g_err << "Cluster 2 was not ready within 30 secs.\n";
exit(-1);
}
// Object representing the database
Ndb myNdb1(&cluster1_connection, opt_db);
Ndb myNdb2(&cluster2_connection, opt_db);
//
struct Xxx xxx1;
struct Xxx xxx2;
struct XxxR xxxr;
prepare_master_or_slave(myNdb1, opt_table, opt_pk, opt_pk_val, opt_col,
xxx1, xxxr);
prepare_master_or_slave(myNdb2, opt_table, opt_pk, opt_pk_val, opt_col,
xxx2, xxxr);
while (1)
{
// run the application code
run_master_update(xxx1, xxxr);
run_slave_wait(xxx2, xxxr);
ndbout << "latency: " << xxxr.latency << endl;
}
}
// Note: all connections must have been destroyed before calling ndb_end()
ndb_end(0);
return 0;
}
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, char** argv)
{
if (argc != 3)
{
std::cout << "Arguments are <socket mysqld> <connect_string cluster>.\n";
exit(-1);
}
char * mysqld_sock = argv[1];
const char *connectstring = argv[2];
ndb_init();
MYSQL mysql;
/**************************************************************
* Connect to mysql server and create table *
**************************************************************/
{
if ( !mysql_init(&mysql) ) {
std::cout << "mysql_init failed\n";
exit(-1);
}
if ( !mysql_real_connect(&mysql, "localhost", "root", "", "",
0, mysqld_sock, 0) )
MYSQLERROR(mysql);
mysql_query(&mysql, "CREATE DATABASE ndb_examples_1");
if (mysql_query(&mysql, "USE ndb_examples") != 0) MYSQLERROR(mysql);
while (mysql_query(&mysql,
"CREATE TABLE"
" api_simple_index"
" (ATTR1 INT UNSIGNED,"
" ATTR2 INT UNSIGNED NOT NULL,"
" PRIMARY KEY USING HASH (ATTR1),"
" UNIQUE MYINDEXNAME USING HASH (ATTR2))"
" ENGINE=NDB"))
{
if (mysql_errno(&mysql) == ER_TABLE_EXISTS_ERROR)
{
std::cout << "MySQL Cluster already has example table: api_scan. "
<< "Dropping it..." << std::endl;
mysql_query(&mysql, "DROP TABLE api_simple_index");
}
else MYSQLERROR(mysql);
}
}
/**************************************************************
* Connect to ndb cluster *
**************************************************************/
Ndb_cluster_connection *cluster_connection=
new Ndb_cluster_connection(connectstring); // Object representing the cluster
if (cluster_connection->connect(5,3,1))
{
std::cout << "Connect to cluster management server failed.\n";
exit(-1);
}
if (cluster_connection->wait_until_ready(30,30))
{
std::cout << "Cluster was not ready within 30 secs.\n";
exit(-1);
}
Ndb* myNdb = new Ndb( cluster_connection,
"ndb_examples" ); // Object representing the database
if (myNdb->init() == -1) {
APIERROR(myNdb->getNdbError());
exit(-1);
}
const NdbDictionary::Dictionary* myDict= myNdb->getDictionary();
const NdbDictionary::Table *myTable= myDict->getTable("api_simple_index");
if (myTable == NULL)
APIERROR(myDict->getNdbError());
const NdbDictionary::Index *myIndex= myDict->getIndex("MYINDEXNAME$unique","api_simple_index");
if (myIndex == NULL)
APIERROR(myDict->getNdbError());
/**************************************************************************
* Using 5 transactions, insert 10 tuples in table: (0,0),(1,1),...,(9,9) *
**************************************************************************/
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);
}
/*****************************************
* Read and print all tuples using index *
*****************************************/
std::cout << "ATTR1 ATTR2" << std::endl;
for (int i = 0; i < 10; i++) {
NdbTransaction *myTransaction= myNdb->startTransaction();
if (myTransaction == NULL) APIERROR(myNdb->getNdbError());
NdbIndexOperation *myIndexOperation=
myTransaction->getNdbIndexOperation(myIndex);
if (myIndexOperation == NULL) APIERROR(myTransaction->getNdbError());
myIndexOperation->readTuple(NdbOperation::LM_Read);
myIndexOperation->equal("ATTR2", i);
NdbRecAttr *myRecAttr= myIndexOperation->getValue("ATTR1", NULL);
if (myRecAttr == NULL) APIERROR(myTransaction->getNdbError());
if(myTransaction->execute( NdbTransaction::Commit,
NdbOperation::AbortOnError ) != -1)
printf(" %2d %2d\n", myRecAttr->u_32_value(), i);
myNdb->closeTransaction(myTransaction);
}
/*****************************************************************
* Update the second attribute in half of the tuples (adding 10) *
*****************************************************************/
for (int i = 0; i < 10; i+=2) {
NdbTransaction *myTransaction= myNdb->startTransaction();
if (myTransaction == NULL) APIERROR(myNdb->getNdbError());
NdbIndexOperation *myIndexOperation=
myTransaction->getNdbIndexOperation(myIndex);
if (myIndexOperation == NULL) APIERROR(myTransaction->getNdbError());
myIndexOperation->updateTuple();
myIndexOperation->equal( "ATTR2", i );
myIndexOperation->setValue( "ATTR2", i+10);
if( myTransaction->execute( NdbTransaction::Commit ) == -1 )
APIERROR(myTransaction->getNdbError());
myNdb->closeTransaction(myTransaction);
}
/*************************************************
* Delete one tuple (the one with primary key 3) *
*************************************************/
{
NdbTransaction *myTransaction= myNdb->startTransaction();
if (myTransaction == NULL) APIERROR(myNdb->getNdbError());
NdbIndexOperation *myIndexOperation=
myTransaction->getNdbIndexOperation(myIndex);
if (myIndexOperation == NULL) APIERROR(myTransaction->getNdbError());
myIndexOperation->deleteTuple();
myIndexOperation->equal( "ATTR2", 3 );
if (myTransaction->execute(NdbTransaction::Commit) == -1)
APIERROR(myTransaction->getNdbError());
myNdb->closeTransaction(myTransaction);
}
/*****************************
* Read and print all tuples *
*****************************/
{
std::cout << "ATTR1 ATTR2" << std::endl;
for (int i = 0; i < 10; i++) {
NdbTransaction *myTransaction= myNdb->startTransaction();
if (myTransaction == NULL) APIERROR(myNdb->getNdbError());
NdbOperation *myOperation= myTransaction->getNdbOperation(myTable);
if (myOperation == NULL) APIERROR(myTransaction->getNdbError());
myOperation->readTuple(NdbOperation::LM_Read);
myOperation->equal("ATTR1", i);
NdbRecAttr *myRecAttr= myOperation->getValue("ATTR2", NULL);
if (myRecAttr == NULL) APIERROR(myTransaction->getNdbError());
if(myTransaction->execute( NdbTransaction::Commit,
NdbOperation::AbortOnError ) == -1)
if (i == 3) {
std::cout << "Detected that deleted tuple doesn't exist!\n";
} else {
APIERROR(myTransaction->getNdbError());
}
if (i != 3) {
printf(" %2d %2d\n", i, myRecAttr->u_32_value());
}
myNdb->closeTransaction(myTransaction);
}
}
delete myNdb;
delete cluster_connection;
ndb_end(0);
return 0;
}
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, char** argv)
{
if (argc != 3)
{
std::cout << "Arguments are <socket mysqld> <connect_string cluster>.\n";
exit(-1);
}
char * mysqld_sock = argv[1];
const char *connectstring = argv[2];
ndb_init();
MYSQL mysql;
/**************************************************************
* Connect to mysql server and create table *
**************************************************************/
{
if ( !mysql_init(&mysql) ) {
std::cout << "mysql_init failed\n";
exit(-1);
}
if ( !mysql_real_connect(&mysql, "localhost", "root", "", "",
0, mysqld_sock, 0) )
MYSQLERROR(mysql);
mysql_query(&mysql, "CREATE DATABASE ndb_examples");
if (mysql_query(&mysql, "USE ndb_examples") != 0) MYSQLERROR(mysql);
create_table(mysql);
}
/**************************************************************
* Connect to ndb cluster *
**************************************************************/
Ndb_cluster_connection cluster_connection(connectstring);
if (cluster_connection.connect(4, 5, 1))
{
std::cout << "Unable to connect to cluster within 30 secs." << std::endl;
exit(-1);
}
// Optionally connect and wait for the storage nodes (ndbd's)
if (cluster_connection.wait_until_ready(30,0) < 0)
{
std::cout << "Cluster was not ready within 30 secs.\n";
exit(-1);
}
Ndb myNdb(&cluster_connection,"ndb_examples");
if (myNdb.init(1024) == -1) { // Set max 1024 parallel transactions
APIERROR(myNdb.getNdbError());
exit(-1);
}
/*******************************************
* Check table definition *
*******************************************/
int column_color;
{
const NdbDictionary::Dictionary* myDict= myNdb.getDictionary();
const NdbDictionary::Table *t= myDict->getTable("api_scan");
if(t == NULL)
{
std::cout << "Dictionary::getTable() failed.";
exit(-1);
}
Car car;
if (t->getColumn("COLOR")->getLength() != sizeof(car.color) ||
t->getColumn("BRAND")->getLength() != sizeof(car.brand))
{
std::cout << "Wrong table definition" << std::endl;
exit(-1);
}
column_color= t->getColumn("COLOR")->getColumnNo();
}
if(populate(&myNdb) > 0)
std::cout << "populate: Success!" << std::endl;
if(scan_print(&myNdb) > 0)
std::cout << "scan_print: Success!" << std::endl << std::endl;
std::cout << "Going to delete all pink cars!" << std::endl;
{
/**
* Note! color needs to be of exact the same size as column defined
*/
Car tmp;
sprintf(tmp.color, "Pink");
if(scan_delete(&myNdb, column_color, tmp.color) > 0)
std::cout << "scan_delete: Success!" << std::endl << std::endl;
}
if(scan_print(&myNdb) > 0)
std::cout << "scan_print: Success!" << std::endl << std::endl;
{
/**
* Note! color1 & 2 need to be of exact the same size as column defined
*/
Car tmp1, tmp2;
sprintf(tmp1.color, "Blue");
sprintf(tmp2.color, "Black");
std::cout << "Going to update all " << tmp1.color
<< " cars to " << tmp2.color << " cars!" << std::endl;
if(scan_update(&myNdb, column_color, tmp1.color, tmp2.color) > 0)
std::cout << "scan_update: Success!" << std::endl << std::endl;
}
if(scan_print(&myNdb) > 0)
std::cout << "scan_print: Success!" << std::endl << std::endl;
/**
* Drop table
*/
drop_table(mysql);
return 0;
}
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, 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);
}
// 函数实现
BOOL nes_init(NES *nes, char *file, DWORD extra)
{
int *mirroring = NULL;
int i = 0;
log_init("DEBUGER"); // log init
// clear it
memset(nes, 0, sizeof(NES));
// extra data
nes->extra = extra;
// load cartridge first
if (!cartridge_load(&(nes->cart), file))
{
log_printf("failed to load nes rom file !\n");
}
//++ cbus mem map ++//
// create cpu ram
nes->cram.type = MEM_RAM;
nes->cram.size = NES_CRAM_SIZE;
nes->cram.data = nes->cpu.cram;
// create ppu regs
nes->ppuregs.type = MEM_REG;
nes->ppuregs.size = NES_PPUREGS_SIZE;
nes->ppuregs.data = nes->ppu.regs;
nes->ppuregs.r_callback = NES_PPU_REG_RCB;
nes->ppuregs.w_callback = NES_PPU_REG_WCB;
// create apu regs
nes->apuregs.type = MEM_REG;
nes->apuregs.size = NES_APUREGS_SIZE;
nes->apuregs.data = nes->apu.regs;
nes->apuregs.r_callback = NES_APU_REG_RCB;
nes->apuregs.w_callback = NES_APU_REG_WCB;
// create expansion rom
nes->erom.type = MEM_ROM;
nes->erom.size = NES_EROM_SIZE;
nes->erom.data = nes->buf_erom;
// create sram
nes->sram.type = MEM_RAM;
nes->sram.size = NES_SRAM_SIZE;
nes->sram.data = nes->cart.buf_sram;
// create PRG-ROM 0
nes->prom0.type = MEM_ROM;
nes->prom0.size = NES_PRGROM_SIZE;
// create PRG-ROM 1
nes->prom1.type = MEM_ROM;
nes->prom1.size = NES_PRGROM_SIZE;
// init nes cbus
bus_setmem(nes->cbus, 0, 0xC000, 0xFFFF, &(nes->prom1 ));
bus_setmem(nes->cbus, 1, 0x8000, 0xBFFF, &(nes->prom0 ));
bus_setmem(nes->cbus, 2, 0x6000, 0x7FFF, &(nes->sram ));
bus_setmem(nes->cbus, 3, 0x4020, 0x5FFF, &(nes->erom ));
bus_setmem(nes->cbus, 4, 0x4000, 0x401F, &(nes->apuregs));
bus_setmem(nes->cbus, 5, 0x2000, 0x3FFF, &(nes->ppuregs));
bus_setmem(nes->cbus, 6, 0x0000, 0x1FFF, &(nes->cram ));
//-- cbus mem map --//
//++ pbus mem map ++//
// create CHR-ROM0
nes->chrrom0.type = MEM_ROM;
nes->chrrom0.size = NES_CHRROM_SIZE;
// create CHR-ROM1
nes->chrrom1.type = MEM_ROM;
nes->chrrom1.size = NES_CHRROM_SIZE;
// create vram
mirroring = cartridge_get_vram_mirroring(&(nes->cart));
for (i=0; i<4; i++)
{
nes->vram[i].type = MEM_RAM;
nes->vram[i].size = NES_VRAM_SIZE;
nes->vram[i].data = nes->buf_vram[mirroring[i]];
}
// create color palette
nes->palette.type = MEM_RAM;
nes->palette.size = NES_PALETTE_SIZE;
nes->palette.data = nes->ppu.palette;
// init nes pbus
bus_setmir(nes->pbus, 0, 0x3F20, 0x3FFF, 0x3F1F);
bus_setmem(nes->pbus, 1, 0x3F00, 0x3F1F, &(nes->palette));
bus_setmir(nes->pbus, 2, 0x3000, 0x3EFF, 0x2FFF);
bus_setmem(nes->pbus, 3, 0x2C00, 0x2FFF, &(nes->vram[3]));
bus_setmem(nes->pbus, 4, 0x2800, 0x2BFF, &(nes->vram[2]));
bus_setmem(nes->pbus, 5, 0x2400, 0x27FF, &(nes->vram[1]));
bus_setmem(nes->pbus, 6, 0x2000, 0x23FF, &(nes->vram[0]));
bus_setmem(nes->pbus, 7, 0x1000, 0x1FFF, &(nes->chrrom1));
bus_setmem(nes->pbus, 8, 0x0000, 0x0FFF, &(nes->chrrom0));
//-- pbus mem map --//
// init mmc before cpu & ppu & apu, due to mmc will do bank switch
// this will change memory mapping on cbus & pbus
mmc_init(&(nes->mmc), &(nes->cart), nes->cbus, nes->pbus);
// now it's time to init cpu & ppu & apu
cpu_init(&(nes->cpu), nes->cbus );
ppu_init(&(nes->ppu), nes->extra, NULL);
apu_init(&(nes->apu), nes->extra, NULL);
ndb_init(&(nes->ndb), nes );
// init joypad
joypad_init (&(nes->pad));
joypad_setkey(&(nes->pad), 0, NES_PAD_CONNECT, 1);
joypad_setkey(&(nes->pad), 1, NES_PAD_CONNECT, 1);
// init replay
replay_init(&(nes->replay));
// create nes event & thread
pthread_create(&(nes->thread_id), NULL, nes_thread_proc, nes);
return TRUE;
}
int main(int argc, char** argv)
{
if (argc != 3)
{
std::cout << "Arguments are <socket mysqld> <connect_string cluster>.\n";
exit(-1);
}
char * mysqld_sock = argv[1];
const char *connectstring = argv[2];
ndb_init();
MYSQL mysql;
/**************************************************************
* Connect to mysql server and create table *
**************************************************************/
{
if ( !mysql_init(&mysql) ) {
std::cout << "mysql_init failed\n";
exit(-1);
}
if ( !mysql_real_connect(&mysql, "localhost", "root", "", "",
0, mysqld_sock, 0) )
MYSQLERROR(mysql);
mysql_query(&mysql, "CREATE DATABASE ndb_examples");
if (mysql_query(&mysql, "USE ndb_examples") != 0) MYSQLERROR(mysql);
create_table(mysql);
}
/**************************************************************
* Connect to ndb cluster *
**************************************************************/
Ndb_cluster_connection cluster_connection(connectstring);
if (cluster_connection.connect(4, 5, 1))
{
std::cout << "Unable to connect to cluster within 30 secs." << std::endl;
exit(-1);
}
// Optionally connect and wait for the storage nodes (ndbd's)
if (cluster_connection.wait_until_ready(30,0) < 0)
{
std::cout << "Cluster was not ready within 30 secs.\n";
exit(-1);
}
Ndb* myNdb = new Ndb( &cluster_connection,
"ndb_examples" ); // Object representing the database
if (myNdb->init(1024) == -1) { // Set max 1024 parallel transactions
APIERROR(myNdb->getNdbError());
}
/**
* Initialise transaction array
*/
for(int i = 0 ; i < 10 ; i++)
{
transaction[i].used = 0;
transaction[i].conn = 0;
}
int i=0;
/**
* Do 10 insert transactions.
*/
while(i < 10)
{
while(populate(myNdb,i,0)<0) // <0, no space on free list. Sleep and try again.
milliSleep(10);
i++;
}
std::cout << "Number of temporary errors: " << tempErrors << std::endl;
delete myNdb;
}
static int init_ndb(int argc, char** argv)
{
ndb_init();
return 0;
}
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);
}
int
main(int argc, char ** argv){
ndb_init();
require(!init_ndb(argc, argv));
if(parse_args(argc, argv))
return -1;
require(!connect_ndb());
if(g_setup_tables){
require(!drop_all_tables());
if(NDBT_Tables::createTable(g_ndb, g_tablename) != 0){
exit(-1);
}
}
g_table = g_ndb->getDictionary()->getTable(g_tablename);
if(g_table == 0){
g_err << "Failed to retreive table: " << g_tablename << endl;
exit(-1);
}
require(g_hugo_ops = new HugoOperations(* g_table));
require(!g_hugo_ops->startTransaction(g_ndb));
g_ops= new CASE[g_rows];
const int use_ops = g_use_ops;
for(size_t i = 0; i<OP_COUNT; i++)
{
if(g_one_op_at_a_time){
while(i < OP_COUNT && (use_ops & (1 << i)) == 0) i++;
if(i == OP_COUNT)
break;
ndbout_c("-- loop\noperation: %c use_ops: %x", 'a'+i, use_ops);
g_use_ops = (1 << i);
} else {
i = OP_COUNT - 1;
}
size_t test_case = 0;
if((1 << test_case++) & g_cases)
{
for(size_t tl = 0; tl<g_case_loop; tl++){
g_info << "Performing all ops wo/ inteference of LCP" << endl;
g_info << "Testing pre LCP operations, ZLCP_OP_WRITE_RT_BREAK" << endl;
g_info << " where ZLCP_OP_WRITE_RT_BREAK is "
" finished before SAVE_PAGES" << endl;
require(!load_table());
require(!pause_lcp(5900));
for(size_t j = 0; j<g_rows; j++){
require(!do_op(j));
}
require(!continue_lcp(5900));
require(!commit());
require(!pause_lcp(5900));
require(!restart());
require(!validate());
}
}
if((1 << test_case++) & g_cases)
{
for(size_t tl = 0; tl<g_case_loop; tl++){
g_info << "Testing pre LCP operations, ZLCP_OP_WRITE_RT_BREAK" << endl;
g_info << " where ZLCP_OP_WRITE_RT_BREAK is finished after SAVE_PAGES"
<< endl;
require(!load_table());
require(!pause_lcp(5901));
for(size_t j = 0; j<g_rows; j++){
require(!do_op(j));
}
require(!continue_lcp(5901));
require(!commit());
require(!pause_lcp(5900));
require(!restart());
require(!validate());
}
}
if((1 << test_case++) & g_cases)
{
for(size_t tl = 0; tl<g_case_loop; tl++){
g_info << "Testing pre LCP operations, undo-ed at commit" << endl;
require(!load_table());
require(!pause_lcp(5902));
for(size_t j = 0; j<g_rows; j++){
require(!do_op(j));
}
require(!continue_lcp(5902));
require(!commit());
require(!continue_lcp(5903));
require(!pause_lcp(5900));
require(!restart());
require(!validate());
}
}
if((1 << test_case++) & g_cases)
{
for(size_t tl = 0; tl<g_case_loop; tl++){
g_info << "Testing prepared during LCP and committed after" << endl;
require(!load_table());
require(!pause_lcp(5904)); // Start LCP, but don't save pages
for(size_t j = 0; j<g_rows; j++){
require(!do_op(j));
}
require(!continue_lcp(5904)); // Start ACC save pages
require(!pause_lcp(5900)); // Next LCP
require(!commit());
require(!restart());
require(!validate());
}
}
}
}
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);
}
