开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
testOIBasic.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：77k
源码类别：

MySQL数据库

开发平台：

Visual C++

testOIBasic.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /*
  18.  * testOIBasic - ordered index test
  19.  */
  21. #include <ndb_global.h>
  23. #include <NdbMain.h>
  24. #include <NdbOut.hpp>
  25. #include <NdbApi.hpp>
  26. #include <NdbTest.hpp>
  27. #include <NdbMutex.h>
  28. #include <NdbCondition.h>
  29. #include <NdbThread.h>
  30. #include <NdbTick.h>
  31. #include <my_sys.h>
  33. // options
  35. struct Opt {
  36.   // common options
  37.   unsigned m_batch;
  38.   const char* m_bound;
  39.   const char* m_case;
  40.   bool m_core;
  41.   const char* m_csname;
  42.   CHARSET_INFO* m_cs;
  43.   int m_die;
  44.   bool m_dups;
  45.   NdbDictionary::Object::FragmentType m_fragtype;
  46.   unsigned m_subsubloop;
  47.   const char* m_index;
  48.   unsigned m_loop;
  49.   bool m_msglock;
  50.   bool m_nologging;
  51.   bool m_noverify;
  52.   unsigned m_pctnull;
  53.   unsigned m_rows;
  54.   unsigned m_samples;
  55.   unsigned m_scanbat;
  56.   unsigned m_scanpar;
  57.   unsigned m_scanstop;
  58.   unsigned m_seed;
  59.   unsigned m_subloop;
  60.   const char* m_table;
  61.   unsigned m_threads;
  62.   int m_v;
  63.   Opt() :
  64.     m_batch(32),
  65.     m_bound("01234"),
  66.     m_case(0),
  67.     m_core(false),
  68.     m_csname("latin1_bin"),
  69.     m_cs(0),
  70.     m_die(0),
  71.     m_dups(false),
  72.     m_fragtype(NdbDictionary::Object::FragUndefined),
  73.     m_subsubloop(4),
  74.     m_index(0),
  75.     m_loop(1),
  76.     m_msglock(true),
  77.     m_nologging(false),
  78.     m_noverify(false),
  79.     m_pctnull(10),
  80.     m_rows(1000),
  81.     m_samples(0),
  82.     m_scanbat(0),
  83.     m_scanpar(0),
  84.     m_scanstop(0),
  85.     m_seed(0),
  86.     m_subloop(4),
  87.     m_table(0),
  88.     m_threads(10),
  89.     m_v(1) {
  90.   }
  91. };
  93. static Opt g_opt;
  95. static void printcases();
  96. static void printtables();
  98. static void
  99. printhelp()
  100. {
  101.   Opt d;
  102.   ndbout
  103.     << "usage: testOIbasic [options]" << endl
  104.     << "  -batch N      pk operations in batch [" << d.m_batch << "]" << endl
  105.     << "  -bound xyz    use only these bound types 0-4 [" << d.m_bound << "]" << endl
  106.     << "  -case abc     only given test cases (letters a-z)" << endl
  107.     << "  -core         core dump on error [" << d.m_core << "]" << endl
  108.     << "  -csname S     charset (collation) of non-pk char column [" << d.m_csname << "]" << endl
  109.     << "  -die nnn      exit immediately on NDB error code nnn" << endl
  110.     << "  -dups         allow duplicate tuples from index scan [" << d.m_dups << "]" << endl
  111.     << "  -fragtype T   fragment type single/small/medium/large" << endl
  112.     << "  -index xyz    only given index numbers (digits 1-9)" << endl
  113.     << "  -loop N       loop count full suite 0=forever [" << d.m_loop << "]" << endl
  114.     << "  -nologging    create tables in no-logging mode" << endl
  115.     << "  -noverify     skip index verifications" << endl
  116.     << "  -pctnull N    pct NULL values in nullable column [" << d.m_pctnull << "]" << endl
  117.     << "  -rows N       rows per thread [" << d.m_rows << "]" << endl
  118.     << "  -samples N    samples for some timings (0=all) [" << d.m_samples << "]" << endl
  119.     << "  -scanbat N    scan batch per fragment (ignored by ndb api) [" << d.m_scanbat << "]" << endl
  120.     << "  -scanpar N    scan parallelism [" << d.m_scanpar << "]" << endl
  121.     << "  -seed N       srandom seed 0=loop number[" << d.m_seed << "]" << endl
  122.     << "  -subloop N    subtest loop count [" << d.m_subloop << "]" << endl
  123.     << "  -table xyz    only given table numbers (digits 1-9)" << endl
  124.     << "  -threads N    number of threads [" << d.m_threads << "]" << endl
  125.     << "  -vN           verbosity [" << d.m_v << "]" << endl
  126.     << "  -h or -help   print this help text" << endl
  127.     ;
  128.   printcases();
  129.   printtables();
  130. }
  132. // not yet configurable
  133. static const bool g_store_null_key = true;
  135. // compare NULL like normal value (NULL < not NULL, NULL == NULL)
  136. static const bool g_compare_null = true;
  138. // log and error macros
  140. static NdbMutex *ndbout_mutex= NULL;
  142. static unsigned getthrno();
  144. static const char*
  145. getthrstr()
  146. {
  147.   static char buf[20];
  148.   unsigned n = getthrno();
  149.   if (n == (unsigned)-1)
  150.     strcpy(buf, "");
  151.   else {
  152.     unsigned m =
  153.       g_opt.m_threads < 10 ? 1 :
  154.       g_opt.m_threads < 100 ? 2 : 3;
  155.     sprintf(buf, "[%0*u] ", m, n);
  156.   }
  157.   return buf;
  158. }
  160. #define LLN(n, s) 
  161.   do { 
  162.     if ((n) > g_opt.m_v) break; 
  163.     if (g_opt.m_msglock) NdbMutex_Lock(ndbout_mutex); 
  164.     ndbout << getthrstr() << s << endl; 
  165.     if (g_opt.m_msglock) NdbMutex_Unlock(ndbout_mutex); 
  166.   } while(0)
  168. #define LL0(s) LLN(0, s)
  169. #define LL1(s) LLN(1, s)
  170. #define LL2(s) LLN(2, s)
  171. #define LL3(s) LLN(3, s)
  172. #define LL4(s) LLN(4, s)
  173. #define LL5(s) LLN(5, s)
  175. // following check a condition and return -1 on failure
  177. #undef CHK      // simple check
  178. #undef CHKTRY   // check with action on fail
  179. #undef CHKCON   // print NDB API errors on failure
  181. #define CHK(x)  CHKTRY(x, ;)
  183. #define CHKTRY(x, act) 
  184.   do { 
  185.     if (x) break; 
  186.     LL0("line " << __LINE__ << ": " << #x << " failed"); 
  187.     if (g_opt.m_core) abort(); 
  188.     act; 
  189.     return -1; 
  190.   } while (0)
  192. #define CHKCON(x, con) 
  193.   do { 
  194.     if (x) break; 
  195.     LL0("line " << __LINE__ << ": " << #x << " failed"); 
  196.     (con).printerror(ndbout); 
  197.     if (g_opt.m_core) abort(); 
  198.     return -1; 
  199.   } while (0)
  201. // method parameters base class
  203. class Thr;
  204. class Con;
  205. class Tab;
  206. class Set;
  207. class Tmr;
  209. struct Par : public Opt {
  210.   unsigned m_no;
  211.   Con* m_con;
  212.   Con& con() const { assert(m_con != 0); return *m_con; }
  213.   const Tab* m_tab;
  214.   const Tab& tab() const { assert(m_tab != 0); return *m_tab; }
  215.   Set* m_set;
  216.   Set& set() const { assert(m_set != 0); return *m_set; }
  217.   Tmr* m_tmr;
  218.   Tmr& tmr() const { assert(m_tmr != 0); return *m_tmr; }
  219.   unsigned m_lno;
  220.   unsigned m_slno;
  221.   unsigned m_totrows;
  222.   // value calculation
  223.   unsigned m_range;
  224.   unsigned m_pctrange;
  225.   // choice of key
  226.   bool m_randomkey;
  227.   // do verify after read
  228.   bool m_verify;
  229.   // deadlock possible
  230.   bool m_deadlock;
  231.   // abort percentabge
  232.   unsigned m_abortpct;
  233.   // timer location
  234.   Par(const Opt& opt) :
  235.     Opt(opt),
  236.     m_no(0),
  237.     m_con(0),
  238.     m_tab(0),
  239.     m_set(0),
  240.     m_tmr(0),
  241.     m_lno(0),
  242.     m_slno(0),
  243.     m_totrows(m_threads * m_rows),
  244.     m_range(m_rows),
  245.     m_pctrange(0),
  246.     m_randomkey(false),
  247.     m_verify(false),
  248.     m_deadlock(false),
  249.     m_abortpct(0) {
  250.   }
  251. };
  253. static bool
  254. usetable(unsigned i)
  255. {
  256.   return g_opt.m_table == 0 || strchr(g_opt.m_table, '1' + i) != 0;
  257. }
  259. static bool
  260. useindex(unsigned i)
  261. {
  262.   return g_opt.m_index == 0 || strchr(g_opt.m_index, '1' + i) != 0;
  263. }
  265. static unsigned
  266. thrrow(Par par, unsigned j)
  267. {
  268.   return par.m_threads * j + par.m_no;
  269. }
  271. static bool
  272. isthrrow(Par par, unsigned i)
  273. {
  274.   return i % par.m_threads == par.m_no;
  275. }
  277. // timer
  279. struct Tmr {
  280.   void clr();
  281.   void on();
  282.   void off(unsigned cnt = 0);
  283.   const char* time();
  284.   const char* pct(const Tmr& t1);
  285.   const char* over(const Tmr& t1);
  286.   NDB_TICKS m_on;
  287.   unsigned m_ms;
  288.   unsigned m_cnt;
  289.   char m_time[100];
  290.   char m_text[100];
  291.   Tmr() { clr(); }
  292. };
  294. void
  295. Tmr::clr()
  296. {
  297.   m_on = m_ms = m_cnt = m_time[0] = m_text[0] = 0;
  298. }
  300. void
  301. Tmr::on()
  302. {
  303.   assert(m_on == 0);
  304.   m_on = NdbTick_CurrentMillisecond();
  305. }
  307. void
  308. Tmr::off(unsigned cnt)
  309. {
  310.   NDB_TICKS off = NdbTick_CurrentMillisecond();
  311.   assert(m_on != 0 && off >= m_on);
  312.   m_ms += off - m_on;
  313.   m_cnt += cnt;
  314.   m_on = 0;
  315. }
  317. const char*
  318. Tmr::time()
  319. {
  320.   if (m_cnt == 0) {
  321.     sprintf(m_time, "%u ms", m_ms);
  322.   } else {
  323.     sprintf(m_time, "%u ms per %u ( %u ms per 1000 )", m_ms, m_cnt, (1000 * m_ms) / m_cnt);
  324.   }
  325.   return m_time;
  326. }
  328. const char*
  329. Tmr::pct(const Tmr& t1)
  330. {
  331.   if (0 < t1.m_ms) {
  332.     sprintf(m_text, "%u pct", (100 * m_ms) / t1.m_ms);
  333.   } else {
  334.     sprintf(m_text, "[cannot measure]");
  335.   }
  336.   return m_text;
  337. }
  339. const char*
  340. Tmr::over(const Tmr& t1)
  341. {
  342.   if (0 < t1.m_ms) {
  343.     if (t1.m_ms <= m_ms)
  344.       sprintf(m_text, "%u pct", (100 * (m_ms - t1.m_ms)) / t1.m_ms);
  345.     else
  346.       sprintf(m_text, "-%u pct", (100 * (t1.m_ms - m_ms)) / t1.m_ms);
  347.   } else {
  348.     sprintf(m_text, "[cannot measure]");
  349.   }
  350.   return m_text;
  351. }
  353. // list of ints
  355. struct Lst {
  356.   Lst();
  357.   unsigned m_arr[1000];
  358.   unsigned m_cnt;
  359.   void push(unsigned i);
  360.   unsigned cnt() const;
  361.   void reset();
  362. };
  364. Lst::Lst() :
  365.   m_cnt(0)
  366. {
  367. }
  369. void
  370. Lst::push(unsigned i)
  371. {
  372.   assert(m_cnt < sizeof(m_arr)/sizeof(m_arr[0]));
  373.   m_arr[m_cnt++] = i;
  374. }
  376. unsigned
  377. Lst::cnt() const
  378. {
  379.   return m_cnt;
  380. }
  382. void
  383. Lst::reset()
  384. {
  385.   m_cnt = 0;
  386. }
  388. // tables and indexes
  390. // Col - table column
  392. struct Col {
  393.   unsigned m_num;
  394.   const char* m_name;
  395.   bool m_pk;
  396.   NdbDictionary::Column::Type m_type;
  397.   unsigned m_length;
  398.   bool m_nullable;
  399.   void verify(const void* addr) const;
  400. };
  402. void
  403. Col::verify(const void* addr) const
  404. {
  405.   switch (m_type) {
  406.   case NdbDictionary::Column::Unsigned:
  407.     break;
  408.   case NdbDictionary::Column::Varchar:
  409.     {
  410.       const unsigned char* p = (const unsigned char*)addr;
  411.       unsigned n = (p[0] << 8) | p[1];
  412.       assert(n <= m_length);
  413.       unsigned i;
  414.       for (i = 0; i < n; i++) {
  415.         assert(p[2 + i] != 0);
  416.       }
  417.       for (i = n; i < m_length; i++) {
  418.         assert(p[2 + i] == 0);
  419.       }
  420.     }
  421.     break;
  422.   default:
  423.     assert(false);
  424.     break;
  425.   }
  426. }
  428. static NdbOut&
  429. operator<<(NdbOut& out, const Col& col)
  430. {
  431.   out << "col " << col.m_num;
  432.   out << " " << col.m_name;
  433.   switch (col.m_type) {
  434.   case NdbDictionary::Column::Unsigned:
  435.     out << " unsigned";
  436.     break;
  437.   case NdbDictionary::Column::Varchar:
  438.     out << " varchar(" << col.m_length << ")";
  439.     break;
  440.   default:
  441.     out << "type" << (int)col.m_type;
  442.     assert(false);
  443.     break;
  444.   }
  445.   out << (col.m_pk ? " pk" : "");
  446.   out << (col.m_nullable ? " nullable" : "");
  447.   return out;
  448. }
  450. // ICol - index column
  452. struct ICol {
  453.   unsigned m_num;
  454.   struct Col m_col;
  455. };
  457. // ITab - index
  459. struct ITab {
  460.   const char* m_name;
  461.   unsigned m_icols;
  462.   const ICol* m_icol;
  463. };
  465. static NdbOut&
  466. operator<<(NdbOut& out, const ITab& itab)
  467. {
  468.   out << "itab " << itab.m_name << " " << itab.m_icols;
  469.   for (unsigned k = 0; k < itab.m_icols; k++) {
  470.     out << endl;
  471.     out << "icol " << k << " " << itab.m_icol[k].m_col;
  472.   }
  473.   return out;
  474. }
  476. // Tab - table
  478. struct Tab {
  479.   const char* m_name;
  480.   unsigned m_cols;
  481.   const Col* m_col;
  482.   unsigned m_itabs;
  483.   const ITab* m_itab;
  484. };
  486. static NdbOut&
  487. operator<<(NdbOut& out, const Tab& tab)
  488. {
  489.   out << "tab " << tab.m_name << " " << tab.m_cols;
  490.   for (unsigned k = 0; k < tab.m_cols; k++) {
  491.     out << endl;
  492.     out << tab.m_col[k];
  493.   }
  494.   for (unsigned i = 0; i < tab.m_itabs; i++) {
  495.     if (! useindex(i))
  496.       continue;
  497.     out << endl;
  498.     out << tab.m_itab[i];
  499.   }
  500.   return out;
  501. }
  503. // tt1 + tt1x1 tt1x2 tt1x3 tt1x4 tt1x5
  505. static const Col
  506. tt1col[] = {
  507.   { 0, "A", 1, NdbDictionary::Column::Unsigned, 1, 0 },
  508.   { 1, "B", 0, NdbDictionary::Column::Unsigned, 1, 1 },
  509.   { 2, "C", 0, NdbDictionary::Column::Unsigned, 1, 1 },
  510.   { 3, "D", 0, NdbDictionary::Column::Unsigned, 1, 1 },
  511.   { 4, "E", 0, NdbDictionary::Column::Unsigned, 1, 1 }
  512. };
  514. static const ICol
  515. tt1x1col[] = {
  516.   { 0, tt1col[0] }
  517. };
  519. static const ICol
  520. tt1x2col[] = {
  521.   { 0, tt1col[1] }
  522. };
  524. static const ICol
  525. tt1x3col[] = {
  526.   { 0, tt1col[1] },
  527.   { 1, tt1col[2] }
  528. };
  530. static const ICol
  531. tt1x4col[] = {
  532.   { 0, tt1col[3] },
  533.   { 1, tt1col[2] },
  534.   { 2, tt1col[1] }
  535. };
  537. static const ICol
  538. tt1x5col[] = {
  539.   { 0, tt1col[1] },
  540.   { 1, tt1col[4] },
  541.   { 2, tt1col[2] },
  542.   { 3, tt1col[3] }
  543. };
  545. static const ITab
  546. tt1x1 = {
  547.   "TT1X1", 1, tt1x1col
  548. };
  550. static const ITab
  551. tt1x2 = {
  552.   "TT1X2", 1, tt1x2col
  553. };
  555. static const ITab
  556. tt1x3 = {
  557.   "TT1X3", 2, tt1x3col
  558. };
  560. static const ITab
  561. tt1x4 = {
  562.   "TT1X4", 3, tt1x4col
  563. };
  565. static const ITab
  566. tt1x5 = {
  567.   "TT1X5", 4, tt1x5col
  568. };
  570. static const ITab
  571. tt1itab[] = {
  572.   tt1x1,
  573.   tt1x2,
  574.   tt1x3,
  575.   tt1x4,
  576.   tt1x5
  577. };
  579. static const Tab
  580. tt1 = {
  581.   "TT1", 5, tt1col, 5, tt1itab
  582. };
  584. // tt2 + tt2x1 tt2x2 tt2x3 tt2x4 tt2x5
  586. static const Col
  587. tt2col[] = {
  588.   { 0, "A", 1, NdbDictionary::Column::Unsigned, 1, 0 },
  589.   { 1, "B", 0, NdbDictionary::Column::Unsigned, 1, 1 },
  590.   { 2, "C", 0, NdbDictionary::Column::Varchar, 20, 1 },
  591.   { 3, "D", 0, NdbDictionary::Column::Varchar, 5, 1 },
  592.   { 4, "E", 0, NdbDictionary::Column::Varchar, 5, 1 }
  593. };
  595. static const ICol
  596. tt2x1col[] = {
  597.   { 0, tt2col[0] }
  598. };
  600. static const ICol
  601. tt2x2col[] = {
  602.   { 0, tt2col[1] },
  603.   { 1, tt2col[2] }
  604. };
  606. static const ICol
  607. tt2x3col[] = {
  608.   { 0, tt2col[2] },
  609.   { 1, tt2col[1] }
  610. };
  612. static const ICol
  613. tt2x4col[] = {
  614.   { 0, tt2col[3] },
  615.   { 1, tt2col[4] }
  616. };
  618. static const ICol
  619. tt2x5col[] = {
  620.   { 0, tt2col[4] },
  621.   { 1, tt2col[3] },
  622.   { 2, tt2col[2] },
  623.   { 3, tt2col[1] }
  624. };
  626. static const ITab
  627. tt2x1 = {
  628.   "TT2X1", 1, tt2x1col
  629. };
  631. static const ITab
  632. tt2x2 = {
  633.   "TT2X2", 2, tt2x2col
  634. };
  636. static const ITab
  637. tt2x3 = {
  638.   "TT2X3", 2, tt2x3col
  639. };
  641. static const ITab
  642. tt2x4 = {
  643.   "TT2X4", 2, tt2x4col
  644. };
  646. static const ITab
  647. tt2x5 = {
  648.   "TT2X5", 4, tt2x5col
  649. };
  651. static const ITab
  652. tt2itab[] = {
  653.   tt2x1,
  654.   tt2x2,
  655.   tt2x3,
  656.   tt2x4,
  657.   tt2x5
  658. };
  660. static const Tab
  661. tt2 = {
  662.   "TT2", 5, tt2col, 5, tt2itab
  663. };
  665. // all tables
  667. static const Tab
  668. tablist[] = {
  669.   tt1,
  670.   tt2
  671. };
  673. static const unsigned
  674. tabcount = sizeof(tablist) / sizeof(tablist[0]);
  676. // connections
  678. static Ndb_cluster_connection* g_ncc = 0;
  680. struct Con {
  681.   Ndb* m_ndb;
  682.   NdbDictionary::Dictionary* m_dic;
  683.   NdbConnection* m_tx;
  684.   NdbOperation* m_op;
  685.   NdbScanOperation* m_scanop;
  686.   NdbIndexScanOperation* m_indexscanop;
  687.   NdbResultSet* m_resultset;
  688.   enum ScanMode { ScanNo = 0, Committed, Latest, Exclusive };
  689.   ScanMode m_scanmode;
  690.   enum ErrType { ErrNone = 0, ErrDeadlock, ErrNospace, ErrOther };
  691.   ErrType m_errtype;
  692.   Con() :
  693.     m_ndb(0), m_dic(0), m_tx(0), m_op(0),
  694.     m_scanop(0), m_indexscanop(0), m_resultset(0), m_scanmode(ScanNo), m_errtype(ErrNone) {}
  695.   ~Con() {
  696.     if (m_tx != 0)
  697.       closeTransaction();
  698.   }
  699.   int connect();
  700.   void connect(const Con& con);
  701.   void disconnect();
  702.   int startTransaction();
  703.   int getNdbOperation(const Tab& tab);
  704.   int getNdbScanOperation(const Tab& tab);
  705.   int getNdbScanOperation(const ITab& itab, const Tab& tab);
  706.   int equal(int num, const char* addr);
  707.   int getValue(int num, NdbRecAttr*& rec);
  708.   int setValue(int num, const char* addr);
  709.   int setBound(int num, int type, const void* value);
  710.   int execute(ExecType t);
  711.   int execute(ExecType t, bool& deadlock, bool& nospace);
  712.   int openScanRead(unsigned scanbat, unsigned scanpar);
  713.   int openScanExclusive(unsigned scanbat, unsigned scanpar);
  714.   int executeScan();
  715.   int nextScanResult(bool fetchAllowed);
  716.   int nextScanResult(bool fetchAllowed, bool& deadlock);
  717.   int updateScanTuple(Con& con2);
  718.   int deleteScanTuple(Con& con2);
  719.   void closeScan();
  720.   void closeTransaction();
  721.   void printerror(NdbOut& out);
  722. };
  724. int
  725. Con::connect()
  726. {
  727.   assert(m_ndb == 0);
  728.   m_ndb = new Ndb(g_ncc, "TEST_DB");
  729.   CHKCON(m_ndb->init() == 0, *this);
  730.   CHKCON(m_ndb->waitUntilReady(30) == 0, *this);
  731.   m_tx = 0, m_op = 0;
  732.   return 0;
  733. }
  735. void
  736. Con::connect(const Con& con)
  737. {
  738.   assert(m_ndb == 0);
  739.   m_ndb = con.m_ndb;
  740. }
  742. void
  743. Con::disconnect()
  744. {
  745.   delete m_ndb;
  746.   m_ndb = 0, m_dic = 0, m_tx = 0, m_op = 0;
  747. }
  749. int
  750. Con::startTransaction()
  751. {
  752.   assert(m_ndb != 0);
  753.   if (m_tx != 0)
  754.     closeTransaction();
  755.   CHKCON((m_tx = m_ndb->startTransaction()) != 0, *this);
  756.   return 0;
  757. }
  759. int
  760. Con::getNdbOperation(const Tab& tab)
  761. {
  762.   assert(m_tx != 0);
  763.   CHKCON((m_op = m_tx->getNdbOperation(tab.m_name)) != 0, *this);
  764.   return 0;
  765. }
  767. int
  768. Con::getNdbScanOperation(const Tab& tab)
  769. {
  770.   assert(m_tx != 0);
  771.   CHKCON((m_op = m_scanop = m_tx->getNdbScanOperation(tab.m_name)) != 0, *this);
  772.   return 0;
  773. }
  775. int
  776. Con::getNdbScanOperation(const ITab& itab, const Tab& tab)
  777. {
  778.   assert(m_tx != 0);
  779.   CHKCON((m_op = m_scanop = m_indexscanop = m_tx->getNdbIndexScanOperation(itab.m_name, tab.m_name)) != 0, *this);
  780.   return 0;
  781. }
  783. int
  784. Con::equal(int num, const char* addr)
  785. {
  786.   assert(m_tx != 0 && m_op != 0);
  787.   CHKCON(m_op->equal(num, addr) == 0, *this);
  788.   return 0;
  789. }
  791. int
  792. Con::getValue(int num, NdbRecAttr*& rec)
  793. {
  794.   assert(m_tx != 0 && m_op != 0);
  795.   CHKCON((rec = m_op->getValue(num, 0)) != 0, *this);
  796.   return 0;
  797. }
  799. int
  800. Con::setValue(int num, const char* addr)
  801. {
  802.   assert(m_tx != 0 && m_op != 0);
  803.   CHKCON(m_op->setValue(num, addr) == 0, *this);
  804.   return 0;
  805. }
  807. int
  808. Con::setBound(int num, int type, const void* value)
  809. {
  810.   assert(m_tx != 0 && m_op != 0);
  811.   CHKCON(m_indexscanop->setBound(num, type, value) == 0, *this);
  812.   return 0;
  813. }
  815. int
  816. Con::execute(ExecType t)
  817. {
  818.   assert(m_tx != 0);
  819.   CHKCON(m_tx->execute(t) == 0, *this);
  820.   return 0;
  821. }
  823. int
  824. Con::execute(ExecType t, bool& deadlock, bool& nospace)
  825. {
  826.   int ret = execute(t);
  827.   if (ret != 0 && deadlock && m_errtype == ErrDeadlock) {
  828.     LL3("caught deadlock");
  829.     ret = 0;
  830.   } else {
  831.     deadlock = false;
  832.   }
  833.   if (ret != 0 && nospace && m_errtype == ErrNospace) {
  834.     LL3("caught nospace");
  835.     ret = 0;
  836.   } else {
  837.     nospace = false;
  838.   }
  839.   CHK(ret == 0);
  840.   return 0;
  841. }
  843. int
  844. Con::openScanRead(unsigned scanbat, unsigned scanpar)
  845. {
  846.   assert(m_tx != 0 && m_op != 0);
  847.   NdbOperation::LockMode lm = NdbOperation::LM_Read;
  848.   CHKCON((m_resultset = m_scanop->readTuples(lm, scanbat, scanpar)) != 0, *this);
  849.   return 0;
  850. }
  852. int
  853. Con::openScanExclusive(unsigned scanbat, unsigned scanpar)
  854. {
  855.   assert(m_tx != 0 && m_op != 0);
  856.   NdbOperation::LockMode lm = NdbOperation::LM_Exclusive;
  857.   CHKCON((m_resultset = m_scanop->readTuples(lm, scanbat, scanpar)) != 0, *this);
  858.   return 0;
  859. }
  861. int
  862. Con::executeScan()
  863. {
  864.   CHKCON(m_tx->execute(NoCommit) == 0, *this);
  865.   return 0;
  866. }
  868. int
  869. Con::nextScanResult(bool fetchAllowed)
  870. {
  871.   int ret;
  872.   assert(m_resultset != 0);
  873.   CHKCON((ret = m_resultset->nextResult(fetchAllowed)) != -1, *this);
  874.   assert(ret == 0 || ret == 1 || (! fetchAllowed && ret == 2));
  875.   return ret;
  876. }
  878. int
  879. Con::nextScanResult(bool fetchAllowed, bool& deadlock)
  880. {
  881.   int ret = nextScanResult(fetchAllowed);
  882.   if (ret == -1) {
  883.     if (deadlock && m_errtype == ErrDeadlock) {
  884.       LL3("caught deadlock");
  885.       ret = 0;
  886.     }
  887.   } else {
  888.     deadlock = false;
  889.   }
  890.   CHK(ret == 0 || ret == 1 || (! fetchAllowed && ret == 2));
  891.   return ret;
  892. }
  894. int
  895. Con::updateScanTuple(Con& con2)
  896. {
  897.   assert(con2.m_tx != 0);
  898.   CHKCON((con2.m_op = m_resultset->updateTuple(con2.m_tx)) != 0, *this);
  899.   return 0;
  900. }
  902. int
  903. Con::deleteScanTuple(Con& con2)
  904. {
  905.   assert(con2.m_tx != 0);
  906.   CHKCON(m_resultset->deleteTuple(con2.m_tx) == 0, *this);
  907.   return 0;
  908. }
  910. void
  911. Con::closeScan()
  912. {
  913.   assert(m_resultset != 0);
  914.   m_resultset->close();
  915.   m_scanop = 0, m_indexscanop = 0, m_resultset = 0;
  917. }
  919. void
  920. Con::closeTransaction()
  921. {
  922.   assert(m_ndb != 0 && m_tx != 0);
  923.   m_ndb->closeTransaction(m_tx);
  924.   m_tx = 0, m_op = 0;
  925.   m_scanop = 0, m_indexscanop = 0, m_resultset = 0;
  926. }
  928. void
  929. Con::printerror(NdbOut& out)
  930. {
  931.   m_errtype = ErrOther;
  932.   unsigned any = 0;
  933.   int code;
  934.   int die = 0;
  935.   if (m_ndb) {
  936.     if ((code = m_ndb->getNdbError().code) != 0) {
  937.       LL0(++any << " ndb: error " << m_ndb->getNdbError());
  938.       die += (code == g_opt.m_die);
  939.     }
  940.     if (m_dic && (code = m_dic->getNdbError().code) != 0) {
  941.       LL0(++any << " dic: error " << m_dic->getNdbError());
  942.       die += (code == g_opt.m_die);
  943.     }
  944.     if (m_tx) {
  945.       if ((code = m_tx->getNdbError().code) != 0) {
  946.         LL0(++any << " con: error " << m_tx->getNdbError());
  947.         die += (code == g_opt.m_die);
  948.         if (code == 266 || code == 274 || code == 296 || code == 297 || code == 499)
  949.           m_errtype = ErrDeadlock;
  950.         if (code == 826 || code == 827 || code == 902)
  951.           m_errtype = ErrNospace;
  952.       }
  953.       if (m_op && m_op->getNdbError().code != 0) {
  954.         LL0(++any << " op : error " << m_op->getNdbError());
  955.         die += (code == g_opt.m_die);
  956.       }
  957.     }
  958.   }
  959.   if (! any) {
  960.     LL0("failed but no NDB error code");
  961.   }
  962.   if (die) {
  963.     if (g_opt.m_core)
  964.       abort();
  965.     exit(1);
  966.   }
  967. }
  969. // dictionary operations
  971. static int
  972. invalidateindex(Par par, const ITab& itab)
  973. {
  974.   Con& con = par.con();
  975.   const Tab& tab = par.tab();
  976.   con.m_ndb->getDictionary()->invalidateIndex(itab.m_name, tab.m_name);
  977.   return 0;
  978. }
  980. static int
  981. invalidateindex(Par par)
  982. {
  983.   Con& con = par.con();
  984.   const Tab& tab = par.tab();
  985.   for (unsigned i = 0; i < tab.m_itabs; i++) {
  986.     if (! useindex(i))
  987.       continue;
  988.     const ITab& itab = tab.m_itab[i];
  989.     invalidateindex(par, itab);
  990.   }
  991.   return 0;
  992. }
  994. static int
  995. invalidatetable(Par par)
  996. {
  997.   Con& con = par.con();
  998.   const Tab& tab = par.tab();
  999.   invalidateindex(par);
  1000.   con.m_ndb->getDictionary()->invalidateTable(tab.m_name);
  1001.   return 0;
  1002. }
  1004. static int
  1005. droptable(Par par)
  1006. {
  1007.   Con& con = par.con();
  1008.   const Tab& tab = par.tab();
  1009.   con.m_dic = con.m_ndb->getDictionary();
  1010.   if (con.m_dic->getTable(tab.m_name) == 0) {
  1011.     // how to check for error
  1012.     LL4("no table " << tab.m_name);
  1013.   } else {
  1014.     LL3("drop table " << tab.m_name);
  1015.     CHKCON(con.m_dic->dropTable(tab.m_name) == 0, con);
  1016.   }
  1017.   con.m_dic = 0;
  1018.   return 0;
  1019. }
  1021. static int
  1022. createtable(Par par)
  1023. {
  1024.   Con& con = par.con();
  1025.   const Tab& tab = par.tab();
  1026.   LL3("create table " << tab.m_name);
  1027.   LL4(tab);
  1028.   NdbDictionary::Table t(tab.m_name);
  1029.   if (par.m_fragtype != NdbDictionary::Object::FragUndefined) {
  1030.     t.setFragmentType(par.m_fragtype);
  1031.   }
  1032.   if (par.m_nologging) {
  1033.     t.setLogging(false);
  1034.   }
  1035.   for (unsigned k = 0; k < tab.m_cols; k++) {
  1036.     const Col& col = tab.m_col[k];
  1037.     NdbDictionary::Column c(col.m_name);
  1038.     c.setType(col.m_type);
  1039.     c.setLength(col.m_length);
  1040.     c.setPrimaryKey(col.m_pk);
  1041.     c.setNullable(col.m_nullable);
  1042.     if (c.getCharset()) { // test if char type
  1043.       if (! col.m_pk)
  1044.         c.setCharset(par.m_cs);
  1045.     }
  1046.     t.addColumn(c);
  1047.   }
  1048.   con.m_dic = con.m_ndb->getDictionary();
  1049.   CHKCON(con.m_dic->createTable(t) == 0, con);
  1050.   con.m_dic = 0;
  1051.   return 0;
  1052. }
  1054. static int
  1055. dropindex(Par par, const ITab& itab)
  1056. {
  1057.   Con& con = par.con();
  1058.   const Tab& tab = par.tab();
  1059.   con.m_dic = con.m_ndb->getDictionary();
  1060.   if (con.m_dic->getIndex(itab.m_name, tab.m_name) == 0) {
  1061.     // how to check for error
  1062.     LL4("no index " << itab.m_name);
  1063.   } else {
  1064.     LL3("drop index " << itab.m_name);
  1065.     CHKCON(con.m_dic->dropIndex(itab.m_name, tab.m_name) == 0, con);
  1066.   }
  1067.   con.m_dic = 0;
  1068.   return 0;
  1069. }
  1071. static int
  1072. dropindex(Par par)
  1073. {
  1074.   const Tab& tab = par.tab();
  1075.   for (unsigned i = 0; i < tab.m_itabs; i++) {
  1076.     if (! useindex(i))
  1077.       continue;
  1078.     const ITab& itab = tab.m_itab[i];
  1079.     CHK(dropindex(par, itab) == 0);
  1080.   }
  1081.   return 0;
  1082. }
  1084. static int
  1085. createindex(Par par, const ITab& itab)
  1086. {
  1087.   Con& con = par.con();
  1088.   const Tab& tab = par.tab();
  1089.   LL3("create index " << itab.m_name);
  1090.   LL4(itab);
  1091.   NdbDictionary::Index x(itab.m_name);
  1092.   x.setTable(tab.m_name);
  1093.   x.setType(NdbDictionary::Index::OrderedIndex);
  1094.   x.setLogging(false);
  1095.   for (unsigned k = 0; k < itab.m_icols; k++) {
  1096.     const Col& col = itab.m_icol[k].m_col;
  1097.     x.addColumnName(col.m_name);
  1098.   }
  1099.   con.m_dic = con.m_ndb->getDictionary();
  1100.   CHKCON(con.m_dic->createIndex(x) == 0, con);
  1101.   con.m_dic = 0;
  1102.   return 0;
  1103. }
  1105. static int
  1106. createindex(Par par)
  1107. {
  1108.   const Tab& tab = par.tab();
  1109.   for (unsigned i = 0; i < tab.m_itabs; i++) {
  1110.     if (! useindex(i))
  1111.       continue;
  1112.     const ITab& itab = tab.m_itab[i];
  1113.     CHK(createindex(par, itab) == 0);
  1114.   }
  1115.   return 0;
  1116. }
  1118. // data sets
  1120. static unsigned
  1121. urandom(unsigned n)
  1122. {
  1123.   if (n == 0)
  1124.     return 0;
  1125.   unsigned i = random() % n;
  1126.   return i;
  1127. }
  1129. static int
  1130. irandom(unsigned n)
  1131. {
  1132.   if (n == 0)
  1133.     return 0;
  1134.   int i = random() % n;
  1135.   if (random() & 0x1)
  1136.     i = -i;
  1137.   return i;
  1138. }
  1140. static bool
  1141. randompct(unsigned pct)
  1142. {
  1143.   if (pct == 0)
  1144.     return false;
  1145.   if (pct >= 100)
  1146.     return true;
  1147.   return urandom(100) < pct;
  1148. }
  1150. // Val - typed column value
  1152. struct Val {
  1153.   const Col& m_col;
  1154.   union {
  1155.   Uint32 m_uint32;
  1156.   char* m_varchar;
  1157.   };
  1158.   Val(const Col& col);
  1159.   ~Val();
  1160.   void copy(const Val& val2);
  1161.   void copy(const void* addr);
  1162.   const void* dataaddr() const;
  1163.   bool m_null;
  1164.   int setval(Par par) const;
  1165.   void calc(Par par, unsigned i);
  1166.   int verify(const Val& val2) const;
  1167.   int cmp(const Val& val2) const;
  1168. private:
  1169.   Val& operator=(const Val& val2);
  1170. };
  1172. static NdbOut&
  1173. operator<<(NdbOut& out, const Val& val);
  1175. Val::Val(const Col& col) :
  1176.   m_col(col)
  1177. {
  1178.   switch (col.m_type) {
  1179.   case NdbDictionary::Column::Unsigned:
  1180.     break;
  1181.   case NdbDictionary::Column::Varchar:
  1182.     m_varchar = new char [2 + col.m_length];
  1183.     break;
  1184.   default:
  1185.     assert(false);
  1186.     break;
  1187.   }
  1188. }
  1190. Val::~Val()
  1191. {
  1192.   const Col& col = m_col;
  1193.   switch (col.m_type) {
  1194.   case NdbDictionary::Column::Unsigned:
  1195.     break;
  1196.   case NdbDictionary::Column::Varchar:
  1197.     delete [] m_varchar;
  1198.     break;
  1199.   default:
  1200.     assert(false);
  1201.     break;
  1202.   }
  1203. }
  1205. void
  1206. Val::copy(const Val& val2)
  1207. {
  1208.   const Col& col = m_col;
  1209.   const Col& col2 = val2.m_col;
  1210.   assert(col.m_type == col2.m_type && col.m_length == col2.m_length);
  1211.   if (val2.m_null) {
  1212.     m_null = true;
  1213.     return;
  1214.   }
  1215.   copy(val2.dataaddr());
  1216. }
  1218. void
  1219. Val::copy(const void* addr)
  1220. {
  1221.   const Col& col = m_col;
  1222.   switch (col.m_type) {
  1223.   case NdbDictionary::Column::Unsigned:
  1224.     m_uint32 = *(const Uint32*)addr;
  1225.     break;
  1226.   case NdbDictionary::Column::Varchar:
  1227.     memcpy(m_varchar, addr, 2 + col.m_length);
  1228.     break;
  1229.   default:
  1230.     assert(false);
  1231.     break;
  1232.   }
  1233.   m_null = false;
  1234. }
  1236. const void*
  1237. Val::dataaddr() const
  1238. {
  1239.   const Col& col = m_col;
  1240.   switch (col.m_type) {
  1241.   case NdbDictionary::Column::Unsigned:
  1242.     return &m_uint32;
  1243.   case NdbDictionary::Column::Varchar:
  1244.     return m_varchar;
  1245.   default:
  1246.     break;
  1247.   }
  1248.   assert(false);
  1249.   return 0;
  1250. }
  1252. int
  1253. Val::setval(Par par) const
  1254. {
  1255.   Con& con = par.con();
  1256.   const Col& col = m_col;
  1257.   const char* addr = (const char*)dataaddr();
  1258.   if (m_null)
  1259.     addr = 0;
  1260.   if (col.m_pk)
  1261.     CHK(con.equal(col.m_num, addr) == 0);
  1262.   else
  1263.     CHK(con.setValue(col.m_num, addr) == 0);
  1264.   LL5("setval [" << m_col << "] " << *this);
  1265.   return 0;
  1266. }
  1268. void
  1269. Val::calc(Par par, unsigned i)
  1270. {
  1271.   const Col& col = m_col;
  1272.   m_null = false;
  1273.   if (col.m_pk) {
  1274.     m_uint32 = i;
  1275.     return;
  1276.   }
  1277.   if (col.m_nullable && urandom(100) < par.m_pctnull) {
  1278.     m_null = true;
  1279.     return;
  1280.   }
  1281.   unsigned v = par.m_range + irandom((par.m_pctrange * par.m_range) / 100);
  1282.   switch (col.m_type) {
  1283.   case NdbDictionary::Column::Unsigned:
  1284.     m_uint32 = v;
  1285.     break;
  1286.   case NdbDictionary::Column::Varchar:
  1287.     {
  1288.       unsigned n = 0;
  1289.       while (n < col.m_length) {
  1290.         if (urandom(1 + col.m_length) == 0) {
  1291.           // nice distribution on lengths
  1292.           break;
  1293.         }
  1294.         m_varchar[2 + n++] = 'a' + urandom((par.m_pctrange * 10) / 100);
  1295.       }
  1296.       m_varchar[0] = (n >> 8);
  1297.       m_varchar[1] = (n & 0xff);
  1298.       while (n < col.m_length) {
  1299.         m_varchar[2 + n++] = 0;
  1300.       }
  1301.     }
  1302.     break;
  1303.   default:
  1304.     assert(false);
  1305.     break;
  1306.   }
  1307.   // verify format
  1308.   col.verify(dataaddr());
  1309. }
  1311. int
  1312. Val::verify(const Val& val2) const
  1313. {
  1314.   CHK(cmp(val2) == 0);
  1315.   return 0;
  1316. }
  1318. int
  1319. Val::cmp(const Val& val2) const
  1320. {
  1321.   const Col& col = m_col;
  1322.   const Col& col2 = val2.m_col;
  1323.   assert(col.m_type == col2.m_type && col.m_length == col2.m_length);
  1324.   if (m_null || val2.m_null) {
  1325.     if (! m_null)
  1326.       return +1;
  1327.     if (! val2.m_null)
  1328.       return -1;
  1329.     return 0;
  1330.   }
  1331.   // verify data formats
  1332.   col.verify(dataaddr());
  1333.   col.verify(val2.dataaddr());
  1334.   // compare
  1335.   switch (col.m_type) {
  1336.   case NdbDictionary::Column::Unsigned:
  1337.     if (m_uint32 < val2.m_uint32)
  1338.       return -1;
  1339.     if (m_uint32 > val2.m_uint32)
  1340.       return +1;
  1341.     return 0;
  1342.   case NdbDictionary::Column::Varchar:
  1343.     return memcmp(&m_varchar[2], &val2.m_varchar[2], col.m_length);
  1344.   default:
  1345.     break;
  1346.   }
  1347.   assert(false);
  1348.   return 0;
  1349. }
  1351. static NdbOut&
  1352. operator<<(NdbOut& out, const Val& val)
  1353. {
  1354.   const Col& col = val.m_col;
  1355.   if (val.m_null) {
  1356.     out << "NULL";
  1357.     return out;
  1358.   }
  1359.   switch (col.m_type) {
  1360.   case NdbDictionary::Column::Unsigned:
  1361.     out << val.m_uint32;
  1362.     break;
  1363.   case NdbDictionary::Column::Varchar:
  1364.     {
  1365.       char buf[8000];
  1366.       unsigned n = (val.m_varchar[0] << 8) | val.m_varchar[1];
  1367.       assert(n <= col.m_length);
  1368.       sprintf(buf, "'%.*s'[%d]", n, &val.m_varchar[2], n);
  1369.       out << buf;
  1370.     }
  1371.     break;
  1372.   default:
  1373.     out << "type" << col.m_type;
  1374.     assert(false);
  1375.     break;
  1376.   }
  1377.   return out;
  1378. }
  1380. // Row - table tuple
  1382. struct Row {
  1383.   const Tab& m_tab;
  1384.   Val** m_val;
  1385.   bool m_exist;
  1386.   enum Op { NoOp = 0, ReadOp, InsOp, UpdOp, DelOp };
  1387.   Op m_pending;
  1388.   Row(const Tab& tab);
  1389.   ~Row();
  1390.   void copy(const Row& row2);
  1391.   void calc(Par par, unsigned i);
  1392.   int verify(const Row& row2) const;
  1393.   int insrow(Par par);
  1394.   int updrow(Par par);
  1395.   int delrow(Par par);
  1396.   int selrow(Par par);
  1397.   int setrow(Par par);
  1398.   int cmp(const Row& row2) const;
  1399. private:
  1400.   Row& operator=(const Row& row2);
  1401. };
  1403. Row::Row(const Tab& tab) :
  1404.   m_tab(tab)
  1405. {
  1406.   m_val = new Val* [tab.m_cols];
  1407.   for (unsigned k = 0; k < tab.m_cols; k++) {
  1408.     const Col& col = tab.m_col[k];
  1409.     m_val[k] = new Val(col);
  1410.   }
  1411.   m_exist = false;
  1412.   m_pending = NoOp;
  1413. }
  1415. Row::~Row()
  1416. {
  1417.   const Tab& tab = m_tab;
  1418.   for (unsigned k = 0; k < tab.m_cols; k++) {
  1419.     delete m_val[k];
  1420.   }
  1421.   delete [] m_val;
  1422. }
  1424. void
  1425. Row::copy(const Row& row2)
  1426. {
  1427.   const Tab& tab = m_tab;
  1428.   assert(&tab == &row2.m_tab);
  1429.   for (unsigned k = 0; k < tab.m_cols; k++) {
  1430.     Val& val = *m_val[k];
  1431.     const Val& val2 = *row2.m_val[k];
  1432.     val.copy(val2);
  1433.   }
  1434. }
  1436. void
  1437. Row::calc(Par par, unsigned i)
  1438. {
  1439.   const Tab& tab = m_tab;
  1440.   for (unsigned k = 0; k < tab.m_cols; k++) {
  1441.     Val& val = *m_val[k];
  1442.     val.calc(par, i);
  1443.   }
  1444. }
  1446. int
  1447. Row::verify(const Row& row2) const
  1448. {
  1449.   const Tab& tab = m_tab;
  1450.   assert(&tab == &row2.m_tab && m_exist && row2.m_exist);
  1451.   for (unsigned k = 0; k < tab.m_cols; k++) {
  1452.     const Val& val = *m_val[k];
  1453.     const Val& val2 = *row2.m_val[k];
  1454.     CHK(val.verify(val2) == 0);
  1455.   }
  1456.   return 0;
  1457. }
  1459. int
  1460. Row::insrow(Par par)
  1461. {
  1462.   Con& con = par.con();
  1463.   const Tab& tab = m_tab;
  1464.   assert(! m_exist);
  1465.   CHK(con.getNdbOperation(tab) == 0);
  1466.   CHKCON(con.m_op->insertTuple() == 0, con);
  1467.   for (unsigned k = 0; k < tab.m_cols; k++) {
  1468.     const Val& val = *m_val[k];
  1469.     CHK(val.setval(par) == 0);
  1470.   }
  1471.   m_pending = InsOp;
  1472.   return 0;
  1473. }
  1475. int
  1476. Row::updrow(Par par)
  1477. {
  1478.   Con& con = par.con();
  1479.   const Tab& tab = m_tab;
  1480.   assert(m_exist);
  1481.   CHK(con.getNdbOperation(tab) == 0);
  1482.   CHKCON(con.m_op->updateTuple() == 0, con);
  1483.   for (unsigned k = 0; k < tab.m_cols; k++) {
  1484.     const Val& val = *m_val[k];
  1485.     CHK(val.setval(par) == 0);
  1486.   }
  1487.   m_pending = UpdOp;
  1488.   return 0;
  1489. }
  1491. int
  1492. Row::delrow(Par par)
  1493. {
  1494.   Con& con = par.con();
  1495.   const Tab& tab = m_tab;
  1496.   assert(m_exist);
  1497.   CHK(con.getNdbOperation(m_tab) == 0);
  1498.   CHKCON(con.m_op->deleteTuple() == 0, con);
  1499.   for (unsigned k = 0; k < tab.m_cols; k++) {
  1500.     const Val& val = *m_val[k];
  1501.     const Col& col = val.m_col;
  1502.     if (col.m_pk)
  1503.       CHK(val.setval(par) == 0);
  1504.   }
  1505.   m_pending = DelOp;
  1506.   return 0;
  1507. }
  1509. int
  1510. Row::selrow(Par par)
  1511. {
  1512.   Con& con = par.con();
  1513.   const Tab& tab = m_tab;
  1514.   CHK(con.getNdbOperation(m_tab) == 0);
  1515.   CHKCON(con.m_op->readTuple() == 0, con);
  1516.   for (unsigned k = 0; k < tab.m_cols; k++) {
  1517.     const Val& val = *m_val[k];
  1518.     const Col& col = val.m_col;
  1519.     if (col.m_pk)
  1520.       CHK(val.setval(par) == 0);
  1521.   }
  1522.   return 0;
  1523. }
  1525. int
  1526. Row::setrow(Par par)
  1527. {
  1528.   Con& con = par.con();
  1529.   const Tab& tab = m_tab;
  1530.   for (unsigned k = 0; k < tab.m_cols; k++) {
  1531.     const Val& val = *m_val[k];
  1532.     const Col& col = val.m_col;
  1533.     if (! col.m_pk)
  1534.       CHK(val.setval(par) == 0);
  1535.   }
  1536.   m_pending = UpdOp;
  1537.   return 0;
  1538. }
  1540. int
  1541. Row::cmp(const Row& row2) const
  1542. {
  1543.   const Tab& tab = m_tab;
  1544.   assert(&tab == &row2.m_tab);
  1545.   int c = 0;
  1546.   for (unsigned k = 0; k < tab.m_cols; k++) {
  1547.     const Val& val = *m_val[k];
  1548.     const Val& val2 = *row2.m_val[k];
  1549.     if ((c = val.cmp(val2)) != 0)
  1550.       break;
  1551.   }
  1552.   return c;
  1553. }
  1555. static NdbOut&
  1556. operator<<(NdbOut& out, const Row& row)
  1557. {
  1558.   const Tab& tab = row.m_tab;
  1559.   for (unsigned i = 0; i < tab.m_cols; i++) {
  1560.     if (i > 0)
  1561.       out << " ";
  1562.     out << *row.m_val[i];
  1563.   }
  1564.   out << " [exist=" << row.m_exist;
  1565.   if (row.m_pending)
  1566.     out << " pending=" << row.m_pending;
  1567.   out << "]";
  1568.   return out;
  1569. }
  1571. // Set - set of table tuples
  1573. struct Set {
  1574.   const Tab& m_tab;
  1575.   unsigned m_rows;
  1576.   Row** m_row;
  1577.   Row** m_saverow;
  1578.   Row* m_keyrow;
  1579.   NdbRecAttr** m_rec;
  1580.   Set(const Tab& tab, unsigned rows);
  1581.   ~Set();
  1582.   void reset();
  1583.   unsigned count() const;
  1584.   // row methods
  1585.   bool exist(unsigned i) const;
  1586.   Row::Op pending(unsigned i) const;
  1587.   void notpending(unsigned i, ExecType et = Commit);
  1588.   void notpending(const Lst& lst, ExecType et = Commit);
  1589.   void calc(Par par, unsigned i);
  1590.   int insrow(Par par, unsigned i);
  1591.   int updrow(Par par, unsigned i);
  1592.   int delrow(Par par, unsigned i);
  1593.   int selrow(Par par, unsigned i);
  1594.   int setrow(Par par, unsigned i);
  1595.   int getval(Par par);
  1596.   int getkey(Par par, unsigned* i);
  1597.   int putval(unsigned i, bool force);
  1598.   // set methods
  1599.   int verify(const Set& set2) const;
  1600.   void savepoint();
  1601.   void commit();
  1602.   void rollback();
  1603.   // protect structure
  1604.   NdbMutex* m_mutex;
  1605.   void lock() {
  1606.     NdbMutex_Lock(m_mutex);
  1607.   }
  1608.   void unlock() {
  1609.     NdbMutex_Unlock(m_mutex);
  1610.   }
  1611. private:
  1612.   Set& operator=(const Set& set2);
  1613. };
  1615. Set::Set(const Tab& tab, unsigned rows) :
  1616.   m_tab(tab)
  1617. {
  1618.   m_rows = rows;
  1619.   m_row = new Row* [m_rows];
  1620.   for (unsigned i = 0; i < m_rows; i++) {
  1621.     // allocate on need to save space
  1622.     m_row[i] = 0;
  1623.   }
  1624.   m_saverow = 0;
  1625.   m_keyrow = new Row(tab);
  1626.   m_rec = new NdbRecAttr* [tab.m_cols];
  1627.   for (unsigned k = 0; k < tab.m_cols; k++) {
  1628.     m_rec[k] = 0;
  1629.   }
  1630.   m_mutex = NdbMutex_Create();
  1631.   assert(m_mutex != 0);
  1632. }
  1634. Set::~Set()
  1635. {
  1636.   for (unsigned i = 0; i < m_rows; i++) {
  1637.     delete m_row[i];
  1638.     if (m_saverow != 0)
  1639.       delete m_saverow[i];
  1640.   }
  1641.   delete [] m_row;
  1642.   delete [] m_saverow;
  1643.   delete m_keyrow;
  1644.   delete [] m_rec;
  1645.   NdbMutex_Destroy(m_mutex);
  1646. }
  1648. void
  1649. Set::reset()
  1650. {
  1651.   for (unsigned i = 0; i < m_rows; i++) {
  1652.     if (m_row[i] != 0) {
  1653.       Row& row = *m_row[i];
  1654.       row.m_exist = false;
  1655.     }
  1656.   }
  1657. }
  1659. unsigned
  1660. Set::count() const
  1661. {
  1662.   unsigned count = 0;
  1663.   for (unsigned i = 0; i < m_rows; i++) {
  1664.     if (m_row[i] != 0) {
  1665.       Row& row = *m_row[i];
  1666.       if (row.m_exist)
  1667.         count++;
  1668.     }
  1669.   }
  1670.   return count;
  1671. }
  1673. bool
  1674. Set::exist(unsigned i) const
  1675. {
  1676.   assert(i < m_rows);
  1677.   if (m_row[i] == 0)    // not allocated => not exist
  1678.     return false;
  1679.   return m_row[i]->m_exist;
  1680. }
  1682. Row::Op
  1683. Set::pending(unsigned i) const
  1684. {
  1685.   assert(i < m_rows);
  1686.   if (m_row[i] == 0)    // not allocated => not pending
  1687.     return Row::NoOp;
  1688.   return m_row[i]->m_pending;
  1689. }
  1691. void
  1692. Set::calc(Par par, unsigned i)
  1693. {
  1694.   const Tab& tab = m_tab;
  1695.   if (m_row[i] == 0)
  1696.     m_row[i] = new Row(tab);
  1697.   Row& row = *m_row[i];
  1698.   // value generation parameters
  1699.   par.m_pctrange = 40;
  1700.   row.calc(par, i);
  1701. }
  1703. int
  1704. Set::insrow(Par par, unsigned i)
  1705. {
  1706.   assert(m_row[i] != 0);
  1707.   Row& row = *m_row[i];
  1708.   CHK(row.insrow(par) == 0);
  1709.   return 0;
  1710. }
  1712. int
  1713. Set::updrow(Par par, unsigned i)
  1714. {
  1715.   assert(m_row[i] != 0);
  1716.   Row& row = *m_row[i];
  1717.   CHK(row.updrow(par) == 0);
  1718.   return 0;
  1719. }
  1721. int
  1722. Set::delrow(Par par, unsigned i)
  1723. {
  1724.   assert(m_row[i] != 0);
  1725.   Row& row = *m_row[i];
  1726.   CHK(row.delrow(par) == 0);
  1727.   return 0;
  1728. }
  1730. int
  1731. Set::selrow(Par par, unsigned i)
  1732. {
  1733.   Con& con = par.con();
  1734.   m_keyrow->calc(par, i);
  1735.   CHK(m_keyrow->selrow(par) == 0);
  1736.   CHK(getval(par) == 0);
  1737.   return 0;
  1738. }
  1740. int
  1741. Set::setrow(Par par, unsigned i)
  1742. {
  1743.   Con& con = par.con();
  1744.   assert(m_row[i] != 0);
  1745.   CHK(m_row[i]->setrow(par) == 0);
  1746.   return 0;
  1747. }
  1749. int
  1750. Set::getval(Par par)
  1751. {
  1752.   Con& con = par.con();
  1753.   const Tab& tab = m_tab;
  1754.   for (unsigned k = 0; k < tab.m_cols; k++) {
  1755.     CHK(con.getValue(k, m_rec[k]) == 0);
  1756.   }
  1757.   return 0;
  1758. }
  1760. int
  1761. Set::getkey(Par par, unsigned* i)
  1762. {
  1763.   assert(m_rec[0] != 0);
  1764.   const char* aRef0 = m_rec[0]->aRef();
  1765.   Uint32 key = *(const Uint32*)aRef0;
  1766.   CHK(key < m_rows);
  1767.   *i = key;
  1768.   return 0;
  1769. }
  1771. int
  1772. Set::putval(unsigned i, bool force)
  1773. {
  1774.   const Tab& tab = m_tab;
  1775.   if (m_row[i] == 0)
  1776.     m_row[i] = new Row(tab);
  1777.   Row& row = *m_row[i];
  1778.   CHK(! row.m_exist || force);
  1779.   for (unsigned k = 0; k < tab.m_cols; k++) {
  1780.     Val& val = *row.m_val[k];
  1781.     NdbRecAttr* rec = m_rec[k];
  1782.     assert(rec != 0);
  1783.     if (rec->isNULL()) {
  1784.       val.m_null = true;
  1785.       continue;
  1786.     }
  1787.     const char* aRef = m_rec[k]->aRef();
  1788.     val.copy(aRef);
  1789.     val.m_null = false;
  1790.   }
  1791.   if (! row.m_exist)
  1792.     row.m_exist = true;
  1793.   return 0;
  1794. }
  1796. void
  1797. Set::notpending(unsigned i, ExecType et)
  1798. {
  1799.   assert(m_row[i] != 0);
  1800.   Row& row = *m_row[i];
  1801.   if (et == Commit) {
  1802.     if (row.m_pending == Row::InsOp)
  1803.       row.m_exist = true;
  1804.     if (row.m_pending == Row::DelOp)
  1805.       row.m_exist = false;
  1806.   } else {
  1807.     if (row.m_pending == Row::InsOp)
  1808.       row.m_exist = false;
  1809.     if (row.m_pending == Row::DelOp)
  1810.       row.m_exist = true;
  1811.   }
  1812.   row.m_pending = Row::NoOp;
  1813. }
  1815. void
  1816. Set::notpending(const Lst& lst, ExecType et)
  1817. {
  1818.   for (unsigned j = 0; j < lst.m_cnt; j++) {
  1819.     unsigned i = lst.m_arr[j];
  1820.     notpending(i, et);
  1821.   }
  1822. }
  1824. int
  1825. Set::verify(const Set& set2) const
  1826. {
  1827.   const Tab& tab = m_tab;
  1828.   assert(&tab == &set2.m_tab && m_rows == set2.m_rows);
  1829.   for (unsigned i = 0; i < m_rows; i++) {
  1830.     CHK(exist(i) == set2.exist(i));
  1831.     if (! exist(i))
  1832.       continue;
  1833.     Row& row = *m_row[i];
  1834.     Row& row2 = *set2.m_row[i];
  1835.     CHK(row.verify(row2) == 0);
  1836.   }
  1837.   return 0;
  1838. }
  1840. void
  1841. Set::savepoint()
  1842. {
  1843.   const Tab& tab = m_tab;
  1844.   assert(m_saverow == 0);
  1845.   m_saverow = new Row* [m_rows];
  1846.   for (unsigned i = 0; i < m_rows; i++) {
  1847.     if (m_row[i] == 0)
  1848.       m_saverow[i] = 0;
  1849.     else {
  1850.       m_saverow[i] = new Row(tab);
  1851.       m_saverow[i]->copy(*m_row[i]);
  1852.     }
  1853.   }
  1854. }
  1856. void
  1857. Set::commit()
  1858. {
  1859.   delete [] m_saverow;
  1860.   m_saverow = 0;
  1861. }
  1863. void
  1864. Set::rollback()
  1865. {
  1866.   assert(m_saverow != 0);
  1867.   m_row = m_saverow;
  1868.   m_saverow = 0;
  1869. }
  1871. static NdbOut&
  1872. operator<<(NdbOut& out, const Set& set)
  1873. {
  1874.   for (unsigned i = 0; i < set.m_rows; i++) {
  1875.     const Row& row = *set.m_row[i];
  1876.     if (i > 0)
  1877.       out << endl;
  1878.     out << row;
  1879.   }
  1880.   return out;
  1881. }
  1883. // BVal - range scan bound
  1885. struct BVal : public Val {
  1886.   const ICol& m_icol;
  1887.   int m_type;
  1888.   BVal(const ICol& icol);
  1889.   int setbnd(Par par) const;
  1890. };
  1892. BVal::BVal(const ICol& icol) :
  1893.   Val(icol.m_col),
  1894.   m_icol(icol)
  1895. {
  1896. }
  1898. int
  1899. BVal::setbnd(Par par) const
  1900. {
  1901.   Con& con = par.con();
  1902.   assert(g_compare_null || ! m_null);
  1903.   const char* addr = ! m_null ? (const char*)dataaddr() : 0;
  1904.   const ICol& icol = m_icol;
  1905.   CHK(con.setBound(icol.m_num, m_type, addr) == 0);
  1906.   return 0;
  1907. }
  1909. static NdbOut&
  1910. operator<<(NdbOut& out, const BVal& bval)
  1911. {
  1912.   const ICol& icol = bval.m_icol;
  1913.   const Col& col = icol.m_col;
  1914.   const Val& val = bval;
  1915.   out << "type " << bval.m_type;
  1916.   out << " icol " << icol.m_num;
  1917.   out << " col " << col.m_name << "(" << col.m_num << ")";
  1918.   out << " value " << val;
  1919.   return out;
  1920. }
  1922. // BSet - set of bounds
  1924. struct BSet {
  1925.   const Tab& m_tab;
  1926.   const ITab& m_itab;
  1927.   unsigned m_alloc;
  1928.   unsigned m_bvals;
  1929.   BVal** m_bval;
  1930.   BSet(const Tab& tab, const ITab& itab, unsigned rows);
  1931.   ~BSet();
  1932.   void reset();
  1933.   void calc(Par par);
  1934.   void calcpk(Par par, unsigned i);
  1935.   int setbnd(Par par) const;
  1936.   void filter(const Set& set, Set& set2) const;
  1937. };
  1939. BSet::BSet(const Tab& tab, const ITab& itab, unsigned rows) :
  1940.   m_tab(tab),
  1941.   m_itab(itab),
  1942.   m_alloc(2 * itab.m_icols),
  1943.   m_bvals(0)
  1944. {
  1945.   m_bval = new BVal* [m_alloc];
  1946.   for (unsigned i = 0; i < m_alloc; i++) {
  1947.     m_bval[i] = 0;
  1948.   }
  1949. }
  1951. BSet::~BSet()
  1952. {
  1953.   delete [] m_bval;
  1954. }
  1956. void
  1957. BSet::reset()
  1958. {
  1959.   while (m_bvals > 0) {
  1960.     unsigned i = --m_bvals;
  1961.     delete m_bval[i];
  1962.     m_bval[i] = 0;
  1963.   }
  1964. }
  1966. void
  1967. BSet::calc(Par par)
  1968. {
  1969.   const ITab& itab = m_itab;
  1970.   reset();
  1971.   for (unsigned k = 0; k < itab.m_icols; k++) {
  1972.     const ICol& icol = itab.m_icol[k];
  1973.     const Col& col = icol.m_col;
  1974.     for (unsigned i = 0; i <= 1; i++) {
  1975.       if (urandom(10) == 0)
  1976.         return;
  1977.       assert(m_bvals < m_alloc);
  1978.       BVal& bval = *new BVal(icol);
  1979.       m_bval[m_bvals++] = &bval;
  1980.       bval.m_null = false;
  1981.       unsigned sel;
  1982.       do {
  1983.         // equality bound only on i==0
  1984.         sel = urandom(5 - i);
  1985.       } while (strchr(par.m_bound, '0' + sel) == 0);
  1986.       if (sel < 2)
  1987.         bval.m_type = 0 | (1 << i);
  1988.       else if (sel < 4)
  1989.         bval.m_type = 1 | (1 << i);
  1990.       else
  1991.         bval.m_type = 4;
  1992.       if (k + 1 < itab.m_icols)
  1993.         bval.m_type = 4;
  1994.       // value generation parammeters
  1995.       if (! g_compare_null)
  1996.         par.m_pctnull = 0;
  1997.       par.m_pctrange = 50;      // bit higher
  1998.       do {
  1999.         bval.calc(par, 0);
  2000.         if (i == 1) {
  2001.           assert(m_bvals >= 2);
  2002.           const BVal& bv1 = *m_bval[m_bvals - 2];
  2003.           const BVal& bv2 = *m_bval[m_bvals - 1];
  2004.           if (bv1.cmp(bv2) > 0 && urandom(100) != 0)
  2005.             continue;
  2006.         }
  2007.       } while (0);
  2008.       // equality bound only once
  2009.       if (bval.m_type == 4)
  2010.         break;
  2011.     }
  2012.   }
  2013. }
  2015. void
  2016. BSet::calcpk(Par par, unsigned i)
  2017. {
  2018.   const ITab& itab = m_itab;
  2019.   reset();
  2020.   for (unsigned k = 0; k < itab.m_icols; k++) {
  2021.     const ICol& icol = itab.m_icol[k];
  2022.     const Col& col = icol.m_col;
  2023.     assert(col.m_pk);
  2024.     assert(m_bvals < m_alloc);
  2025.     BVal& bval = *new BVal(icol);
  2026.     m_bval[m_bvals++] = &bval;
  2027.     bval.m_type = 4;
  2028.     bval.calc(par, i);
  2029.   }
  2030. }
  2032. int
  2033. BSet::setbnd(Par par) const
  2034. {
  2035.   if (m_bvals != 0) {
  2036.     unsigned p1 = urandom(m_bvals);
  2037.     unsigned p2 = 10009;        // prime
  2038.     // random order
  2039.     for (unsigned j = 0; j < m_bvals; j++) {
  2040.       unsigned k = p1 + p2 * j;
  2041.       const BVal& bval = *m_bval[k % m_bvals];
  2042.       CHK(bval.setbnd(par) == 0);
  2043.     }
  2044.     // duplicate
  2045.     if (urandom(5) == 0) {
  2046.       unsigned k = urandom(m_bvals);
  2047.       const BVal& bval = *m_bval[k];
  2048.       CHK(bval.setbnd(par) == 0);
  2049.     }
  2050.   }
  2051.   return 0;
  2052. }
  2054. void
  2055. BSet::filter(const Set& set, Set& set2) const
  2056. {
  2057.   const Tab& tab = m_tab;
  2058.   const ITab& itab = m_itab;
  2059.   assert(&tab == &set2.m_tab && set.m_rows == set2.m_rows);
  2060.   assert(set2.count() == 0);
  2061.   for (unsigned i = 0; i < set.m_rows; i++) {
  2062.     if (! set.exist(i))
  2063.       continue;
  2064.     const Row& row = *set.m_row[i];
  2065.     if (! g_store_null_key) {
  2066.       bool ok1 = false;
  2067.       for (unsigned k = 0; k < itab.m_icols; k++) {
  2068.         const ICol& icol = itab.m_icol[k];
  2069.         const Col& col = icol.m_col;
  2070.         const Val& val = *row.m_val[col.m_num];
  2071.         if (! val.m_null) {
  2072.           ok1 = true;
  2073.           break;
  2074.         }
  2075.       }
  2076.       if (! ok1)
  2077.         continue;
  2078.     }
  2079.     bool ok2 = true;
  2080.     for (unsigned j = 0; j < m_bvals; j++) {
  2081.       const BVal& bval = *m_bval[j];
  2082.       const ICol& icol = bval.m_icol;
  2083.       const Col& col = icol.m_col;
  2084.       const Val& val = *row.m_val[col.m_num];
  2085.       int ret = bval.cmp(val);
  2086.       if (bval.m_type == 0)
  2087.         ok2 = (ret <= 0);
  2088.       else if (bval.m_type == 1)
  2089.         ok2 = (ret < 0);
  2090.       else if (bval.m_type == 2)
  2091.         ok2 = (ret >= 0);
  2092.       else if (bval.m_type == 3)
  2093.         ok2 = (ret > 0);
  2094.       else if (bval.m_type == 4)
  2095.         ok2 = (ret == 0);
  2096.       else {
  2097.         assert(false);
  2098.       }
  2099.       if (! ok2)
  2100.         break;
  2101.     }
  2102.     if (! ok2)
  2103.       continue;
  2104.     if (set2.m_row[i] == 0)
  2105.       set2.m_row[i] = new Row(tab);
  2106.     Row& row2 = *set2.m_row[i];
  2107.     assert(! row2.m_exist);
  2108.     row2.copy(row);
  2109.     row2.m_exist = true;
  2110.   }
  2111. }
  2113. static NdbOut&
  2114. operator<<(NdbOut& out, const BSet& bset)
  2115. {
  2116.   out << "bounds=" << bset.m_bvals;
  2117.   for (unsigned j = 0; j < bset.m_bvals; j++) {
  2118.     out << endl;
  2119.     const BVal& bval = *bset.m_bval[j];
  2120.     out << "bound " << j << ": " << bval;
  2121.   }
  2122.   return out;
  2123. }
  2125. // pk operations
  2127. static int
  2128. pkinsert(Par par)
  2129. {
  2130.   Con& con = par.con();
  2131.   Set& set = par.set();
  2132.   LL3("pkinsert");
  2133.   CHK(con.startTransaction() == 0);
  2134.   Lst lst;
  2135.   for (unsigned j = 0; j < par.m_rows; j++) {
  2136.     unsigned j2 = ! par.m_randomkey ? j : urandom(par.m_rows);
  2137.     unsigned i = thrrow(par, j2);
  2138.     set.lock();
  2139.     if (set.exist(i) || set.pending(i)) {
  2140.       set.unlock();
  2141.       continue;
  2142.     }
  2143.     set.calc(par, i);
  2144.     CHK(set.insrow(par, i) == 0);
  2145.     set.unlock();
  2146.     LL4("pkinsert " << i << ": " << *set.m_row[i]);
  2147.     lst.push(i);
  2148.     if (lst.cnt() == par.m_batch) {
  2149.       bool deadlock = par.m_deadlock;
  2150.       bool nospace = true;
  2151.       ExecType et = randompct(par.m_abortpct) ? Rollback : Commit;
  2152.       CHK(con.execute(et, deadlock, nospace) == 0);
  2153.       con.closeTransaction();
  2154.       if (deadlock) {
  2155.         LL1("pkinsert: stop on deadlock");
  2156.         return 0;
  2157.       }
  2158.       if (nospace) {
  2159.         LL1("pkinsert: cnt=" << j << " stop on nospace");
  2160.         return 0;
  2161.       }
  2162.       set.lock();
  2163.       set.notpending(lst, et);
  2164.       set.unlock();
  2165.       lst.reset();
  2166.       CHK(con.startTransaction() == 0);
  2167.     }
  2168.   }
  2169.   if (lst.cnt() != 0) {
  2170.     bool deadlock = par.m_deadlock;
  2171.     bool nospace = true;
  2172.     ExecType et = randompct(par.m_abortpct) ? Rollback : Commit;
  2173.     CHK(con.execute(et, deadlock, nospace) == 0);
  2174.     con.closeTransaction();
  2175.     if (deadlock) {
  2176.       LL1("pkinsert: stop on deadlock");
  2177.       return 0;
  2178.     }
  2179.     if (nospace) {
  2180.       LL1("pkinsert: end: stop on nospace");
  2181.       return 0;
  2182.     }
  2183.     set.lock();
  2184.     set.notpending(lst, et);
  2185.     set.unlock();
  2186.     return 0;
  2187.   }
  2188.   con.closeTransaction();
  2189.   return 0;
  2190. }
  2192. static int
  2193. pkupdate(Par par)
  2194. {
  2195.   Con& con = par.con();
  2196.   Set& set = par.set();
  2197.   LL3("pkupdate");
  2198.   CHK(con.startTransaction() == 0);
  2199.   Lst lst;
  2200.   bool deadlock = false;
  2201.   bool nospace = false;
  2202.   for (unsigned j = 0; j < par.m_rows; j++) {
  2203.     unsigned j2 = ! par.m_randomkey ? j : urandom(par.m_rows);
  2204.     unsigned i = thrrow(par, j2);
  2205.     set.lock();
  2206.     if (! set.exist(i) || set.pending(i)) {
  2207.       set.unlock();
  2208.       continue;
  2209.     }
  2210.     set.calc(par, i);
  2211.     CHK(set.updrow(par, i) == 0);
  2212.     set.unlock();
  2213.     LL4("pkupdate " << i << ": " << *set.m_row[i]);
  2214.     lst.push(i);
  2215.     if (lst.cnt() == par.m_batch) {
  2216.       deadlock = par.m_deadlock;
  2217.       nospace = true;
  2218.       ExecType et = randompct(par.m_abortpct) ? Rollback : Commit;
  2219.       CHK(con.execute(et, deadlock, nospace) == 0);
  2220.       if (deadlock) {
  2221.         LL1("pkupdate: stop on deadlock");
  2222.         break;
  2223.       }
  2224.       if (nospace) {
  2225.         LL1("pkupdate: cnt=" << j << " stop on nospace");
  2226.         break;
  2227.       }
  2228.       con.closeTransaction();
  2229.       set.lock();
  2230.       set.notpending(lst, et);
  2231.       set.unlock();
  2232.       lst.reset();
  2233.       CHK(con.startTransaction() == 0);
  2234.     }
  2235.   }
  2236.   if (! deadlock && ! nospace && lst.cnt() != 0) {
  2237.     deadlock = par.m_deadlock;
  2238.     nospace = true;
  2239.     ExecType et = randompct(par.m_abortpct) ? Rollback : Commit;
  2240.     CHK(con.execute(et, deadlock, nospace) == 0);
  2241.     if (deadlock) {
  2242.       LL1("pkupdate: stop on deadlock");
  2243.     } else if (nospace) {
  2244.       LL1("pkupdate: end: stop on nospace");
  2245.     } else {
  2246.       set.lock();
  2247.       set.notpending(lst, et);
  2248.       set.unlock();
  2249.     }
  2250.   }
  2251.   con.closeTransaction();
  2252.   return 0;
  2253. }
  2255. static int
  2256. pkdelete(Par par)
  2257. {
  2258.   Con& con = par.con();
  2259.   Set& set = par.set();
  2260.   LL3("pkdelete");
  2261.   CHK(con.startTransaction() == 0);
  2262.   Lst lst;
  2263.   bool deadlock = false;
  2264.   bool nospace = false;
  2265.   for (unsigned j = 0; j < par.m_rows; j++) {
  2266.     unsigned j2 = ! par.m_randomkey ? j : urandom(par.m_rows);
  2267.     unsigned i = thrrow(par, j2);
  2268.     set.lock();
  2269.     if (! set.exist(i) || set.pending(i)) {
  2270.       set.unlock();
  2271.       continue;
  2272.     }
  2273.     CHK(set.delrow(par, i) == 0);
  2274.     set.unlock();
  2275.     LL4("pkdelete " << i << ": " << *set.m_row[i]);
  2276.     lst.push(i);
  2277.     if (lst.cnt() == par.m_batch) {
  2278.       deadlock = par.m_deadlock;
  2279.       nospace = true;
  2280.       ExecType et = randompct(par.m_abortpct) ? Rollback : Commit;
  2281.       CHK(con.execute(et, deadlock, nospace) == 0);
  2282.       if (deadlock) {
  2283.         LL1("pkdelete: stop on deadlock");
  2284.         break;
  2285.       }
  2286.       con.closeTransaction();
  2287.       set.lock();
  2288.       set.notpending(lst, et);
  2289.       set.unlock();
  2290.       lst.reset();
  2291.       CHK(con.startTransaction() == 0);
  2292.     }
  2293.   }
  2294.   if (! deadlock && ! nospace && lst.cnt() != 0) {
  2295.     deadlock = par.m_deadlock;
  2296.     nospace = true;
  2297.     ExecType et = randompct(par.m_abortpct) ? Rollback : Commit;
  2298.     CHK(con.execute(et, deadlock, nospace) == 0);
  2299.     if (deadlock) {
  2300.       LL1("pkdelete: stop on deadlock");
  2301.     } else {
  2302.       set.lock();
  2303.       set.notpending(lst, et);
  2304.       set.unlock();
  2305.     }
  2306.   }
  2307.   con.closeTransaction();
  2308.   return 0;
  2309. }
  2311. static int
  2312. pkread(Par par)
  2313. {
  2314.   Con& con = par.con();
  2315.   const Tab& tab = par.tab();
  2316.   Set& set = par.set();
  2317.   LL3((par.m_verify ? "pkverify " : "pkread ") << tab.m_name);
  2318.   // expected
  2319.   const Set& set1 = set;
  2320.   Set set2(tab, set.m_rows);
  2321.   for (unsigned i = 0; i < set.m_rows; i++) {
  2322.     set.lock();
  2323.     if (! set.exist(i) || set.pending(i)) {
  2324.       set.unlock();
  2325.       continue;
  2326.     }
  2327.     set.unlock();
  2328.     CHK(con.startTransaction() == 0);
  2329.     CHK(set2.selrow(par, i) == 0);
  2330.     CHK(con.execute(Commit) == 0);
  2331.     unsigned i2 = (unsigned)-1;
  2332.     CHK(set2.getkey(par, &i2) == 0 && i == i2);
  2333.     CHK(set2.putval(i, false) == 0);
  2334.     LL4("row " << set2.count() << ": " << *set2.m_row[i]);
  2335.     con.closeTransaction();
  2336.   }
  2337.   if (par.m_verify)
  2338.     CHK(set1.verify(set2) == 0);
  2339.   return 0;
  2340. }
  2342. static int
  2343. pkreadfast(Par par, unsigned count)
  2344. {
  2345.   Con& con = par.con();
  2346.   const Tab& tab = par.tab();
  2347.   const Set& set = par.set();
  2348.   LL3("pkfast " << tab.m_name);
  2349.   Row keyrow(tab);
  2350.   // not batched on purpose
  2351.   for (unsigned j = 0; j < count; j++) {
  2352.     unsigned i = urandom(set.m_rows);
  2353.     assert(set.exist(i));
  2354.     CHK(con.startTransaction() == 0);
  2355.     // define key
  2356.     keyrow.calc(par, i);
  2357.     CHK(keyrow.selrow(par) == 0);
  2358.     NdbRecAttr* rec;
  2359.     // get 1st column
  2360.     CHK(con.getValue((Uint32)0, rec) == 0);
  2361.     CHK(con.execute(Commit) == 0);
  2362.     con.closeTransaction();
  2363.   }
  2364.   return 0;
  2365. }
  2367. // scan read
  2369. static int
  2370. scanreadtable(Par par)
  2371. {
  2372.   Con& con = par.con();
  2373.   const Tab& tab = par.tab();
  2374.   const Set& set = par.set();
  2375.   // expected
  2376.   const Set& set1 = set;
  2377.   LL3((par.m_verify ? "scanverify " : "scanread ") << tab.m_name);
  2378.   Set set2(tab, set.m_rows);
  2379.   CHK(con.startTransaction() == 0);
  2380.   CHK(con.getNdbScanOperation(tab) == 0);
  2381.   CHK(con.openScanRead(par.m_scanbat, par.m_scanpar) == 0);
  2382.   set2.getval(par);
  2383.   CHK(con.executeScan() == 0);
  2384.   while (1) {
  2385.     int ret;
  2386.     CHK((ret = con.nextScanResult(true)) == 0 || ret == 1);
  2387.     if (ret == 1)
  2388.       break;
  2389.     unsigned i = (unsigned)-1;
  2390.     CHK(set2.getkey(par, &i) == 0);
  2391.     CHK(set2.putval(i, false) == 0);
  2392.     LL4("row " << set2.count() << ": " << *set2.m_row[i]);
  2393.   }
  2394.   con.closeTransaction();
  2395.   if (par.m_verify)
  2396.     CHK(set1.verify(set2) == 0);
  2397.   return 0;
  2398. }
  2400. static int
  2401. scanreadtablefast(Par par, unsigned countcheck)
  2402. {
  2403.   Con& con = par.con();
  2404.   const Tab& tab = par.tab();
  2405.   const Set& set = par.set();
  2406.   LL3("scanfast " << tab.m_name);
  2407.   CHK(con.startTransaction() == 0);
  2408.   CHK(con.getNdbScanOperation(tab) == 0);
  2409.   CHK(con.openScanRead(par.m_scanbat, par.m_scanpar) == 0);
  2410.   // get 1st column
  2411.   NdbRecAttr* rec;
  2412.   CHK(con.getValue((Uint32)0, rec) == 0);
  2413.   CHK(con.executeScan() == 0);
  2414.   unsigned count = 0;
  2415.   while (1) {
  2416.     int ret;
  2417.     CHK((ret = con.nextScanResult(true)) == 0 || ret == 1);
  2418.     if (ret == 1)
  2419.       break;
  2420.     count++;
  2421.   }
  2422.   con.closeTransaction();
  2423.   CHK(count == countcheck);
  2424.   return 0;
  2425. }
  2427. static int
  2428. scanreadindex(Par par, const ITab& itab, const BSet& bset)
  2429. {
  2430.   Con& con = par.con();
  2431.   const Tab& tab = par.tab();
  2432.   const Set& set = par.set();
  2433.   // expected
  2434.   Set set1(tab, set.m_rows);
  2435.   bset.filter(set, set1);
  2436.   LL3((par.m_verify ? "scanverify " : "scanread ") << itab.m_name << " bounds=" << bset.m_bvals);
  2437.   LL4(bset);
  2438.   Set set2(tab, set.m_rows);
  2439.   CHK(con.startTransaction() == 0);
  2440.   CHK(con.getNdbScanOperation(itab, tab) == 0);
  2441.   CHK(con.openScanRead(par.m_scanbat, par.m_scanpar) == 0);
  2442.   CHK(bset.setbnd(par) == 0);
  2443.   set2.getval(par);
  2444.   CHK(con.executeScan() == 0);
  2445.   while (1) {
  2446.     int ret;
  2447.     CHK((ret = con.nextScanResult(true)) == 0 || ret == 1);
  2448.     if (ret == 1)
  2449.       break;
  2450.     unsigned i = (unsigned)-1;
  2451.     CHK(set2.getkey(par, &i) == 0);
  2452.     LL4("key " << i);
  2453.     CHK(set2.putval(i, par.m_dups) == 0);
  2454.     LL4("row " << set2.count() << ": " << *set2.m_row[i]);
  2455.   }
  2456.   con.closeTransaction();
  2457.   if (par.m_verify)
  2458.     CHK(set1.verify(set2) == 0);
  2459.   return 0;
  2460. }
  2462. static int
  2463. scanreadindexfast(Par par, const ITab& itab, const BSet& bset, unsigned countcheck)
  2464. {
  2465.   Con& con = par.con();
  2466.   const Tab& tab = par.tab();
  2467.   const Set& set = par.set();
  2468.   LL3("scanfast " << itab.m_name << " bounds=" << bset.m_bvals);
  2469.   LL4(bset);
  2470.   CHK(con.startTransaction() == 0);
  2471.   CHK(con.getNdbScanOperation(itab, tab) == 0);
  2472.   CHK(con.openScanRead(par.m_scanbat, par.m_scanpar) == 0);
  2473.   CHK(bset.setbnd(par) == 0);
  2474.   // get 1st column
  2475.   NdbRecAttr* rec;
  2476.   CHK(con.getValue((Uint32)0, rec) == 0);
  2477.   CHK(con.executeScan() == 0);
  2478.   unsigned count = 0;
  2479.   while (1) {
  2480.     int ret;
  2481.     CHK((ret = con.nextScanResult(true)) == 0 || ret == 1);
  2482.     if (ret == 1)
  2483.       break;
  2484.     count++;
  2485.   }
  2486.   con.closeTransaction();
  2487.   CHK(count == countcheck);
  2488.   return 0;
  2489. }
  2491. static int
  2492. scanreadindex(Par par, const ITab& itab)
  2493. {
  2494.   const Tab& tab = par.tab();
  2495.   for (unsigned i = 0; i < par.m_subsubloop; i++) {
  2496.     BSet bset(tab, itab, par.m_rows);
  2497.     bset.calc(par);
  2498.     CHK(scanreadindex(par, itab, bset) == 0);
  2499.   }
  2500.   return 0;
  2501. }
  2503. static int
  2504. scanreadindex(Par par)
  2505. {
  2506.   const Tab& tab = par.tab();
  2507.   for (unsigned i = 0; i < tab.m_itabs; i++) {
  2508.     if (! useindex(i))
  2509.       continue;
  2510.     const ITab& itab = tab.m_itab[i];
  2511.     CHK(scanreadindex(par, itab) == 0);
  2512.   }
  2513.   return 0;
  2514. }
  2516. static int
  2517. scanreadall(Par par)
  2518. {
  2519.   if (par.m_no < 11)
  2520.     CHK(scanreadtable(par) == 0);
  2521.   CHK(scanreadindex(par) == 0);
  2522.   return 0;
  2523. }
  2525. // timing scans
  2527. static int
  2528. timescantable(Par par)
  2529. {
  2530.   par.tmr().on();
  2531.   CHK(scanreadtablefast(par, par.m_totrows) == 0);
  2532.   par.tmr().off(par.set().m_rows);
  2533.   return 0;
  2534. }
  2536. static int
  2537. timescanpkindex(Par par)
  2538. {
  2539.   const Tab& tab = par.tab();
  2540.   const ITab& itab = tab.m_itab[0];     // 1st index is on PK
  2541.   BSet bset(tab, itab, par.m_rows);
  2542.   par.tmr().on();
  2543.   CHK(scanreadindexfast(par, itab, bset, par.m_totrows) == 0);
  2544.   par.tmr().off(par.set().m_rows);
  2545.   return 0;
  2546. }
  2548. static int
  2549. timepkreadtable(Par par)
  2550. {
  2551.   par.tmr().on();
  2552.   unsigned count = par.m_samples;
  2553.   if (count == 0)
  2554.     count = par.m_totrows;
  2555.   CHK(pkreadfast(par, count) == 0);
  2556.   par.tmr().off(count);
  2557.   return 0;
  2558. }
  2560. static int
  2561. timepkreadindex(Par par)
  2562. {
  2563.   const Tab& tab = par.tab();
  2564.   const ITab& itab = tab.m_itab[0];     // 1st index is on PK
  2565.   BSet bset(tab, itab, par.m_rows);
  2566.   unsigned count = par.m_samples;
  2567.   if (count == 0)
  2568.     count = par.m_totrows;
  2569.   par.tmr().on();
  2570.   for (unsigned j = 0; j < count; j++) {
  2571.     unsigned i = urandom(par.m_totrows);
  2572.     bset.calcpk(par, i);
  2573.     CHK(scanreadindexfast(par, itab, bset, 1) == 0);
  2574.   }
  2575.   par.tmr().off(count);
  2576.   return 0;
  2577. }
  2579. // scan update
  2581. static int
  2582. scanupdatetable(Par par)
  2583. {
  2584.   Con& con = par.con();
  2585.   const Tab& tab = par.tab();
  2586.   Set& set = par.set();
  2587.   LL3("scan update " << tab.m_name);
  2588.   Set set2(tab, set.m_rows);
  2589.   CHK(con.startTransaction() == 0);
  2590.   CHK(con.getNdbScanOperation(tab) == 0);
  2591.   CHK(con.openScanExclusive(par.m_scanbat, par.m_scanpar) == 0);
  2592.   set2.getval(par);
  2593.   CHK(con.executeScan() == 0);
  2594.   unsigned count = 0;
  2595.   // updating trans
  2596.   Con con2;
  2597.   con2.connect(con);
  2598.   CHK(con2.startTransaction() == 0);
  2599.   Lst lst;
  2600.   bool deadlock = false;
  2601.   while (1) {
  2602.     int ret;
  2603.     deadlock = par.m_deadlock;
  2604.     CHK((ret = con.nextScanResult(true, deadlock)) == 0 || ret == 1);
  2605.     if (ret == 1)
  2606.       break;
  2607.     if (deadlock) {
  2608.       LL1("scanupdatetable: stop on deadlock");
  2609.       break;
  2610.     }
  2611.     if (par.m_scanstop != 0 && urandom(par.m_scanstop) == 0) {
  2612.       con.closeScan();
  2613.       break;
  2614.     }
  2615.     do {
  2616.       unsigned i = (unsigned)-1;
  2617.       CHK(set2.getkey(par, &i) == 0);
  2618.       const Row& row = *set.m_row[i];
  2619.       set.lock();
  2620.       if (! set.exist(i) || set.pending(i)) {
  2621.         LL4("scan update " << tab.m_name << ": skip: " << row);
  2622.       } else {
  2623.         CHKTRY(set2.putval(i, false) == 0, set.unlock());
  2624.         CHKTRY(con.updateScanTuple(con2) == 0, set.unlock());
  2625.         Par par2 = par;
  2626.         par2.m_con = &con2;
  2627.         set.calc(par, i);
  2628.         CHKTRY(set.setrow(par2, i) == 0, set.unlock());
  2629.         LL4("scan update " << tab.m_name << ": " << row);
  2630.         lst.push(i);
  2631.       }
  2632.       set.unlock();
  2633.       if (lst.cnt() == par.m_batch) {
  2634.         CHK(con2.execute(Commit) == 0);
  2635.         con2.closeTransaction();
  2636.         set.lock();
  2637.         set.notpending(lst);
  2638.         set.unlock();
  2639.         count += lst.cnt();
  2640.         lst.reset();
  2641.         CHK(con2.startTransaction() == 0);
  2642.       }
  2643.       CHK((ret = con.nextScanResult(false)) == 0 || ret == 1 || ret == 2);
  2644.       if (ret == 2 && lst.cnt() != 0) {
  2645.         CHK(con2.execute(Commit) == 0);
  2646.         con2.closeTransaction();
  2647.         set.lock();
  2648.         set.notpending(lst);
  2649.         set.unlock();
  2650.         count += lst.cnt();
  2651.         lst.reset();
  2652.         CHK(con2.startTransaction() == 0);
  2653.       }
  2654.     } while (ret == 0);
  2655.     if (ret == 1)
  2656.       break;
  2657.   }
  2658.   con2.closeTransaction();
  2659.   LL3("scan update " << tab.m_name << " rows updated=" << count);
  2660.   con.closeTransaction();
  2661.   return 0;
  2662. }
  2664. static int
  2665. scanupdateindex(Par par, const ITab& itab, const BSet& bset)
  2666. {
  2667.   Con& con = par.con();
  2668.   const Tab& tab = par.tab();
  2669.   Set& set = par.set();
  2670.   LL3("scan update " << itab.m_name);
  2671.   Set set2(tab, set.m_rows);
  2672.   CHK(con.startTransaction() == 0);
  2673.   CHK(con.getNdbScanOperation(itab, tab) == 0);
  2674.   CHK(con.openScanExclusive(par.m_scanbat, par.m_scanpar) == 0);
  2675.   CHK(bset.setbnd(par) == 0);
  2676.   set2.getval(par);
  2677.   CHK(con.executeScan() == 0);
  2678.   unsigned count = 0;
  2679.   // updating trans
  2680.   Con con2;
  2681.   con2.connect(con);
  2682.   CHK(con2.startTransaction() == 0);
  2683.   Lst lst;
  2684.   bool deadlock = false;
  2685.   while (1) {
  2686.     int ret;
  2687.     deadlock = par.m_deadlock;
  2688.     CHK((ret = con.nextScanResult(true, deadlock)) == 0 || ret == 1);
  2689.     if (ret == 1)
  2690.       break;
  2691.     if (deadlock) {
  2692.       LL1("scanupdateindex: stop on deadlock");
  2693.       break;
  2694.     }
  2695.     if (par.m_scanstop != 0 && urandom(par.m_scanstop) == 0) {
  2696.       con.closeScan();
  2697.       break;
  2698.     }
  2699.     do {
  2700.       unsigned i = (unsigned)-1;
  2701.       CHK(set2.getkey(par, &i) == 0);
  2702.       const Row& row = *set.m_row[i];
  2703.       set.lock();
  2704.       if (! set.exist(i) || set.pending(i)) {
  2705.         LL4("scan update " << itab.m_name << ": skip: " << row);
  2706.       } else {
  2707.         CHKTRY(set2.putval(i, par.m_dups) == 0, set.unlock());
  2708.         CHKTRY(con.updateScanTuple(con2) == 0, set.unlock());
  2709.         Par par2 = par;
  2710.         par2.m_con = &con2;
  2711.         set.calc(par, i);
  2712.         CHKTRY(set.setrow(par2, i) == 0, set.unlock());
  2713.         LL4("scan update " << itab.m_name << ": " << row);
  2714.         lst.push(i);
  2715.       }
  2716.       set.unlock();
  2717.       if (lst.cnt() == par.m_batch) {
  2718.         CHK(con2.execute(Commit) == 0);
  2719.         con2.closeTransaction();
  2720.         set.lock();
  2721.         set.notpending(lst);
  2722.         set.unlock();
  2723.         count += lst.cnt();
  2724.         lst.reset();
  2725.         CHK(con2.startTransaction() == 0);
  2726.       }
  2727.       CHK((ret = con.nextScanResult(false)) == 0 || ret == 1 || ret == 2);
  2728.       if (ret == 2 && lst.cnt() != 0) {
  2729.         CHK(con2.execute(Commit) == 0);
  2730.         con2.closeTransaction();
  2731.         set.lock();
  2732.         set.notpending(lst);
  2733.         set.unlock();
  2734.         count += lst.cnt();
  2735.         lst.reset();
  2736.         CHK(con2.startTransaction() == 0);
  2737.       }
  2738.     } while (ret == 0);
  2739.   }
  2740.   con2.closeTransaction();
  2741.   LL3("scan update " << itab.m_name << " rows updated=" << count);
  2742.   con.closeTransaction();
  2743.   return 0;
  2744. }
  2746. static int
  2747. scanupdateindex(Par par, const ITab& itab)
  2748. {
  2749.   const Tab& tab = par.tab();
  2750.   for (unsigned i = 0; i < par.m_subsubloop; i++) {
  2751.     BSet bset(tab, itab, par.m_rows);
  2752.     bset.calc(par);
  2753.     CHK(scanupdateindex(par, itab, bset) == 0);
  2754.   }
  2755.   return 0;
  2756. }
  2758. static int
  2759. scanupdateindex(Par par)
  2760. {
  2761.   const Tab& tab = par.tab();
  2762.   for (unsigned i = 0; i < tab.m_itabs; i++) {
  2763.     if (! useindex(i))
  2764.       continue;
  2765.     const ITab& itab = tab.m_itab[i];
  2766.     CHK(scanupdateindex(par, itab) == 0);
  2767.   }
  2768.   return 0;
  2769. }
  2771. static int
  2772. scanupdateall(Par par)
  2773. {
  2774.   CHK(scanupdatetable(par) == 0);
  2775.   CHK(scanupdateindex(par) == 0);
  2776.   return 0;
  2777. }
  2779. // medium level routines
  2781. static int
  2782. readverify(Par par)
  2783. {
  2784.   if (par.m_noverify)
  2785.     return 0;
  2786.   par.m_verify = true;
  2787.   if (par.m_abortpct != 0) {
  2788.     LL2("skip verify in this version"); // implement in 5.0 version
  2789.     par.m_verify = false;
  2790.   }
  2791.   CHK(pkread(par) == 0);
  2792.   CHK(scanreadall(par) == 0);
  2793.   return 0;
  2794. }
  2796. static int
  2797. readverifyfull(Par par)
  2798. {
  2799.   if (par.m_noverify)
  2800.     return 0;
  2801.   par.m_verify = true;
  2802.   if (par.m_no == 0)
  2803.     CHK(scanreadtable(par) == 0);
  2804.   else {
  2805.     const Tab& tab = par.tab();
  2806.     unsigned i = par.m_no;
  2807.     if (i <= tab.m_itabs && useindex(i)) {
  2808.       const ITab& itab = tab.m_itab[i - 1];
  2809.       BSet bset(tab, itab, par.m_rows);
  2810.       CHK(scanreadindex(par, itab, bset) == 0);
  2811.     }
  2812.   }
  2813.   return 0;
  2814. }
  2816. static int
  2817. pkops(Par par)
  2818. {
  2819.   par.m_randomkey = true;
  2820.   for (unsigned i = 0; i < par.m_subsubloop; i++) {
  2821.     unsigned sel = urandom(10);
  2822.     if (par.m_slno % 2 == 0) {
  2823.       // favor insert
  2824.       if (sel < 8) {
  2825.         CHK(pkinsert(par) == 0);
  2826.       } else if (sel < 9) {
  2827.         CHK(pkupdate(par) == 0);
  2828.       } else {
  2829.         CHK(pkdelete(par) == 0);
  2830.       }
  2831.     } else {
  2832.       // favor delete
  2833.       if (sel < 1) {
  2834.         CHK(pkinsert(par) == 0);
  2835.       } else if (sel < 2) {
  2836.         CHK(pkupdate(par) == 0);
  2837.       } else {
  2838.         CHK(pkdelete(par) == 0);
  2839.       }
  2840.     }
  2841.   }
  2842.   return 0;
  2843. }
  2845. static int
  2846. pkupdatescanread(Par par)
  2847. {
  2848.   par.m_dups = true;
  2849.   unsigned sel = urandom(10);
  2850.   if (sel < 5) {
  2851.     CHK(pkupdate(par) == 0);
  2852.   } else if (sel < 6) {
  2853.     par.m_verify = false;
  2854.     CHK(scanreadtable(par) == 0);
  2855.   } else {
  2856.     par.m_verify = false;
  2857.     CHK(scanreadindex(par) == 0);
  2858.   }
  2859.   return 0;
  2860. }
  2862. static int
  2863. mixedoperations(Par par)
  2864. {
  2865.   par.m_dups = true;
  2866.   par.m_deadlock = true;
  2867.   par.m_scanstop = par.m_totrows;       // randomly close scans
  2868.   unsigned sel = urandom(10);
  2869.   if (sel < 2) {
  2870.     CHK(pkdelete(par) == 0);
  2871.   } else if (sel < 4) {
  2872.     CHK(pkupdate(par) == 0);
  2873.   } else if (sel < 6) {
  2874.     CHK(scanupdatetable(par) == 0);
  2875.   } else {
  2876.     CHK(scanupdateindex(par) == 0);
  2877.   }
  2878.   return 0;
  2879. }
  2881. static int
  2882. pkupdateindexbuild(Par par)
  2883. {
  2884.   if (par.m_no == 0) {
  2885.     CHK(createindex(par) == 0);
  2886.   } else {
  2887.     par.m_randomkey = true;
  2888.     CHK(pkupdate(par) == 0);
  2889.   }
  2890.   return 0;
  2891. }
  2893. // threads
  2895. typedef int (*TFunc)(Par par);
  2896. enum TMode { ST = 1, MT = 2 };
  2898. extern "C" { static void* runthread(void* arg); }
  2900. struct Thr {
  2901.   enum State { Wait, Start, Stop, Stopped, Exit };
  2902.   State m_state;
  2903.   Par m_par;
  2904.   Uint64 m_id;
  2905.   NdbThread* m_thread;
  2906.   NdbMutex* m_mutex;
  2907.   NdbCondition* m_cond;
  2908.   TFunc m_func;
  2909.   int m_ret;
  2910.   void* m_status;
  2911.   Thr(Par par, unsigned n);
  2912.   ~Thr();
  2913.   int run();
  2914.   void start();
  2915.   void stop();
  2916.   void stopped();
  2917.   void exit();
  2918.   //
  2919.   void lock() {
  2920.     NdbMutex_Lock(m_mutex);
  2921.   }
  2922.   void unlock() {
  2923.     NdbMutex_Unlock(m_mutex);
  2924.   }
  2925.   void wait() {
  2926.     NdbCondition_Wait(m_cond, m_mutex);
  2927.   }
  2928.   void signal() {
  2929.     NdbCondition_Signal(m_cond);
  2930.   }
  2931.   void join() {
  2932.     NdbThread_WaitFor(m_thread, &m_status);
  2933.     m_thread = 0;
  2934.   }
  2935. };
  2937. Thr::Thr(Par par, unsigned n) :
  2938.   m_state(Wait),
  2939.   m_par(par),
  2940.   m_id(0),
  2941.   m_thread(0),
  2942.   m_mutex(0),
  2943.   m_cond(0),
  2944.   m_func(0),
  2945.   m_ret(0),
  2946.   m_status(0)
  2947. {
  2948.   m_par.m_no = n;
  2949.   char buf[10];
  2950.   sprintf(buf, "thr%03u", par.m_no);
  2951.   const char* name = strcpy(new char[10], buf);
  2952.   // mutex
  2953.   m_mutex = NdbMutex_Create();
  2954.   m_cond = NdbCondition_Create();
  2955.   assert(m_mutex != 0 && m_cond != 0);
  2956.   // run
  2957.   const unsigned stacksize = 256 * 1024;
  2958.   const NDB_THREAD_PRIO prio = NDB_THREAD_PRIO_LOW;
  2959.   m_thread = NdbThread_Create(runthread, (void**)this, stacksize, name, prio);
  2960. }
  2962. Thr::~Thr()
  2963. {
  2964.   if (m_thread != 0) {
  2965.     NdbThread_Destroy(&m_thread);
  2966.     m_thread = 0;
  2967.   }
  2968.   if (m_cond != 0) {
  2969.     NdbCondition_Destroy(m_cond);
  2970.     m_cond = 0;
  2971.   }
  2972.   if (m_mutex != 0) {
  2973.     NdbMutex_Destroy(m_mutex);
  2974.     m_mutex = 0;
  2975.   }
  2976. }
  2978. static void*
  2979. runthread(void* arg)
  2980. {
  2981.   Thr& thr = *(Thr*)arg;
  2982.   thr.m_id = (Uint64)pthread_self();
  2983.   if (thr.run() < 0) {
  2984.     LL1("exit on error");
  2985.   } else {
  2986.     LL4("exit ok");
  2987.   }
  2988.   return 0;
  2989. }
  2991. int
  2992. Thr::run()
  2993. {
  2994.   LL4("run");
  2995.   Con con;
  2996.   CHK(con.connect() == 0);
  2997.   m_par.m_con = &con;
  2998.   LL4("connected");
  2999.   while (1) {
  3000.     lock();
  3001.     while (m_state != Start && m_state != Exit) {
  3002.       LL4("wait");
  3003.       wait();
  3004.     }
  3005.     if (m_state == Exit) {
  3006.       LL4("exit");
  3007.       unlock();
  3008.       break;
  3009.     }
  3010.     LL4("start");
  3011.     assert(m_state == Start);
  3012.     m_ret = (*m_func)(m_par);
  3013.     m_state = Stopped;
  3014.     LL4("stop");
  3015.     signal();
  3016.     unlock();
  3017.     CHK(m_ret == 0);
  3018.   }
  3019.   con.disconnect();
  3020.   return 0;
  3021. }
  3023. void
  3024. Thr::start()
  3025. {
  3026.   lock();
  3027.   m_state = Start;
  3028.   signal();
  3029.   unlock();
  3030. }
  3032. void
  3033. Thr::stop()
  3034. {
  3035.   lock();
  3036.   m_state = Stop;
  3037.   signal();
  3038.   unlock();
  3039. }
  3041. void
  3042. Thr::stopped()
  3043. {
  3044.   lock();
  3045.   while (m_state != Stopped)
  3046.     wait();
  3047.   m_state = Wait;
  3048.   unlock();
  3049. }
  3051. void
  3052. Thr::exit()
  3053. {
  3054.   lock();
  3055.   m_state = Exit;
  3056.   signal();
  3057.   unlock();
  3058. }
  3060. // test run
  3062. static Thr** g_thrlist = 0;
  3064. static unsigned
  3065. getthrno()
  3066. {
  3067.   if (g_thrlist != 0) {
  3068.     Uint64 id = (Uint64)pthread_self();
  3069.     for (unsigned n = 0; n < g_opt.m_threads; n++) {
  3070.       if (g_thrlist[n] != 0) {
  3071.         const Thr& thr = *g_thrlist[n];
  3072.         if (thr.m_id == id)
  3073.           return thr.m_par.m_no;
  3074.       }
  3075.     }
  3076.   }
  3077.   return (unsigned)-1;
  3078. }
  3080. static int
  3081. runstep(Par par, const char* fname, TFunc func, unsigned mode)
  3082. {
  3083.   LL2(fname);
  3084.   const int threads = (mode & ST ? 1 : par.m_threads);
  3085.   int n; 
  3086.   for (n = 0; n < threads; n++) {
  3087.     LL4("start " << n);
  3088.     Thr& thr = *g_thrlist[n];
  3089.     Par oldpar = thr.m_par;
  3090.     // update parameters
  3091.     thr.m_par = par;
  3092.     thr.m_par.m_no = oldpar.m_no;
  3093.     thr.m_par.m_con = oldpar.m_con;
  3094.     thr.m_func = func;
  3095.     thr.start();
  3096.   }
  3097.   unsigned errs = 0;
  3098.   for (n = threads - 1; n >= 0; n--) {
  3099.     LL4("stop " << n);
  3100.     Thr& thr = *g_thrlist[n];
  3101.     thr.stopped();
  3102.     if (thr.m_ret != 0)
  3103.       errs++;
  3104.   }
  3105.   CHK(errs == 0);
  3106.   return 0;
  3107. }
  3109. #define RUNSTEP(par, func, mode) CHK(runstep(par, #func, func, mode) == 0)
  3111. static int
  3112. tbuild(Par par)
  3113. {
  3114.   RUNSTEP(par, droptable, ST);
  3115.   RUNSTEP(par, createtable, ST);
  3116.   RUNSTEP(par, invalidatetable, MT);
  3117.   for (par.m_slno = 0; par.m_slno < par.m_subloop; par.m_slno++) {
  3118.     if (par.m_slno % 2 == 0) {
  3119.       RUNSTEP(par, createindex, ST);
  3120.       RUNSTEP(par, invalidateindex, MT);
  3121.       RUNSTEP(par, pkinsert, MT);
  3122.     } else {
  3123.       RUNSTEP(par, pkinsert, MT);
  3124.       RUNSTEP(par, createindex, ST);
  3125.       RUNSTEP(par, invalidateindex, MT);
  3126.     }
  3127.     RUNSTEP(par, pkupdate, MT);
  3128.     RUNSTEP(par, readverifyfull, MT);
  3129.     RUNSTEP(par, pkdelete, MT);
  3130.     RUNSTEP(par, readverifyfull, MT);
  3131.     RUNSTEP(par, dropindex, ST);
  3132.   }
  3133.   return 0;
  3134. }
  3136. static int
  3137. tpkops(Par par)
  3138. {
  3139.   RUNSTEP(par, droptable, ST);
  3140.   RUNSTEP(par, createtable, ST);
  3141.   RUNSTEP(par, invalidatetable, MT);
  3142.   RUNSTEP(par, createindex, ST);
  3143.   RUNSTEP(par, invalidateindex, MT);
  3144.   for (par.m_slno = 0; par.m_slno < par.m_subloop; par.m_slno++) {
  3145.     RUNSTEP(par, pkops, MT);
  3146.     LL2("rows=" << par.set().count());
  3147.     RUNSTEP(par, readverifyfull, MT);
  3148.   }
  3149.   return 0;
  3150. }
  3152. static int
  3153. tpkopsread(Par par)
  3154. {
  3155.   RUNSTEP(par, droptable, ST);
  3156.   RUNSTEP(par, createtable, ST);
  3157.   RUNSTEP(par, invalidatetable, MT);
  3158.   RUNSTEP(par, pkinsert, MT);
  3159.   RUNSTEP(par, createindex, ST);
  3160.   RUNSTEP(par, invalidateindex, MT);
  3161.   RUNSTEP(par, readverify, ST);
  3162.   for (par.m_slno = 0; par.m_slno < par.m_subloop; par.m_slno++) {
  3163.     RUNSTEP(par, pkupdatescanread, MT);
  3164.     RUNSTEP(par, readverify, ST);
  3165.   }
  3166.   RUNSTEP(par, pkdelete, MT);
  3167.   RUNSTEP(par, readverify, ST);
  3168.   return 0;
  3169. }
  3171. static int
  3172. tmixedops(Par par)
  3173. {
  3174.   RUNSTEP(par, droptable, ST);
  3175.   RUNSTEP(par, createtable, ST);
  3176.   RUNSTEP(par, invalidatetable, MT);
  3177.   RUNSTEP(par, pkinsert, MT);
  3178.   RUNSTEP(par, createindex, ST);
  3179.   RUNSTEP(par, invalidateindex, MT);
  3180.   RUNSTEP(par, readverify, ST);
  3181.   for (par.m_slno = 0; par.m_slno < par.m_subloop; par.m_slno++) {
  3182.     RUNSTEP(par, mixedoperations, MT);
  3183.     RUNSTEP(par, readverify, ST);
  3184.   }
  3185.   return 0;
  3186. }
  3188. static int
  3189. tbusybuild(Par par)
  3190. {
  3191.   RUNSTEP(par, droptable, ST);
  3192.   RUNSTEP(par, createtable, ST);
  3193.   RUNSTEP(par, invalidatetable, MT);
  3194.   RUNSTEP(par, pkinsert, MT);
  3195.   for (par.m_slno = 0; par.m_slno < par.m_subloop; par.m_slno++) {
  3196.     RUNSTEP(par, pkupdateindexbuild, MT);
  3197.     RUNSTEP(par, invalidateindex, MT);
  3198.     RUNSTEP(par, readverify, ST);
  3199.     RUNSTEP(par, dropindex, ST);
  3200.   }
  3201.   return 0;
  3202. }
  3204. static int
  3205. trollback(Par par)
  3206. {
  3207.   par.m_abortpct = 50;
  3208.   RUNSTEP(par, droptable, ST);
  3209.   RUNSTEP(par, createtable, ST);
  3210.   RUNSTEP(par, invalidatetable, MT);
  3211.   RUNSTEP(par, pkinsert, MT);
  3212.   RUNSTEP(par, createindex, ST);
  3213.   RUNSTEP(par, invalidateindex, MT);
  3214.   RUNSTEP(par, readverify, ST);
  3215.   for (par.m_slno = 0; par.m_slno < par.m_subloop; par.m_slno++) {
  3216.     RUNSTEP(par, mixedoperations, MT);
  3217.     RUNSTEP(par, readverify, ST);
  3218.   }
  3219.   return 0;
  3220. }
  3222. static int
  3223. ttimebuild(Par par)
  3224. {
  3225.   Tmr t1;
  3226.   RUNSTEP(par, droptable, ST);
  3227.   RUNSTEP(par, createtable, ST);
  3228.   RUNSTEP(par, invalidatetable, MT);
  3229.   for (par.m_slno = 0; par.m_slno < par.m_subloop; par.m_slno++) {
  3230.     RUNSTEP(par, pkinsert, MT);
  3231.     t1.on();
  3232.     RUNSTEP(par, createindex, ST);
  3233.     t1.off(par.m_totrows);
  3234.     RUNSTEP(par, invalidateindex, MT);
  3235.     RUNSTEP(par, dropindex, ST);
  3236.   }
  3237.   LL1("build index - " << t1.time());
  3238.   return 0;
  3239. }
  3241. static int
  3242. ttimemaint(Par par)
  3243. {
  3244.   Tmr t1, t2;
  3245.   RUNSTEP(par, droptable, ST);
  3246.   RUNSTEP(par, createtable, ST);
  3247.   RUNSTEP(par, invalidatetable, MT);
  3248.   for (par.m_slno = 0; par.m_slno < par.m_subloop; par.m_slno++) {
  3249.     RUNSTEP(par, pkinsert, MT);
  3250.     t1.on();
  3251.     RUNSTEP(par, pkupdate, MT);
  3252.     t1.off(par.m_totrows);
  3253.     RUNSTEP(par, createindex, ST);
  3254.     RUNSTEP(par, invalidateindex, MT);
  3255.     t2.on();
  3256.     RUNSTEP(par, pkupdate, MT);
  3257.     t2.off(par.m_totrows);
  3258.     RUNSTEP(par, dropindex, ST);
  3259.   }
  3260.   LL1("update - " << t1.time());
  3261.   LL1("update indexed - " << t2.time());
  3262.   LL1("overhead - " << t2.over(t1));
  3263.   return 0;
  3264. }
  3266. static int
  3267. ttimescan(Par par)
  3268. {
  3269.   Tmr t1, t2;
  3270.   RUNSTEP(par, droptable, ST);
  3271.   RUNSTEP(par, createtable, ST);
  3272.   RUNSTEP(par, invalidatetable, MT);
  3273.   for (par.m_slno = 0; par.m_slno < par.m_subloop; par.m_slno++) {
  3274.     RUNSTEP(par, pkinsert, MT);
  3275.     RUNSTEP(par, createindex, ST);
  3276.     par.m_tmr = &t1;
  3277.     RUNSTEP(par, timescantable, ST);
  3278.     par.m_tmr = &t2;
  3279.     RUNSTEP(par, timescanpkindex, ST);
  3280.     RUNSTEP(par, dropindex, ST);
  3281.   }
  3282.   LL1("full scan table - " << t1.time());
  3283.   LL1("full scan PK index - " << t2.time());
  3284.   LL1("overhead - " << t2.over(t1));
  3285.   return 0;
  3286. }
  3288. static int
  3289. ttimepkread(Par par)
  3290. {
  3291.   Tmr t1, t2;
  3292.   RUNSTEP(par, droptable, ST);
  3293.   RUNSTEP(par, createtable, ST);
  3294.   RUNSTEP(par, invalidatetable, MT);
  3295.   for (par.m_slno = 0; par.m_slno < par.m_subloop; par.m_slno++) {
  3296.     RUNSTEP(par, pkinsert, MT);
  3297.     RUNSTEP(par, createindex, ST);
  3298.     par.m_tmr = &t1;
  3299.     RUNSTEP(par, timepkreadtable, ST);
  3300.     par.m_tmr = &t2;
  3301.     RUNSTEP(par, timepkreadindex, ST);
  3302.     RUNSTEP(par, dropindex, ST);
  3303.   }
  3304.   LL1("pk read table - " << t1.time());
  3305.   LL1("pk read PK index - " << t2.time());
  3306.   LL1("overhead - " << t2.over(t1));
  3307.   return 0;
  3308. }
  3310. static int
  3311. tdrop(Par par)
  3312. {
  3313.   RUNSTEP(par, droptable, ST);
  3314.   return 0;
  3315. }
  3317. struct TCase {
  3318.   const char* m_name;
  3319.   TFunc m_func;
  3320.   const char* m_desc;
  3321.   TCase(const char* name, TFunc func, const char* desc) :
  3322.     m_name(name),
  3323.     m_func(func),
  3324.     m_desc(desc) {
  3325.   }
  3326. };
  3328. static const TCase
  3329. tcaselist[] = {
  3330.   TCase("a", tbuild, "index build"),
  3331.   // "b" in 5.0
  3332.   TCase("c", tpkops, "pk operations"),
  3333.   TCase("d", tpkopsread, "pk operations and scan reads"),
  3334.   TCase("e", tmixedops, "pk operations and scan operations"),
  3335.   TCase("f", tbusybuild, "pk operations and index build"),
  3336.   TCase("g", trollback, "operations with random rollbacks"),
  3337.   TCase("t", ttimebuild, "time index build"),
  3338.   TCase("u", ttimemaint, "time index maintenance"),
  3339.   TCase("v", ttimescan, "time full scan table vs index on pk"),
  3340.   TCase("w", ttimepkread, "time pk read table vs index on pk"),
  3341.   TCase("z", tdrop, "drop test tables")
  3342. };
  3344. static const unsigned
  3345. tcasecount = sizeof(tcaselist) / sizeof(tcaselist[0]);
  3347. static void
  3348. printcases()
  3349. {
  3350.   ndbout << "test cases:" << endl;
  3351.   for (unsigned i = 0; i < tcasecount; i++) {
  3352.     const TCase& tcase = tcaselist[i];
  3353.     ndbout << "  " << tcase.m_name << " - " << tcase.m_desc << endl;
  3354.   }
  3355. }
  3357. static void
  3358. printtables()
  3359. {
  3360.   ndbout << "tables and indexes (X1 is on table PK):" << endl;
  3361.   for (unsigned j = 0; j < tabcount; j++) {
  3362.     const Tab& tab = tablist[j];
  3363.     ndbout << "  " << tab.m_name;
  3364.     for (unsigned i = 0; i < tab.m_itabs; i++) {
  3365.       const ITab& itab = tab.m_itab[i];
  3366.       ndbout << " " << itab.m_name;
  3367.     }
  3368.     ndbout << endl;
  3369.   }
  3370. }
  3372. static int
  3373. runtest(Par par)
  3374. {
  3375.   LL1("start");
  3376.   if (par.m_seed != 0)
  3377.     srandom(par.m_seed);
  3378.   assert(par.m_csname != 0);
  3379.   CHARSET_INFO* cs;
  3380.   CHK((cs = get_charset_by_name(par.m_csname, MYF(0))) != 0 || (cs = get_charset_by_csname(par.m_csname, MY_CS_PRIMARY, MYF(0))) != 0);
  3381.   par.m_cs = cs;
  3382.   Con con;
  3383.   CHK(con.connect() == 0);
  3384.   par.m_con = &con;
  3385.   g_thrlist = new Thr* [par.m_threads];
  3386.   unsigned n;
  3387.   for (n = 0; n < par.m_threads; n++) {
  3388.     g_thrlist[n] = 0;
  3389.   }
  3390.   for (n = 0; n < par.m_threads; n++) {
  3391.     g_thrlist[n] = new Thr(par, n);
  3392.     Thr& thr = *g_thrlist[n];
  3393.     assert(thr.m_thread != 0);
  3394.   }
  3395.   for (par.m_lno = 0; par.m_loop == 0 || par.m_lno < par.m_loop; par.m_lno++) {
  3396.     LL1("loop " << par.m_lno);
  3397.     if (par.m_seed == 0)
  3398.       srandom(par.m_lno);
  3399.     for (unsigned i = 0; i < tcasecount; i++) {
  3400.       const TCase& tcase = tcaselist[i];
  3401.       if (par.m_case != 0 && strchr(par.m_case, tcase.m_name[0]) == 0)
  3402.         continue;
  3403.       LL1("case " << tcase.m_name << " - " << tcase.m_desc);
  3404.       for (unsigned j = 0; j < tabcount; j++) {
  3405.         if (! usetable(j))
  3406.           continue;
  3407.         const Tab& tab = tablist[j];
  3408.         par.m_tab = &tab;
  3409.         delete par.m_set;
  3410.         par.m_set = new Set(tab, par.m_totrows);
  3411.         LL1("table " << tab.m_name);
  3412.         CHK(tcase.m_func(par) == 0);
  3413.       }
  3414.     }
  3415.   }
  3416.   for (n = 0; n < par.m_threads; n++) {
  3417.     Thr& thr = *g_thrlist[n];
  3418.     thr.exit();
  3419.   }
  3420.   for (n = 0; n < par.m_threads; n++) {
  3421.     Thr& thr = *g_thrlist[n];
  3422.     thr.join();
  3423.     delete &thr;
  3424.   }
  3425.   delete [] g_thrlist;
  3426.   g_thrlist = 0;
  3427.   con.disconnect();
  3428.   LL1("done");
  3429.   return 0;
  3430. }
  3432. NDB_COMMAND(testOIBasic, "testOIBasic", "testOIBasic", "testOIBasic", 65535)
  3433. {
  3434.   ndb_init();
  3435.   if (ndbout_mutex == NULL)
  3436.     ndbout_mutex= NdbMutex_Create();
  3437.   while (++argv, --argc > 0) {
  3438.     const char* arg = argv[0];
  3439.     if (*arg != '-') {
  3440.       ndbout << "testOIBasic: unknown argument " << arg;
  3441.       goto usage;
  3442.     }
  3443.     if (strcmp(arg, "-batch") == 0) {
  3444.       if (++argv, --argc > 0) {
  3445.         g_opt.m_batch = atoi(argv[0]);
  3446.         continue;
  3447.       }
  3448.     }
  3449.     if (strcmp(arg, "-bound") == 0) {
  3450.       if (++argv, --argc > 0) {
  3451.         const char* p = argv[0];
  3452.         if (strlen(p) != 0 && strlen(p) == strspn(p, "01234")) {
  3453.           g_opt.m_bound = strdup(p);
  3454.           continue;
  3455.         }
  3456.       }
  3457.     }
  3458.     if (strcmp(arg, "-case") == 0) {
  3459.       if (++argv, --argc > 0) {
  3460.         g_opt.m_case = strdup(argv[0]);
  3461.         continue;
  3462.       }
  3463.     }
  3464.     if (strcmp(arg, "-core") == 0) {
  3465.       g_opt.m_core = true;
  3466.       continue;
  3467.     }
  3468.     if (strcmp(arg, "-csname") == 0) {
  3469.       if (++argv, --argc > 0) {
  3470.         g_opt.m_csname = strdup(argv[0]);
  3471.         continue;
  3472.       }
  3473.     }
  3474.     if (strcmp(arg, "-die") == 0) {
  3475.       if (++argv, --argc > 0) {
  3476.         g_opt.m_die = atoi(argv[0]);
  3477.         continue;
  3478.       }
  3479.     }
  3480.     if (strcmp(arg, "-dups") == 0) {
  3481.       g_opt.m_dups = true;
  3482.       continue;
  3483.     }
  3484.     if (strcmp(arg, "-fragtype") == 0) {
  3485.       if (++argv, --argc > 0) {
  3486.         if (strcmp(argv[0], "single") == 0) {
  3487.           g_opt.m_fragtype = NdbDictionary::Object::FragSingle;
  3488.           continue;
  3489.         }
  3490.         if (strcmp(argv[0], "small") == 0) {
  3491.           g_opt.m_fragtype = NdbDictionary::Object::FragAllSmall;
  3492.           continue;
  3493.         }
  3494.         if (strcmp(argv[0], "medium") == 0) {
  3495.           g_opt.m_fragtype = NdbDictionary::Object::FragAllMedium;
  3496.           continue;
  3497.         }
  3498.         if (strcmp(argv[0], "large") == 0) {
  3499.           g_opt.m_fragtype = NdbDictionary::Object::FragAllLarge;
  3500.           continue;
  3501.         }
  3502.       }
  3503.     }
  3504.     if (strcmp(arg, "-index") == 0) {
  3505.       if (++argv, --argc > 0) {
  3506.         g_opt.m_index = strdup(argv[0]);
  3507.         continue;
  3508.       }
  3509.     }
  3510.     if (strcmp(arg, "-loop") == 0) {
  3511.       if (++argv, --argc > 0) {
  3512.         g_opt.m_loop = atoi(argv[0]);
  3513.         continue;
  3514.       }
  3515.     }
  3516.     if (strcmp(arg, "-nologging") == 0) {
  3517.       g_opt.m_nologging = true;
  3518.       continue;
  3519.     }
  3520.     if (strcmp(arg, "-noverify") == 0) {
  3521.       g_opt.m_noverify = true;
  3522.       continue;
  3523.     }
  3524.     if (strcmp(arg, "-pctnull") == 0) {
  3525.       if (++argv, --argc > 0) {
  3526.         g_opt.m_pctnull = atoi(argv[0]);
  3527.         continue;
  3528.       }
  3529.     }
  3530.     if (strcmp(arg, "-rows") == 0) {
  3531.       if (++argv, --argc > 0) {
  3532.         g_opt.m_rows = atoi(argv[0]);
  3533.         continue;
  3534.       }
  3535.     }
  3536.     if (strcmp(arg, "-samples") == 0) {
  3537.       if (++argv, --argc > 0) {
  3538.         g_opt.m_samples = atoi(argv[0]);
  3539.         continue;
  3540.       }
  3541.     }
  3542.     if (strcmp(arg, "-scanbat") == 0) {
  3543.       if (++argv, --argc > 0) {
  3544.         g_opt.m_scanbat = atoi(argv[0]);
  3545.         continue;
  3546.       }
  3547.     }
  3548.     if (strcmp(arg, "-scanpar") == 0) {
  3549.       if (++argv, --argc > 0) {
  3550.         g_opt.m_scanpar = atoi(argv[0]);
  3551.         continue;
  3552.       }
  3553.     }
  3554.     if (strcmp(arg, "-seed") == 0) {
  3555.       if (++argv, --argc > 0) {
  3556.         g_opt.m_seed = atoi(argv[0]);
  3557.         continue;
  3558.       }
  3559.     }
  3560.     if (strcmp(arg, "-subloop") == 0) {
  3561.       if (++argv, --argc > 0) {
  3562.         g_opt.m_subloop = atoi(argv[0]);
  3563.         continue;
  3564.       }
  3565.     }
  3566.     if (strcmp(arg, "-table") == 0) {
  3567.       if (++argv, --argc > 0) {
  3568.         g_opt.m_table = strdup(argv[0]);
  3569.         continue;
  3570.       }
  3571.     }
  3572.     if (strcmp(arg, "-threads") == 0) {
  3573.       if (++argv, --argc > 0) {
  3574.         g_opt.m_threads = atoi(argv[0]);
  3575.         continue;
  3576.       }
  3577.     }
  3578.     if (strcmp(arg, "-v") == 0) {
  3579.       if (++argv, --argc > 0) {
  3580.         g_opt.m_v = atoi(argv[0]);
  3581.         continue;
  3582.       }
  3583.     }
  3584.     if (strncmp(arg, "-v", 2) == 0 && isdigit(arg[2])) {
  3585.       g_opt.m_v = atoi(&arg[2]);
  3586.       continue;
  3587.     }
  3588.     if (strcmp(arg, "-h") == 0 || strcmp(arg, "-help") == 0) {
  3589.       printhelp();
  3590.       goto wrongargs;
  3591.     }
  3592.     ndbout << "testOIBasic: unknown option " << arg;
  3593.     goto usage;
  3594.   }
  3595.   {
  3596.     Par par(g_opt);
  3597.     g_ncc = new Ndb_cluster_connection();
  3598.     if (g_ncc->connect(30) != 0 || runtest(par) < 0)
  3599.       goto failed;
  3600.     delete g_ncc;
  3601.     g_ncc = 0;
  3602.   }
  3603.   // always exit with NDBT code
  3604. ok:
  3605.   return NDBT_ProgramExit(NDBT_OK);
  3606. failed:
  3607.   return NDBT_ProgramExit(NDBT_FAILED);
  3608. usage:
  3609.   ndbout << " (use -h for help)" << endl;
  3610. wrongargs:
  3611.   return NDBT_ProgramExit(NDBT_WRONGARGS);
  3612. }
  3614. // vim: set sw=2 et: