int NDBT_TestSuite::executeOneCtx(Ndb_cluster_connection& con, const NdbDictionary::Table *ptab, const char* _testname){ testSuiteTimer.doStart(); do{ if(tests.size() == 0) break; Ndb ndb(&con, "TEST_DB"); ndb.init(1024); int result = ndb.waitUntilReady(300); // 5 minutes if (result != 0){ g_err << name <<": Ndb was not ready" << endl; break; } ndbout << name << " started [" << getDate() << "]" << endl; ndbout << "|- " << ptab->getName() << endl; for (unsigned t = 0; t < tests.size(); t++){ if (_testname != NULL && strcasecmp(tests[t]->getName(), _testname) != 0) continue; tests[t]->initBeforeTest(); ctx = new NDBT_Context(con); ctx->setTab(ptab); ctx->setNumRecords(records); ctx->setNumLoops(loops); if(remote_mgm != NULL) ctx->setRemoteMgm(remote_mgm); ctx->setSuite(this); result = tests[t]->execute(ctx); if (result != NDBT_OK) numTestsFail++; else numTestsOk++; numTestsExecuted++; delete ctx; } if (numTestsFail > 0) break; }while(0); testSuiteTimer.doStop(); int res = report(_testname); return NDBT_ProgramExit(res); }
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){ NDB_INIT(argv[0]); load_defaults("my",load_default_groups,&argc,&argv); const char* _hostName = NULL; #ifndef DBUG_OFF opt_debug= "d:t:O,/tmp/ndb_waiter.trace"; #endif if (handle_options(&argc, &argv, my_long_options, ndb_std_get_one_option)) return NDBT_ProgramExit(NDBT_WRONGARGS); _hostName = argv[0]; if (_hostName == 0) _hostName= opt_connect_str; enum ndb_mgm_node_status wait_status; if (_no_contact) { wait_status= NDB_MGM_NODE_STATUS_NO_CONTACT; } else if (_not_started) { wait_status= NDB_MGM_NODE_STATUS_NOT_STARTED; } else if (_single_user) { wait_status= NDB_MGM_NODE_STATUS_SINGLEUSER; } else { wait_status= NDB_MGM_NODE_STATUS_STARTED; } if (waitClusterStatus(_hostName, wait_status) != 0) return NDBT_ProgramExit(NDBT_FAILED); return NDBT_ProgramExit(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 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); }
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; #ifndef DBUG_OFF opt_debug= "d:t:O,/tmp/ndb_select_count.trace"; #endif if ((ho_error=handle_options(&argc, &argv, my_long_options, ndb_std_get_one_option))) return NDBT_ProgramExit(NDBT_WRONGARGS); if (argc < 1) { usage(); return NDBT_ProgramExit(NDBT_WRONGARGS); } Ndb_cluster_connection con(opt_ndb_connectstring, opt_ndb_nodeid); con.set_name("ndb_select_count"); if(con.connect(12, 5, 1) != 0) { ndbout << "Unable to connect to management server." << endl; 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, _dbname ); if(MyNdb.init() != 0) { ERR(MyNdb.getNdbError()); return NDBT_ProgramExit(NDBT_FAILED); } for(int i = 0; i<argc; i++) { // Check if table exists in db const NdbDictionary::Table * pTab = NDBT_Table::discoverTableFromDb(&MyNdb, argv[i]); if(pTab == NULL) { ndbout << " Table " << argv[i] << " does not exist!" << endl; continue; } Uint64 rows = 0; if (select_count(&MyNdb, pTab, _parallelism, &rows, (NdbOperation::LockMode)_lock) != 0) { return NDBT_ProgramExit(NDBT_FAILED); } ndbout << rows << " records in table " << argv[i] << endl; } return NDBT_ProgramExit(NDBT_OK); }
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){ NDB_INIT(argv[0]); const char* _tabname; ndb_opt_set_usage_funcs(short_usage_sub, usage); ndb_load_defaults(NULL,load_default_groups,&argc,&argv); int ho_error; #ifndef DBUG_OFF opt_debug= "d:t:O,/tmp/ndb_show_tables.trace"; #endif if ((ho_error=handle_options(&argc, &argv, my_long_options, ndb_std_get_one_option))) return NDBT_ProgramExit(NDBT_WRONGARGS); _tabname = argv[0]; ndb_cluster_connection = new Ndb_cluster_connection(opt_ndb_connectstring, opt_ndb_nodeid); if (ndb_cluster_connection == NULL) fatal("Unable to create cluster connection"); ndb_cluster_connection->set_name("ndb_show_tables"); if (ndb_cluster_connection->connect(12,5,1)) fatal("Unable to connect to management server."); if (ndb_cluster_connection->wait_until_ready(30,0) < 0) fatal("Cluster nodes not ready in 30 seconds."); ndb = new Ndb(ndb_cluster_connection, _dbname); if (ndb->init() != 0) fatal("init"); dic = ndb->getDictionary(); for (int i = 0; _loops == 0 || i < _loops; i++) { list(_tabname, (NdbDictionary::Object::Type)_type); } delete ndb; delete ndb_cluster_connection; return NDBT_ProgramExit(NDBT_OK); }
static void fatal_dict(char const* fmt, ...) { va_list ap; char buf[500]; va_start(ap, fmt); BaseString::vsnprintf(buf, sizeof(buf), fmt, ap); va_end(ap); ndbout << buf; if (dic) ndbout << " - " << dic->getNdbError(); ndbout << endl; NDBT_ProgramExit(NDBT_FAILED); exit(1); }
int NDBT_Tables::dropAllTables(Ndb* pNdb){ for (int i=0; i < NDBT_Tables::getNumTables(); i++){ const NdbDictionary::Table* tab = NDBT_Tables::getTable(i); if (tab == NULL){ return NDBT_ProgramExit(NDBT_FAILED); } if(pNdb->getDictionary()->dropTable(tab->getName()) == -1){ return NDBT_FAILED; } } return NDBT_OK; }
int main(int argc, char** argv){ NDB_INIT(argv[0]); load_defaults("my",load_default_groups,&argc,&argv); int ho_error; if ((ho_error=handle_options(&argc, &argv, my_long_options, ndb_std_get_one_option))) return NDBT_ProgramExit(NDBT_WRONGARGS); if (argc < 1) { usage(); return NDBT_ProgramExit(NDBT_WRONGARGS); } Ndb_cluster_connection con(opt_connect_str); con.set_name("ndb_drop_table"); if(con.connect(12, 5, 1) != 0) { ndbout << "Unable to connect to management server." << endl; return NDBT_ProgramExit(NDBT_FAILED); } if (con.wait_until_ready(30,3) < 0) { ndbout << "Cluster nodes not ready in 30 seconds." << endl; return NDBT_ProgramExit(NDBT_FAILED); } Ndb MyNdb(&con, _dbname ); if(MyNdb.init() != 0){ ERR(MyNdb.getNdbError()); return NDBT_ProgramExit(NDBT_FAILED); } int res = 0; for(int i = 0; i<argc; i++){ ndbout << "Dropping table " << argv[i] << "..."; int tmp; if((tmp = MyNdb.getDictionary()->dropTable(argv[i])) != 0){ ndbout << endl << MyNdb.getDictionary()->getNdbError() << endl; res = tmp; } else { ndbout << "OK" << endl; } } if(res != 0){ return NDBT_ProgramExit(NDBT_FAILED); } return NDBT_ProgramExit(NDBT_OK); }
int main(int argc, char** argv){ NDB_INIT(argv[0]); load_defaults("my",load_default_groups,&argc,&argv); int ho_error; #ifndef DBUG_OFF opt_debug= "d:t:O,/tmp/ndb_delete_all.trace"; #endif if ((ho_error=handle_options(&argc, &argv, my_long_options, ndb_std_get_one_option))) return NDBT_ProgramExit(NDBT_WRONGARGS); Ndb_cluster_connection con(opt_connect_str); con.set_name("ndb_delete_all"); if(con.connect(12, 5, 1) != 0) { ndbout << "Unable to connect to management server." << endl; 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, _dbname ); if(MyNdb.init() != 0){ ERR(MyNdb.getNdbError()); return NDBT_ProgramExit(NDBT_FAILED); } // Check if table exists in db int res = NDBT_OK; for(int i = 0; i<argc; i++){ const NdbDictionary::Table * pTab = NDBT_Table::discoverTableFromDb(&MyNdb, argv[i]); if(pTab == NULL){ ndbout << " Table " << argv[i] << " does not exist!" << endl; return NDBT_ProgramExit(NDBT_WRONGARGS); } ndbout << "Deleting all from " << argv[i]; if (! _transactional) ndbout << " (non-transactional)"; ndbout << " ..."; if(clear_table(&MyNdb, pTab, ! _transactional) == NDBT_FAILED){ res = NDBT_FAILED; ndbout << "FAILED" << endl; } } return NDBT_ProgramExit(res); }
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); }
int NDBT_TestSuite::execute(int argc, const char** argv){ int res = NDBT_FAILED; /* Arguments: Run only a subset of tests -n testname Which test to run Recommendations to test functions: --records Number of records to use(default: 10000) --loops Number of loops to execute in the test(default: 100) Other parameters should: * be calculated from the above two parameters * be divided into different test cases, ex. one testcase runs with FragmentType = Single and another perfoms the same test with FragmentType = Large * let the test case iterate over all/subset of appropriate parameters ex. iterate over FragmentType = Single to FragmentType = AllLarge Remeber that the intention is that it should be _easy_ to run a complete test suite without any greater knowledge of what should be tested ie. keep arguments at a minimum */ char **_argv= (char **)argv; if (!my_progname) my_progname= _argv[0]; ndb_opt_set_usage_funcs(short_usage_sub, usage); ndb_load_defaults(NULL, load_default_groups,&argc,&_argv); // Save pointer to memory allocated by 'ndb_load_defaults' char** defaults_argv= _argv; int ho_error; #ifndef DBUG_OFF opt_debug= "d:t:i:F:L"; #endif if ((ho_error=handle_options(&argc, &_argv, my_long_options, ndb_std_get_one_option))) { usage(); ndb_free_defaults(defaults_argv); return NDBT_ProgramExit(NDBT_WRONGARGS); } if (opt_verbose) setOutputLevel(2); // Show g_info else setOutputLevel(0); // Show only g_err ? records = opt_records; loops = opt_loops; timer = opt_timer; if (opt_nologging) setLogging(false); temporaryTables = opt_temporary; m_noddl = opt_noddl; m_forceShort = opt_forceShort; if (opt_seed == 0) { opt_seed = (unsigned)NdbTick_CurrentMillisecond(); } ndbout_c("random seed: %u", opt_seed); srand(opt_seed); srandom(opt_seed); global_flag_skip_invalidate_cache = 1; int num_tables= argc; if (argc == 0) num_tables = NDBT_Tables::getNumTables(); for(int i = 0; i<num_tables; i++) { if (argc == 0) m_tables_in_test.push_back(NDBT_Tables::getTable(i)->getName()); else m_tables_in_test.push_back(_argv[i]); } if (m_createTable) { for (unsigned t = 0; t < tests.size(); t++) { const char* createFuncName= NULL; NDBT_TESTFUNC* createFunc= NULL; const char* dropFuncName= NULL; NDBT_TESTFUNC* dropFunc= NULL; if (!m_noddl) { createFuncName= m_createAll ? "runCreateTable" : "runCreateTable"; createFunc= m_createAll ? &runCreateTables : &runCreateTable; dropFuncName= m_createAll ? "runDropTables" : "runDropTable"; dropFunc= m_createAll ? &runDropTables : &runDropTable; } else { /* No DDL allowed, so we substitute 'do nothing' variants * of the create + drop table test procs */ createFuncName= "runCheckTableExists"; createFunc= &runCheckTableExists; dropFuncName= "runEmptyDropTable"; dropFunc= &runEmptyDropTable; } NDBT_TestCaseImpl1* pt= (NDBT_TestCaseImpl1*)tests[t]; NDBT_Initializer* pti = new NDBT_Initializer(pt, createFuncName, *createFunc); pt->addInitializer(pti, true); NDBT_Finalizer* ptf = new NDBT_Finalizer(pt, dropFuncName, *dropFunc); pt->addFinalizer(ptf); } for (unsigned t = 0; t < explicitTests.size(); t++) { const char* createFuncName= NULL; NDBT_TESTFUNC* createFunc= NULL; const char* dropFuncName= NULL; NDBT_TESTFUNC* dropFunc= NULL; if (!m_noddl) { createFuncName= m_createAll ? "runCreateTable" : "runCreateTable"; createFunc= m_createAll ? &runCreateTables : &runCreateTable; dropFuncName= m_createAll ? "runDropTables" : "runDropTable"; dropFunc= m_createAll ? &runDropTables : &runDropTable; } else { /* No DDL allowed, so we substitute 'do nothing' variants * of the create + drop table test procs */ createFuncName= "runCheckTableExists"; createFunc= &runCheckTableExists; dropFuncName= "runEmptyDropTable"; dropFunc= &runEmptyDropTable; } NDBT_TestCaseImpl1* pt= (NDBT_TestCaseImpl1*)explicitTests[t]; NDBT_Initializer* pti = new NDBT_Initializer(pt, createFuncName, *createFunc); pt->addInitializer(pti, true); NDBT_Finalizer* ptf = new NDBT_Finalizer(pt, dropFuncName, *dropFunc); pt->addFinalizer(ptf); } } if (opt_print == true){ printExecutionTree(); ndb_free_defaults(defaults_argv); return 0; } if (opt_print_html == true){ printExecutionTreeHTML(); ndb_free_defaults(defaults_argv); return 0; } if (opt_print_cases == true){ printCases(); ndb_free_defaults(defaults_argv); return 0; } Ndb_cluster_connection con(opt_ndb_connectstring, opt_ndb_nodeid); if(m_connect_cluster && con.connect(12, 5, 1)) { ndb_free_defaults(defaults_argv); return NDBT_ProgramExit(NDBT_FAILED); } if(argc == 0){ // No table specified res = executeAll(con, opt_testname); } else { testSuiteTimer.doStart(); for(int i = 0; i<argc; i++){ executeOne(con, _argv[i], opt_testname); } testSuiteTimer.doStop(); res = report(opt_testname); } ndb_free_defaults(defaults_argv); return NDBT_ProgramExit(res); }
int main(int argc, char** argv) { if (argc != 3) { return NDBT_ProgramExit(NDBT_WRONGARGS); } myConnectString = argv[1]; if ( strcmp(argv[2], "help") == 0 ) { ndbout << "Number of Testing Program " << " Name of Testing Program" << endl; ndbout << " 1 SQLGetDataTest()" << endl; ndbout << " 2 SQLTablesTest()" << endl; ndbout << " 3 SQLGetFunctionsTest()" << endl; ndbout << " 4 SQLGetInfoTest()" << endl; ndbout << " 5 SQLGetTypeInfoTest()" << endl; ndbout << " 6 SQLDisconnectTest()" << endl; ndbout << " 7 SQLFetchTest()" << endl; ndbout << " 8 SQLRowCountTest()" << endl; ndbout << " 9 SQLGetCursorNameTest()" << endl; ndbout << " 10 SQLCancelTest()" << endl; ndbout << " 11 SQLTransactTest()" << endl; ndbout << " 12 SQLSetCursorNameTest()" << endl; ndbout << " 13 SQLNumResultColsTest()" << endl; ndbout << " 14 SQLDescribeColTest()" << endl; ndbout << " 15 SQLExecDirectTest()" << endl; ndbout << " 16 SQLColAttributeTest3()" << endl; ndbout << " 17 SQLColAttributeTest2()" << endl; ndbout << " 18 SQLColAttributeTest1()" << endl; ndbout << " 19 SQLColAttributeTest()" << endl; ndbout << " 20 SQLBindColTest()" << endl; ndbout << " 21 SQLGetDiagRecSimpleTest()" << endl; ndbout << " 22 SQLConnectTest()" << endl; ndbout << " 23 SQLPrepareTest()" << endl; } else { ndbout << endl << "Executing Files Name = " << argv[0] << endl; ndbout << "The Number of testing program = " << argv[2] << endl; int i = atoi(argv[2]); switch (i) { case 1: if (check == NDBT_OK) check = SQLGetDataTest(); break; case 2: if (check == NDBT_OK) check = SQLTablesTest(); break; case 3: if (check == NDBT_OK) check = SQLGetFunctionsTest(); break; case 4: if (check == NDBT_OK) check = SQLGetInfoTest(); break; case 5: if (check == NDBT_OK) check = SQLGetTypeInfoTest(); break; case 6: if (check == NDBT_OK) check = SQLDisconnectTest(); break; case 7: if (check == NDBT_OK) check = SQLFetchTest(); break; case 8: if (check == NDBT_OK) check = SQLRowCountTest(); break; case 9: if (check == NDBT_OK) check = SQLGetCursorNameTest(); break; case 10: if (check == NDBT_OK) check = SQLCancelTest(); break; case 11: if (check == NDBT_OK) check = SQLTransactTest(); break; case 12: if (check == NDBT_OK) check = SQLSetCursorNameTest(); break; case 13: if (check == NDBT_OK) check = SQLNumResultColsTest(); break; case 14: if (check == NDBT_OK) check = SQLDescribeColTest(); break; case 15: if (check == NDBT_OK) check = SQLExecDirectTest(); break; case 16: if (check == NDBT_OK) check = SQLColAttributeTest3(); break; case 17: if (check == NDBT_OK) check = SQLColAttributeTest2(); break; case 18: if (check == NDBT_OK) check = SQLColAttributeTest1(); break; case 19: if (check == NDBT_OK) check = SQLColAttributeTest(); break; case 20: if (check == NDBT_OK) check = SQLBindColTest(); break; case 21: if (check == NDBT_OK) check = SQLGetDiagRecSimpleTest(); break; case 22: if (check == NDBT_OK) check = SQLConnectTest(); break; case 23: if (check == NDBT_OK) check = SQLPrepareTest(); break; } } return NDBT_ProgramExit(check); }
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, 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); }
int main(int argc, char** argv) { NDB_INIT(argv[0]); const char *load_default_groups[]= { "mysql_cluster",0 }; load_defaults("my",load_default_groups,&argc,&argv); int ho_error; #ifndef DBUG_OFF opt_debug= "d:t:F:L"; #endif if ((ho_error=handle_options(&argc, &argv, my_long_options, ndb_std_get_one_option))) return NDBT_ProgramExit(NDBT_WRONGARGS); DBUG_ENTER("main"); Ndb_cluster_connection con(opt_connect_str); if(con.connect(12, 5, 1)) { DBUG_RETURN(NDBT_ProgramExit(NDBT_FAILED)); } Ndb ndb(&con,_dbname); ndb.init(); while (ndb.waitUntilReady() != 0); NdbDictionary::Dictionary * dict = ndb.getDictionary(); int no_error= 1; int i; // create all tables Vector<const NdbDictionary::Table*> pTabs; if (argc == 0) { NDBT_Tables::dropAllTables(&ndb); NDBT_Tables::createAllTables(&ndb); for (i= 0; no_error && i < NDBT_Tables::getNumTables(); i++) { const NdbDictionary::Table *pTab= dict->getTable(NDBT_Tables::getTable(i)->getName()); if (pTab == 0) { ndbout << "Failed to create table" << endl; ndbout << dict->getNdbError() << endl; no_error= 0; break; } pTabs.push_back(pTab); } } else { for (i= 0; no_error && argc; argc--, i++) { dict->dropTable(argv[i]); NDBT_Tables::createTable(&ndb, argv[i]); const NdbDictionary::Table *pTab= dict->getTable(argv[i]); if (pTab == 0) { ndbout << "Failed to create table" << endl; ndbout << dict->getNdbError() << endl; no_error= 0; break; } pTabs.push_back(pTab); } } pTabs.push_back(NULL); // create an event for each table for (i= 0; no_error && pTabs[i]; i++) { HugoTransactions ht(*pTabs[i]); if (ht.createEvent(&ndb)){ no_error= 0; break; } } // create an event operation for each event Vector<NdbEventOperation *> pOps; for (i= 0; no_error && pTabs[i]; i++) { char buf[1024]; sprintf(buf, "%s_EVENT", pTabs[i]->getName()); NdbEventOperation *pOp= ndb.createEventOperation(buf, 1000); if ( pOp == NULL ) { no_error= 0; break; } pOps.push_back(pOp); } // get storage for each event operation for (i= 0; no_error && pTabs[i]; i++) { int n_columns= pTabs[i]->getNoOfColumns(); for (int j = 0; j < n_columns; j++) { pOps[i]->getValue(pTabs[i]->getColumn(j)->getName()); pOps[i]->getPreValue(pTabs[i]->getColumn(j)->getName()); } } // start receiving events for (i= 0; no_error && pTabs[i]; i++) { if ( pOps[i]->execute() ) { no_error= 0; break; } } // create a "shadow" table for each table Vector<const NdbDictionary::Table*> pShadowTabs; for (i= 0; no_error && pTabs[i]; i++) { char buf[1024]; sprintf(buf, "%s_SHADOW", pTabs[i]->getName()); dict->dropTable(buf); if (dict->getTable(buf)) { no_error= 0; break; } NdbDictionary::Table table_shadow(*pTabs[i]); table_shadow.setName(buf); dict->createTable(table_shadow); pShadowTabs.push_back(dict->getTable(buf)); if (!pShadowTabs[i]) { no_error= 0; break; } } // create a hugo operation per table Vector<HugoOperations *> hugo_ops; for (i= 0; no_error && pTabs[i]; i++) { hugo_ops.push_back(new HugoOperations(*pTabs[i])); } int n_records= 3; // insert n_records records per table do { if (start_transaction(&ndb, hugo_ops)) { no_error= 0; break; } for (i= 0; no_error && pTabs[i]; i++) { hugo_ops[i]->pkInsertRecord(&ndb, 0, n_records); } if (execute_commit(&ndb, hugo_ops)) { no_error= 0; break; } if(close_transaction(&ndb, hugo_ops)) { no_error= 0; break; } } while(0); // copy events and verify do { if (copy_events(&ndb) < 0) { no_error= 0; break; } if (verify_copy(&ndb, pTabs, pShadowTabs)) { no_error= 0; break; } } while (0); // update n_records-1 records in first table do { if (start_transaction(&ndb, hugo_ops)) { no_error= 0; break; } hugo_ops[0]->pkUpdateRecord(&ndb, n_records-1); if (execute_commit(&ndb, hugo_ops)) { no_error= 0; break; } if(close_transaction(&ndb, hugo_ops)) { no_error= 0; break; } } while(0); // copy events and verify do { if (copy_events(&ndb) < 0) { no_error= 0; break; } if (verify_copy(&ndb, pTabs, pShadowTabs)) { no_error= 0; break; } } while (0); { NdbRestarts restarts; for (int j= 0; j < 10; j++) { // restart a node if (no_error) { int timeout = 240; if (restarts.executeRestart("RestartRandomNodeAbort", timeout)) { no_error= 0; break; } } // update all n_records records on all tables if (start_transaction(&ndb, hugo_ops)) { no_error= 0; break; } for (int r= 0; r < n_records; r++) { for (i= 0; pTabs[i]; i++) { hugo_ops[i]->pkUpdateRecord(&ndb, r); } } if (execute_commit(&ndb, hugo_ops)) { no_error= 0; break; } if(close_transaction(&ndb, hugo_ops)) { no_error= 0; break; } // copy events and verify if (copy_events(&ndb) < 0) { no_error= 0; break; } if (verify_copy(&ndb, pTabs, pShadowTabs)) { no_error= 0; break; } } } // drop the event operations for (i= 0; i < (int)pOps.size(); i++) { if (ndb.dropEventOperation(pOps[i])) { no_error= 0; } } if (no_error) DBUG_RETURN(NDBT_ProgramExit(NDBT_OK)); DBUG_RETURN(NDBT_ProgramExit(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); }
int main(int argc, char** argv) { NDB_INIT(argv[0]); const char *load_default_groups[]= { "mysql_cluster",0 }; ndb_load_defaults(NULL,load_default_groups,&argc,&argv); int ho_error; #ifndef DBUG_OFF opt_debug= "d:t:O,/tmp/eventlog.trace"; #endif #ifndef _WIN32 // Catching signal to allow testing of EINTR safeness // with "while killall -USR1 eventlog; do true; done" signal(SIGUSR1, catch_signal); #endif if ((ho_error=handle_options(&argc, &argv, my_long_options, ndb_std_get_one_option))) return NDBT_ProgramExit(NDBT_WRONGARGS); NdbMgmHandle handle= ndb_mgm_create_handle(); ndb_mgm_set_connectstring(handle, opt_ndb_connectstring); while (true) { if (ndb_mgm_connect(handle,0,0,0) == -1) { ndbout_c("Failed to connect"); exit(0); } NdbLogEventHandle le = ndb_mgm_create_logevent_handle(handle, filter); if (le == 0) { ndbout_c("Failed to create logevent handle"); exit(0); } struct ndb_logevent event; while (true) { int r= ndb_logevent_get_next(le, &event,5000); if (r < 0) { ndbout_c("Error while getting next event"); break; } if (r == 0) { continue; } ndbout_c("Got event: %d", event.type); } ndb_mgm_destroy_logevent_handle(&le); ndb_mgm_disconnect(handle); } return 0; }
int main(int argc, const char** argv){ ndb_init(); int _records = 0; int _loops = 1; int _percentVal = 1; int _lockTime = 1000; const char* _tabname = NULL; int _help = 0; struct getargs args[] = { { "loops", 'l', arg_integer, &_loops, "number of times to run this program(0=infinite loop)", "loops" }, { "records", 'r', arg_integer, &_records, "Number of records", "recs" }, { "locktime", 't', arg_integer, &_lockTime, "Time in ms to hold lock(default=1000)", "ms" }, { "percent", 'p', arg_integer, &_percentVal, "Percent of records to lock(default=1%)", "%" }, { "usage", '?', arg_flag, &_help, "Print help", "" } }; int num_args = sizeof(args) / sizeof(args[0]); int optind = 0; char desc[] = "tabname\n"\ "This program will lock p% of the records in the table for x milliseconds\n"\ "then it will lock the next 1% and continue to do so until it has locked \n"\ "all records in the table\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, "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 << i << ": "; if (hugoTrans.lockRecords(&MyNdb, _records, _percentVal, _lockTime) != 0){ return NDBT_ProgramExit(NDBT_FAILED); } i++; } return NDBT_ProgramExit(NDBT_OK); }
int main(int argc, char** argv){ NDB_INIT(argv[0]); ndb_opt_set_usage_funcs(short_usage_sub, usage); load_defaults("my",load_default_groups,&argc,&argv); #ifndef DBUG_OFF opt_debug= "d:t:O,/tmp/ndb_waiter.trace"; #endif #ifndef _WIN32 // Catching signal to allow testing of EINTR safeness // with "while killall -USR1 ndbwaiter; do true; done" signal(SIGUSR1, catch_signal); #endif if (handle_options(&argc, &argv, my_long_options, ndb_std_get_one_option)) return NDBT_ProgramExit(NDBT_WRONGARGS); const char* connect_string = argv[0]; if (connect_string == 0) connect_string = opt_ndb_connectstring; enum ndb_mgm_node_status wait_status; if (_no_contact) { wait_status= NDB_MGM_NODE_STATUS_NO_CONTACT; } else if (_not_started) { wait_status= NDB_MGM_NODE_STATUS_NOT_STARTED; } else if (_single_user) { wait_status= NDB_MGM_NODE_STATUS_SINGLEUSER; } else { wait_status= NDB_MGM_NODE_STATUS_STARTED; } if (_nowait_nodes) { int res = parse_mask(_nowait_nodes, nowait_nodes_bitmask); if(res == -2 || (res > 0 && nowait_nodes_bitmask.get(0))) { ndbout_c("Invalid nodeid specified in nowait-nodes: %s", _nowait_nodes); exit(-1); } else if (res < 0) { ndbout_c("Unable to parse nowait-nodes argument: %s", _nowait_nodes); exit(-1); } } if (_wait_nodes) { if (_nowait_nodes) { ndbout_c("Can not set both wait-nodes and nowait-nodes."); exit(-1); } int res = parse_mask(_wait_nodes, nowait_nodes_bitmask); if (res == -2 || (res > 0 && nowait_nodes_bitmask.get(0))) { ndbout_c("Invalid nodeid specified in wait-nodes: %s", _wait_nodes); exit(-1); } else if (res < 0) { ndbout_c("Unable to parse wait-nodes argument: %s", _wait_nodes); exit(-1); } // Don't wait for any other nodes than the ones we have set explicitly nowait_nodes_bitmask.bitNOT(); } if (waitClusterStatus(connect_string, wait_status) != 0) return NDBT_ProgramExit(NDBT_FAILED); return NDBT_ProgramExit(NDBT_OK); }
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; 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)", "" }, { "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); } 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; int res = NDBT_FAILED; while (i<_loops || _loops==0) { ndbout << i << ": "; if (_ver2 == 0){ res = hugoTrans.scanUpdateRecords(&MyNdb, _records, 0, _parallelism); } else{ res = hugoTrans.scanUpdateRecords2(&MyNdb, _records, 0, _parallelism); } if (res != NDBT_OK ){ return NDBT_ProgramExit(NDBT_FAILED); } i++; //NdbSleep_MilliSleep(300); } return NDBT_ProgramExit(NDBT_OK); }
int NDBT_TestSuite::execute(int argc, const char** argv){ int res = NDBT_FAILED; /* Arguments: Run only a subset of tests -n testname Which test to run Recommendations to test functions: --records Number of records to use(default: 10000) --loops Number of loops to execute in the test(default: 100) Other parameters should: * be calculated from the above two parameters * be divided into different test cases, ex. one testcase runs with FragmentType = Single and another perfoms the same test with FragmentType = Large * let the test case iterate over all/subset of appropriate parameters ex. iterate over FragmentType = Single to FragmentType = AllLarge Remeber that the intention is that it should be _easy_ to run a complete test suite without any greater knowledge of what should be tested ie. keep arguments at a minimum */ char **_argv= (char **)argv; if (!my_progname) my_progname= _argv[0]; const char *load_default_groups[]= { "mysql_cluster",0 }; load_defaults("my",load_default_groups,&argc,&_argv); int ho_error; #ifndef DBUG_OFF opt_debug= "d:t:i:F:L"; #endif if ((ho_error=handle_options(&argc, &_argv, my_long_options, ndb_std_get_one_option))) { usage(); return NDBT_ProgramExit(NDBT_WRONGARGS); } if (opt_print == true){ printExecutionTree(); return 0; } if (opt_print_html == true){ printExecutionTreeHTML(); return 0; } if (opt_print_cases == true){ printCases(); return 0; } if (opt_verbose) setOutputLevel(2); // Show g_info else setOutputLevel(0); // Show only g_err ? remote_mgm = opt_remote_mgm; records = opt_records; loops = opt_loops; timer = opt_timer; Ndb_cluster_connection con; if(con.connect(12, 5, 1)) { return NDBT_ProgramExit(NDBT_FAILED); } if (opt_seed == 0) { opt_seed = NdbTick_CurrentMillisecond(); } ndbout_c("random seed: %u", opt_seed); srand(opt_seed); srandom(opt_seed); global_flag_skip_invalidate_cache = 1; { Ndb ndb(&con, "TEST_DB"); ndb.init(1024); if (ndb.waitUntilReady(500)){ g_err << "Ndb was not ready" << endl; return NDBT_ProgramExit(NDBT_FAILED); } NdbDictionary::Dictionary* pDict = ndb.getDictionary(); int num_tables= argc; if (argc == 0) num_tables = NDBT_Tables::getNumTables(); for(int i = 0; i<num_tables; i++) { if (argc == 0) m_tables_in_test.push_back(NDBT_Tables::getTable(i)->getName()); else m_tables_in_test.push_back(_argv[i]); if (createAllTables == true) { const char *tab_name= m_tables_in_test[i].c_str(); const NdbDictionary::Table* pTab = pDict->getTable(tab_name); if (pTab && pDict->dropTable(tab_name) != 0) { g_err << "ERROR0: Failed to drop table " << tab_name << pDict->getNdbError() << endl; return NDBT_ProgramExit(NDBT_FAILED); } if(NDBT_Tables::createTable(&ndb, tab_name) != 0) { g_err << "ERROR1: Failed to create table " << tab_name << pDict->getNdbError() << endl; return NDBT_ProgramExit(NDBT_FAILED); } } } } if(argc == 0){ // No table specified res = executeAll(con, opt_testname); } else { testSuiteTimer.doStart(); for(int i = 0; i<argc; i++){ executeOne(con, _argv[i], opt_testname); } testSuiteTimer.doStop(); res = report(opt_testname); } if (res == NDBT_OK && createAllTables == true) { Ndb ndb(&con, "TEST_DB"); ndb.init(1024); if (ndb.waitUntilReady(500)){ g_err << "Ndb was not ready" << endl; return NDBT_ProgramExit(NDBT_FAILED); } NdbDictionary::Dictionary* pDict = ndb.getDictionary(); for(unsigned i = 0; i<m_tables_in_test.size(); i++) { pDict->dropTable(m_tables_in_test[i].c_str()); } } return NDBT_ProgramExit(res); }
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); }
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){ NDB_INIT(argv[0]); const char *load_default_groups[]= { "mysql_cluster",0 }; load_defaults("my",load_default_groups,&argc,&argv); int ho_error; #ifndef DBUG_OFF opt_debug= "d:t:O,/tmp/ndb_desc.trace"; #endif if ((ho_error=handle_options(&argc, &argv, my_long_options, ndb_std_get_one_option))) return NDBT_ProgramExit(NDBT_WRONGARGS); for (int i = 0; i<_loop; i++) { Ndb_cluster_connection con(opt_connect_str); if(con.connect(12, 5, 1) != 0) { ndbout << "Unable to connect to management server." << endl; return NDBT_ProgramExit(NDBT_FAILED); } if (con.wait_until_ready(30,30) != 0) { ndbout << "Cluster nodes not ready in 30 seconds." << endl; return NDBT_ProgramExit(NDBT_FAILED); } Ndb MyNdb(&con, "TEST_DB"); if(MyNdb.init() != 0){ ERR(MyNdb.getNdbError()); return NDBT_ProgramExit(NDBT_FAILED); } Vector<NdbEventOperation*> ops; const NdbDictionary::Dictionary * dict= MyNdb.getDictionary(); for (int j = 0; j < argc; j++) { const NdbDictionary::Table * pTab = dict->getTable(argv[j]); if (pTab == 0) { ndbout_c("Failed to retreive table: \"%s\"", argv[j]); } BaseString tmp; tmp.appfmt("EV-%s", argv[j]); NdbEventOperation* pOp = MyNdb.createEventOperation(tmp.c_str()); if ( pOp == NULL ) { ndbout << "Event operation creation failed: " << MyNdb.getNdbError() << endl; return NDBT_ProgramExit(NDBT_FAILED); } for (int a = 0; a < pTab->getNoOfColumns(); a++) { pOp->getValue(pTab->getColumn(a)->getName()); pOp->getPreValue(pTab->getColumn(a)->getName()); } if (pOp->execute()) { ndbout << "operation execution failed: " << pOp->getNdbError() << endl; return NDBT_ProgramExit(NDBT_FAILED); } ops.push_back(pOp); } if (_sleep) { NdbSleep_MilliSleep(10 + rand() % _sleep); } for (Uint32 i = 0; i<ops.size(); i++) { switch(_drop){ case 0: break; do_drop: case 1: if (MyNdb.dropEventOperation(ops[i])) { ndbout << "drop event operation failed " << MyNdb.getNdbError() << endl; return NDBT_ProgramExit(NDBT_FAILED); } break; default: if ((rand() % 100) > 50) goto do_drop; } } } return NDBT_ProgramExit(NDBT_OK); }
int main(int argc, const char** argv) { ndb_init(); int _row = 0; int _hex = 0; int _primaryKey = 0; const char* _tableName = NULL; struct getargs args[] = { { "row", 'r', arg_integer, &_row, "The row number", "row" }, { "primarykey", 'p', arg_integer, &_primaryKey, "The primary key", "primarykey" }, { "hex", 'h', arg_flag, &_hex, "Print hex", "hex" } }; int num_args = sizeof(args) / sizeof(args[0]); int optind = 0, i; if(getarg(args, num_args, argc, argv, &optind) || argv[optind] == NULL) { arg_printusage(args, num_args, argv[0], "table name\n"); return NDBT_WRONGARGS; } // Check if table name is supplied if (argv[optind] != NULL) _tableName = argv[optind]; const NdbDictionary::Table* table = NDBT_Tables::getTable(_tableName); // const NDBT_Attribute* attribute = table->getAttribute(_column); g_info << "Table " << _tableName << endl << "Row: " << _row << ", PrimaryKey: " << _primaryKey << endl; Ndb_cluster_connection con; if(con.connect(12, 5, 1) != 0) { return NDBT_ProgramExit(NDBT_FAILED); } Ndb* ndb = new Ndb(&con, "TEST_DB"); if (ndb->init() == 0 && ndb->waitUntilReady(30) == 0) { NdbConnection* conn = ndb->startTransaction(); if (conn == NULL) { g_info << "ERROR: " << ndb->getNdbError() << endl; delete ndb; return -1; } NdbOperation* op = conn->getNdbOperation(_tableName); if (op == NULL) { g_info << "ERROR: " << conn->getNdbError() << endl; delete ndb; return -1; } op->readTuple(); NdbRecAttr** data = new NdbRecAttr*[table->getNoOfColumns()]; for (i = 0; i < table->getNoOfColumns(); i++) { const NdbDictionary::Column* c = table->getColumn(i); if (c->getPrimaryKey()) { op->equal(c->getName(), _primaryKey); data[i] = op->getValue(c->getName(), NULL); } else { data[i] = op->getValue(c->getName(), NULL); } } if (conn->execute(Commit) == 0) { // Print column names for (i = 0; i < table->getNoOfColumns(); i++) { const NdbDictionary::Column* c = table->getColumn(i); g_info << c->getName() << "[" << c->getType() << "] "; } g_info << endl; if (_hex) { g_info << hex; } for (i = 0; i < table->getNoOfColumns(); i++) { NdbRecAttr* a = data[i]; ndbout << (* a) << " "; } // for g_info << endl; } // if (conn else { g_info << "Failed to commit read transaction... " << conn->getNdbError() << ", commitStatus = " << conn->commitStatus() << endl; } delete[] data; ndb->closeTransaction(conn); } // if (ndb.init else { g_info << "ERROR: Unable to connect to NDB, " << ndb->getNdbError() << endl; } delete ndb; return 0; }
extern "C" void* NdbThreadFuncRead(void* pArg) { myRandom48Init((long int)NdbTick_CurrentMillisecond()); unsigned nSucc = 0; unsigned nFail = 0; NdbRecAttr** ppNdbRecAttrDSum = new NdbRecAttr*[g_nDistrictPerWarehouse]; NdbRecAttr** ppNdbRecAttrDCnt = new NdbRecAttr*[g_nDistrictPerWarehouse]; Ndb* pNdb = NULL ; pNdb = new Ndb("TEST_DB"); VerifyMethodInt(pNdb, init()); VerifyMethodInt(pNdb, waitUntilReady()); while(NdbMutex_Trylock(g_pNdbMutex)) { Uint32 nWarehouse = myRandom48(g_nWarehouseCount); NdbConnection* pNdbConnection = NULL ; VerifyMethodPtr(pNdbConnection, pNdb, startTransaction()); CHK_TR(pNdbConnection) ; // epaulsa NdbOperation* pNdbOperationW = NULL ; VerifyMethodPtr(pNdbOperationW, pNdbConnection, getNdbOperation(c_szWarehouse)); VerifyMethodInt(pNdbOperationW, readTuple()); VerifyMethodInt(pNdbOperationW, equal(c_szWarehouseNumber, nWarehouse)); NdbRecAttr* pNdbRecAttrWSum; VerifyMethodPtr(pNdbRecAttrWSum, pNdbOperationW, getValue(c_szWarehouseSum, 0)); NdbRecAttr* pNdbRecAttrWCnt; VerifyMethodPtr(pNdbRecAttrWCnt, pNdbOperationW, getValue(c_szWarehouseCount, 0)); for(Uint32 nDistrict=0; nDistrict<g_nDistrictPerWarehouse; ++nDistrict) { NdbOperation* pNdbOperationD = NULL ; VerifyMethodPtr(pNdbOperationD, pNdbConnection, getNdbOperation(c_szDistrict)); VerifyMethodInt(pNdbOperationD, readTuple()); VerifyMethodInt(pNdbOperationD, equal(c_szDistrictWarehouseNumber, nWarehouse)); VerifyMethodInt(pNdbOperationD, equal(c_szDistrictNumber, nDistrict)); VerifyMethodPtr(ppNdbRecAttrDSum[nDistrict], pNdbOperationD, getValue(c_szDistrictSum, 0)); VerifyMethodPtr(ppNdbRecAttrDCnt[nDistrict], pNdbOperationD, getValue(c_szDistrictCount, 0)); } int iExec = pNdbConnection->execute(Commit); int iError = pNdbConnection->getNdbError().code; if(iExec<0 && iError!=0 && iError!=266 && iError!=626) { ReportMethodInt(iExec, pNdbConnection, "pNdbConnection", "execute(Commit)", __FILE__, __LINE__); } if(iExec==0) { Uint32 nSum = 0; Uint32 nCnt = 0; for(Uint32 nDistrict=0; nDistrict<g_nDistrictPerWarehouse; ++nDistrict) { nSum += ppNdbRecAttrDSum[nDistrict]->u_32_value(); nCnt += ppNdbRecAttrDCnt[nDistrict]->u_32_value(); } if(nSum!=pNdbRecAttrWSum->u_32_value() || nCnt!=g_nDistrictPerWarehouse*pNdbRecAttrWCnt->u_32_value()) { ndbout << "INCONSISTENT!" << endl; ndbout << "iExec==" << iExec << endl; ndbout << "iError==" << iError << endl; ndbout << endl; ndbout << c_szWarehouseSum << "==" << pNdbRecAttrWSum->u_32_value() << ", "; ndbout << c_szWarehouseCount << "==" << pNdbRecAttrWCnt->u_32_value() << endl; ndbout << "nSum==" << nSum << ", nCnt=" << nCnt << endl; for(Uint32 nDistrict=0; nDistrict<g_nDistrictPerWarehouse; ++nDistrict) { ndbout << c_szDistrictSum << "[" << nDistrict << "]==" << ppNdbRecAttrDSum[nDistrict]->u_32_value() << ", "; ndbout << c_szDistrictCount << "[" << nDistrict << "]==" << ppNdbRecAttrDCnt[nDistrict]->u_32_value() << endl; } VerifyMethodVoid(pNdb, closeTransaction(pNdbConnection)); delete pNdb; pNdb = NULL ; delete[] ppNdbRecAttrDSum; ppNdbRecAttrDSum = NULL ; delete[] ppNdbRecAttrDCnt; ppNdbRecAttrDCnt = NULL ; NDBT_ProgramExit(NDBT_FAILED); } ++nSucc; } else { ++nFail; } VerifyMethodVoid(pNdb, closeTransaction(pNdbConnection)); } ndbout << "read: " << nSucc << " succeeded, " << nFail << " failed " << endl; NdbMutex_Unlock(g_pNdbMutex); delete pNdb; pNdb = NULL ; delete[] ppNdbRecAttrDSum; ppNdbRecAttrDSum = NULL ; delete[] ppNdbRecAttrDCnt; ppNdbRecAttrDCnt = NULL ; return NULL; }