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

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

MySQL数据库

开发平台：

Visual C++

testBlobs.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.  * testBlobs
  19.  */
  21. #include <ndb_global.h>
  22. #include <NdbMain.h>
  23. #include <NdbOut.hpp>
  24. #include <NdbTest.hpp>
  25. #include <NdbTick.h>
  26. #include <ndb/src/ndbapi/NdbBlobImpl.hpp>
  28. struct Bcol {
  29.   bool m_nullable;
  30.   unsigned m_inline;
  31.   unsigned m_partsize;
  32.   unsigned m_stripe;
  33.   char m_btname[NdbBlobImpl::BlobTableNameSize];
  34.   Bcol(bool a, unsigned b, unsigned c, unsigned d) :
  35.     m_nullable(a),
  36.     m_inline(b),
  37.     m_partsize(c),
  38.     m_stripe(d)
  39.     {}
  40. };
  42. struct Opt {
  43.   unsigned m_batch;
  44.   bool m_core;
  45.   bool m_dbg;
  46.   bool m_dbgall;
  47.   const char* m_dbug;
  48.   bool m_full;
  49.   unsigned m_loop;
  50.   unsigned m_parts;
  51.   unsigned m_rows;
  52.   unsigned m_seed;
  53.   const char* m_skip;
  54.   const char* m_test;
  55.   // metadata
  56.   const char* m_tname;
  57.   const char* m_x1name;  // hash index
  58.   const char* m_x2name;  // ordered index
  59.   unsigned m_pk1off;
  60.   unsigned m_pk2len;
  61.   bool m_oneblob;
  62.   Bcol m_blob1;
  63.   Bcol m_blob2;
  64.   // perf
  65.   const char* m_tnameperf;
  66.   unsigned m_rowsperf;
  67.   // bugs
  68.   int m_bug;
  69.   int (*m_bugtest)();
  70.   Opt() :
  71.     m_batch(7),
  72.     m_core(false),
  73.     m_dbg(false),
  74.     m_dbgall(false),
  75.     m_dbug(0),
  76.     m_full(false),
  77.     m_loop(1),
  78.     m_parts(10),
  79.     m_rows(100),
  80.     m_seed(0),
  81.     m_skip(0),
  82.     m_test(0),
  83.     // metadata
  84.     m_tname("TBLOB1"),
  85.     m_x1name("TBLOB1X1"),
  86.     m_x2name("TBLOB1X2"),
  87.     m_pk1off(0x12340000),
  88.     m_pk2len(55),
  89.     m_oneblob(false),
  90.     m_blob1(false, 7, 1137, 10),
  91.     m_blob2(true, 99, 55, 1),
  92.     // perf
  93.     m_tnameperf("TBLOB2"),
  94.     m_rowsperf(10000),
  95.     // bugs
  96.     m_bug(0),
  97.     m_bugtest(0) {
  98.   }
  99. };
  101. static const unsigned g_max_pk2len = 256;
  103. static void
  104. printusage()
  105. {
  106.   Opt d;
  107.   ndbout
  108.     << "usage: testBlobs options [default/max]" << endl
  109.     << "  -batch N    number of pk ops in batch [" << d.m_batch << "]" << endl
  110.     << "  -core       dump core on error" << endl
  111.     << "  -dbg        print debug" << endl
  112.     << "  -dbgall     print also NDB API debug (if compiled in)" << endl
  113.     << "  -dbug opt   dbug options" << endl
  114.     << "  -full       read/write only full blob values" << endl
  115.     << "  -loop N     loop N times 0=forever [" << d.m_loop << "]" << endl
  116.     << "  -parts N    max parts in blob value [" << d.m_parts << "]" << endl
  117.     << "  -rows N     number of rows [" << d.m_rows << "]" << endl
  118.     << "  -rowsperf N rows for performace test [" << d.m_rowsperf << "]" << endl
  119.     << "  -seed N     random seed 0=loop number [" << d.m_seed << "]" << endl
  120.     << "  -skip xxx   skip given tests (see list) [no tests]" << endl
  121.     << "  -test xxx   only given tests (see list) [all tests]" << endl
  122.     << "metadata" << endl
  123.     << "  -pk2len N   length of PK2 [" << d.m_pk2len << "/" << g_max_pk2len <<"]" << endl
  124.     << "  -oneblob    only 1 blob attribute [default 2]" << endl
  125.     << "testcases for test/skip" << endl
  126.     << "  k           primary key ops" << endl
  127.     << "  i           hash index ops" << endl
  128.     << "  s           table scans" << endl
  129.     << "  r           ordered index scans" << endl
  130.     << "  p           performance test" << endl
  131.     << "additional flags for test/skip" << endl
  132.     << "  u           update existing blob value" << endl
  133.     << "  n           normal insert and update" << endl
  134.     << "  w           insert and update using writeTuple" << endl
  135.     << "  0           getValue / setValue" << endl
  136.     << "  1           setActiveHook" << endl
  137.     << "  2           readData / writeData" << endl
  138.     << "bug tests (no blob test)" << endl
  139.     << "  -bug 4088   ndb api hang with mixed ops on index table" << endl
  140.     << "  -bug nnnn   delete + write gives 626" << endl
  141.     << "  -bug nnnn   acc crash on delete and long key" << endl
  142.     ;
  143. }
  145. static Opt g_opt;
  147. static bool
  148. testcase(char x)
  149. {
  150.   if (x < 10)
  151.     x += '0';
  152.   return
  153.     (g_opt.m_test == 0 || strchr(g_opt.m_test, x) != 0) &&
  154.     (g_opt.m_skip == 0 || strchr(g_opt.m_skip, x) == 0);
  155. }
  157. static Ndb_cluster_connection* g_ncc = 0;
  158. static Ndb* g_ndb = 0;
  159. static NdbDictionary::Dictionary* g_dic = 0;
  160. static NdbConnection* g_con = 0;
  161. static NdbOperation* g_opr = 0;
  162. static NdbIndexOperation* g_opx = 0;
  163. static NdbScanOperation* g_ops = 0;
  164. static NdbBlob* g_bh1 = 0;
  165. static NdbBlob* g_bh2 = 0;
  166. static bool g_printerror = true;
  167. static unsigned g_loop = 0;
  169. static void
  170. printerror(int line, const char* msg)
  171. {
  172.   ndbout << "line " << line << " FAIL " << msg << endl;
  173.   if (! g_printerror) {
  174.     return;
  175.   }
  176.   if (g_ndb != 0 && g_ndb->getNdbError().code != 0) {
  177.     ndbout << "ndb: " << g_ndb->getNdbError() << endl;
  178.   }
  179.   if (g_dic != 0 && g_dic->getNdbError().code != 0) {
  180.     ndbout << "dic: " << g_dic->getNdbError() << endl;
  181.   }
  182.   if (g_con != 0 && g_con->getNdbError().code != 0) {
  183.     ndbout << "con: " << g_con->getNdbError() << endl;
  184.     if (g_opr != 0 && g_opr->getNdbError().code != 0) {
  185.       ndbout << "opr: table=" << g_opr->getTableName() << " " << g_opr->getNdbError() << endl;
  186.     }
  187.     if (g_opx != 0 && g_opx->getNdbError().code != 0) {
  188.       ndbout << "opx: table=" << g_opx->getTableName() << " " << g_opx->getNdbError() << endl;
  189.     }
  190.     if (g_ops != 0 && g_ops->getNdbError().code != 0) {
  191.       ndbout << "ops: table=" << g_ops->getTableName() << " " << g_ops->getNdbError() << endl;
  192.     }
  193.     NdbOperation* ope = g_con->getNdbErrorOperation();
  194.     if (ope != 0 && ope->getNdbError().code != 0) {
  195.       if (ope != g_opr && ope != g_opx && ope != g_ops)
  196.         ndbout << "ope: table=" << ope->getTableName() << " " << ope->getNdbError() << endl;
  197.     }
  198.   }
  199.   if (g_bh1 != 0 && g_bh1->getNdbError().code != 0) {
  200.     ndbout << "bh1: " << g_bh1->getNdbError() << endl;
  201.   }
  202.   if (g_bh2 != 0 && g_bh2->getNdbError().code != 0) {
  203.     ndbout << "bh2: " << g_bh2->getNdbError() << endl;
  204.   }
  205.   if (g_opt.m_core) {
  206.     abort();
  207.   }
  208.   g_printerror = false;
  209. }
  211. #define CHK(x) 
  212.   do { 
  213.     if (x) break; 
  214.     printerror(__LINE__, #x); return -1; 
  215.   } while (0)
  216. #define DBG(x) 
  217.   do { 
  218.     if (! g_opt.m_dbg) break; 
  219.     ndbout << "line " << __LINE__ << " " << x << endl; 
  220.   } while (0)
  222. static int
  223. dropTable()
  224. {
  225.   NdbDictionary::Table tab(g_opt.m_tname);
  226.   if (g_dic->getTable(g_opt.m_tname) != 0)
  227.     CHK(g_dic->dropTable(tab) == 0);
  228.   return 0;
  229. }
  231. static int
  232. createTable()
  233. {
  234.   NdbDictionary::Table tab(g_opt.m_tname);
  235.   tab.setLogging(false);
  236.   // col PK1 - Uint32
  237.   { NdbDictionary::Column col("PK1");
  238.     col.setType(NdbDictionary::Column::Unsigned);
  239.     col.setPrimaryKey(true);
  240.     tab.addColumn(col);
  241.   }
  242.   // col BL1 - Blob not-nullable
  243.   { NdbDictionary::Column col("BL1");
  244.     const Bcol& b = g_opt.m_blob1;
  245.     col.setType(NdbDictionary::Column::Blob);
  246.     col.setInlineSize(b.m_inline);
  247.     col.setPartSize(b.m_partsize);
  248.     col.setStripeSize(b.m_stripe);
  249.     tab.addColumn(col);
  250.   }
  251.   // col PK2 - Char[55]
  252.   if (g_opt.m_pk2len != 0)
  253.   { NdbDictionary::Column col("PK2");
  254.     col.setType(NdbDictionary::Column::Char);
  255.     col.setLength(g_opt.m_pk2len);
  256.     col.setPrimaryKey(true);
  257.     tab.addColumn(col);
  258.   }
  259.   // col BL2 - Text nullable
  260.   if (! g_opt.m_oneblob)
  261.   { NdbDictionary::Column col("BL2");
  262.     const Bcol& b = g_opt.m_blob2;
  263.     col.setType(NdbDictionary::Column::Text);
  264.     col.setNullable(true);
  265.     col.setInlineSize(b.m_inline);
  266.     col.setPartSize(b.m_partsize);
  267.     col.setStripeSize(b.m_stripe);
  268.     tab.addColumn(col);
  269.   }
  270.   // create table
  271.   CHK(g_dic->createTable(tab) == 0);
  272.   // unique hash index on PK2
  273.   if (g_opt.m_pk2len != 0)
  274.   { NdbDictionary::Index idx(g_opt.m_x1name);
  275.     idx.setType(NdbDictionary::Index::UniqueHashIndex);
  276.     idx.setLogging(false);
  277.     idx.setTable(g_opt.m_tname);
  278.     idx.addColumnName("PK2");
  279.     CHK(g_dic->createIndex(idx) == 0);
  280.   }
  281.   // ordered index on PK2
  282.   if (g_opt.m_pk2len != 0)
  283.   { NdbDictionary::Index idx(g_opt.m_x2name);
  284.     idx.setType(NdbDictionary::Index::OrderedIndex);
  285.     idx.setLogging(false);
  286.     idx.setTable(g_opt.m_tname);
  287.     idx.addColumnName("PK2");
  288.     CHK(g_dic->createIndex(idx) == 0);
  289.   }
  290.   return 0;
  291. }
  293. // tuples
  295. struct Bval {
  296.   char* m_val;
  297.   unsigned m_len;
  298.   char* m_buf;
  299.   unsigned m_buflen;
  300.   Bval() :
  301.     m_val(0),
  302.     m_len(0),
  303.     m_buf(0),   // read/write buffer
  304.     m_buflen(0)
  305.     {}
  306.   ~Bval() { delete [] m_val; delete [] m_buf; }
  307.   void alloc(unsigned buflen) {
  308.     m_buflen = buflen;
  309.     delete [] m_buf;
  310.     m_buf = new char [m_buflen];
  311.     trash();
  312.   }
  313.   void copyfrom(const Bval& v) {
  314.     m_len = v.m_len;
  315.     delete [] m_val;
  316.     if (v.m_val == 0)
  317.       m_val = 0;
  318.     else
  319.       m_val = (char*)memcpy(new char [m_len], v.m_val, m_len);
  320.   }
  321.   void trash() const {
  322.     assert(m_buf != 0);
  323.     memset(m_buf, 'x', m_buflen);
  324.   }
  325. private:
  326.   Bval(const Bval&);
  327.   Bval& operator=(const Bval&);
  328. };
  330. struct Tup {
  331.   bool m_exists;        // exists in table
  332.   Uint32 m_pk1;         // primary keys concatenated like keyinfo
  333.   char m_pk2[g_max_pk2len + 1];
  334.   Bval m_blob1;
  335.   Bval m_blob2;
  336.   Tup() :
  337.     m_exists(false)
  338.     {}
  339.   ~Tup() { }
  340.   // alloc buffers of max size
  341.   void alloc() {
  342.     m_blob1.alloc(g_opt.m_blob1.m_inline + g_opt.m_blob1.m_partsize * g_opt.m_parts);
  343.     m_blob2.alloc(g_opt.m_blob2.m_inline + g_opt.m_blob2.m_partsize * g_opt.m_parts);
  344.   }
  345.   void copyfrom(const Tup& tup) {
  346.     assert(m_pk1 == tup.m_pk1);
  347.     m_blob1.copyfrom(tup.m_blob1);
  348.     m_blob2.copyfrom(tup.m_blob2);
  349.   }
  350. private:
  351.   Tup(const Tup&);
  352.   Tup& operator=(const Tup&);
  353. };
  355. static Tup* g_tups;
  357. static unsigned
  358. urandom(unsigned n)
  359. {
  360.   return n == 0 ? 0 : random() % n;
  361. }
  363. static void
  364. calcBval(const Bcol& b, Bval& v, bool keepsize)
  365. {
  366.   if (b.m_nullable && urandom(10) == 0) {
  367.     v.m_len = 0;
  368.     delete [] v.m_val;
  369.     v.m_val = 0;
  370.     v.m_buf = new char [1];
  371.   } else {
  372.     if (keepsize && v.m_val != 0)
  373.       ;
  374.     else if (urandom(10) == 0)
  375.       v.m_len = urandom(b.m_inline);
  376.     else
  377.       v.m_len = urandom(b.m_inline + g_opt.m_parts * b.m_partsize + 1);
  378.     delete [] v.m_val;
  379.     v.m_val = new char [v.m_len + 1];
  380.     for (unsigned i = 0; i < v.m_len; i++)
  381.       v.m_val[i] = 'a' + urandom(25);
  382.     v.m_val[v.m_len] = 0;
  383.     v.m_buf = new char [v.m_len];
  384.   }
  385.   v.m_buflen = v.m_len;
  386.   v.trash();
  387. }
  389. static void
  390. calcBval(Tup& tup, bool keepsize)
  391. {
  392.   calcBval(g_opt.m_blob1, tup.m_blob1, keepsize);
  393.   if (! g_opt.m_oneblob)
  394.     calcBval(g_opt.m_blob2, tup.m_blob2, keepsize);
  395. }
  397. static void
  398. calcTups(bool keepsize)
  399. {
  400.   for (unsigned k = 0; k < g_opt.m_rows; k++) {
  401.     Tup& tup = g_tups[k];
  402.     tup.m_pk1 = g_opt.m_pk1off + k;
  403.     for (unsigned i = 0, n = k; i < g_opt.m_pk2len; i++) {
  404.       if (n != 0) {
  405.         tup.m_pk2[i] = '0' + n % 10;
  406.         n = n / 10;
  407.       } else {
  408.         tup.m_pk2[i] = 'a' + i % 26;
  409.       }
  410.     }
  411.     calcBval(tup, keepsize);
  412.   }
  413. }
  415. // blob handle ops
  417. static int
  418. getBlobHandles(NdbOperation* opr)
  419. {
  420.   CHK((g_bh1 = opr->getBlobHandle("BL1")) != 0);
  421.   if (! g_opt.m_oneblob)
  422.     CHK((g_bh2 = opr->getBlobHandle("BL2")) != 0);
  423.   return 0;
  424. }
  426. static int
  427. getBlobHandles(NdbIndexOperation* opx)
  428. {
  429.   CHK((g_bh1 = opx->getBlobHandle("BL1")) != 0);
  430.   if (! g_opt.m_oneblob)
  431.     CHK((g_bh2 = opx->getBlobHandle("BL2")) != 0);
  432.   return 0;
  433. }
  435. static int
  436. getBlobHandles(NdbScanOperation* ops)
  437. {
  438.   CHK((g_bh1 = ops->getBlobHandle("BL1")) != 0);
  439.   if (! g_opt.m_oneblob)
  440.     CHK((g_bh2 = ops->getBlobHandle("BL2")) != 0);
  441.   return 0;
  442. }
  444. static int
  445. getBlobLength(NdbBlob* h, unsigned& len)
  446. {
  447.   Uint64 len2 = (unsigned)-1;
  448.   CHK(h->getLength(len2) == 0);
  449.   len = (unsigned)len2;
  450.   assert(len == len2);
  451.   bool isNull;
  452.   CHK(h->getNull(isNull) == 0);
  453.   DBG("getBlobLength " << h->getColumn()->getName() << " len=" << len << " null=" << isNull);
  454.   return 0;
  455. }
  457. // setValue / getValue
  459. static int
  460. setBlobValue(NdbBlob* h, const Bval& v)
  461. {
  462.   bool null = (v.m_val == 0);
  463.   bool isNull;
  464.   unsigned len;
  465.   DBG("setValue " <<  h->getColumn()->getName() << " len=" << v.m_len << " null=" << null);
  466.   if (null) {
  467.     CHK(h->setNull() == 0);
  468.     isNull = false;
  469.     CHK(h->getNull(isNull) == 0 && isNull == true);
  470.     CHK(getBlobLength(h, len) == 0 && len == 0);
  471.   } else {
  472.     CHK(h->setValue(v.m_val, v.m_len) == 0);
  473.     CHK(h->getNull(isNull) == 0 && isNull == false);
  474.     CHK(getBlobLength(h, len) == 0 && len == v.m_len);
  475.   }
  476.   return 0;
  477. }
  479. static int
  480. setBlobValue(const Tup& tup)
  481. {
  482.   CHK(setBlobValue(g_bh1, tup.m_blob1) == 0);
  483.   if (! g_opt.m_oneblob)
  484.     CHK(setBlobValue(g_bh2, tup.m_blob2) == 0);
  485.   return 0;
  486. }
  488. static int
  489. getBlobValue(NdbBlob* h, const Bval& v)
  490. {
  491.   bool null = (v.m_val == 0);
  492.   DBG("getValue " <<  h->getColumn()->getName() << " buflen=" << v.m_buflen);
  493.   CHK(h->getValue(v.m_buf, v.m_buflen) == 0);
  494.   return 0;
  495. }
  497. static int
  498. getBlobValue(const Tup& tup)
  499. {
  500.   CHK(getBlobValue(g_bh1, tup.m_blob1) == 0);
  501.   if (! g_opt.m_oneblob)
  502.     CHK(getBlobValue(g_bh2, tup.m_blob2) == 0);
  503.   return 0;
  504. }
  506. static int
  507. verifyBlobValue(NdbBlob* h, const Bval& v)
  508. {
  509.   bool null = (v.m_val == 0);
  510.   bool isNull;
  511.   unsigned len;
  512.   if (null) {
  513.     isNull = false;
  514.     CHK(h->getNull(isNull) == 0 && isNull == true);
  515.     CHK(getBlobLength(h, len) == 0 && len == 0);
  516.   } else {
  517.     isNull = true;
  518.     CHK(h->getNull(isNull) == 0 && isNull == false);
  519.     CHK(getBlobLength(h, len) == 0 && len == v.m_len);
  520.     for (unsigned i = 0; i < v.m_len; i++)
  521.       CHK(v.m_val[i] == v.m_buf[i]);
  522.   }
  523.   return 0;
  524. }
  526. static int
  527. verifyBlobValue(const Tup& tup)
  528. {
  529.   CHK(verifyBlobValue(g_bh1, tup.m_blob1) == 0);
  530.   if (! g_opt.m_oneblob)
  531.     CHK(verifyBlobValue(g_bh2, tup.m_blob2) == 0);
  532.   return 0;
  533. }
  535. // readData / writeData
  537. static int
  538. writeBlobData(NdbBlob* h, const Bval& v)
  539. {
  540.   bool null = (v.m_val == 0);
  541.   bool isNull;
  542.   unsigned len;
  543.   DBG("write " <<  h->getColumn()->getName() << " len=" << v.m_len << " null=" << null);
  544.   if (null) {
  545.     CHK(h->setNull() == 0);
  546.     isNull = false;
  547.     CHK(h->getNull(isNull) == 0 && isNull == true);
  548.     CHK(getBlobLength(h, len) == 0 && len == 0);
  549.   } else {
  550.     CHK(h->truncate(v.m_len) == 0);
  551.     unsigned n = 0;
  552.     do {
  553.       unsigned m = g_opt.m_full ? v.m_len : urandom(v.m_len + 1);
  554.       if (m > v.m_len - n)
  555.         m = v.m_len - n;
  556.       DBG("write pos=" << n << " cnt=" << m);
  557.       CHK(h->writeData(v.m_val + n, m) == 0);
  558.       n += m;
  559.     } while (n < v.m_len);
  560.     assert(n == v.m_len);
  561.     isNull = true;
  562.     CHK(h->getNull(isNull) == 0 && isNull == false);
  563.     CHK(getBlobLength(h, len) == 0 && len == v.m_len);
  564.   }
  565.   return 0;
  566. }
  568. static int
  569. writeBlobData(const Tup& tup)
  570. {
  571.   CHK(writeBlobData(g_bh1, tup.m_blob1) == 0);
  572.   if (! g_opt.m_oneblob)
  573.     CHK(writeBlobData(g_bh2, tup.m_blob2) == 0);
  574.   return 0;
  575. }
  577. static int
  578. readBlobData(NdbBlob* h, const Bval& v)
  579. {
  580.   bool null = (v.m_val == 0);
  581.   bool isNull;
  582.   unsigned len;
  583.   DBG("read " <<  h->getColumn()->getName() << " len=" << v.m_len << " null=" << null);
  584.   if (null) {
  585.     isNull = false;
  586.     CHK(h->getNull(isNull) == 0 && isNull == true);
  587.     CHK(getBlobLength(h, len) == 0 && len == 0);
  588.   } else {
  589.     isNull = true;
  590.     CHK(h->getNull(isNull) == 0 && isNull == false);
  591.     CHK(getBlobLength(h, len) == 0 && len == v.m_len);
  592.     v.trash();
  593.     unsigned n = 0;
  594.     while (n < v.m_len) {
  595.       unsigned m = g_opt.m_full ? v.m_len : urandom(v.m_len + 1);
  596.       if (m > v.m_len - n)
  597.         m = v.m_len - n;
  598.       DBG("read pos=" << n << " cnt=" << m);
  599.       const unsigned m2 = m;
  600.       CHK(h->readData(v.m_buf + n, m) == 0);
  601.       CHK(m2 == m);
  602.       n += m;
  603.     }
  604.     assert(n == v.m_len);
  605.     // need to execute to see the data
  606.     CHK(g_con->execute(NoCommit) == 0);
  607.     for (unsigned i = 0; i < v.m_len; i++)
  608.       CHK(v.m_val[i] == v.m_buf[i]);
  609.   }
  610.   return 0;
  611. }
  613. static int
  614. readBlobData(const Tup& tup)
  615. {
  616.   CHK(readBlobData(g_bh1, tup.m_blob1) == 0);
  617.   if (! g_opt.m_oneblob)
  618.     CHK(readBlobData(g_bh2, tup.m_blob2) == 0);
  619.   return 0;
  620. }
  622. // hooks
  624. static NdbBlob::ActiveHook blobWriteHook;
  626. static int
  627. blobWriteHook(NdbBlob* h, void* arg)
  628. {
  629.   DBG("blobWriteHook");
  630.   Bval& v = *(Bval*)arg;
  631.   CHK(writeBlobData(h, v) == 0);
  632.   return 0;
  633. }
  635. static int
  636. setBlobWriteHook(NdbBlob* h, Bval& v)
  637. {
  638.   DBG("setBlobWriteHook");
  639.   CHK(h->setActiveHook(blobWriteHook, &v) == 0);
  640.   return 0;
  641. }
  643. static int
  644. setBlobWriteHook(Tup& tup)
  645. {
  646.   CHK(setBlobWriteHook(g_bh1, tup.m_blob1) == 0);
  647.   if (! g_opt.m_oneblob)
  648.     CHK(setBlobWriteHook(g_bh2, tup.m_blob2) == 0);
  649.   return 0;
  650. }
  652. static NdbBlob::ActiveHook blobReadHook;
  654. // no PK yet to identify tuple so just read the value
  655. static int
  656. blobReadHook(NdbBlob* h, void* arg)
  657. {
  658.   DBG("blobReadHook");
  659.   Bval& v = *(Bval*)arg;
  660.   unsigned len;
  661.   CHK(getBlobLength(h, len) == 0);
  662.   v.alloc(len);
  663.   Uint32 maxlen = 0xffffffff;
  664.   CHK(h->readData(v.m_buf, maxlen) == 0);
  665.   DBG("read " << maxlen << " bytes");
  666.   CHK(len == maxlen);
  667.   return 0;
  668. }
  670. static int
  671. setBlobReadHook(NdbBlob* h, Bval& v)
  672. {
  673.   DBG("setBlobReadHook");
  674.   CHK(h->setActiveHook(blobReadHook, &v) == 0);
  675.   return 0;
  676. }
  678. static int
  679. setBlobReadHook(Tup& tup)
  680. {
  681.   CHK(setBlobReadHook(g_bh1, tup.m_blob1) == 0);
  682.   if (! g_opt.m_oneblob)
  683.     CHK(setBlobReadHook(g_bh2, tup.m_blob2) == 0);
  684.   return 0;
  685. }
  687. // verify blob data
  689. static int
  690. verifyHeadInline(const Bcol& c, const Bval& v, NdbRecAttr* ra)
  691. {
  692.   if (v.m_val == 0) {
  693.     CHK(ra->isNULL() == 1);
  694.   } else {
  695.     CHK(ra->isNULL() == 0);
  696.     const NdbBlob::Head* head = (const NdbBlob::Head*)ra->aRef();
  697.     CHK(head->length == v.m_len);
  698.     const char* data = (const char*)(head + 1);
  699.     for (unsigned i = 0; i < head->length && i < c.m_inline; i++)
  700.       CHK(data[i] == v.m_val[i]);
  701.   }
  702.   return 0;
  703. }
  705. static int
  706. verifyHeadInline(const Tup& tup)
  707. {
  708.   DBG("verifyHeadInline pk1=" << hex << tup.m_pk1);
  709.   CHK((g_con = g_ndb->startTransaction()) != 0);
  710.   CHK((g_opr = g_con->getNdbOperation(g_opt.m_tname)) != 0);
  711.   CHK(g_opr->readTuple() == 0);
  712.   CHK(g_opr->equal("PK1", tup.m_pk1) == 0);
  713.   if (g_opt.m_pk2len != 0)
  714.     CHK(g_opr->equal("PK2", tup.m_pk2) == 0);
  715.   NdbRecAttr* ra1;
  716.   NdbRecAttr* ra2;
  717.   CHK((ra1 = g_opr->getValue("BL1")) != 0);
  718.   if (! g_opt.m_oneblob)
  719.     CHK((ra2 = g_opr->getValue("BL2")) != 0);
  720.   if (tup.m_exists) {
  721.     CHK(g_con->execute(Commit) == 0);
  722.     DBG("verifyHeadInline BL1");
  723.     CHK(verifyHeadInline(g_opt.m_blob1, tup.m_blob1, ra1) == 0);
  724.     if (! g_opt.m_oneblob) {
  725.       DBG("verifyHeadInline BL2");
  726.       CHK(verifyHeadInline(g_opt.m_blob2, tup.m_blob2, ra2) == 0);
  727.     }
  728.   } else {
  729.     CHK(g_con->execute(Commit) == -1 && g_con->getNdbError().code == 626);
  730.   }
  731.   g_ndb->closeTransaction(g_con);
  732.   g_opr = 0;
  733.   g_con = 0;
  734.   return 0;
  735. }
  737. static int
  738. verifyBlobTable(const Bcol& b, const Bval& v, Uint32 pk1, bool exists)
  739. {
  740.   DBG("verify " << b.m_btname << " pk1=" << hex << pk1);
  741.   NdbRecAttr* ra_pk;
  742.   NdbRecAttr* ra_part;
  743.   NdbRecAttr* ra_data;
  744.   NdbResultSet* rs;
  745.   CHK((g_con = g_ndb->startTransaction()) != 0);
  746.   CHK((g_ops = g_con->getNdbScanOperation(b.m_btname)) != 0);
  747.   CHK((rs = g_ops->readTuples()) != 0);
  748.   CHK((ra_pk = g_ops->getValue("PK")) != 0);
  749.   CHK((ra_part = g_ops->getValue("PART")) != 0);
  750.   CHK((ra_data = g_ops->getValue("DATA")) != 0);
  751.   CHK(g_con->execute(NoCommit) == 0);
  752.   unsigned partcount;
  753.   if (! exists || v.m_len <= b.m_inline)
  754.     partcount = 0;
  755.   else
  756.     partcount = (v.m_len - b.m_inline + b.m_partsize - 1) / b.m_partsize;
  757.   char* seen = new char [partcount];
  758.   memset(seen, 0, partcount);
  759.   while (1) {
  760.     int ret;
  761.     CHK((ret = rs->nextResult()) == 0 || ret == 1);
  762.     if (ret == 1)
  763.       break;
  764.     if (pk1 != ra_pk->u_32_value())
  765.       continue;
  766.     Uint32 part = ra_part->u_32_value();
  767.     DBG("part " << part << " of " << partcount);
  768.     const char* data = ra_data->aRef();
  769.     CHK(part < partcount && ! seen[part]);
  770.     seen[part] = 1;
  771.     unsigned n = b.m_inline + part * b.m_partsize;
  772.     assert(exists && v.m_val != 0 && n < v.m_len);
  773.     unsigned m = v.m_len - n;
  774.     if (m > b.m_partsize)
  775.       m = b.m_partsize;
  776.     CHK(memcmp(data, v.m_val + n, m) == 0);
  777.   }
  778.   for (unsigned i = 0; i < partcount; i++)
  779.     CHK(seen[i] == 1);
  780.   g_ndb->closeTransaction(g_con);
  781.   g_ops = 0;
  782.   g_con = 0;
  783.   return 0;
  784. }
  786. static int
  787. verifyBlobTable(const Tup& tup)
  788. {
  789.   CHK(verifyBlobTable(g_opt.m_blob1, tup.m_blob1, tup.m_pk1, tup.m_exists) == 0);
  790.   if (! g_opt.m_oneblob)
  791.     CHK(verifyBlobTable(g_opt.m_blob2, tup.m_blob2, tup.m_pk1, tup.m_exists) == 0);
  792.   return 0;
  793. }
  795. static int
  796. verifyBlob()
  797. {
  798.   for (unsigned k = 0; k < g_opt.m_rows; k++) {
  799.     const Tup& tup = g_tups[k];
  800.     DBG("verifyBlob pk1=" << hex << tup.m_pk1);
  801.     CHK(verifyHeadInline(tup) == 0);
  802.     CHK(verifyBlobTable(tup) == 0);
  803.   }
  804.   return 0;
  805. }
  807. // operations
  809. static const char* stylename[3] = {
  810.   "style=getValue/setValue",
  811.   "style=setActiveHook",
  812.   "style=readData/writeData"
  813. };
  815. // pk ops
  817. static int
  818. insertPk(int style)
  819. {
  820.   DBG("--- insertPk " << stylename[style] << " ---");
  821.   unsigned n = 0;
  822.   CHK((g_con = g_ndb->startTransaction()) != 0);
  823.   for (unsigned k = 0; k < g_opt.m_rows; k++) {
  824.     Tup& tup = g_tups[k];
  825.     DBG("insertPk pk1=" << hex << tup.m_pk1);
  826.     CHK((g_opr = g_con->getNdbOperation(g_opt.m_tname)) != 0);
  827.     CHK(g_opr->insertTuple() == 0);
  828.     CHK(g_opr->equal("PK1", tup.m_pk1) == 0);
  829.     if (g_opt.m_pk2len != 0)
  830.       CHK(g_opr->equal("PK2", tup.m_pk2) == 0);
  831.     CHK(getBlobHandles(g_opr) == 0);
  832.     if (style == 0) {
  833.       CHK(setBlobValue(tup) == 0);
  834.     } else if (style == 1) {
  835.       // non-nullable must be set
  836.       CHK(g_bh1->setValue("", 0) == 0);
  837.       CHK(setBlobWriteHook(tup) == 0);
  838.     } else {
  839.       // non-nullable must be set
  840.       CHK(g_bh1->setValue("", 0) == 0);
  841.       CHK(g_con->execute(NoCommit) == 0);
  842.       CHK(writeBlobData(tup) == 0);
  843.     }
  844.     // just another trap
  845.     if (urandom(10) == 0)
  846.       CHK(g_con->execute(NoCommit) == 0);
  847.     if (++n == g_opt.m_batch) {
  848.       CHK(g_con->execute(Commit) == 0);
  849.       g_ndb->closeTransaction(g_con);
  850.       CHK((g_con = g_ndb->startTransaction()) != 0);
  851.       n = 0;
  852.     }
  853.     g_opr = 0;
  854.     tup.m_exists = true;
  855.   }
  856.   if (n != 0) {
  857.     CHK(g_con->execute(Commit) == 0);
  858.     n = 0;
  859.   }
  860.   g_ndb->closeTransaction(g_con);
  861.   g_con = 0;
  862.   return 0;
  863. }
  865. static int
  866. readPk(int style)
  867. {
  868.   DBG("--- readPk " << stylename[style] << " ---");
  869.   for (unsigned k = 0; k < g_opt.m_rows; k++) {
  870.     Tup& tup = g_tups[k];
  871.     DBG("readPk pk1=" << hex << tup.m_pk1);
  872.     CHK((g_con = g_ndb->startTransaction()) != 0);
  873.     CHK((g_opr = g_con->getNdbOperation(g_opt.m_tname)) != 0);
  874.     CHK(g_opr->readTuple() == 0);
  875.     CHK(g_opr->equal("PK1", tup.m_pk1) == 0);
  876.     if (g_opt.m_pk2len != 0)
  877.       CHK(g_opr->equal("PK2", tup.m_pk2) == 0);
  878.     CHK(getBlobHandles(g_opr) == 0);
  879.     if (style == 0) {
  880.       CHK(getBlobValue(tup) == 0);
  881.     } else if (style == 1) {
  882.       CHK(setBlobReadHook(tup) == 0);
  883.     } else {
  884.       CHK(g_con->execute(NoCommit) == 0);
  885.       CHK(readBlobData(tup) == 0);
  886.     }
  887.     CHK(g_con->execute(Commit) == 0);
  888.     if (style == 0 || style == 1) {
  889.       CHK(verifyBlobValue(tup) == 0);
  890.     }
  891.     g_ndb->closeTransaction(g_con);
  892.     g_opr = 0;
  893.     g_con = 0;
  894.   }
  895.   return 0;
  896. }
  898. static int
  899. updatePk(int style)
  900. {
  901.   DBG("--- updatePk " << stylename[style] << " ---");
  902.   for (unsigned k = 0; k < g_opt.m_rows; k++) {
  903.     Tup& tup = g_tups[k];
  904.     DBG("updatePk pk1=" << hex << tup.m_pk1);
  905.     CHK((g_con = g_ndb->startTransaction()) != 0);
  906.     CHK((g_opr = g_con->getNdbOperation(g_opt.m_tname)) != 0);
  907.     CHK(g_opr->updateTuple() == 0);
  908.     CHK(g_opr->equal("PK1", tup.m_pk1) == 0);
  909.     if (g_opt.m_pk2len != 0)
  910.       CHK(g_opr->equal("PK2", tup.m_pk2) == 0);
  911.     CHK(getBlobHandles(g_opr) == 0);
  912.     if (style == 0) {
  913.       CHK(setBlobValue(tup) == 0);
  914.     } else if (style == 1) {
  915.       CHK(setBlobWriteHook(tup) == 0);
  916.     } else {
  917.       CHK(g_con->execute(NoCommit) == 0);
  918.       CHK(writeBlobData(tup) == 0);
  919.     }
  920.     CHK(g_con->execute(Commit) == 0);
  921.     g_ndb->closeTransaction(g_con);
  922.     g_opr = 0;
  923.     g_con = 0;
  924.     tup.m_exists = true;
  925.   }
  926.   return 0;
  927. }
  929. static int
  930. writePk(int style)
  931. {
  932.   DBG("--- writePk " << stylename[style] << " ---");
  933.   for (unsigned k = 0; k < g_opt.m_rows; k++) {
  934.     Tup& tup = g_tups[k];
  935.     DBG("writePk pk1=" << hex << tup.m_pk1);
  936.     CHK((g_con = g_ndb->startTransaction()) != 0);
  937.     CHK((g_opr = g_con->getNdbOperation(g_opt.m_tname)) != 0);
  938.     CHK(g_opr->writeTuple() == 0);
  939.     CHK(g_opr->equal("PK1", tup.m_pk1) == 0);
  940.     if (g_opt.m_pk2len != 0)
  941.       CHK(g_opr->equal("PK2", tup.m_pk2) == 0);
  942.     CHK(getBlobHandles(g_opr) == 0);
  943.     if (style == 0) {
  944.       CHK(setBlobValue(tup) == 0);
  945.     } else if (style == 1) {
  946.       // non-nullable must be set
  947.       CHK(g_bh1->setValue("", 0) == 0);
  948.       CHK(setBlobWriteHook(tup) == 0);
  949.     } else {
  950.       // non-nullable must be set
  951.       CHK(g_bh1->setValue("", 0) == 0);
  952.       CHK(g_con->execute(NoCommit) == 0);
  953.       CHK(writeBlobData(tup) == 0);
  954.     }
  955.     CHK(g_con->execute(Commit) == 0);
  956.     g_ndb->closeTransaction(g_con);
  957.     g_opr = 0;
  958.     g_con = 0;
  959.     tup.m_exists = true;
  960.   }
  961.   return 0;
  962. }
  964. static int
  965. deletePk()
  966. {
  967.   DBG("--- deletePk ---");
  968.   for (unsigned k = 0; k < g_opt.m_rows; k++) {
  969.     Tup& tup = g_tups[k];
  970.     DBG("deletePk pk1=" << hex << tup.m_pk1);
  971.     CHK((g_con = g_ndb->startTransaction()) != 0);
  972.     CHK((g_opr = g_con->getNdbOperation(g_opt.m_tname)) != 0);
  973.     CHK(g_opr->deleteTuple() == 0);
  974.     CHK(g_opr->equal("PK1", tup.m_pk1) == 0);
  975.     if (g_opt.m_pk2len != 0)
  976.       CHK(g_opr->equal("PK2", tup.m_pk2) == 0);
  977.     CHK(g_con->execute(Commit) == 0);
  978.     g_ndb->closeTransaction(g_con);
  979.     g_opr = 0;
  980.     g_con = 0;
  981.     tup.m_exists = false;
  982.   }
  983.   return 0;
  984. }
  986. // hash index ops
  988. static int
  989. readIdx(int style)
  990. {
  991.   DBG("--- readIdx " << stylename[style] << " ---");
  992.   for (unsigned k = 0; k < g_opt.m_rows; k++) {
  993.     Tup& tup = g_tups[k];
  994.     DBG("readIdx pk1=" << hex << tup.m_pk1);
  995.     CHK((g_con = g_ndb->startTransaction()) != 0);
  996.     CHK((g_opx = g_con->getNdbIndexOperation(g_opt.m_x1name, g_opt.m_tname)) != 0);
  997.     CHK(g_opx->readTuple() == 0);
  998.     CHK(g_opx->equal("PK2", tup.m_pk2) == 0);
  999.     CHK(getBlobHandles(g_opx) == 0);
  1000.     if (style == 0) {
  1001.       CHK(getBlobValue(tup) == 0);
  1002.     } else if (style == 1) {
  1003.       CHK(setBlobReadHook(tup) == 0);
  1004.     } else {
  1005.       CHK(g_con->execute(NoCommit) == 0);
  1006.       CHK(readBlobData(tup) == 0);
  1007.     }
  1008.     CHK(g_con->execute(Commit) == 0);
  1009.     if (style == 0 || style == 1) {
  1010.       CHK(verifyBlobValue(tup) == 0);
  1011.     }
  1012.     g_ndb->closeTransaction(g_con);
  1013.     g_opx = 0;
  1014.     g_con = 0;
  1015.   }
  1016.   return 0;
  1017. }
  1019. static int
  1020. updateIdx(int style)
  1021. {
  1022.   DBG("--- updateIdx " << stylename[style] << " ---");
  1023.   for (unsigned k = 0; k < g_opt.m_rows; k++) {
  1024.     Tup& tup = g_tups[k];
  1025.     DBG("updateIdx pk1=" << hex << tup.m_pk1);
  1026.     CHK((g_con = g_ndb->startTransaction()) != 0);
  1027.     CHK((g_opx = g_con->getNdbIndexOperation(g_opt.m_x1name, g_opt.m_tname)) != 0);
  1028.     CHK(g_opx->updateTuple() == 0);
  1029.     CHK(g_opx->equal("PK2", tup.m_pk2) == 0);
  1030.     CHK(getBlobHandles(g_opx) == 0);
  1031.     if (style == 0) {
  1032.       CHK(setBlobValue(tup) == 0);
  1033.     } else if (style == 1) {
  1034.       CHK(setBlobWriteHook(tup) == 0);
  1035.     } else {
  1036.       CHK(g_con->execute(NoCommit) == 0);
  1037.       CHK(writeBlobData(tup) == 0);
  1038.     }
  1039.     CHK(g_con->execute(Commit) == 0);
  1040.     g_ndb->closeTransaction(g_con);
  1041.     g_opx = 0;
  1042.     g_con = 0;
  1043.     tup.m_exists = true;
  1044.   }
  1045.   return 0;
  1046. }
  1048. static int
  1049. writeIdx(int style)
  1050. {
  1051.   DBG("--- writeIdx " << stylename[style] << " ---");
  1052.   for (unsigned k = 0; k < g_opt.m_rows; k++) {
  1053.     Tup& tup = g_tups[k];
  1054.     DBG("writeIdx pk1=" << hex << tup.m_pk1);
  1055.     CHK((g_con = g_ndb->startTransaction()) != 0);
  1056.     CHK((g_opx = g_con->getNdbIndexOperation(g_opt.m_x1name, g_opt.m_tname)) != 0);
  1057.     CHK(g_opx->writeTuple() == 0);
  1058.     CHK(g_opx->equal("PK2", tup.m_pk2) == 0);
  1059.     CHK(getBlobHandles(g_opx) == 0);
  1060.     if (style == 0) {
  1061.       CHK(setBlobValue(tup) == 0);
  1062.     } else if (style == 1) {
  1063.       // non-nullable must be set
  1064.       CHK(g_bh1->setValue("", 0) == 0);
  1065.       CHK(setBlobWriteHook(tup) == 0);
  1066.     } else {
  1067.       // non-nullable must be set
  1068.       CHK(g_bh1->setValue("", 0) == 0);
  1069.       CHK(g_con->execute(NoCommit) == 0);
  1070.       CHK(writeBlobData(tup) == 0);
  1071.     }
  1072.     CHK(g_con->execute(Commit) == 0);
  1073.     g_ndb->closeTransaction(g_con);
  1074.     g_opx = 0;
  1075.     g_con = 0;
  1076.     tup.m_exists = true;
  1077.   }
  1078.   return 0;
  1079. }
  1081. static int
  1082. deleteIdx()
  1083. {
  1084.   DBG("--- deleteIdx ---");
  1085.   for (unsigned k = 0; k < g_opt.m_rows; k++) {
  1086.     Tup& tup = g_tups[k];
  1087.     DBG("deleteIdx pk1=" << hex << tup.m_pk1);
  1088.     CHK((g_con = g_ndb->startTransaction()) != 0);
  1089.     CHK((g_opx = g_con->getNdbIndexOperation(g_opt.m_x1name, g_opt.m_tname)) != 0);
  1090.     CHK(g_opx->deleteTuple() == 0);
  1091.     CHK(g_opx->equal("PK2", tup.m_pk2) == 0);
  1092.     CHK(g_con->execute(Commit) == 0);
  1093.     g_ndb->closeTransaction(g_con);
  1094.     g_opx = 0;
  1095.     g_con = 0;
  1096.     tup.m_exists = false;
  1097.   }
  1098.   return 0;
  1099. }
  1101. // scan ops table and index
  1103. static int
  1104. readScan(int style, bool idx)
  1105. {
  1106.   DBG("--- " << "readScan" << (idx ? "Idx" : "") << " " << stylename[style] << " ---");
  1107.   Tup tup;
  1108.   tup.alloc();  // allocate buffers
  1109.   NdbResultSet* rs;
  1110.   CHK((g_con = g_ndb->startTransaction()) != 0);
  1111.   if (! idx) {
  1112.     CHK((g_ops = g_con->getNdbScanOperation(g_opt.m_tname)) != 0);
  1113.   } else {
  1114.     CHK((g_ops = g_con->getNdbIndexScanOperation(g_opt.m_x2name, g_opt.m_tname)) != 0);
  1115.   }
  1116.   CHK((rs = g_ops->readTuples(NdbScanOperation::LM_Read)) != 0);
  1117.   CHK(g_ops->getValue("PK1", (char*)&tup.m_pk1) != 0);
  1118.   if (g_opt.m_pk2len != 0)
  1119.     CHK(g_ops->getValue("PK2", tup.m_pk2) != 0);
  1120.   CHK(getBlobHandles(g_ops) == 0);
  1121.   if (style == 0) {
  1122.     CHK(getBlobValue(tup) == 0);
  1123.   } else if (style == 1) {
  1124.     CHK(setBlobReadHook(tup) == 0);
  1125.   }
  1126.   CHK(g_con->execute(NoCommit) == 0);
  1127.   unsigned rows = 0;
  1128.   while (1) {
  1129.     int ret;
  1130.     tup.m_pk1 = (Uint32)-1;
  1131.     memset(tup.m_pk2, 'x', g_opt.m_pk2len);
  1132.     CHK((ret = rs->nextResult(true)) == 0 || ret == 1);
  1133.     if (ret == 1)
  1134.       break;
  1135.     DBG("readScan" << (idx ? "Idx" : "") << " pk1=" << hex << tup.m_pk1);
  1136.     Uint32 k = tup.m_pk1 - g_opt.m_pk1off;
  1137.     CHK(k < g_opt.m_rows && g_tups[k].m_exists);
  1138.     tup.copyfrom(g_tups[k]);
  1139.     if (style == 0) {
  1140.       CHK(verifyBlobValue(tup) == 0);
  1141.     } else if (style == 1) {
  1142.       // execute ops generated by callbacks, if any
  1143.       CHK(verifyBlobValue(tup) == 0);
  1144.     } else {
  1145.       CHK(readBlobData(tup) == 0);
  1146.     }
  1147.     rows++;
  1148.   }
  1149.   g_ndb->closeTransaction(g_con);
  1150.   g_con = 0;
  1151.   g_ops = 0;
  1152.   CHK(g_opt.m_rows == rows);
  1153.   return 0;
  1154. }
  1156. static int
  1157. updateScan(int style, bool idx)
  1158. {
  1159.   DBG("--- " << "updateScan" << (idx ? "Idx" : "") << " " << stylename[style] << " ---");
  1160.   Tup tup;
  1161.   tup.alloc();  // allocate buffers
  1162.   NdbResultSet* rs;
  1163.   CHK((g_con = g_ndb->startTransaction()) != 0);
  1164.   if (! idx) {
  1165.     CHK((g_ops = g_con->getNdbScanOperation(g_opt.m_tname)) != 0);
  1166.   } else {
  1167.     CHK((g_ops = g_con->getNdbIndexScanOperation(g_opt.m_x2name, g_opt.m_tname)) != 0);
  1168.   }
  1169.   CHK((rs = g_ops->readTuples(NdbScanOperation::LM_Exclusive)) != 0);
  1170.   CHK(g_ops->getValue("PK1", (char*)&tup.m_pk1) != 0);
  1171.   if (g_opt.m_pk2len != 0)
  1172.     CHK(g_ops->getValue("PK2", tup.m_pk2) != 0);
  1173.   CHK(g_con->execute(NoCommit) == 0);
  1174.   unsigned rows = 0;
  1175.   while (1) {
  1176.     int ret;
  1177.     tup.m_pk1 = (Uint32)-1;
  1178.     memset(tup.m_pk2, 'x', g_opt.m_pk2len);
  1179.     CHK((ret = rs->nextResult(true)) == 0 || ret == 1);
  1180.     if (ret == 1)
  1181.       break;
  1182.     DBG("updateScan" << (idx ? "Idx" : "") << " pk1=" << hex << tup.m_pk1);
  1183.     Uint32 k = tup.m_pk1 - g_opt.m_pk1off;
  1184.     CHK(k < g_opt.m_rows && g_tups[k].m_exists);
  1185.     // calculate new blob values
  1186.     calcBval(g_tups[k], false);
  1187.     tup.copyfrom(g_tups[k]);
  1188.     CHK((g_opr = rs->updateTuple()) != 0);
  1189.     CHK(getBlobHandles(g_opr) == 0);
  1190.     if (style == 0) {
  1191.       CHK(setBlobValue(tup) == 0);
  1192.     } else if (style == 1) {
  1193.       CHK(setBlobWriteHook(tup) == 0);
  1194.     } else {
  1195.       CHK(g_con->execute(NoCommit) == 0);
  1196.       CHK(writeBlobData(tup) == 0);
  1197.     }
  1198.     CHK(g_con->execute(NoCommit) == 0);
  1199.     g_opr = 0;
  1200.     rows++;
  1201.   }
  1202.   CHK(g_con->execute(Commit) == 0);
  1203.   g_ndb->closeTransaction(g_con);
  1204.   g_con = 0;
  1205.   g_ops = 0;
  1206.   CHK(g_opt.m_rows == rows);
  1207.   return 0;
  1208. }
  1210. static int
  1211. deleteScan(bool idx)
  1212. {
  1213.   DBG("--- " << "deleteScan" << (idx ? "Idx" : "") << " ---");
  1214.   Tup tup;
  1215.   NdbResultSet* rs;
  1216.   CHK((g_con = g_ndb->startTransaction()) != 0);
  1217.   if (! idx) {
  1218.     CHK((g_ops = g_con->getNdbScanOperation(g_opt.m_tname)) != 0);
  1219.   } else {
  1220.     CHK((g_ops = g_con->getNdbIndexScanOperation(g_opt.m_x2name, g_opt.m_tname)) != 0);
  1221.   }
  1222.   CHK((rs = g_ops->readTuples(NdbScanOperation::LM_Exclusive)) != 0);
  1223.   CHK(g_ops->getValue("PK1", (char*)&tup.m_pk1) != 0);
  1224.   if (g_opt.m_pk2len != 0)
  1225.     CHK(g_ops->getValue("PK2", tup.m_pk2) != 0);
  1226.   CHK(g_con->execute(NoCommit) == 0);
  1227.   unsigned rows = 0;
  1228.   while (1) {
  1229.     int ret;
  1230.     tup.m_pk1 = (Uint32)-1;
  1231.     memset(tup.m_pk2, 'x', g_opt.m_pk2len);
  1232.     CHK((ret = rs->nextResult()) == 0 || ret == 1);
  1233.     if (ret == 1)
  1234.       break;
  1235.     DBG("deleteScan" << (idx ? "Idx" : "") << " pk1=" << hex << tup.m_pk1);
  1236.     CHK(rs->deleteTuple() == 0);
  1237.     CHK(g_con->execute(NoCommit) == 0);
  1238.     Uint32 k = tup.m_pk1 - g_opt.m_pk1off;
  1239.     CHK(k < g_opt.m_rows && g_tups[k].m_exists);
  1240.     g_tups[k].m_exists = false;
  1241.     rows++;
  1242.   }
  1243.   CHK(g_con->execute(Commit) == 0);
  1244.   g_ndb->closeTransaction(g_con);
  1245.   g_con = 0;
  1246.   g_ops = 0;
  1247.   CHK(g_opt.m_rows == rows);
  1248.   return 0;
  1249. }
  1251. // main
  1253. // from here on print always
  1254. #undef DBG
  1255. #define DBG(x) 
  1256.   do { 
  1257.     ndbout << "line " << __LINE__ << " " << x << endl; 
  1258.   } while (0)
  1260. static int
  1261. testmain()
  1262. {
  1263.   g_ndb = new Ndb(g_ncc, "TEST_DB");
  1264.   CHK(g_ndb->init() == 0);
  1265.   CHK(g_ndb->waitUntilReady() == 0);
  1266.   g_dic = g_ndb->getDictionary();
  1267.   g_tups = new Tup [g_opt.m_rows];
  1268.   CHK(dropTable() == 0);
  1269.   CHK(createTable() == 0);
  1270.   if (g_opt.m_bugtest != 0) {
  1271.     // test a general bug instead of blobs
  1272.     CHK((*g_opt.m_bugtest)() == 0);
  1273.     return 0;
  1274.   }
  1275.   Bcol& b1 = g_opt.m_blob1;
  1276.   CHK(NdbBlob::getBlobTableName(b1.m_btname, g_ndb, g_opt.m_tname, "BL1") == 0);
  1277.   DBG("BL1: inline=" << b1.m_inline << " part=" << b1.m_partsize << " table=" << b1.m_btname);
  1278.   if (! g_opt.m_oneblob) {
  1279.     Bcol& b2 = g_opt.m_blob2;
  1280.     CHK(NdbBlob::getBlobTableName(b2.m_btname, g_ndb, g_opt.m_tname, "BL2") == 0);
  1281.     DBG("BL2: inline=" << b2.m_inline << " part=" << b2.m_partsize << " table=" << b2.m_btname);
  1282.   }
  1283.   if (g_opt.m_seed != 0)
  1284.     srandom(g_opt.m_seed);
  1285.   for (g_loop = 0; g_opt.m_loop == 0 || g_loop < g_opt.m_loop; g_loop++) {
  1286.     int style;
  1287.     DBG("=== loop " << g_loop << " ===");
  1288.     if (g_opt.m_seed == 0)
  1289.       srandom(g_loop);
  1290.     // pk
  1291.     for (style = 0; style <= 2; style++) {
  1292.       if (! testcase('k') || ! testcase(style))
  1293.         continue;
  1294.       DBG("--- pk ops " << stylename[style] << " ---");
  1295.       if (testcase('n')) {
  1296.         calcTups(false);
  1297.         CHK(insertPk(style) == 0);
  1298.         CHK(verifyBlob() == 0);
  1299.         CHK(readPk(style) == 0);
  1300.         if (testcase('u')) {
  1301.           calcTups(style);
  1302.           CHK(updatePk(style) == 0);
  1303.           CHK(verifyBlob() == 0);
  1304.           CHK(readPk(style) == 0);
  1305.         }
  1306.         CHK(deletePk() == 0);
  1307.         CHK(verifyBlob() == 0);
  1308.       }
  1309.       if (testcase('w')) {
  1310.         calcTups(false);
  1311.         CHK(writePk(style) == 0);
  1312.         CHK(verifyBlob() == 0);
  1313.         CHK(readPk(style) == 0);
  1314.         if (testcase('u')) {
  1315.           calcTups(style);
  1316.           CHK(writePk(style) == 0);
  1317.           CHK(verifyBlob() == 0);
  1318.           CHK(readPk(style) == 0);
  1319.         }
  1320.         CHK(deletePk() == 0);
  1321.         CHK(verifyBlob() == 0);
  1322.       }
  1323.     }
  1324.     // hash index
  1325.     for (style = 0; style <= 2; style++) {
  1326.       if (! testcase('i') || ! testcase(style))
  1327.         continue;
  1328.       DBG("--- idx ops " << stylename[style] << " ---");
  1329.       if (testcase('n')) {
  1330.         calcTups(false);
  1331.         CHK(insertPk(style) == 0);
  1332.         CHK(verifyBlob() == 0);
  1333.         CHK(readIdx(style) == 0);
  1334.         if (testcase('u')) {
  1335.           calcTups(style);
  1336.           CHK(updateIdx(style) == 0);
  1337.           CHK(verifyBlob() == 0);
  1338.           CHK(readIdx(style) == 0);
  1339.         }
  1340.         CHK(deleteIdx() == 0);
  1341.         CHK(verifyBlob() == 0);
  1342.       }
  1343.       if (testcase('w')) {
  1344.         calcTups(false);
  1345.         CHK(writePk(style) == 0);
  1346.         CHK(verifyBlob() == 0);
  1347.         CHK(readIdx(style) == 0);
  1348.         if (testcase('u')) {
  1349.           calcTups(style);
  1350.           CHK(writeIdx(style) == 0);
  1351.           CHK(verifyBlob() == 0);
  1352.           CHK(readIdx(style) == 0);
  1353.         }
  1354.         CHK(deleteIdx() == 0);
  1355.         CHK(verifyBlob() == 0);
  1356.       }
  1357.     }
  1358.     // scan table
  1359.     for (style = 0; style <= 2; style++) {
  1360.       if (! testcase('s') || ! testcase(style))
  1361.         continue;
  1362.       DBG("--- table scan " << stylename[style] << " ---");
  1363.       calcTups(false);
  1364.       CHK(insertPk(style) == 0);
  1365.       CHK(verifyBlob() == 0);
  1366.       CHK(readScan(style, false) == 0);
  1367.       if (testcase('u')) {
  1368.         CHK(updateScan(style, false) == 0);
  1369.         CHK(verifyBlob() == 0);
  1370.       }
  1371.       CHK(deleteScan(false) == 0);
  1372.       CHK(verifyBlob() == 0);
  1373.     }
  1374.     // scan index
  1375.     for (style = 0; style <= 2; style++) {
  1376.       if (! testcase('r') || ! testcase(style))
  1377.         continue;
  1378.       DBG("--- index scan " << stylename[style] << " ---");
  1379.       calcTups(false);
  1380.       CHK(insertPk(style) == 0);
  1381.       CHK(verifyBlob() == 0);
  1382.       CHK(readScan(style, true) == 0);
  1383.       if (testcase('u')) {
  1384.         CHK(updateScan(style, true) == 0);
  1385.         CHK(verifyBlob() == 0);
  1386.       }
  1387.       CHK(deleteScan(true) == 0);
  1388.       CHK(verifyBlob() == 0);
  1389.     }
  1390.   }
  1391.   delete g_ndb;
  1392.   return 0;
  1393. }
  1395. // separate performance test
  1397. struct Tmr {    // stolen from testOIBasic
  1398.   Tmr() {
  1399.     clr();
  1400.   }
  1401.   void clr() {
  1402.     m_on = m_ms = m_cnt = m_time[0] = m_text[0] = 0;
  1403.   }
  1404.   void on() {
  1405.     assert(m_on == 0);
  1406.     m_on = NdbTick_CurrentMillisecond();
  1407.   }
  1408.   void off(unsigned cnt = 0) {
  1409.     NDB_TICKS off = NdbTick_CurrentMillisecond();
  1410.     assert(m_on != 0 && off >= m_on);
  1411.     m_ms += off - m_on;
  1412.     m_cnt += cnt;
  1413.     m_on = 0;
  1414.   }
  1415.   const char* time() {
  1416.     if (m_cnt == 0)
  1417.       sprintf(m_time, "%u ms", m_ms);
  1418.     else
  1419.       sprintf(m_time, "%u ms per %u ( %u ms per 1000 )", m_ms, m_cnt, (1000 * m_ms) / m_cnt);
  1420.     return m_time;
  1421.   }
  1422.   const char* pct (const Tmr& t1) {
  1423.     if (0 < t1.m_ms)
  1424.       sprintf(m_text, "%u pct", (100 * m_ms) / t1.m_ms);
  1425.     else
  1426.       sprintf(m_text, "[cannot measure]");
  1427.     return m_text;
  1428.   }
  1429.   const char* over(const Tmr& t1) {
  1430.     if (0 < t1.m_ms) {
  1431.       if (t1.m_ms <= m_ms)
  1432.         sprintf(m_text, "%u pct", (100 * (m_ms - t1.m_ms)) / t1.m_ms);
  1433.       else
  1434.         sprintf(m_text, "-%u pct", (100 * (t1.m_ms - m_ms)) / t1.m_ms);
  1435.     } else
  1436.       sprintf(m_text, "[cannot measure]");
  1437.     return m_text;
  1438.   }
  1439.   NDB_TICKS m_on;
  1440.   unsigned m_ms;
  1441.   unsigned m_cnt;
  1442.   char m_time[100];
  1443.   char m_text[100];
  1444. };
  1446. static int
  1447. testperf()
  1448. {
  1449.   if (! testcase('p'))
  1450.     return 0;
  1451.   DBG("=== perf test ===");
  1452.   g_bh1 = g_bh2 = 0;
  1453.   g_ndb = new Ndb(g_ncc, "TEST_DB");
  1454.   CHK(g_ndb->init() == 0);
  1455.   CHK(g_ndb->waitUntilReady() == 0);
  1456.   g_dic = g_ndb->getDictionary();
  1457.   NdbDictionary::Table tab(g_opt.m_tnameperf);
  1458.   if (g_dic->getTable(tab.getName()) != 0)
  1459.     CHK(g_dic->dropTable(tab) == 0);
  1460.   // col A - pk
  1461.   { NdbDictionary::Column col("A");
  1462.     col.setType(NdbDictionary::Column::Unsigned);
  1463.     col.setPrimaryKey(true);
  1464.     tab.addColumn(col);
  1465.   }
  1466.   // col B - char 20
  1467.   { NdbDictionary::Column col("B");
  1468.     col.setType(NdbDictionary::Column::Char);
  1469.     col.setLength(20);
  1470.     col.setNullable(true);
  1471.     tab.addColumn(col);
  1472.   }
  1473.   // col C - text
  1474.   { NdbDictionary::Column col("C");
  1475.     col.setType(NdbDictionary::Column::Text);
  1476.     col.setInlineSize(20);
  1477.     col.setPartSize(512);
  1478.     col.setStripeSize(1);
  1479.     col.setNullable(true);
  1480.     tab.addColumn(col);
  1481.   }
  1482.   // create
  1483.   CHK(g_dic->createTable(tab) == 0);
  1484.   Uint32 cA = 0, cB = 1, cC = 2;
  1485.   // timers
  1486.   Tmr t1;
  1487.   Tmr t2;
  1488.   // insert char (one trans)
  1489.   {
  1490.     DBG("--- insert char ---");
  1491.     t1.on();
  1492.     CHK((g_con = g_ndb->startTransaction()) != 0);
  1493.     for (Uint32 k = 0; k < g_opt.m_rowsperf; k++) {
  1494.       CHK((g_opr = g_con->getNdbOperation(tab.getName())) != 0);
  1495.       CHK(g_opr->insertTuple() == 0);
  1496.       CHK(g_opr->equal(cA, (char*)&k) == 0);
  1497.       CHK(g_opr->setValue(cB, "b") == 0);
  1498.       CHK(g_con->execute(NoCommit) == 0);
  1499.     }
  1500.     t1.off(g_opt.m_rowsperf);
  1501.     CHK(g_con->execute(Rollback) == 0);
  1502.     DBG(t1.time());
  1503.     g_opr = 0;
  1504.     g_con = 0;
  1505.   }
  1506.   // insert text (one trans)
  1507.   {
  1508.     DBG("--- insert text ---");
  1509.     t2.on();
  1510.     CHK((g_con = g_ndb->startTransaction()) != 0);
  1511.     for (Uint32 k = 0; k < g_opt.m_rowsperf; k++) {
  1512.       CHK((g_opr = g_con->getNdbOperation(tab.getName())) != 0);
  1513.       CHK(g_opr->insertTuple() == 0);
  1514.       CHK(g_opr->equal(cA, (char*)&k) == 0);
  1515.       CHK((g_bh1 = g_opr->getBlobHandle(cC)) != 0);
  1516.       CHK((g_bh1->setValue("c", 1) == 0));
  1517.       CHK(g_con->execute(NoCommit) == 0);
  1518.     }
  1519.     t2.off(g_opt.m_rowsperf);
  1520.     CHK(g_con->execute(Rollback) == 0);
  1521.     DBG(t2.time());
  1522.     g_bh1 = 0;
  1523.     g_opr = 0;
  1524.     g_con = 0;
  1525.   }
  1526.   // insert overhead
  1527.   DBG("insert overhead: " << t2.over(t1));
  1528.   t1.clr();
  1529.   t2.clr();
  1530.   // insert
  1531.   {
  1532.     DBG("--- insert for read test ---");
  1533.     unsigned n = 0;
  1534.     CHK((g_con = g_ndb->startTransaction()) != 0);
  1535.     for (Uint32 k = 0; k < g_opt.m_rowsperf; k++) {
  1536.       CHK((g_opr = g_con->getNdbOperation(tab.getName())) != 0);
  1537.       CHK(g_opr->insertTuple() == 0);
  1538.       CHK(g_opr->equal(cA, (char*)&k) == 0);
  1539.       CHK(g_opr->setValue(cB, "b") == 0);
  1540.       CHK((g_bh1 = g_opr->getBlobHandle(cC)) != 0);
  1541.       CHK((g_bh1->setValue("c", 1) == 0));
  1542.       if (++n == g_opt.m_batch) {
  1543.         CHK(g_con->execute(Commit) == 0);
  1544.         g_ndb->closeTransaction(g_con);
  1545.         CHK((g_con = g_ndb->startTransaction()) != 0);
  1546.         n = 0;
  1547.       }
  1548.     }
  1549.     if (n != 0) {
  1550.       CHK(g_con->execute(Commit) == 0);
  1551.       g_ndb->closeTransaction(g_con); g_con = 0;
  1552.       n = 0;
  1553.     }
  1554.     g_bh1 = 0;
  1555.     g_opr = 0;
  1556.   }
  1557.   // pk read char (one trans)
  1558.   {
  1559.     DBG("--- pk read char ---");
  1560.     CHK((g_con = g_ndb->startTransaction()) != 0);
  1561.     Uint32 a;
  1562.     char b[20];
  1563.     t1.on();
  1564.     for (Uint32 k = 0; k < g_opt.m_rowsperf; k++) {
  1565.       CHK((g_opr = g_con->getNdbOperation(tab.getName())) != 0);
  1566.       CHK(g_opr->readTuple() == 0);
  1567.       CHK(g_opr->equal(cA, (char*)&k) == 0);
  1568.       CHK(g_opr->getValue(cA, (char*)&a) != 0);
  1569.       CHK(g_opr->getValue(cB, b) != 0);
  1570.       a = (Uint32)-1;
  1571.       b[0] = 0;
  1572.       CHK(g_con->execute(NoCommit) == 0);
  1573.       CHK(a == k && strcmp(b, "b") == 0);
  1574.     }
  1575.     CHK(g_con->execute(Commit) == 0);
  1576.     t1.off(g_opt.m_rowsperf);
  1577.     DBG(t1.time());
  1578.     g_opr = 0;
  1579.     g_ndb->closeTransaction(g_con); g_con = 0;
  1580.   }
  1581.   // pk read text (one trans)
  1582.   {
  1583.     DBG("--- pk read text ---");
  1584.     CHK((g_con = g_ndb->startTransaction()) != 0);
  1585.     Uint32 a;
  1586.     char c[20];
  1587.     t2.on();
  1588.     for (Uint32 k = 0; k < g_opt.m_rowsperf; k++) {
  1589.       CHK((g_opr = g_con->getNdbOperation(tab.getName())) != 0);
  1590.       CHK(g_opr->readTuple() == 0);
  1591.       CHK(g_opr->equal(cA, (char*)&k) == 0);
  1592.       CHK(g_opr->getValue(cA, (char*)&a) != 0);
  1593.       CHK((g_bh1 = g_opr->getBlobHandle(cC)) != 0);
  1594.       a = (Uint32)-1;
  1595.       c[0] = 0;
  1596.       CHK(g_con->execute(NoCommit) == 0);
  1597.       Uint32 m = 20;
  1598.       CHK(g_bh1->readData(c, m) == 0);
  1599.       CHK(a == k && m == 1 && strcmp(c, "c") == 0);
  1600.     }
  1601.     CHK(g_con->execute(Commit) == 0);
  1602.     t2.off(g_opt.m_rowsperf);
  1603.     DBG(t2.time());
  1604.     g_ndb->closeTransaction(g_con); g_opr = 0;
  1605.     g_con = 0;
  1606.   }
  1607.   // pk read overhead
  1608.   DBG("pk read overhead: " << t2.over(t1));
  1609.   t1.clr();
  1610.   t2.clr();
  1611.   // scan read char
  1612.   {
  1613.     DBG("--- scan read char ---");
  1614.     NdbResultSet* rs;
  1615.     Uint32 a;
  1616.     char b[20];
  1617.     CHK((g_con = g_ndb->startTransaction()) != 0);
  1618.     CHK((g_ops = g_con->getNdbScanOperation(tab.getName())) != 0);
  1619.     CHK((rs = g_ops->readTuples(NdbScanOperation::LM_Read)) != 0);
  1620.     CHK(g_ops->getValue(cA, (char*)&a) != 0);
  1621.     CHK(g_ops->getValue(cB, b) != 0);
  1622.     CHK(g_con->execute(NoCommit) == 0);
  1623.     unsigned n = 0;
  1624.     t1.on();
  1625.     while (1) {
  1626.       a = (Uint32)-1;
  1627.       b[0] = 0;
  1628.       int ret;
  1629.       CHK((ret = rs->nextResult(true)) == 0 || ret == 1);
  1630.       if (ret == 1)
  1631.         break;
  1632.       CHK(a < g_opt.m_rowsperf && strcmp(b, "b") == 0);
  1633.       n++;
  1634.     }
  1635.     CHK(n == g_opt.m_rowsperf);
  1636.     t1.off(g_opt.m_rowsperf);
  1637.     DBG(t1.time());
  1638.     g_ndb->closeTransaction(g_con); g_ops = 0;
  1639.     g_con = 0;
  1640.   }
  1641.   // scan read text
  1642.   {
  1643.     DBG("--- read text ---");
  1644.     NdbResultSet* rs;
  1645.     Uint32 a;
  1646.     char c[20];
  1647.     CHK((g_con = g_ndb->startTransaction()) != 0);
  1648.     CHK((g_ops = g_con->getNdbScanOperation(tab.getName())) != 0);
  1649.     CHK((rs = g_ops->readTuples(NdbScanOperation::LM_Read)) != 0);
  1650.     CHK(g_ops->getValue(cA, (char*)&a) != 0);
  1651.     CHK((g_bh1 = g_ops->getBlobHandle(cC)) != 0);
  1652.     CHK(g_con->execute(NoCommit) == 0);
  1653.     unsigned n = 0;
  1654.     t2.on();
  1655.     while (1) {
  1656.       a = (Uint32)-1;
  1657.       c[0] = 0;
  1658.       int ret;
  1659.       CHK((ret = rs->nextResult(true)) == 0 || ret == 1);
  1660.       if (ret == 1)
  1661.         break;
  1662.       Uint32 m = 20;
  1663.       CHK(g_bh1->readData(c, m) == 0);
  1664.       CHK(a < g_opt.m_rowsperf && m == 1 && strcmp(c, "c") == 0);
  1665.       n++;
  1666.     }
  1667.     CHK(n == g_opt.m_rowsperf);
  1668.     t2.off(g_opt.m_rowsperf);
  1669.     DBG(t2.time());
  1670.     g_bh1 = 0;
  1671.     g_ops = 0;
  1672.     g_ndb->closeTransaction(g_con); g_con = 0;
  1673.   }
  1674.   // scan read overhead
  1675.   DBG("scan read overhead: " << t2.over(t1));
  1676.   t1.clr();
  1677.   t2.clr();
  1678.   delete g_ndb;
  1679.   return 0;
  1680. }
  1682. // bug tests
  1684. static int
  1685. bugtest_4088()
  1686. {
  1687.   unsigned i;
  1688.   DBG("bug test 4088 - ndb api hang with mixed ops on index table");
  1689.   // insert rows
  1690.   calcTups(false);
  1691.   CHK(insertPk(false) == 0);
  1692.   // new trans
  1693.   CHK((g_con = g_ndb->startTransaction()) != 0);
  1694.   for (unsigned k = 0; k < g_opt.m_rows; k++) {
  1695.     Tup& tup = g_tups[k];
  1696.     // read table pk via index as a table
  1697.     const unsigned pkcnt = 2;
  1698.     Tup pktup[pkcnt];
  1699.     for (i = 0; i < pkcnt; i++) {
  1700.       char name[20];
  1701.       // XXX guess table id
  1702.       sprintf(name, "%d/%s", 4, g_opt.m_x1name);
  1703.       CHK((g_opr = g_con->getNdbOperation(name)) != 0);
  1704.       CHK(g_opr->readTuple() == 0);
  1705.       CHK(g_opr->equal("PK2", tup.m_pk2) == 0);
  1706.       CHK(g_opr->getValue("NDB$PK", (char*)&pktup[i].m_pk1) != 0);
  1707.     }
  1708.     // read blob inline via index as an index
  1709.     CHK((g_opx = g_con->getNdbIndexOperation(g_opt.m_x1name, g_opt.m_tname)) != 0);
  1710.     CHK(g_opx->readTuple() == 0);
  1711.     CHK(g_opx->equal("PK2", tup.m_pk2) == 0);
  1712.     assert(tup.m_blob1.m_buf != 0);
  1713.     CHK(g_opx->getValue("BL1", (char*)tup.m_blob1.m_buf) != 0);
  1714.     // execute
  1715.     // BUG 4088: gets 1 tckeyconf, 1 tcindxconf, then hangs
  1716.     CHK(g_con->execute(Commit) == 0);
  1717.     // verify
  1718.     for (i = 0; i < pkcnt; i++) {
  1719.       CHK(pktup[i].m_pk1 == tup.m_pk1);
  1720.       CHK(memcmp(pktup[i].m_pk2, tup.m_pk2, g_opt.m_pk2len) == 0);
  1721.     }
  1722.     CHK(memcmp(tup.m_blob1.m_val, tup.m_blob1.m_buf, 8 + g_opt.m_blob1.m_inline) == 0);
  1723.   }
  1724.   return 0;
  1725. }
  1727. static int
  1728. bugtest_2222()
  1729. {
  1730.   return 0;
  1731. }
  1733. static int
  1734. bugtest_3333()
  1735. {
  1736.   return 0;
  1737. }
  1739. static struct {
  1740.   int m_bug;
  1741.   int (*m_test)();
  1742. } g_bugtest[] = {
  1743.   { 4088, bugtest_4088 }
  1744. };
  1746. NDB_COMMAND(testOdbcDriver, "testBlobs", "testBlobs", "testBlobs", 65535)
  1747. {
  1748.   ndb_init();
  1749.   while (++argv, --argc > 0) {
  1750.     const char* arg = argv[0];
  1751.     if (strcmp(arg, "-batch") == 0) {
  1752.       if (++argv, --argc > 0) {
  1753. g_opt.m_batch = atoi(argv[0]);
  1754.         continue;
  1755.       }
  1756.     }
  1757.     if (strcmp(arg, "-core") == 0) {
  1758.       g_opt.m_core = true;
  1759.       continue;
  1760.     }
  1761.     if (strcmp(arg, "-dbg") == 0) {
  1762.       g_opt.m_dbg = true;
  1763.       continue;
  1764.     }
  1765.     if (strcmp(arg, "-dbgall") == 0) {
  1766.       g_opt.m_dbg = true;
  1767.       g_opt.m_dbgall = true;
  1768.       putenv(strdup("NDB_BLOB_DEBUG=1"));
  1769.       continue;
  1770.     }
  1771.     if (strcmp(arg, "-dbug") == 0) {
  1772.       if (++argv, --argc > 0) {
  1773.         g_opt.m_dbug = strdup(argv[0]);
  1774. continue;
  1775.       }
  1776.     }
  1777.     if (strcmp(arg, "-full") == 0) {
  1778.       g_opt.m_full = true;
  1779.       continue;
  1780.     }
  1781.     if (strcmp(arg, "-loop") == 0) {
  1782.       if (++argv, --argc > 0) {
  1783. g_opt.m_loop = atoi(argv[0]);
  1784. continue;
  1785.       }
  1786.     }
  1787.     if (strcmp(arg, "-parts") == 0) {
  1788.       if (++argv, --argc > 0) {
  1789. g_opt.m_parts = atoi(argv[0]);
  1790. continue;
  1791.       }
  1792.     }
  1793.     if (strcmp(arg, "-rows") == 0) {
  1794.       if (++argv, --argc > 0) {
  1795. g_opt.m_rows = atoi(argv[0]);
  1796. continue;
  1797.       }
  1798.     }
  1799.     if (strcmp(arg, "-rowsperf") == 0) {
  1800.       if (++argv, --argc > 0) {
  1801. g_opt.m_rowsperf = atoi(argv[0]);
  1802. continue;
  1803.       }
  1804.     }
  1805.     if (strcmp(arg, "-seed") == 0) {
  1806.       if (++argv, --argc > 0) {
  1807. g_opt.m_seed = atoi(argv[0]);
  1808. continue;
  1809.       }
  1810.     }
  1811.     if (strcmp(arg, "-skip") == 0) {
  1812.       if (++argv, --argc > 0) {
  1813.         g_opt.m_skip = strdup(argv[0]);
  1814. continue;
  1815.       }
  1816.     }
  1817.     if (strcmp(arg, "-test") == 0) {
  1818.       if (++argv, --argc > 0) {
  1819.         g_opt.m_test = strdup(argv[0]);
  1820. continue;
  1821.       }
  1822.     }
  1823.     // metadata
  1824.     if (strcmp(arg, "-pk2len") == 0) {
  1825.       if (++argv, --argc > 0) {
  1826. g_opt.m_pk2len = atoi(argv[0]);
  1827.         if (g_opt.m_pk2len <= g_max_pk2len)
  1828.           continue;
  1829.       }
  1830.     }
  1831.     if (strcmp(arg, "-oneblob") == 0) {
  1832.       g_opt.m_oneblob = true;
  1833.       continue;
  1834.     }
  1835.     // bugs
  1836.     if (strcmp(arg, "-bug") == 0) {
  1837.       if (++argv, --argc > 0) {
  1838. g_opt.m_bug = atoi(argv[0]);
  1839.         for (unsigned i = 0; i < sizeof(g_bugtest)/sizeof(g_bugtest[0]); i++) {
  1840.           if (g_opt.m_bug == g_bugtest[i].m_bug) {
  1841.             g_opt.m_bugtest = g_bugtest[i].m_test;
  1842.             break;
  1843.           }
  1844.         }
  1845.         if (g_opt.m_bugtest != 0)
  1846.           continue;
  1847.       }
  1848.     }
  1849.     ndbout << "testOIBasic: unknown option " << arg << endl;
  1850.     printusage();
  1851.     return NDBT_ProgramExit(NDBT_WRONGARGS);
  1852.   }
  1853.   if (g_opt.m_dbug != 0) {
  1854.     DBUG_PUSH(g_opt.m_dbug);
  1855.   }
  1856.   if (g_opt.m_pk2len == 0) {
  1857.     char b[100];
  1858.     b[0] = 0;
  1859.     if (g_opt.m_skip != 0)
  1860.       strcpy(b, g_opt.m_skip);
  1861.     strcat(b, "i");
  1862.     strcat(b, "r");
  1863.     g_opt.m_skip = strdup(b);
  1864.   }
  1865.   g_ncc = new Ndb_cluster_connection();
  1866.   if (g_ncc->connect(30) != 0 || testmain() == -1 || testperf() == -1) {
  1867.     ndbout << "line " << __LINE__ << " FAIL loop=" << g_loop << endl;
  1868.     return NDBT_ProgramExit(NDBT_FAILED);
  1869.   }
  1870.   delete g_ncc;
  1871.   g_ncc = 0;
  1872.   return NDBT_ProgramExit(NDBT_OK);
  1873. }
  1875. // vim: set sw=2 et: