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

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

MySQL数据库

开发平台：

Visual C++

testOdbcDriver.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. /* Copyright (C) 2003 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  19.    This program is free software; you can redistribute it and/or modify
  20.    it under the terms of the GNU General Public License as published by
  21.    the Free Software Foundation; either version 2 of the License, or
  22.    (at your option) any later version.
  24.    This program is distributed in the hope that it will be useful,
  25.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27.    GNU General Public License for more details.
  29.    You should have received a copy of the GNU General Public License
  30.    along with this program; if not, write to the Free Software
  31.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  33. /*
  34.  * testOdbcDriver
  35.  *
  36.  * Test of ODBC and SQL using a fixed set of tables.
  37.  */
  39. #include <ndb_global.h>
  40. #undef test
  41. #include <ndb_version.h>
  42. #include <kernel/ndb_limits.h>
  43. #include <Bitmask.hpp>
  44. #include <kernel/AttributeList.hpp>
  45. #ifdef ndbODBC
  46. #include <NdbApi.hpp>
  47. #endif
  48. #include <sqlext.h>
  50. #undef BOOL
  52. #include <NdbMain.h>
  53. #include <NdbOut.hpp>
  54. #include <NdbThread.h>
  55. #include <NdbMutex.h>
  56. #include <NdbCondition.h>
  57. #include <NdbTick.h>
  58. #include <NdbSleep.h>
  60. #ifdef ndbODBC
  61. #include <NdbTest.hpp>
  62. #else
  63. #define NDBT_OK 0
  64. #define NDBT_FAILED 1
  65. #define NDBT_WRONGARGS 2
  66. static int
  67. NDBT_ProgramExit(int rcode)
  68. {
  69.     const char* rtext = "Unknown";
  70.     switch (rcode) {
  71.     case NDBT_OK:
  72. rtext = "OK";
  73. break;
  74.     case NDBT_FAILED:
  75. rtext = "Failed";
  76. break;
  77.     case NDBT_WRONGARGS:
  78. rtext = "Wrong arguments";
  79. break;
  80.     };
  81.     ndbout_c("nNDBT_ProgramExit: %d - %sn", rcode, rtext);
  82.     return rcode;
  83. }
  84. #endif
  86. #ifdef DMALLOC
  87. #include <dmalloc.h>
  88. #endif
  90. #define arraySize(x) (sizeof(x)/sizeof(x[0]))
  92. #define SQL_ATTR_NDB_TUPLES_FETCHED 66601
  94. // options
  96. #define MAX_THR 128 // max threads
  98. struct Opt {
  99.     const char* m_name[100];
  100.     unsigned m_namecnt;
  101.     bool m_core;
  102.     unsigned m_depth;
  103.     const char* m_dsn;
  104.     unsigned m_errs;
  105.     const char* m_fragtype;
  106.     unsigned m_frob;
  107.     const char* m_home;
  108.     unsigned m_loop;
  109.     bool m_nogetd;
  110.     bool m_noputd;
  111.     bool m_nosort;
  112.     unsigned m_scale;
  113.     bool m_serial;
  114.     const char* m_skip[100];
  115.     unsigned m_skipcnt;
  116.     unsigned m_subloop;
  117.     const char* m_table;
  118.     unsigned m_threads;
  119.     unsigned m_trace;
  120.     unsigned m_v;
  121.     Opt() :
  122. m_namecnt(0),
  123. m_core(false),
  124. m_depth(5),
  125. m_dsn("NDB"),
  126. m_errs(0),
  127.         m_fragtype(0),
  128.         m_frob(0),
  129. m_home(0),
  130. m_loop(1),
  131. m_nogetd(false),
  132. m_noputd(false),
  133. m_nosort(false),
  134. m_scale(100),
  135. m_serial(false),
  136. m_skipcnt(0),
  137. m_subloop(1),
  138. m_table(0),
  139. m_threads(1),
  140. m_trace(0),
  141. m_v(1) {
  142. for (unsigned i = 0; i < arraySize(m_name); i++)
  143.     m_name[i] = 0;
  144. for (unsigned i = 0; i < arraySize(m_skip); i++)
  145.     m_skip[i] = 0;
  146.     }
  147. };
  149. static Opt opt;
  151. static void listCases();
  152. static void listTables();
  153. static void printusage()
  154. {
  155.     Opt d;
  156.     ndbout
  157. << "usage: testOdbcDriver [options]" << endl
  158. << "-case name  run only named tests (substring match - can be repeated)" << endl
  159. << "-core       dump core on failure" << endl
  160. << "-depth N    join depth - default " << d.m_depth << endl
  161. << "-dsn string data source name - default " << d.m_dsn << endl
  162. << "-errs N     allow N errors before quitting - default " << d.m_errs << endl
  163.         << "-fragtype t fragment type single/small/medium/large" << d.m_errs << endl
  164.         << "-frob X     case-dependent tweak (number)" << endl
  165. << "-home dir   set NDB_HOME (contains Ndb.cfg)" << endl
  166. << "-loop N     loop N times (0 = forever) - default " << d.m_loop << endl
  167. << "-nogetd     do not use SQLGetData - default " << d.m_nogetd << endl
  168. << "-noputd     do not use SQLPutData - default " << d.m_noputd << endl
  169. << "-nosort     no order-by in verify scan (checks non-Pk values only)" << endl
  170. << "-scale N    row count etc - default " << d.m_scale << endl
  171. << "-serial     run multi-threaded test cases one at a time" << endl
  172. << "-skip name  skip named tests (substring match - can be repeated)" << endl
  173. << "-subloop N  loop count per case (same threads) - default " << d.m_subloop << endl
  174. << "-table T    do only table T (table name on built-in list)" << endl
  175. << "-threads N  number of threads (max " << MAX_THR << ") - default " << d.m_threads << endl
  176. << "-trace N    trace in NDB ODBC driver - default " << d.m_trace << endl
  177. << "-v N        verbosity - default " << d.m_v << endl
  178. ;
  179.     listCases();
  180.     listTables();
  181. }
  183. static void
  184. fatal(const char* fmt, ...)
  185. {
  186.     va_list ap;
  187.     char buf[200];
  188.     va_start(ap, fmt);
  189.     vsnprintf(buf, sizeof(buf), fmt, ap);
  190.     va_end(ap);
  191.     ndbout << buf << endl;
  192.     if (opt.m_errs != 0) {
  193. opt.m_errs--;
  194. return;
  195.     }
  196.     if (opt.m_core)
  197. abort();
  198.     NDBT_ProgramExit(NDBT_FAILED);
  199.     exit(1);
  200. }
  202. static void
  203. cleanprint(const char* s, unsigned n)
  204. {
  205.     for (unsigned i = 0; i < n; i++) {
  206. char b[10];
  207. if (0x20 < s[i] && s[i] <= 0x7e)
  208.     sprintf(b, "%c", s[i]);
  209. else
  210.     sprintf(b, "\%02x", (unsigned)s[i]);
  211. ndbout << b;
  212.     }
  213. }
  215. // global mutex
  216. static NdbMutex my_mutex = NDB_MUTEX_INITIALIZER;
  217. static void lock_mutex() { NdbMutex_Lock(&my_mutex); }
  218. static void unlock_mutex() { NdbMutex_Unlock(&my_mutex); }
  220. // semaphore zeroed before each call to a test routine
  221. static unsigned my_sema = 0;
  223. // print mutex
  224. static NdbMutex out_mutex = NDB_MUTEX_INITIALIZER;
  225. static NdbOut& lock(NdbOut& out) { NdbMutex_Lock(&out_mutex); return out; }
  226. static NdbOut& unlock(NdbOut& out) { NdbMutex_Unlock(&out_mutex); return out; }
  228. static unsigned
  229. urandom(unsigned n)
  230. {
  231.     assert(n != 0);
  232.     unsigned i = random();
  233.     return i % n;
  234. }
  236. // test cases
  238. struct Test;
  240. struct Case {
  241.     enum Mode {
  242. Single = 1, // single thread
  243. Serial = 2, // all threads but one at a time
  244. Thread = 3 // all threads in parallel
  245.     };
  246.     const char* m_name;
  247.     void (*m_func)(Test& test);
  248.     Mode m_mode;
  249.     unsigned m_stuff;
  250.     const char* m_desc;
  251.     Case(const char* name, void (*func)(Test& test), Mode mode, unsigned stuff, const char* desc) :
  252. m_name(name),
  253. m_func(func),
  254. m_mode(mode),
  255. m_stuff(stuff),
  256. m_desc(desc) {
  257.     }
  258.     const char* modename() const {
  259. const char* s = "?";
  260. if (m_mode == Case::Single)
  261.     return "Single";
  262. if (m_mode == Case::Serial)
  263.     return "Serial";
  264. if (m_mode == Case::Thread)
  265.     return "Thread";
  266. return "?";
  267.     }
  268.     bool matchcase() const {
  269. if (opt.m_namecnt == 0)
  270.     return ! skipcase();
  271. for (unsigned i = 0; i < opt.m_namecnt; i++) {
  272.     if (strstr(m_name, opt.m_name[i]) != 0)
  273. return ! skipcase();
  274. }
  275. return false;
  276.     }
  277. private:
  278.     bool skipcase() const {
  279. for (unsigned i = 0; i < opt.m_skipcnt; i++) {
  280.     if (strstr(m_name, opt.m_skip[i]) != 0)
  281. return true;
  282. }
  283. return false;
  284.     }
  285. };
  287. // calculate values
  289. struct Calc {
  290.     enum { m_mul = 1000000 };
  291.     unsigned m_no;
  292.     unsigned m_base;
  293.     unsigned m_salt; // modifies non-PK values
  294.     bool m_const; // base non-PK values on PK of row 0
  295.     Calc(unsigned no) :
  296. m_no(no),
  297. m_salt(0),
  298. m_const(false) {
  299. m_base = m_no * m_mul;
  300.     }
  301.     void calcPk(unsigned rownum, char* v, unsigned n) const {
  302. char b[10];
  303. sprintf(b, "%08x", m_base + rownum);
  304. for (unsigned i = 0; i < n; i++) {
  305.     char c = i < n - 1 ? b[i % 8] : 0;
  306.     v[i] = c;
  307. }
  308.     }
  309.     void calcPk(unsigned rownum, long* v) const {
  310. *v = m_base + rownum;
  311.     }
  312.     void hashPk(unsigned* hash, const char* v, unsigned n) const {
  313. for (unsigned i = 0; i < n; i++) {
  314.     *hash ^= (v[i] << i);
  315. }
  316.     }
  317.     void hashPk(unsigned* hash, long v) const {
  318. *hash ^= v;
  319.     }
  320.     void calcNk(unsigned hash, char* v, unsigned n, SQLINTEGER* ind, bool null) const {
  321. unsigned m = hash % n;
  322. for (unsigned i = 0; i < n; i++) {
  323.     char c = i < m ? 'a' + (hash + i) % ('z' - 'a' + 1) : i < n - 1 ? ' ' : 0;
  324.     v[i] = c;
  325. }
  326. *ind = null && hash % 9 == 0 ? SQL_NULL_DATA : SQL_NTS;
  327.     }
  328.     void calcNk(unsigned hash, long* v, SQLINTEGER* ind, bool null) const {
  329. *v = long(hash);
  330. *ind = null && hash % 7 == 0 ? SQL_NULL_DATA : 0;
  331.     }
  332.     void calcNk(unsigned hash, double* v, SQLINTEGER* ind, bool null) const {
  333. *v = long(hash) / 1000.0;
  334. *ind = null && hash % 5 == 0 ? SQL_NULL_DATA : 0;
  335.     }
  336.     bool verify(const char* v1, SQLINTEGER ind1, const char* v2, SQLINTEGER ind2, unsigned n) {
  337. if (ind1 == SQL_NULL_DATA && ind2 == SQL_NULL_DATA)
  338.     return true;
  339. if (ind1 != SQL_NULL_DATA && ind2 != SQL_NULL_DATA)
  340.     if (memcmp(v1, v2, n) == 0)
  341. return true;
  342. if (ind1 == SQL_NULL_DATA)
  343.     v1 = "NULL";
  344. if (ind2 == SQL_NULL_DATA)
  345.     v2 = "NULL";
  346. ndbout << "verify failed: got ";
  347. if (ind1 == SQL_NULL_DATA)
  348.     ndbout << "NULL";
  349. else
  350.     cleanprint(v1, n);
  351. ndbout << " != ";
  352. if (ind2 == SQL_NULL_DATA)
  353.     ndbout << "NULL";
  354. else
  355.     cleanprint(v2, n);
  356. ndbout << endl;
  357. return false;
  358.     }
  359.     bool verify(long v1, SQLINTEGER ind1, long v2, SQLINTEGER ind2) {
  360. char buf1[40], buf2[40];
  361. if (ind1 == SQL_NULL_DATA && ind2 == SQL_NULL_DATA)
  362.     return true;
  363. if (ind1 != SQL_NULL_DATA && ind2 != SQL_NULL_DATA)
  364.     if (v1 == v2)
  365. return true;
  366. if (ind1 == SQL_NULL_DATA)
  367.     strcpy(buf1, "NULL");
  368. else
  369.     sprintf(buf1, "%ld", v1);
  370. if (ind2 == SQL_NULL_DATA)
  371.     strcpy(buf2, "NULL");
  372. else
  373.     sprintf(buf2, "%ld", v2);
  374. ndbout << "verify failed: got " << buf1 << " != " << buf2 << endl;
  375. return false;
  376.     }
  377.     bool verify(double v1, SQLINTEGER ind1, double v2, SQLINTEGER ind2) {
  378. char buf1[40], buf2[40];
  379. if (ind1 == SQL_NULL_DATA && ind2 == SQL_NULL_DATA)
  380.     return true;
  381. if (ind1 != SQL_NULL_DATA && ind2 != SQL_NULL_DATA)
  382.     if (fabs(v1 - v2) < 1) // XXX
  383. return true;
  384. if (ind1 == SQL_NULL_DATA)
  385.     strcpy(buf1, "NULL");
  386. else
  387.     sprintf(buf1, "%.10f", v1);
  388. if (ind2 == SQL_NULL_DATA)
  389.     strcpy(buf2, "NULL");
  390. else
  391.     sprintf(buf2, "%.10f", v2);
  392. ndbout << "verify failed: got " << buf1 << " != " << buf2 << endl;
  393. return false;
  394.     }
  395. };
  397. #if defined(NDB_SOLARIS) || defined(NDB_LINUX) || defined(NDB_MACOSX)
  398. #define HAVE_SBRK
  399. #else
  400. #undef HAVE_SBRK
  401. #endif
  403. struct Timer {
  404.     Timer() :
  405. m_cnt(0),
  406. m_calls(0),
  407. m_on(0),
  408. m_msec(0)
  409. #ifndef NDB_WIN32
  410. ,
  411. m_brk(0),
  412. m_incr(0)
  413. #endif
  414. {
  415.     }
  416.     void timerOn() {
  417. m_cnt = 0;
  418. m_calls = 0;
  419. m_on = NdbTick_CurrentMillisecond();
  420. #ifdef HAVE_SBRK
  421. m_brk = (int)sbrk(0);
  422. #endif
  423.     }
  424.     void timerOff() {
  425. m_msec = NdbTick_CurrentMillisecond() - m_on;
  426. if (m_msec <= 0)
  427.     m_msec = 1;
  428. #ifdef HAVE_SBRK
  429. m_incr = (int)sbrk(0) - m_brk;
  430. if (m_incr < 0)
  431.     m_incr = 0;
  432. #endif
  433.     }
  434.     void timerCnt(unsigned cnt) {
  435. m_cnt += cnt;
  436.     }
  437.     void timerCnt(const Timer& timer) {
  438. m_cnt += timer.m_cnt;
  439. m_calls += timer.m_calls;
  440.     }
  441.     friend NdbOut& operator<<(NdbOut& out, const Timer& timer) {
  442. out << timer.m_cnt << " ( " << 1000 * timer.m_cnt / timer.m_msec << "/sec )";
  443. #ifdef HAVE_SBRK
  444. out << " - " << timer.m_incr << " sbrk";
  445. if (opt.m_namecnt != 0) { // per case meaningless if many cases
  446.     if (timer.m_cnt > 0)
  447. out << " ( " << timer.m_incr / timer.m_cnt << "/cnt )";
  448. }
  449. #endif
  450. out << " - " << timer.m_calls << " calls";
  451. return out;
  452.     }
  453. protected:
  454.     unsigned m_cnt; // count rows or whatever
  455.     unsigned m_calls; // count ODBC function calls
  456.     NDB_TICKS m_on;
  457.     unsigned m_msec;
  458. #ifdef HAVE_SBRK
  459.     int m_brk;
  460.     int m_incr;
  461. #endif
  462. };
  464. #define MAX_MESSAGE 500
  465. #define MAX_DIAG 20
  467. struct Diag {
  468.     char m_state[5+1];
  469.     SQLINTEGER m_native;
  470.     char m_message[MAX_MESSAGE];
  471.     unsigned m_flag; // temp use
  472.     Diag() {
  473. strcpy(m_state, "00000");
  474. m_native = 0;
  475. memset(m_message, 0, sizeof(m_message));
  476. m_flag = 0;
  477.     }
  478.     const char* text() {
  479. snprintf(m_buf, sizeof(m_buf), "%s %d '%s'", m_state, (int)m_native, m_message);
  480. return m_buf;
  481.     }
  482.     void getDiag(SQLSMALLINT type, SQLHANDLE handle, unsigned k, unsigned count) {
  483. int ret;
  484. SQLSMALLINT length = -1;
  485. memset(m_message, 0, MAX_MESSAGE);
  486. ret = SQLGetDiagRec(type, handle, k, (SQLCHAR*)m_state, &m_native, (SQLCHAR*)m_message, MAX_MESSAGE, &length);
  487. if (k <= count && ret != SQL_SUCCESS)
  488.     fatal("SQLGetDiagRec %d of %d: return %d != SQL_SUCCESS", k, count, (int)ret);
  489. if (k <= count && strlen(m_message) != length)
  490.     fatal("SQLGetDiagRec %d of %d: message length %d != %d", k, count, strlen(m_message), length);
  491. if (k > count && ret != SQL_NO_DATA)
  492.     fatal("SQLGetDiagRec %d of %d: return %d != SQL_NO_DATA", k, count, (int)ret);
  493. m_flag = 0;
  494.     }
  495. private:
  496.     char m_buf[MAX_MESSAGE];
  497. };
  499. struct Diags {
  500.     Diag m_diag[MAX_DIAG];
  501.     SQLINTEGER m_diagCount;
  502.     SQLINTEGER m_rowCount;
  503.     SQLINTEGER m_functionCode;
  504.     void getDiags(SQLSMALLINT type, SQLHANDLE handle) {
  505. int ret;
  506. m_diagCount = -1;
  507. ret = SQLGetDiagField(type, handle, 0, SQL_DIAG_NUMBER, &m_diagCount, SQL_IS_INTEGER, 0);
  508. if (ret == SQL_INVALID_HANDLE)
  509.     return;
  510. if (ret != SQL_SUCCESS)
  511.     fatal("SQLGetDiagField: return %d != SQL_SUCCESS", (int)ret);
  512. if (m_diagCount < 0 || m_diagCount > MAX_DIAG)
  513.     fatal("SQLGetDiagField: count %d", (int)m_diagCount);
  514. for (unsigned k = 0; k < MAX_DIAG; k++) {
  515.     m_diag[k].getDiag(type, handle, k + 1, m_diagCount);
  516.     if (k == m_diagCount + 1)
  517. break;
  518. }
  519. m_rowCount = -1;
  520. m_functionCode = SQL_DIAG_UNKNOWN_STATEMENT;
  521. if (type == SQL_HANDLE_STMT) {
  522.     ret = SQLGetDiagField(type, handle, 0, SQL_DIAG_ROW_COUNT, &m_rowCount, SQL_IS_INTEGER, 0);
  523. #ifndef iODBC
  524.     if (ret != SQL_SUCCESS)
  525. fatal("SQLGetDiagField: return %d != SQL_SUCCESS", (int)ret);
  526. #endif
  527.     ret = SQLGetDiagField(type, handle, 0, SQL_DIAG_DYNAMIC_FUNCTION_CODE, &m_functionCode, SQL_IS_INTEGER, 0);
  528. }
  529.     }
  530.     void showDiags() {
  531. for (unsigned k = 0; 0 <= m_diagCount && k < m_diagCount; k++) {
  532.     Diag& diag = m_diag[k];
  533.     ndbout << "diag " << k + 1;
  534.     ndbout << (diag.m_flag ? " [*]" : " [ ]");
  535.     ndbout << " " << diag.text() << endl;
  536.     if (k > 10)
  537. abort();
  538. }
  539.     }
  540. };
  542. struct Exp {
  543.     int m_ret;
  544.     const char* m_state;
  545.     SQLINTEGER m_native;
  546.     Exp() : m_ret(SQL_SUCCESS), m_state(""), m_native(0) {}
  547.     Exp(int ret, const char* state) : m_ret(ret), m_state(state) {}
  548. };
  550. struct Test : Calc, Timer, Diags {
  551.     Test(unsigned no, unsigned loop) :
  552. Calc(no),
  553. m_loop(loop),
  554. m_stuff(0),
  555. m_perf(false),
  556. ccp(0) {
  557. exp(SQL_SUCCESS, 0, 0, true);
  558.     }
  559.     unsigned m_loop; // current loop
  560.     Exp m_expList[20]; // expected results
  561.     unsigned m_expCount;
  562.     int m_ret; // actual return code
  563.     int m_stuff; // the stuff of abuse
  564.     bool m_perf; // check no diags on success
  565.     const Case* ccp; // current case
  566.     void exp(int ret, const char* state, SQLINTEGER native, bool reset) {
  567. if (reset)
  568.     m_expCount = 0;
  569. unsigned i = m_expCount++;
  570. assert(i < arraySize(m_expList) - 1);
  571. m_expList[i].m_ret = ret;
  572. m_expList[i].m_state = state == 0 ? "" : state;
  573. m_expList[i].m_native = native;
  574.     }
  575.     void runCase(const Case& cc) {
  576. ccp = &cc;
  577. if (opt.m_v >= 3)
  578.     ndbout << cc.m_name << ": start" << endl;
  579. m_rowCount = -1;
  580. NDB_TICKS m_ms1 = NdbTick_CurrentMillisecond();
  581. m_salt = m_loop | (16 << cc.m_stuff);
  582. m_const = cc.m_stuff == 0;
  583. m_stuff = cc.m_stuff;
  584. (*cc.m_func)(*this);
  585. NDB_TICKS m_ms2 = NdbTick_CurrentMillisecond();
  586.     }
  587.     void run(SQLSMALLINT type, SQLHANDLE handle, int line, int ret) {
  588. m_calls++;
  589. m_ret = ret;
  590. if (m_perf && (m_ret == SQL_SUCCESS))
  591.     return;
  592. m_diagCount = 0;
  593. if (handle != SQL_NULL_HANDLE)
  594.     getDiags(type, handle);
  595. if (m_diagCount <= 0 && (ret != SQL_SUCCESS && ret != SQL_INVALID_HANDLE && ret != SQL_NEED_DATA && ret != SQL_NO_DATA)) {
  596.     fatal("%s: thr %d line %d: ret=%d but no diag records", ccp->m_name, m_no, line, ret);
  597. }
  598. for (unsigned k = 0; 0 <= m_diagCount && k < m_diagCount; k++) {
  599.     Diag& diag = m_diag[k];
  600.     bool match = false;
  601.     for (unsigned i = 0; i < m_expCount; i++) {
  602. if (strcmp(diag.m_state, m_expList[i].m_state) == 0 && (diag.m_native % 10000 == m_expList[i].m_native % 10000 || m_expList[i].m_native == -1)) {
  603.     match = true;
  604.     diag.m_flag = 0;
  605.     continue;
  606. }
  607. diag.m_flag = 1; // mark unexpected
  608.     }
  609.     if (! match) {
  610. showDiags();
  611. fatal("%s: thr %d line %d: unexpected diag [*] ret=%d cnt=%d", ccp->m_name, m_no, line, (int)ret, (int)m_diagCount);
  612.     }
  613. }
  614. bool match = false;
  615. for (unsigned i = 0; i < m_expCount; i++) {
  616.     if (ret == m_expList[i].m_ret) {
  617. match = true;
  618. break;
  619.     }
  620. }
  621. if (! match) {
  622.     showDiags();
  623.     fatal("%s: thr %d line %d: ret=%d not expected", ccp->m_name, m_no, line, ret);
  624. }
  625. // reset expected to success
  626. exp(SQL_SUCCESS, 0, 0, true);
  627.     }
  628.     void chk(SQLSMALLINT type, SQLHANDLE handle, int line, bool match, const char* fmt, ...) {
  629. if (match)
  630.     return;
  631. va_list ap;
  632. va_start(ap, fmt);
  633. char buf[500];
  634. vsnprintf(buf, sizeof(buf), fmt, ap);
  635. va_end(ap);
  636. fatal("%s: thr %d line %d: check failed - %s", ccp->m_name, m_no, line, buf);
  637.     }
  638. };
  640. #define HNull 0, SQL_NULL_HANDLE, __LINE__
  641. #define HEnv(h) SQL_HANDLE_ENV, h, __LINE__
  642. #define HDbc(h) SQL_HANDLE_DBC, h, __LINE__
  643. #define HStmt(h) SQL_HANDLE_STMT, h, __LINE__
  644. #define HDesc(h) SQL_HANDLE_DESC, h, __LINE__
  646. // string support
  648. #define MAX_SQL 20000
  650. static void
  651. scopy(char*& ptr, const char* fmt, ...)
  652. {
  653.     va_list ap;
  654.     va_start(ap, fmt);
  655.     vsprintf(ptr, fmt, ap);
  656.     va_end(ap);
  657.     ptr += strlen(ptr);
  658. }
  660. static bool
  661. blankeq(const char* s1, const char* s2, bool caseSensitive = false)
  662. {
  663.     unsigned n1 = strlen(s1);
  664.     unsigned n2 = strlen(s2);
  665.     unsigned i = 0;
  666.     char c1 = 0;
  667.     char c2 = 0;
  668.     while (i < n1 || i < n2) {
  669. c1 = i < n1 ? s1[i] : 0x20;
  670. if (! caseSensitive && 'a' <= c1 && c1 <= 'z')
  671.     c1 -= 'a' - 'A';
  672. c2 = i < n2 ? s2[i] : 0x20;
  673. if (! caseSensitive && 'a' <= c2 && c2 <= 'z')
  674.     c2 -= 'a' - 'A';
  675. if (c1 != c2)
  676.     break;
  677. i++;
  678.     }
  679.     return c1 == c2;
  680. }
  682. // columns and tables
  684. struct Col {
  685.     enum Type {
  686. Char = SQL_CHAR,
  687. Varchar = SQL_VARCHAR,
  688. Int = SQL_INTEGER,
  689. Bigint = SQL_BIGINT,
  690. Real = SQL_REAL,
  691. Double = SQL_DOUBLE
  692.     };
  693.     enum CType {
  694. CChar = SQL_C_CHAR,
  695. CLong = SQL_C_SLONG,
  696. CDouble = SQL_C_DOUBLE
  697.     };
  698.     enum Cons {
  699. Null, // nullable
  700. NotNull, // not nullable
  701. Pk // part of primary key
  702.     };
  703.     const char* m_name;
  704.     Type m_type;
  705.     unsigned m_length;
  706.     Cons m_cons;
  707.     CType m_ctype;
  708.     Col() :
  709. m_type((Type)999) {
  710.     }
  711.     Col(const char* name, Type type, unsigned length, Cons cons, CType ctype) :
  712. m_name(name),
  713. m_type(type),
  714. m_length(length),
  715. m_cons(cons),
  716. m_ctype(ctype) {
  717.     }
  718.     unsigned size() const {
  719. switch (m_type) {
  720. case Char:
  721. case Varchar:
  722.     return m_length;
  723. case Int:
  724.     return 4;
  725. case Bigint:
  726.     return 8;
  727. case Real:
  728.     return 4;
  729. case Double:
  730.     return 8;
  731. }
  732. assert(false);
  733. return 0;
  734.     }
  735.     unsigned csize() const { // size as char plus terminating null
  736. switch (m_ctype) {
  737. case CChar:
  738.     return m_length + 1;
  739. case CLong:
  740.     return 12;
  741. case CDouble:
  742.     return 24;
  743. }
  744. assert(false);
  745. return 0;
  746.     }
  747.     void typespec(char*& ptr) const {
  748. switch (m_type) {
  749. case Char:
  750.     scopy(ptr, "char(%d)", m_length);
  751.     return;
  752. case Varchar:
  753.     scopy(ptr, "varchar(%d)", m_length);
  754.     return;
  755. case Int:
  756.     scopy(ptr, "int");
  757.     return;
  758. case Bigint:
  759.     scopy(ptr, "bigint");
  760.     return;
  761. case Real:
  762.     scopy(ptr, "real");
  763.     return;
  764. case Double:
  765.     scopy(ptr, "float");
  766.     return;
  767. }
  768. assert(false);
  769.     }
  770.     SQLSMALLINT type() const {
  771. return (SQLSMALLINT)m_type;
  772.     }
  773.     SQLSMALLINT ctype() const {
  774. return (SQLSMALLINT)m_ctype;
  775.     }
  776.     void create(char*& ptr, bool pk) const {
  777. scopy(ptr, "%s", m_name);
  778. scopy(ptr, " ");
  779. typespec(ptr);
  780. if (m_cons == Pk && pk) {
  781.     scopy(ptr, " primary key");
  782. }
  783. if (m_cons == NotNull) {
  784.     scopy(ptr, " not null");
  785. }
  786.     }
  787. };
  789. static Col ColUndef;
  791. struct Tab {
  792.     const char* m_name;
  793.     const Col* m_colList;
  794.     unsigned m_colCount;
  795.     unsigned m_pkCount;
  796.     unsigned* m_pkIndex;
  797.     unsigned m_nkCount;
  798.     unsigned* m_nkIndex;
  799.     char m_upperName[20];
  800.     Tab(const char* name, const Col* colList, unsigned colCount) :
  801. m_name(name),
  802. m_colList(colList),
  803. m_colCount(colCount) {
  804. m_pkCount = 0;
  805. m_nkCount = 0;
  806. for (unsigned i = 0; i < m_colCount; i++) {
  807.     const Col& col = m_colList[i];
  808.     if (col.m_cons == Col::Pk)
  809. m_pkCount++;
  810.     else
  811. m_nkCount++;
  812. }
  813. m_pkIndex = new unsigned[m_pkCount];
  814. m_nkIndex = new unsigned[m_nkCount];
  815. unsigned pk = 0;
  816. unsigned nk = 0;
  817. for (unsigned i = 0; i < m_colCount; i++) {
  818.     const Col& col = m_colList[i];
  819.     if (col.m_cons == Col::Pk)
  820. m_pkIndex[pk++] = i;
  821.     else
  822. m_nkIndex[nk++] = i;
  823. }
  824. assert(pk == m_pkCount && nk == m_nkCount);
  825. strcpy(m_upperName, m_name);
  826. for (char* p = m_upperName; *p != 0; p++) {
  827.     if ('a' <= *p && *p <= 'z')
  828. *p -= 'a' - 'A';
  829. }
  830.     }
  831.     ~Tab() {
  832. delete[] m_pkIndex;
  833. delete[] m_nkIndex;
  834.     }
  835.     void drop(char*& ptr) const {
  836. scopy(ptr, "drop table %s", m_name);
  837.     }
  838.     void create(char*& ptr) const {
  839. scopy(ptr, "create table %s (", m_name);
  840. for (unsigned i = 0; i < m_colCount; i++) {
  841.     if (i > 0)
  842. scopy(ptr, ", ");
  843.     const Col& col = m_colList[i];
  844.     col.create(ptr, m_pkCount == 1);
  845. }
  846. if (m_pkCount != 1) {
  847.     scopy(ptr, ", primary key (");
  848.     for (unsigned i = 0; i < m_pkCount; i++) {
  849. const Col& col = m_colList[m_pkIndex[i]];
  850. if (i > 0)
  851.     scopy(ptr, ", ");
  852. scopy(ptr, "%s", col.m_name);
  853.     }
  854.     scopy(ptr, ")");
  855. }
  856. scopy(ptr, ")");
  857.     }
  858.     void wherePk(char*& ptr) const {
  859. scopy(ptr, " where");
  860. for (unsigned i = 0; i < m_pkCount; i++) {
  861.     const Col& col = m_colList[m_pkIndex[i]];
  862.     if (i > 0)
  863. scopy(ptr, " and");
  864.     scopy(ptr, " %s = ?", col.m_name);
  865. }
  866.     }
  867.     void whereRange(char*& ptr) const {
  868. scopy(ptr, " where");
  869. for (unsigned i = 0; i < m_pkCount; i++) {
  870.     const Col& col = m_colList[m_pkIndex[i]];
  871.     if (i > 0)
  872. scopy(ptr, " and");
  873.     scopy(ptr, " ? <= %s", col.m_name);
  874.     scopy(ptr, " and ");
  875.     scopy(ptr, "%s < ?", col.m_name);
  876. }
  877.     }
  878.     void orderPk(char*& ptr) const {
  879. scopy(ptr, " order by");
  880. for (unsigned i = 0; i < m_pkCount; i++) {
  881.     const Col& col = m_colList[m_pkIndex[i]];
  882.     if (i > 0)
  883. scopy(ptr, ", ");
  884.     else
  885. scopy(ptr, " ");
  886.     scopy(ptr, "%s", col.m_name);
  887. }
  888.     }
  889.     void selectPk(char*& ptr) const {
  890. scopy(ptr, "select * from %s", m_name);
  891. wherePk(ptr);
  892.     }
  893.     void selectAll(char*& ptr) const {
  894. scopy(ptr, "select * from %s", m_name);
  895.     }
  896.     void selectRange(char*& ptr, bool sort) const {
  897. selectAll(ptr);
  898. whereRange(ptr);
  899. if (sort)
  900.     orderPk(ptr);
  901.     }
  902.     void selectCount(char*& ptr) const {
  903. scopy(ptr, "select count(*) from %s", m_name);
  904.     }
  905.     void insertAll(char*& ptr) const {
  906. scopy(ptr, "insert into %s values (", m_name);
  907. for (unsigned i = 0; i < m_colCount; i++) {
  908.     if (i > 0)
  909. scopy(ptr, ", ");
  910.     scopy(ptr, "?");
  911. }
  912. scopy(ptr, ")");
  913.     }
  914.     void updatePk(char*& ptr) const {
  915. scopy(ptr, "update %s set", m_name);
  916. for (unsigned i = 0; i < m_nkCount; i++) {
  917.     const Col& col = m_colList[m_nkIndex[i]];
  918.     if (i > 0)
  919. scopy(ptr, ", ");
  920.     else
  921. scopy(ptr, " ");
  922.     scopy(ptr, "%s = ?", col.m_name);
  923. }
  924. wherePk(ptr);
  925.     }
  926.     void updateRange(char*& ptr) const {
  927. scopy(ptr, "update %s set", m_name);
  928. for (unsigned i = 0; i < m_nkCount; i++) {
  929.     const Col& col = m_colList[m_nkIndex[i]];
  930.     if (i > 0)
  931. scopy(ptr, ", ");
  932.     else
  933. scopy(ptr, " ");
  934.     scopy(ptr, "%s = ?", col.m_name); // XXX constant for now
  935. }
  936. whereRange(ptr);
  937.     }
  938.     void deleteAll(char*& ptr) const {
  939. scopy(ptr, "delete from %s", m_name);
  940.     }
  941.     void deletePk(char*& ptr) const {
  942. scopy(ptr, "delete from %s", m_name);
  943. wherePk(ptr);
  944.     }
  945.     void deleteRange(char*& ptr) const {
  946. scopy(ptr, "delete from %s", m_name);
  947. whereRange(ptr);
  948.     }
  949.     // simple
  950.     void insertDirect(char*& ptr, unsigned n) const {
  951. scopy(ptr, "insert into %s values (", m_name);
  952. for (unsigned i = 0; i < m_colCount; i++) {
  953.     const Col& col = m_colList[i];
  954.     if (i > 0)
  955. scopy(ptr, ", ");
  956.     if (col.m_type == Col::Char || col.m_type == Col::Varchar) {
  957. scopy(ptr, "'");
  958. for (unsigned i = 0; i <= n % col.m_length; i++)
  959.     scopy(ptr, "%c", 'a' + (n + i) % 26);
  960. scopy(ptr, "'");
  961.     } else if (col.m_type == Col::Int || col.m_type == Col::Bigint) {
  962. scopy(ptr, "%u", n);
  963.     } else if (col.m_type == Col::Real || col.m_type == Col::Double) {
  964. scopy(ptr, "%.3f", n * 0.001);
  965.     } else {
  966. assert(false);
  967.     }
  968. }
  969. scopy(ptr, ")");
  970.     }
  971.     void whereDirect(char*& ptr, unsigned n) const {
  972. scopy(ptr, " where");
  973. for (unsigned i = 0; i < m_pkCount; i++) {
  974.     const Col& col = m_colList[m_pkIndex[i]];
  975.     if (i > 0)
  976. scopy(ptr, ", ");
  977.     else
  978. scopy(ptr, " ");
  979.     scopy(ptr, "%s = ", col.m_name);
  980.     if (col.m_type == Col::Char || col.m_type == Col::Varchar) {
  981. scopy(ptr, "'");
  982. for (unsigned i = 0; i <= n % col.m_length; i++)
  983.     scopy(ptr, "%c", 'a' + (n + i) % 26);
  984. scopy(ptr, "'");
  985.     } else if (col.m_type == Col::Int || col.m_type == Col::Bigint) {
  986. scopy(ptr, "%u", n);
  987.     } else {
  988. assert(false);
  989.     }
  990. }
  991.     }
  992.     void countDirect(char*& ptr, unsigned n) const {
  993. scopy(ptr, "select count(*) from %s", m_name);
  994. whereDirect(ptr, n);
  995.     }
  996.     void deleteDirect(char*& ptr, unsigned n) const {
  997. scopy(ptr, "delete from %s", m_name);
  998. whereDirect(ptr, n);
  999.     }
  1000.     // joins
  1001.     void selectCart(char*& ptr, unsigned cnt) const {
  1002. scopy(ptr, "select count(*) from");
  1003. for (unsigned j = 0; j < cnt; j++) {
  1004.     if (j > 0)
  1005. scopy(ptr, ",");
  1006.     scopy(ptr, " %s", m_name);
  1007.     scopy(ptr, " t%u", j);
  1008. }
  1009.     }
  1010.     void selectJoin(char*& ptr, unsigned cnt) const {
  1011. scopy(ptr, "select * from");
  1012. for (unsigned j = 0; j < cnt; j++) {
  1013.     if (j > 0)
  1014. scopy(ptr, ",");
  1015.     scopy(ptr, " %s", m_name);
  1016.     scopy(ptr, " t%u", j);
  1017. }
  1018. for (unsigned i = 0; i < m_pkCount; i++) {
  1019.     const Col& col = m_colList[m_pkIndex[i]];
  1020.     for (unsigned j = 0; j < cnt - 1; j++) {
  1021. if (i == 0 && j == 0)
  1022.     scopy(ptr, " where");
  1023. else
  1024.     scopy(ptr, " and");
  1025. scopy(ptr, " t%u.%s = t%u.%s", j, col.m_name, j + 1, col.m_name);
  1026.     }
  1027. }
  1028.     }
  1029.     // check if selected on command line
  1030.     bool optok() const {
  1031. return opt.m_table == 0 || strcasecmp(m_name, opt.m_table) == 0;
  1032.     }
  1033. };
  1035. // the test tables
  1037. static Col col0[] = {
  1038.     Col( "a", Col::Bigint, 0, Col::Pk, Col::CLong ),
  1039.     Col( "b", Col::Int, 0, Col::NotNull, Col::CLong ),
  1040.     Col( "c", Col::Char, 4, Col::NotNull, Col::CChar ),
  1041.     Col( "d", Col::Double, 0, Col::Null, Col::CDouble ),
  1042.     Col( "e", Col::Char, 40, Col::Null, Col::CChar ),
  1043.     Col( "f", Col::Char, 10, Col::Null, Col::CChar )
  1044. };
  1046. static Col col1[] = {
  1047.     Col( "c0", Col::Int, 0, Col::Pk, Col::CLong ),
  1048.     Col( "c1", Col::Int, 0, Col::NotNull, Col::CLong ),
  1049.     Col( "c2", Col::Int, 0, Col::NotNull, Col::CLong ),
  1050.     Col( "c3", Col::Int, 0, Col::NotNull, Col::CLong ),
  1051.     Col( "c4", Col::Int, 0, Col::NotNull, Col::CLong ),
  1052.     Col( "c5", Col::Int, 0, Col::NotNull, Col::CLong ),
  1053.     Col( "c6", Col::Int, 0, Col::NotNull, Col::CLong ),
  1054.     Col( "c7", Col::Int, 0, Col::NotNull, Col::CLong ),
  1055.     Col( "c8", Col::Int, 0, Col::NotNull, Col::CLong ),
  1056.     Col( "c9", Col::Int, 0, Col::NotNull, Col::CLong ),
  1057.     Col( "c10", Col::Int, 0, Col::NotNull, Col::CLong ),
  1058.     Col( "c11", Col::Int, 0, Col::NotNull, Col::CLong ),
  1059.     Col( "c12", Col::Int, 0, Col::NotNull, Col::CLong ),
  1060.     Col( "c13", Col::Int, 0, Col::NotNull, Col::CLong ),
  1061.     Col( "c14", Col::Int, 0, Col::NotNull, Col::CLong ),
  1062.     Col( "c15", Col::Int, 0, Col::NotNull, Col::CLong ),
  1063.     Col( "c16", Col::Int, 0, Col::NotNull, Col::CLong ),
  1064.     Col( "c17", Col::Int, 0, Col::NotNull, Col::CLong ),
  1065.     Col( "c18", Col::Int, 0, Col::NotNull, Col::CLong ),
  1066.     Col( "c19", Col::Int, 0, Col::NotNull, Col::CLong ),
  1067.     Col( "c20", Col::Int, 0, Col::NotNull, Col::CLong ),
  1068.     Col( "c21", Col::Int, 0, Col::NotNull, Col::CLong ),
  1069.     Col( "c22", Col::Int, 0, Col::NotNull, Col::CLong ),
  1070.     Col( "c23", Col::Int, 0, Col::NotNull, Col::CLong ),
  1071.     Col( "c24", Col::Int, 0, Col::NotNull, Col::CLong ),
  1072.     Col( "c25", Col::Int, 0, Col::NotNull, Col::CLong )
  1073. };
  1075. static Col col2[] = {
  1076.     Col( "a", Col::Int, 0, Col::Pk, Col::CLong ),
  1077.     Col( "c", Col::Char, 8000, Col::NotNull, Col::CChar )
  1078. };
  1080. static Col col3[] = {
  1081.     Col( "a", Col::Int, 0, Col::Pk, Col::CLong ),
  1082.     Col( "c1", Col::Varchar, 1, Col::Null, Col::CChar ),
  1083.     Col( "c2", Col::Varchar, 2, Col::Null, Col::CChar ),
  1084.     Col( "c3", Col::Varchar, 3, Col::Null, Col::CChar ),
  1085.     Col( "c4", Col::Varchar, 4, Col::Null, Col::CChar ),
  1086.     Col( "c5", Col::Varchar, 10, Col::Null, Col::CChar ),
  1087.     Col( "c6", Col::Varchar, 40, Col::Null, Col::CChar ),
  1088.     Col( "c7", Col::Varchar, 255, Col::Null, Col::CChar ),
  1089.     Col( "c8", Col::Varchar, 4000, Col::Null, Col::CChar )
  1090. };
  1092. static Col col4[] = {
  1093.     Col( "a", Col::Char, 8, Col::Pk, Col::CChar ),
  1094.     Col( "b", Col::Char, 8, Col::NotNull, Col::CChar ),
  1095. };
  1097. static Tab tabList[] = {
  1098. #define colList(x) x, arraySize(x)
  1099.     Tab( "tt00", colList(col0) ),
  1100.     Tab( "tt01", colList(col1) ), // fl鋝kbench special
  1101.     Tab( "tt02", colList(col2) ),
  1102.     Tab( "tt03", colList(col3) ),
  1103.     Tab( "tt04", colList(col4) )
  1104. #undef colList
  1105. };
  1107. static const unsigned tabCount = arraySize(tabList);
  1108. static const unsigned maxColCount = 100; // per table - keep up to date
  1110. static bool
  1111. findTable()
  1112. {
  1113.     for (unsigned i = 0; i < tabCount; i++) {
  1114. const Tab& tab = tabList[i];
  1115. if (tab.optok())
  1116.     return true;
  1117.     }
  1118.     return false;
  1119. }
  1121. static void
  1122. listTables()
  1123. {
  1124.     ndbout << "tables:" << endl;
  1125.     for (unsigned i = 0; i < tabCount; i++) {
  1126. const Tab& tab = tabList[i];
  1127. if (i > 0)
  1128.     ndbout << " ";
  1129. ndbout << tab.m_name;
  1130.     }
  1131.     ndbout << endl;
  1132. }
  1134. // data fields and rows
  1136. struct Fld {
  1137.     const Col& m_col;
  1138.     union {
  1139. char* m_char;
  1140. long m_long;
  1141. double m_double;
  1142.     };
  1143.     SQLINTEGER m_ind;
  1144.     SQLINTEGER m_need; // constant
  1145.     Fld() :
  1146. m_col(ColUndef),
  1147. m_need(0) {
  1148.     }
  1149.     Fld(const Col& col) :
  1150. m_col(col),
  1151. m_need(SQL_LEN_DATA_AT_EXEC(0)) {
  1152. switch (m_col.m_ctype) {
  1153. case Col::CChar:
  1154.     m_char = new char[m_col.csize()];
  1155.     memset(m_char, 0, m_col.csize());
  1156.     break;
  1157. case Col::CLong:
  1158.     m_long = 0;
  1159.     break;
  1160. case Col::CDouble:
  1161.     m_double = 0.0;
  1162.     break;
  1163. }
  1164. m_ind = -1;
  1165.     }
  1166.     ~Fld() {
  1167. switch (m_col.m_ctype) {
  1168. case Col::CChar:
  1169.     delete[] m_char;
  1170.     break;
  1171. case Col::CLong:
  1172.     break;
  1173. case Col::CDouble:
  1174.     break;
  1175. }
  1176.     }
  1177.     void zero() {
  1178. switch (m_col.m_ctype) {
  1179. case Col::CChar:
  1180.     memset(m_char, 0x1f, m_col.csize());
  1181.     break;
  1182. case Col::CLong:
  1183.     m_long = 0x1f1f1f1f;
  1184.     break;
  1185. case Col::CDouble:
  1186.     m_double = 1111111.1111111;
  1187.     break;
  1188. }
  1189. m_ind = -1;
  1190.     }
  1191.     // copy values from another field
  1192.     void copy(const Fld& fld) {
  1193. assert(&m_col == &fld.m_col);
  1194. switch (m_col.m_ctype) {
  1195. case Col::CChar:
  1196.     memcpy(m_char, fld.m_char, m_col.csize());
  1197.     break;
  1198. case Col::CLong:
  1199.     m_long = fld.m_long;
  1200.     break;
  1201. case Col::CDouble:
  1202.     m_double = fld.m_double;
  1203.     break;
  1204. default:
  1205.     assert(false);
  1206.     break;
  1207. }
  1208. m_ind = fld.m_ind;
  1209.     }
  1210.     SQLPOINTER caddr() {
  1211. switch (m_col.m_ctype) {
  1212. case Col::CChar:
  1213.     return (SQLPOINTER)m_char;
  1214. case Col::CLong:
  1215.     return (SQLPOINTER)&m_long;
  1216. case Col::CDouble:
  1217.     return (SQLPOINTER)&m_double;
  1218. }
  1219. assert(false);
  1220. return 0;
  1221.     }
  1222.     SQLINTEGER* ind() {
  1223. return &m_ind;
  1224.     }
  1225.     SQLINTEGER* need() {
  1226. m_need = SQL_LEN_DATA_AT_EXEC(0);
  1227. return &m_need;
  1228.     }
  1229.     void calcPk(const Test& test, unsigned rownum) {
  1230. switch (m_col.m_ctype) {
  1231. case Col::CChar:
  1232.     test.calcPk(rownum, m_char, m_col.csize());
  1233.     m_ind = SQL_NTS;
  1234.     return;
  1235. case Col::CLong:
  1236.     test.calcPk(rownum, &m_long);
  1237.     m_ind = 0;
  1238.     return;
  1239. case Col::CDouble:
  1240.     assert(false);
  1241.     return;
  1242. }
  1243. assert(false);
  1244.     }
  1245.     void hashPk(const Test& test, unsigned* hash) const {
  1246. switch (m_col.m_ctype) {
  1247. case Col::CChar:
  1248.     test.hashPk(hash, m_char, m_col.csize());
  1249.     return;
  1250. case Col::CLong:
  1251.     test.hashPk(hash, m_long);
  1252.     return;
  1253. case Col::CDouble:
  1254.     assert(false);
  1255.     return;
  1256. }
  1257. assert(false);
  1258.     }
  1259.     void calcNk(const Test& test, unsigned hash) {
  1260. bool null = m_col.m_cons == Col::Null;
  1261. switch (m_col.m_ctype) {
  1262. case Col::CChar:
  1263.     test.calcNk(hash, m_char, m_col.csize(), &m_ind, null);
  1264.     return;
  1265. case Col::CLong:
  1266.     test.calcNk(hash, &m_long, &m_ind, null);
  1267.     return;
  1268. case Col::CDouble:
  1269.     test.calcNk(hash, &m_double, &m_ind, null);
  1270.     return;
  1271. }
  1272. assert(false);
  1273.     }
  1274.     bool verify(Test& test, const Fld& fld) {
  1275. assert(&m_col == &fld.m_col);
  1276. switch (m_col.m_ctype) {
  1277. case Col::CChar:
  1278.     return test.verify(m_char, m_ind, fld.m_char, fld.m_ind, m_col.csize());
  1279. case Col::CLong:
  1280.     return test.verify(m_long, m_ind, fld.m_long, fld.m_ind);
  1281. case Col::CDouble:
  1282.     return test.verify(m_double, m_ind, fld.m_double, fld.m_ind);
  1283. }
  1284. assert(false);
  1285. return false;
  1286.     }
  1287.     // debug
  1288.     void print() const {
  1289. if (m_ind == SQL_NULL_DATA)
  1290.     ndbout << "NULL";
  1291. else {
  1292.     switch (m_col.m_ctype) {
  1293.     case Col::CChar:
  1294. ndbout << m_char;
  1295. break;
  1296.     case Col::CLong:
  1297. ndbout << (int)m_long;
  1298. break;
  1299.     case Col::CDouble:
  1300. ndbout << m_double;
  1301. break;
  1302.     }
  1303. }
  1304.     }
  1305. };
  1307. struct Row {
  1308.     const Tab& m_tab;
  1309.     Fld* m_fldList;
  1310.     Row(const Tab& tab) :
  1311. m_tab(tab) {
  1312. m_fldList = new Fld[m_tab.m_colCount];
  1313. for (unsigned i = 0; i < m_tab.m_colCount; i++) {
  1314.     const Col& col = m_tab.m_colList[i];
  1315.     void* place = &m_fldList[i];
  1316.     new (place) Fld(col);
  1317. }
  1318.     }
  1319.     ~Row() {
  1320. delete[] m_fldList;
  1321.     }
  1322.     // copy values from another row
  1323.     void copy(const Row& row) {
  1324. assert(&m_tab == &row.m_tab);
  1325. for (unsigned i = 0; i < m_tab.m_colCount; i++) {
  1326.     Fld& fld = m_fldList[i];
  1327.     fld.copy(row.m_fldList[i]);
  1328. }
  1329.     }
  1330.     // primary key value is determined by row number
  1331.     void calcPk(Test& test, unsigned rownum) {
  1332. for (unsigned i = 0; i < m_tab.m_pkCount; i++) {
  1333.     Fld& fld = m_fldList[m_tab.m_pkIndex[i]];
  1334.     fld.calcPk(test, rownum);
  1335. }
  1336.     }
  1337.     // other fields are determined by primary key value
  1338.     void calcNk(Test& test) {
  1339. unsigned hash = test.m_salt;
  1340. for (unsigned i = 0; i < m_tab.m_pkCount; i++) {
  1341.     Fld& fld = m_fldList[m_tab.m_pkIndex[i]];
  1342.     fld.hashPk(test, &hash);
  1343. }
  1344. for (unsigned i = 0; i < m_tab.m_colCount; i++) {
  1345.     const Col& col = m_tab.m_colList[i];
  1346.     if (col.m_cons == Col::Pk)
  1347. continue;
  1348.     Fld& fld = m_fldList[i];
  1349.     fld.calcNk(test, hash);
  1350. }
  1351.     }
  1352.     // verify against another row
  1353.     bool verifyPk(Test& test, const Row& row) const {
  1354. assert(&m_tab == &row.m_tab);
  1355. for (unsigned i = 0; i < m_tab.m_pkCount; i++) {
  1356.     Fld& fld = m_fldList[m_tab.m_pkIndex[i]];
  1357.     if (! fld.verify(test, row.m_fldList[m_tab.m_pkIndex[i]])) {
  1358. ndbout << "verify failed: tab=" << m_tab.m_name << " col=" << fld.m_col.m_name << endl;
  1359. return false;
  1360.     }
  1361. }
  1362. return true;
  1363.     }
  1364.     bool verifyNk(Test& test, const Row& row) const {
  1365. assert(&m_tab == &row.m_tab);
  1366. for (unsigned i = 0; i < m_tab.m_nkCount; i++) {
  1367.     Fld& fld = m_fldList[m_tab.m_nkIndex[i]];
  1368.     if (! fld.verify(test, row.m_fldList[m_tab.m_nkIndex[i]])) {
  1369. ndbout << "verify failed: tab=" << m_tab.m_name << " col=" << fld.m_col.m_name << endl;
  1370. return false;
  1371.     }
  1372. }
  1373. return true;
  1374.     }
  1375.     bool verify(Test& test, const Row& row) const {
  1376. return verifyPk(test, row) && verifyNk(test, row);
  1377.     }
  1378.     // debug
  1379.     void print() const {
  1380. ndbout << "row";
  1381. for (unsigned i = 0; i < m_tab.m_colCount; i++) {
  1382.     ndbout << " " << i << "=";
  1383.     Fld& fld = m_fldList[i];
  1384.     fld.print();
  1385. }
  1386. ndbout << endl;
  1387.     }
  1388. };
  1390. // set ODBC version - required
  1392. static void
  1393. setVersion(Test& test, SQLHANDLE hEnv)
  1394. {
  1395.     test.run(HEnv(hEnv), SQLSetEnvAttr(hEnv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, SQL_IS_INTEGER));
  1396. }
  1398. // set autocommit
  1400. static void
  1401. setAutocommit(Test& test, SQLHANDLE hDbc, bool on)
  1402. {
  1403.     SQLUINTEGER value = on ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF;
  1404.     test.run(HDbc(hDbc), SQLSetConnectAttr(hDbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)value, SQL_IS_UINTEGER));
  1405.     SQLUINTEGER value2 = (SQLUINTEGER)-1;
  1406.     test.run(HDbc(hDbc), SQLGetConnectAttr(hDbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)&value2, SQL_IS_UINTEGER, 0));
  1407.     test.chk(HDbc(hDbc), value2 == value, "got %u != %u", (unsigned)value2, (unsigned)value);
  1408. }
  1410. // subroutines - migrate simple common routines here
  1412. static void
  1413. allocEnv(Test& test, SQLHANDLE& hEnv)
  1414. {
  1415.     test.run(HNull, SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &hEnv));
  1416.     setVersion(test, hEnv);
  1417. }
  1419. static void
  1420. allocDbc(Test& test, SQLHANDLE hEnv, SQLHANDLE& hDbc)
  1421. {
  1422.     test.run(HEnv(hEnv), SQLAllocHandle(SQL_HANDLE_DBC, hEnv, &hDbc));
  1423. }
  1425. static void
  1426. allocConn(Test& test, SQLHANDLE hEnv, SQLHANDLE& hDbc)
  1427. {
  1428.     allocDbc(test, hEnv, hDbc);
  1429. #ifdef unixODBC
  1430.     test.exp(SQL_SUCCESS_WITH_INFO, "IM003", 0, false); // unicode??
  1431.     test.exp(SQL_SUCCESS_WITH_INFO, "01000", 0, false); // version??
  1432. #endif
  1433.     test.run(HDbc(hDbc), SQLConnect(hDbc, (SQLCHAR*)opt.m_dsn, SQL_NTS, (SQLCHAR*)"user", SQL_NTS, (SQLCHAR*)"pass", SQL_NTS));
  1434. }
  1436. static void
  1437. allocStmt(Test& test, SQLHANDLE hDbc, SQLHANDLE& hStmt)
  1438. {
  1439.     test.run(HDbc(hDbc), SQLAllocHandle(SQL_HANDLE_STMT, hDbc, &hStmt));
  1440. }
  1442. static void
  1443. allocAll(Test& test, SQLHANDLE& hEnv, SQLHANDLE& hDbc, SQLHANDLE& hStmt)
  1444. {
  1445.     allocEnv(test, hEnv);
  1446.     allocConn(test, hEnv, hDbc);
  1447.     allocStmt(test, hDbc, hStmt);
  1448. }
  1450. static void
  1451. allocAll(Test& test, SQLHANDLE& hEnv, SQLHANDLE& hDbc, SQLHANDLE* hStmtList, unsigned nStmt)
  1452. {
  1453.     allocEnv(test, hEnv);
  1454.     allocConn(test, hEnv, hDbc);
  1455.     for (unsigned i = 0; i < nStmt; i++)
  1456. allocStmt(test, hDbc, hStmtList[i]);
  1457. }
  1459. static void
  1460. freeEnv(Test& test, SQLHANDLE hEnv)
  1461. {
  1462.     test.run(HNull, SQLFreeHandle(SQL_HANDLE_ENV, hEnv));
  1463. }
  1465. static void
  1466. freeDbc(Test& test, SQLHANDLE hEnv, SQLHANDLE hDbc)
  1467. {
  1468.     test.run(HEnv(hEnv), SQLFreeHandle(SQL_HANDLE_DBC, hDbc));
  1469. }
  1471. static void
  1472. freeConn(Test& test, SQLHANDLE hEnv, SQLHANDLE hDbc)
  1473. {
  1474.     test.run(HDbc(hDbc), SQLDisconnect(hDbc));
  1475.     test.run(HEnv(hEnv), SQLFreeHandle(SQL_HANDLE_DBC, hDbc));
  1476. }
  1478. static void
  1479. freeStmt(Test& test, SQLHANDLE hDbc, SQLHANDLE hStmt)
  1480. {
  1481.     test.run(HDbc(hDbc), SQLFreeHandle(SQL_HANDLE_STMT, hStmt));
  1482. }
  1484. static void
  1485. freeAll(Test& test, SQLHANDLE hEnv, SQLHANDLE hDbc, SQLHANDLE hStmt)
  1486. {
  1487.     freeStmt(test, hDbc, hStmt);
  1488.     freeConn(test, hEnv, hDbc);
  1489.     freeEnv(test, hEnv);
  1490. }
  1492. static void
  1493. freeAll(Test& test, SQLHANDLE hEnv, SQLHANDLE hDbc, SQLHANDLE* hStmtList, unsigned nStmt)
  1494. {
  1495.     for (unsigned i = 0; i < nStmt; i++)
  1496. freeStmt(test, hDbc, hStmtList[i]);
  1497.     freeConn(test, hEnv, hDbc);
  1498.     freeEnv(test, hEnv);
  1499. }
  1501. #define chkTuplesFetched(/*Test&*/ _test, /*SQLHANDLE*/ _hStmt, /*SQLUINTEGER*/ _countExp) 
  1502. do { 
  1503.     SQLUINTEGER _count = (SQLUINTEGER)-1; 
  1504.     getTuplesFetched(_test, _hStmt, &_count); 
  1505.     test.chk(HStmt(_hStmt), _count == _countExp, "tuples: got %ld != %ld", (long)_count, (long)_countExp); 
  1506. } while (0)
  1508. static void
  1509. getTuplesFetched(Test& test, SQLHANDLE hStmt, SQLUINTEGER* count)
  1510. {
  1511.     *count = (SQLUINTEGER)-1;
  1512.     test.run(HStmt(hStmt), SQLGetStmtAttr(hStmt, SQL_ATTR_NDB_TUPLES_FETCHED, count, SQL_IS_POINTER, 0));
  1513. }
  1515. static void
  1516. selectCount(Test& test, SQLHANDLE hStmt, const char* sql, long* count)
  1517. {
  1518.     if (opt.m_v >= 3)
  1519. ndbout << "SQL: " << sql << endl;
  1520.     test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS));
  1521.     SQLINTEGER ind;
  1522.     test.run(HStmt(hStmt), SQLBindCol(hStmt, 1, SQL_C_SLONG, count, 0, &ind));
  1523.     ind = -1;
  1524.     *count = -1;
  1525.     test.run(HStmt(hStmt), SQLExecute(hStmt));
  1526.     unsigned k = 0;
  1527.     while (1) {
  1528. if (k == 1)
  1529.     test.exp(SQL_NO_DATA, 0, 0, true);
  1530. test.run(HStmt(hStmt), SQLFetch(hStmt));
  1531. if (k == 1)
  1532.     break;
  1533. k++;
  1534.     }
  1535.     test.chk(HStmt(hStmt), ind == sizeof(long), "got %d != %d", (int)ind, (int)sizeof(long));
  1536.     test.chk(HStmt(hStmt), *count >= 0, "got %ld < 0", *count);
  1537.     chkTuplesFetched(test, hStmt, *count);
  1538. #ifndef iODBC
  1539.     //
  1540.     test.run(HStmt(hStmt), SQLCloseCursor(hStmt));
  1541. #else
  1542.     test.run(HStmt(hStmt), SQLFreeStmt(hStmt, SQL_CLOSE));
  1543. #endif
  1544. }
  1546. static void
  1547. selectCount(Test& test, SQLHANDLE hStmt, const Tab& tab, long* count)
  1548. {
  1549.     static char sql[MAX_SQL], *sqlptr; // XXX static or core
  1550.     tab.selectCount(sqlptr = sql);
  1551.     selectCount(test, hStmt, sql, count);
  1552. }
  1554. static void
  1555. verifyCount(Test& test, SQLHANDLE hStmt, const Tab& tab, long countExp)
  1556. {
  1557.     long count = -1;
  1558.     selectCount(test, hStmt, tab, &count);
  1559.     test.chk(HStmt(hStmt), count == countExp, "got %ld != %ld", count, countExp);
  1560. }
  1562. #define chkRowCount(/*Test&*/ _test, /*SQLHANDLE*/ _hStmt, /*SQLINTEGER*/ _countExp) 
  1563. do { 
  1564.     SQLINTEGER _count = -1; 
  1565.     getRowCount(_test, _hStmt, &_count); 
  1566.     test.chk(HStmt(_hStmt), _count == _countExp, "rowcount: got %ld != %ld", (long)_count, (long)_countExp); 
  1567. } while (0)
  1569. static void
  1570. getRowCount(Test& test, SQLHANDLE hStmt, SQLINTEGER* count)
  1571. {
  1572.     *count = -1;
  1573.     test.run(HStmt(hStmt), SQLRowCount(hStmt, count));
  1574. }
  1576. // handle allocation
  1578. static void
  1579. testAlloc(Test& test)
  1580. {
  1581.     const unsigned n1 = (opt.m_scale >> 8) & 0xf; // default 500 = 0x1f4
  1582.     const unsigned n2 = (opt.m_scale >> 4) & 0xf;
  1583.     const unsigned n3 = (opt.m_scale >> 0) & 0xf;
  1584.     const unsigned count = n1 + n1 * n2 + n1 * n2 * n3;
  1585.     SQLHANDLE hEnvList[0xf];
  1586.     SQLHANDLE hDbcList[0xf][0xf];
  1587.     SQLHANDLE hStmtList[0xf][0xf][0xf];
  1588.     for (unsigned i1 = 0; i1 < n1; i1++) {
  1589. SQLHANDLE& hEnv = hEnvList[i1];
  1590. test.run(HNull, SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &hEnv));
  1591. test.run(HEnv(hEnv), SQLSetEnvAttr(hEnv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, SQL_IS_INTEGER));
  1592. for (unsigned i2 = 0; i2 < n2; i2++) {
  1593.     SQLHANDLE& hDbc = hDbcList[i1][i2];
  1594.     test.run(HEnv(hEnv), SQLAllocHandle(SQL_HANDLE_DBC, hEnv, &hDbc));
  1595. #ifdef unixODBC
  1596.     test.exp(SQL_SUCCESS_WITH_INFO, "IM003", 0, false); // unicode??
  1597.     test.exp(SQL_SUCCESS_WITH_INFO, "01000", 0, false); // version??
  1598. #endif
  1599.     test.run(HDbc(hDbc), SQLConnect(hDbc, (SQLCHAR*)opt.m_dsn, SQL_NTS, (SQLCHAR*)"user", SQL_NTS, (SQLCHAR*)"pass", SQL_NTS));
  1600.     // some attributes
  1601.     test.exp(SQL_ERROR, "HY092", -1, true); // read-only attribute
  1602.     test.run(HDbc(hDbc), SQLSetConnectAttr(hDbc, SQL_ATTR_AUTO_IPD, (SQLPOINTER)SQL_TRUE, SQL_IS_UINTEGER));
  1603.     test.exp(SQL_ERROR, "HYC00", -1, true); // not supported
  1604.     test.run(HDbc(hDbc), SQLSetConnectAttr(hDbc, SQL_ATTR_TXN_ISOLATION, (SQLPOINTER)SQL_TXN_SERIALIZABLE, SQL_IS_UINTEGER));
  1605.     test.run(HDbc(hDbc), SQLSetConnectAttr(hDbc, SQL_ATTR_CURRENT_CATALOG, (SQLPOINTER)"DEFAULT", strlen("DEFAULT")));
  1606.     for (unsigned i3 = 0; i3 < n3; i3++) {
  1607. SQLHANDLE& hStmt = hStmtList[i1][i2][i3];
  1608. test.run(HDbc(hDbc), SQLAllocHandle(SQL_HANDLE_STMT, hDbc, &hStmt));
  1609. SQLHANDLE ipd0, ipd1;
  1610. SQLHANDLE ird0, ird1;
  1611. SQLHANDLE apd0, apd1, apd2;
  1612. SQLHANDLE ard0, ard1, ard2;
  1613. // get
  1614. ipd0 = ird0 = apd0 = ard0 = 0;
  1615. test.run(HStmt(hStmt), SQLGetStmtAttr(hStmt, SQL_ATTR_IMP_PARAM_DESC, &ipd0, SQL_IS_POINTER, 0));
  1616. test.run(HStmt(hStmt), SQLGetStmtAttr(hStmt, SQL_ATTR_IMP_ROW_DESC, &ird0, SQL_IS_POINTER, 0));
  1617. test.run(HStmt(hStmt), SQLGetStmtAttr(hStmt, SQL_ATTR_APP_PARAM_DESC, &apd0, SQL_IS_POINTER, 0));
  1618. test.run(HStmt(hStmt), SQLGetStmtAttr(hStmt, SQL_ATTR_APP_ROW_DESC, &ard0, SQL_IS_POINTER, 0));
  1619. #ifndef unixODBC
  1620. test.chk(HStmt(hStmt), ipd0 != 0, "got 0");
  1621. test.chk(HStmt(hStmt), ird0 != 0, "got 0");
  1622. test.chk(HStmt(hStmt), apd0 != 0, "got 0");
  1623. test.chk(HStmt(hStmt), ard0 != 0, "got 0");
  1624. #endif
  1625. // alloc
  1626. ipd1 = ird1 = apd1 = ard1 = 0;
  1627. test.run(HDbc(hDbc), SQLAllocHandle(SQL_HANDLE_DESC, hDbc, &ipd1));
  1628. test.run(HDbc(hDbc), SQLAllocHandle(SQL_HANDLE_DESC, hDbc, &ird1));
  1629. test.run(HDbc(hDbc), SQLAllocHandle(SQL_HANDLE_DESC, hDbc, &apd1));
  1630. test.run(HDbc(hDbc), SQLAllocHandle(SQL_HANDLE_DESC, hDbc, &ard1));
  1631. test.chk(HDbc(hDbc), ipd1 != 0 && ird1 != 0 && apd1 != 0 && ard1 != 0, "got null");
  1632. // set
  1633. test.exp(SQL_ERROR, "HY092", -1, true); // read-only attribute
  1634. test.run(HStmt(hStmt), SQLSetStmtAttr(hStmt, SQL_ATTR_IMP_PARAM_DESC, ipd1, SQL_IS_POINTER));
  1635. test.exp(SQL_ERROR, "HY092", -1, true); // read-only attribute
  1636. test.run(HStmt(hStmt), SQLSetStmtAttr(hStmt, SQL_ATTR_IMP_ROW_DESC, ird1, SQL_IS_POINTER));
  1637. test.run(HStmt(hStmt), SQLSetStmtAttr(hStmt, SQL_ATTR_APP_PARAM_DESC, apd1, SQL_IS_POINTER));
  1638. test.run(HStmt(hStmt), SQLSetStmtAttr(hStmt, SQL_ATTR_APP_ROW_DESC, ard1, SQL_IS_POINTER));
  1639. // get
  1641. apd2 = ard2 = 0;
  1642. test.run(HStmt(hStmt), SQLGetStmtAttr(hStmt, SQL_ATTR_APP_PARAM_DESC, &apd2, SQL_IS_POINTER, 0));
  1643. test.run(HStmt(hStmt), SQLGetStmtAttr(hStmt, SQL_ATTR_APP_ROW_DESC, &ard2, SQL_IS_POINTER, 0));
  1644. test.chk(HStmt(hStmt), apd2 == apd1, "got %x != %x", (unsigned)apd2, (unsigned)apd1);
  1645. test.chk(HStmt(hStmt), ard2 == ard1, "got %x != %x", (unsigned)ard2, (unsigned)ard1);
  1646. // free
  1647. test.run(HDbc(hDbc), SQLFreeHandle(SQL_HANDLE_DESC, ipd1));
  1648. test.run(HDbc(hDbc), SQLFreeHandle(SQL_HANDLE_DESC, ird1));
  1649. test.run(HDbc(hDbc), SQLFreeHandle(SQL_HANDLE_DESC, apd1));
  1650. test.run(HDbc(hDbc), SQLFreeHandle(SQL_HANDLE_DESC, ard1));
  1651.     }
  1652. }
  1653.     }
  1654.     test.timerCnt(count);
  1655.     if (opt.m_v >= 3)
  1656. ndbout << "allocated " << count << endl;
  1657.     for (unsigned i1 = 0; i1 < n1; i1++) {
  1658. SQLHANDLE& hEnv = hEnvList[i1];
  1659. for (unsigned i2 = 0; i2 < n2; i2++) {
  1660.     SQLHANDLE& hDbc = hDbcList[i1][i2];
  1661.     if (i2 % 2 == 0) {
  1662. for (unsigned i3 = 0; i3 < n3; i3++) {
  1663.     SQLHANDLE& hStmt = hStmtList[i1][i2][i3];
  1664.     test.run(HDbc(hDbc), SQLFreeHandle(SQL_HANDLE_STMT, hStmt));
  1665. }
  1666.     } else {
  1667. // cleaned up by SQLDisconnect
  1668.     }
  1669.     test.run(HDbc(hDbc), SQLDisconnect(hDbc));
  1670.     test.run(HEnv(hEnv), SQLFreeHandle(SQL_HANDLE_DBC, hDbc));
  1671. }
  1672. test.run(HNull, SQLFreeHandle(SQL_HANDLE_ENV, hEnv));
  1673.     }
  1674.     test.timerCnt(count);
  1675.     if (opt.m_v >= 3)
  1676. ndbout << "freed " << count << endl;
  1677. }
  1679. // create tables
  1681. static void
  1682. testCreate(Test& test)
  1683. {
  1684.     SQLHANDLE hEnv, hDbc, hStmt;
  1685.     allocAll(test, hEnv, hDbc, hStmt);
  1686.     char sql[MAX_SQL], *sqlptr;
  1687.     for (unsigned i = 0; i < tabCount; i++) {
  1688. Tab& tab = tabList[i];
  1689. if (! tab.optok())
  1690.     continue;
  1691. // drop
  1692. tab.drop(sqlptr = sql);
  1693. if (opt.m_v >= 2)
  1694.     ndbout << "SQL: " << sql << endl;
  1695. test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS));
  1696. test.exp(SQL_ERROR, "IM000", 2040709, false);
  1697. test.run(HStmt(hStmt), SQLExecute(hStmt));
  1698. if (test.m_ret == SQL_SUCCESS)
  1699.     test.chk(HStmt(hStmt), test.m_functionCode == SQL_DIAG_DROP_TABLE, "got %d != %d", test.m_functionCode, SQL_DIAG_DROP_TABLE);
  1700. if (test.m_ret == SQL_SUCCESS && opt.m_v >= 2)
  1701.     ndbout << "table " << tab.m_name << " dropped" << endl;
  1702. if (test.m_ret != SQL_SUCCESS && opt.m_v >= 2)
  1703.     ndbout << "table " << tab.m_name << " does not exist" << endl;
  1704. test.timerCnt(1);
  1705. // create
  1706. tab.create(sqlptr = sql);
  1707. if (opt.m_v >= 2)
  1708.     ndbout << "SQL: " << sql << endl;
  1709. test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS));
  1710. test.exp(SQL_ERROR, "IM000", 2040721, false);
  1711. test.run(HStmt(hStmt), SQLExecute(hStmt));
  1712. if (test.m_ret == SQL_SUCCESS)
  1713.     test.chk(HStmt(hStmt), test.m_functionCode == SQL_DIAG_CREATE_TABLE, "got %d != %d", test.m_functionCode, SQL_DIAG_CREATE_TABLE);
  1714. if (test.m_ret == SQL_SUCCESS && opt.m_v >= 2)
  1715.     ndbout << "table " << tab.m_name << " created" << endl;
  1716. if (test.m_ret != SQL_SUCCESS && opt.m_v >= 2)
  1717.     ndbout << "table " << tab.m_name << " already exists" << endl;
  1718. test.timerCnt(1);
  1719.     }
  1720.     freeAll(test, hEnv, hDbc, hStmt);
  1721. }
  1723. // prepare without execute
  1725. static void
  1726. testPrepare(Test& test)
  1727. {
  1728.     SQLHANDLE hEnv, hDbc, hStmt;
  1729.     allocAll(test, hEnv, hDbc, hStmt);
  1730.     char sql[MAX_SQL], *sqlptr;
  1731.     for (unsigned cnt = opt.m_depth; cnt <= opt.m_depth; cnt++) {
  1732. for (unsigned i = 0; i < tabCount; i++) {
  1733.     Tab& tab = tabList[i];
  1734.     if (! tab.optok())
  1735. continue;
  1736.     tab.selectJoin(sqlptr = sql, cnt);
  1737.     if (opt.m_v >= 2)
  1738. ndbout << "SQL: " << sql << endl;
  1739.     test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS));
  1740.     SQLSMALLINT colCount = -1;
  1741.     SQLSMALLINT colExp = cnt * tab.m_colCount;
  1742.     test.run(HStmt(hStmt), SQLNumResultCols(hStmt, &colCount));
  1743.     test.chk(HStmt(hStmt), colCount == colExp, "got %d != %d", (int)colCount, (int)colExp);
  1744.     test.timerCnt(1);
  1745. }
  1746.     }
  1747.     freeAll(test, hEnv, hDbc, hStmt);
  1748. }
  1750. // catalog functions
  1752. static void
  1753. testCatalog(Test& test)
  1754. {
  1755.     SQLHANDLE hEnv, hDbc, hStmt;
  1756.     allocAll(test, hEnv, hDbc, hStmt);
  1757.     odbc_typeinfo: {
  1758. long type[] = {
  1759.     SQL_CHAR, SQL_VARCHAR, SQL_SMALLINT, SQL_INTEGER, SQL_BIGINT, SQL_REAL, SQL_DOUBLE
  1760. };
  1761. unsigned rows[] = {
  1762.     1, 1, 2, 2, 2, 1, 1 // 2 for signed and unsigned
  1763. };
  1764. for (unsigned i = 0; i < arraySize(type); i++) {
  1765.     test.run(HStmt(hStmt), SQLGetTypeInfo(hStmt, type[i]));
  1766.     long dataType = 0;
  1767.     test.run(HStmt(hStmt), SQLBindCol(hStmt, 2, SQL_C_SLONG, &dataType, 0, 0));
  1768.     unsigned k = 0;
  1769.     while (1) {
  1770. if (k == rows[i])
  1771.     test.exp(SQL_NO_DATA, 0, 0, true);
  1772. test.run(HStmt(hStmt), SQLFetch(hStmt));
  1773. if (k == rows[i])
  1774.     break;
  1775. test.chk(HStmt(hStmt), dataType == type[i], "got %ld != %ld", dataType, type[i]);
  1776. test.timerCnt(1);
  1777. k++;
  1778.     }
  1779. #ifndef iODBC
  1780.     test.run(HStmt(hStmt), SQLCloseCursor(hStmt));
  1781. #else
  1782.     freeStmt(test, hDbc, hStmt);
  1783.     allocStmt(test, hDbc, hStmt);
  1784. #endif
  1785. }
  1786. if (opt.m_v >= 2)
  1787.     ndbout << "found " << (UintPtr)arraySize(type) << " data types" << endl;
  1788. test.run(HStmt(hStmt), SQLFreeStmt(hStmt, SQL_UNBIND));
  1789.     }
  1790.     odbc_tables: {
  1791. unsigned found[tabCount];
  1792. for (unsigned i = 0; i < tabCount; i++)
  1793.     found[i] = 0;
  1794. test.run(HStmt(hStmt), SQLTables(hStmt, (SQLCHAR*)0, 0, (SQLCHAR*)0, 0, (SQLCHAR*)0, 0, (SQLCHAR*)0, 0));
  1795. char tableName[200] = "";
  1796. char tableType[200] = "";
  1797. test.run(HStmt(hStmt), SQLBindCol(hStmt, 3, SQL_C_CHAR, tableName, sizeof(tableName), 0));
  1798. test.run(HStmt(hStmt), SQLBindCol(hStmt, 4, SQL_C_CHAR, tableType, sizeof(tableType), 0));
  1799. unsigned cnt = 0;
  1800. while (1) {
  1801.     test.exp(SQL_NO_DATA, 0, 0, false);
  1802.     test.run(HStmt(hStmt), SQLFetch(hStmt));
  1803.     if (test.m_ret == SQL_NO_DATA)
  1804. break;
  1805.     test.timerCnt(1);
  1806.     cnt++;
  1807.     if (! blankeq(tableType, "TABLE"))
  1808. continue;
  1809.     for (unsigned i = 0; i < tabCount; i++) {
  1810. const Tab& tab = tabList[i];
  1811. if (! tab.optok())
  1812.     continue;
  1813. if (! blankeq(tab.m_name, tableName))
  1814.     continue;
  1815. test.chk(HStmt(hStmt), found[i] == 0, "duplicate table %s", tab.m_name);
  1816. found[i]++;
  1817.     }
  1818. }
  1819. #ifndef iODBC
  1820. test.run(HStmt(hStmt), SQLCloseCursor(hStmt));
  1821. #else
  1822. freeStmt(test, hDbc, hStmt);
  1823. allocStmt(test, hDbc, hStmt);
  1824. #endif
  1825. for (unsigned i = 0; i < tabCount; i++) {
  1826.     const Tab& tab = tabList[i];
  1827.     if (! tab.optok())
  1828. continue;
  1829.     test.chk(HStmt(hStmt), found[i] == 1, "table %s not found", tab.m_name);
  1830. }
  1831. if (opt.m_v >= 2)
  1832.     ndbout << "found " << cnt << " tables" << endl;
  1833. test.run(HStmt(hStmt), SQLFreeStmt(hStmt, SQL_UNBIND));
  1834.     }
  1835.     odbc_columns: {
  1836. unsigned found[tabCount][maxColCount];
  1837. for (unsigned i = 0; i < tabCount; i++) {
  1838.     for (unsigned j = 0; j < maxColCount; j++)
  1839. found[i][j] = 0;
  1840. }
  1841. test.run(HStmt(hStmt), SQLColumns(hStmt, (SQLCHAR*)0, 0, (SQLCHAR*)0, 0, (SQLCHAR*)0, 0, (SQLCHAR*)0, 0));
  1842. char tableName[200] = "";
  1843. char columnName[200] = "";
  1844. long dataType = 0;
  1845. test.run(HStmt(hStmt), SQLBindCol(hStmt, 3, SQL_C_CHAR, tableName, sizeof(tableName), 0));
  1846. test.run(HStmt(hStmt), SQLBindCol(hStmt, 4, SQL_C_CHAR, columnName, sizeof(columnName), 0));
  1847. test.run(HStmt(hStmt), SQLBindCol(hStmt, 5, SQL_C_SLONG, &dataType, 0, 0));
  1848. unsigned cnt = 0;
  1849. while (1) {
  1850.     test.exp(SQL_NO_DATA, 0, 0, false);
  1851.     test.run(HStmt(hStmt), SQLFetch(hStmt));
  1852.     if (test.m_ret == SQL_NO_DATA)
  1853. break;
  1854.     test.timerCnt(1);
  1855.     cnt++;
  1856.     for (unsigned i = 0; i < tabCount; i++) {
  1857. const Tab& tab = tabList[i];
  1858. if (! tab.optok())
  1859.     continue;
  1860. if (! blankeq(tab.m_name, tableName))
  1861.     continue;
  1862. bool columnFound = false;
  1863. for (unsigned j = 0; j < tab.m_colCount; j++) {
  1864.     const Col& col = tab.m_colList[j];
  1865.     if (! blankeq(col.m_name, columnName))
  1866. continue;
  1867.     test.chk(HStmt(hStmt), found[i][j] == 0, "duplicate column %s.%s", tableName, columnName);
  1868.     found[i][j]++;
  1869.     columnFound = true;
  1870. }
  1871. test.chk(HStmt(hStmt), columnFound, "unknown column %s.%s", tableName, columnName);
  1872.     }
  1873. }
  1874. #ifndef iODBC
  1875. test.run(HStmt(hStmt), SQLCloseCursor(hStmt));
  1876. #else
  1877. freeStmt(test, hDbc, hStmt);
  1878. allocStmt(test, hDbc, hStmt);
  1879. #endif
  1880. for (unsigned i = 0; i < tabCount; i++) {
  1881.     const Tab& tab = tabList[i];
  1882.     if (! tab.optok())
  1883. continue;
  1884.     for (unsigned j = 0; j < tab.m_colCount; j++) {
  1885. const Col& col = tab.m_colList[j];
  1886. test.chk(HStmt(hStmt), found[i][j] == 1, "column %s.%s not found", tab.m_name, col.m_name);
  1887.     }
  1888. }
  1889. if (opt.m_v >= 2)
  1890.     ndbout << "found " << cnt << " columns" << endl;
  1891. test.run(HStmt(hStmt), SQLFreeStmt(hStmt, SQL_UNBIND));
  1892.     }
  1893.     odbc_primarykeys: {
  1894. // table patterns are no allowed
  1895. for (unsigned i = 0; i < tabCount; i++) {
  1896.     const Tab& tab = tabList[i];
  1897.     if (! tab.optok())
  1898. continue;
  1899.     char tmp[200]; // p.i.t.a
  1900.     strcpy(tmp, tab.m_name);
  1901.     for (char* a = tmp; *a != 0; a++) {
  1902. if ('a' <= *a && *a <= 'z')
  1903.     *a -= 'a' - 'A';
  1904.     }
  1905.     test.run(HStmt(hStmt), SQLPrimaryKeys(hStmt, (SQLCHAR*)0, 0, (SQLCHAR*)0, 0, (SQLCHAR*)tmp, SQL_NTS));
  1906.     char tableName[200] = "";
  1907.     char columnName[200] = "";
  1908.     long keySeq = -1;
  1909.     test.run(HStmt(hStmt), SQLBindCol(hStmt, 3, SQL_C_CHAR, tableName, sizeof(tableName), 0));
  1910.     test.run(HStmt(hStmt), SQLBindCol(hStmt, 4, SQL_C_CHAR, columnName, sizeof(columnName), 0));
  1911.     test.run(HStmt(hStmt), SQLBindCol(hStmt, 5, SQL_C_SLONG, &keySeq, 0, 0));
  1912.     unsigned cnt = 0;
  1913.     while (1) {
  1914. if (cnt == tab.m_pkCount)
  1915.     test.exp(SQL_NO_DATA, 0, 0, true);
  1916. test.run(HStmt(hStmt), SQLFetch(hStmt));
  1917. if (test.m_ret == SQL_NO_DATA)
  1918.     break;
  1919. test.chk(HStmt(hStmt), keySeq == 1 + cnt, "got %ld != %u", keySeq, 1 + cnt);
  1920. const Col& col = tab.m_colList[tab.m_pkIndex[keySeq - 1]];
  1921. test.chk(HStmt(hStmt), blankeq(columnName, col.m_name), "got %s != %s", columnName, col.m_name);
  1922. test.timerCnt(1);
  1923. cnt++;
  1924.     }
  1925. #ifndef iODBC
  1926.     test.run(HStmt(hStmt), SQLCloseCursor(hStmt));
  1927. #else
  1928.     freeStmt(test, hDbc, hStmt);
  1929.     allocStmt(test, hDbc, hStmt);
  1930. #endif
  1931. }
  1932. test.run(HStmt(hStmt), SQLFreeStmt(hStmt, SQL_UNBIND));
  1933.     }
  1934.     freeAll(test, hEnv, hDbc, hStmt);
  1935. }
  1937. // insert
  1939. static void
  1940. testInsert(Test& test)
  1941. {
  1942.     SQLHANDLE hEnv, hDbc, hStmtList[tabCount];
  1943.     allocAll(test, hEnv, hDbc, hStmtList, tabCount);
  1944.     char sql[MAX_SQL], *sqlptr;
  1945.     for (unsigned i = 0; i < tabCount; i++) {
  1946. SQLHANDLE& hStmt = hStmtList[i];
  1947. const Tab& tab = tabList[i];
  1948. if (! tab.optok())
  1949.     continue;
  1950. // prepare
  1951. tab.insertAll(sqlptr = sql);
  1952. if (opt.m_v >= 2)
  1953.     ndbout << "SQL: " << sql << endl;
  1954. test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS));
  1955. SQLSMALLINT parCount = -1;
  1956. test.run(HStmt(hStmt), SQLNumParams(hStmt, &parCount));
  1957. test.chk(HStmt(hStmt), parCount == tab.m_colCount, "got %d != %d", (int)parCount, (int)tab.m_colCount);
  1958. // bind parameters
  1959. Row row(tab);
  1960. for (unsigned j = 0; j < tab.m_colCount; j++) {
  1961.     Fld& fld = row.m_fldList[j];
  1962.     const Col& col = fld.m_col;
  1963.     // every other at-exec
  1964.     SQLPOINTER caddr;
  1965.     SQLINTEGER* ind;
  1966.     if (opt.m_noputd || j % 2 == 0) {
  1967. caddr = fld.caddr();
  1968. ind = fld.ind();
  1969.     } else {
  1970. caddr = (SQLPOINTER)j;
  1971. ind = fld.need();
  1972.     }
  1973.     test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + j, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, caddr, col.csize(), ind));
  1974. }
  1975. // bind columns (none)
  1976. SQLSMALLINT colCount = -1;
  1977. test.run(HStmt(hStmt), SQLNumResultCols(hStmt, &colCount));
  1978. test.chk(HStmt(hStmt), colCount == 0, "got %d != 0", (int)colCount);
  1979. // execute
  1980. for (unsigned k = 0; k < opt.m_scale; k++) {
  1981.     if (k % 5 == 0) {
  1982. // rebind
  1983. unsigned j = 0;
  1984. Fld& fld = row.m_fldList[j];
  1985. const Col& col = fld.m_col;
  1986. // every other at-exec
  1987. SQLPOINTER caddr;
  1988. SQLINTEGER* ind;
  1989. if (opt.m_noputd || j % 2 == 0) {
  1990.     caddr = fld.caddr();
  1991.     ind = fld.ind();
  1992. } else {
  1993.     caddr = (SQLPOINTER)j;
  1994.     ind = fld.need();
  1995. }
  1996. test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + j, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, caddr, col.csize(), ind));
  1997.     }
  1998.     row.calcPk(test, k);
  1999.     row.calcNk(test);
  2000.     unsigned needData = opt.m_noputd ? 0 : tab.m_colCount / 2;
  2001.     if (needData)
  2002. test.exp(SQL_NEED_DATA, 0, 0, true);
  2003.     test.run(HStmt(hStmt), SQLExecute(hStmt));
  2004.     test.chk(HStmt(hStmt), test.m_functionCode == SQL_DIAG_INSERT, "got %d != %d", test.m_functionCode, SQL_DIAG_INSERT);
  2005.     if (needData) {
  2006. while (1) {
  2007.     SQLPOINTER jPtr = (SQLPOINTER)999;
  2008.     if (needData)
  2009. test.exp(SQL_NEED_DATA, 0, 0, true);
  2010.     // completes SQLExecute on success
  2011.     test.run(HStmt(hStmt), SQLParamData(hStmt, &jPtr));
  2012.     if (! needData)
  2013. break;
  2014.     unsigned j = (unsigned)jPtr;
  2015.     test.chk(HStmt(hStmt), j < tab.m_colCount && j % 2 != 0, "got %u 0x%x", j, j);
  2016.     Fld& fld = row.m_fldList[j];
  2017.     const Col& col = fld.m_col;
  2018.     SQLSMALLINT ctype = col.ctype();
  2019.     if (k % 2 == 0 || ctype != Col::CChar)
  2020. test.run(HStmt(hStmt), SQLPutData(hStmt, fld.caddr(), *fld.ind()));
  2021.     else {
  2022. // put in pieces
  2023. unsigned size = col.csize() - 1; // omit null terminator
  2024. char* caddr = (char*)(fld.caddr());
  2025. unsigned off = 0;
  2026. while (off < size) {
  2027.     unsigned m = size / 7; // bytes to put
  2028.     if (m == 0)
  2029. m = 1;
  2030.     if (m > size - off)
  2031. m = size - off;
  2032.     bool putNull = (*fld.ind() == SQL_NULL_DATA);
  2033.     // no null terminator
  2034.     SQLINTEGER len = putNull ? SQL_NULL_DATA : (int)m;
  2035.     test.run(HStmt(hStmt), SQLPutData(hStmt, caddr + off, len));
  2036.     if (putNull)
  2037. break;
  2038.     off += m;
  2039. }
  2040.     }
  2041.     needData--;
  2042. }
  2043.     }
  2044.     chkRowCount(test, hStmt, 1);
  2045.     chkTuplesFetched(test, hStmt, 0);
  2046. }
  2047. test.timerCnt(opt.m_scale);
  2048. if (opt.m_v >= 3)
  2049.     ndbout << "inserted " << opt.m_scale <<  " into " << tab.m_name << endl;
  2050.     }
  2051.     freeAll(test, hEnv, hDbc, hStmtList, tabCount);
  2052. }
  2054. // count
  2056. static void
  2057. testCount(Test& test)
  2058. {
  2059.     SQLHANDLE hEnv, hDbc, hStmtList[tabCount];
  2060.     allocAll(test, hEnv, hDbc, hStmtList, tabCount);
  2061.     for (unsigned i = 0; i < tabCount; i++) {
  2062. SQLHANDLE& hStmt = hStmtList[i];
  2063. const Tab& tab = tabList[i];
  2064. if (! tab.optok())
  2065.     continue;
  2066. long count = -1;
  2067. selectCount(test, hStmt, tab, &count);
  2068. test.chk(HStmt(hStmt), count == opt.m_scale * opt.m_threads, "got %ld != %u", count, opt.m_scale * opt.m_threads);
  2069. test.timerCnt(count);
  2070. if (opt.m_v >= 3)
  2071.     ndbout << "counted " << (int)count <<  " rows in " << tab.m_name << endl;
  2072.     }
  2073.     // scan all at same time
  2074.     char sql[MAX_SQL], *sqlptr;
  2075.     for (unsigned i = 0; i < tabCount; i++) {
  2076. SQLHANDLE& hStmt = hStmtList[i];
  2077. const Tab& tab = tabList[i];
  2078. if (! tab.optok())
  2079.     continue;
  2080. tab.selectAll(sqlptr = sql);
  2081. test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS));
  2082.     }
  2083.     unsigned k = 0;
  2084.     while (1) {
  2085. for (unsigned i = 0; i < tabCount; i++) {
  2086.     SQLHANDLE& hStmt = hStmtList[i];
  2087.     const Tab& tab = tabList[i];
  2088.     if (! tab.optok())
  2089. continue;
  2090.     if (k == opt.m_scale * opt.m_threads)
  2091. test.exp(SQL_NO_DATA, 0, 0, true);
  2092.     test.run(HStmt(hStmt), SQLFetch(hStmt));
  2093.     if (k != opt.m_scale * opt.m_threads) {
  2094. chkTuplesFetched(test, hStmt, k + 1);
  2095. test.timerCnt(1);
  2096.     } else {
  2097. chkTuplesFetched(test, hStmt, k);
  2098. test.exp(SQL_NO_DATA, 0, 0, true);
  2099. test.run(HStmt(hStmt), SQLMoreResults(hStmt));
  2100.     }
  2101. }
  2102. if (k == opt.m_scale * opt.m_threads)
  2103.     break;
  2104. k++;
  2105.     }
  2106.     if (opt.m_v >= 3)
  2107. ndbout << "scanned " << opt.m_scale <<  " rows from each table" << endl;
  2108.     freeAll(test, hEnv, hDbc, hStmtList, tabCount);
  2109. }
  2111. // update
  2113. static void
  2114. testUpdatePk(Test& test)
  2115. {
  2116.     SQLHANDLE hEnv, hDbc, hStmtList[tabCount];
  2117.     allocAll(test, hEnv, hDbc, hStmtList, tabCount);
  2118.     char sql[MAX_SQL], *sqlptr;
  2119.     for (unsigned i = 0; i < tabCount; i++) {
  2120. SQLHANDLE& hStmt = hStmtList[i];
  2121. const Tab& tab = tabList[i];
  2122. if (! tab.optok())
  2123.     continue;
  2124. // prepare
  2125. tab.updatePk(sqlptr = sql);
  2126. if (opt.m_v >= 2)
  2127.     ndbout << "SQL: " << sql << endl;
  2128. test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS));
  2129. // bind parameters
  2130. Row row(tab);
  2131. SQLSMALLINT parCount = -1;
  2132. test.run(HStmt(hStmt), SQLNumParams(hStmt, &parCount));
  2133. test.chk(HStmt(hStmt), parCount == tab.m_colCount, "got %d != %d", (int)parCount, (int)tab.m_colCount);
  2134. for (unsigned j = 0; j < tab.m_nkCount; j++) {
  2135.     Fld& fld = row.m_fldList[tab.m_nkIndex[j]];
  2136.     const Col& col = fld.m_col;
  2137.     test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + j, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, fld.caddr(), col.csize(), fld.ind()));
  2138. }
  2139. for (unsigned j = 0; j < tab.m_pkCount; j++) {
  2140.     Fld& fld = row.m_fldList[tab.m_pkIndex[j]];
  2141.     const Col& col = fld.m_col;
  2142.     test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + tab.m_nkCount + j, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, fld.caddr(), col.csize(), fld.ind()));
  2143. }
  2144. // bind columns (none)
  2145. SQLSMALLINT colCount = -1;
  2146. test.run(HStmt(hStmt), SQLNumResultCols(hStmt, &colCount));
  2147. test.chk(HStmt(hStmt), colCount == 0, "got %d != 0", (int)colCount);
  2148. // execute
  2149. for (unsigned k = 0; k < opt.m_scale; k++) {
  2150.     if (k % 5 == 0) {
  2151. unsigned j = 0;
  2152. Fld& fld = row.m_fldList[tab.m_nkIndex[j]];
  2153. const Col& col = fld.m_col;
  2154. test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + j, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, fld.caddr(), col.csize(), fld.ind()));
  2155.     }
  2156.     row.calcPk(test, k);
  2157.     row.calcNk(test);
  2158.     test.run(HStmt(hStmt), SQLExecute(hStmt));
  2159.     test.chk(HStmt(hStmt), test.m_functionCode == SQL_DIAG_UPDATE_WHERE, "got %d != %d", test.m_functionCode, SQL_DIAG_UPDATE_WHERE);
  2160.     chkRowCount(test, hStmt, 1);
  2161.     // direct update, no read has been necessary
  2162.     chkTuplesFetched(test, hStmt, 0);
  2163. }
  2164. test.timerCnt(opt.m_scale);
  2165. if (opt.m_v >= 3)
  2166.     ndbout << "updated " << opt.m_scale <<  " in " << tab.m_name << endl;
  2167.     }
  2168.     freeAll(test, hEnv, hDbc, hStmtList, tabCount);
  2169. }
  2171. static void
  2172. testUpdateScan(Test& test)
  2173. {
  2174.     SQLHANDLE hEnv, hDbc, hStmtList[tabCount];
  2175.     allocAll(test, hEnv, hDbc, hStmtList, tabCount);
  2176.     char sql[MAX_SQL], *sqlptr;
  2177.     for (unsigned i = 0; i < tabCount; i++) {
  2178. SQLHANDLE& hStmt = hStmtList[i];
  2179. const Tab& tab = tabList[i];
  2180. if (! tab.optok())
  2181.     continue;
  2182. // prepare
  2183. tab.updateRange(sqlptr = sql);
  2184. if (opt.m_v >= 2)
  2185.     ndbout << "SQL: " << sql << endl;
  2186. test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS));
  2187. // bind parameters
  2188. Row row(tab); // for set clause
  2189. Row rowlo(tab); // for pk ranges
  2190. Row rowhi(tab);
  2191. SQLSMALLINT parCount = -1;
  2192. test.run(HStmt(hStmt), SQLNumParams(hStmt, &parCount));
  2193. test.chk(HStmt(hStmt), parCount == tab.m_nkCount + 2 * tab.m_pkCount, "got %d != %d", (int)parCount, (int)tab.m_nkCount + 2 * (int)tab.m_pkCount);
  2194. for (unsigned j = 0; j < tab.m_nkCount; j++) {
  2195.     const Col& col = tab.m_colList[tab.m_nkIndex[j]];
  2196.     Fld& fld = row.m_fldList[tab.m_nkIndex[j]];
  2197.     test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + j, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, fld.caddr(), col.csize(), fld.ind()));
  2198. }
  2199. bool canInterp = true;
  2200. for (unsigned j = 0; j < tab.m_pkCount; j++) {
  2201.     const Col& col = tab.m_colList[tab.m_pkIndex[j]];
  2202.     Fld& fldlo = rowlo.m_fldList[tab.m_pkIndex[j]];
  2203.     test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + tab.m_nkCount + 2 * j + 0, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, fldlo.caddr(), col.csize(), fldlo.ind()));
  2204.     Fld& fldhi = rowhi.m_fldList[tab.m_pkIndex[j]];
  2205.     test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + tab.m_nkCount + 2 * j + 1, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, fldhi.caddr(), col.csize(), fldhi.ind()));
  2206.     if (col.m_type != Col::Char)
  2207. canInterp = false; // XXX no unsigned yet
  2208. }
  2209. // execute
  2210. row.calcPk(test, 0);
  2211. row.calcNk(test);
  2212. rowlo.calcPk(test, 0);
  2213. rowhi.calcPk(test, test.m_mul); // sucks
  2214. test.run(HStmt(hStmt), SQLExecute(hStmt));
  2215. test.chk(HStmt(hStmt), test.m_functionCode == SQL_DIAG_UPDATE_WHERE, "got %d != %d", test.m_functionCode, SQL_DIAG_UPDATE_WHERE);
  2216. chkRowCount(test, hStmt, opt.m_scale);
  2217. chkTuplesFetched(test, hStmt, canInterp ? opt.m_scale : opt.m_scale * opt.m_threads);
  2218. test.timerCnt(opt.m_scale);
  2219. if (opt.m_v >= 3)
  2220.     ndbout << "updated " << opt.m_scale <<  " in " << tab.m_name << endl;
  2221.     }
  2222.     freeAll(test, hEnv, hDbc, hStmtList, tabCount);
  2223. }
  2225. // verify
  2227. static void
  2228. testVerifyPk(Test& test)
  2229. {
  2230.     SQLHANDLE hEnv, hDbc, hStmtList[tabCount];
  2231.     allocAll(test, hEnv, hDbc, hStmtList, tabCount);
  2232.     char sql[MAX_SQL], *sqlptr;
  2233.     for (unsigned i = 0; i < tabCount; i++) {
  2234. SQLHANDLE& hStmt = hStmtList[i];
  2235. const Tab& tab = tabList[i];
  2236. if (! tab.optok())
  2237.     continue;
  2238. // prepare
  2239. tab.selectPk(sqlptr = sql);
  2240. if (opt.m_v >= 2)
  2241.     ndbout << "SQL: " << sql << endl;
  2242. test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS));
  2243. // use same row for input and output
  2244. Row row(tab);
  2245. // bind parameters
  2246. SQLSMALLINT parCount = -1;
  2247. test.run(HStmt(hStmt), SQLNumParams(hStmt, &parCount));
  2248. test.chk(HStmt(hStmt), parCount == tab.m_pkCount, "got %d != %d", (int)parCount, (int)tab.m_pkCount);
  2249. for (unsigned j = 0; j < tab.m_pkCount; j++) {
  2250.     Fld& fld = row.m_fldList[tab.m_pkIndex[j]];
  2251.     const Col& col = fld.m_col;
  2252.     test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + j, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, fld.caddr(), col.csize(), fld.ind()));
  2253. }
  2254. // bind columns
  2255. SQLSMALLINT colCount = -1;
  2256. test.run(HStmt(hStmt), SQLNumResultCols(hStmt, &colCount));
  2257. test.chk(HStmt(hStmt), colCount == tab.m_colCount, "got %d != %d", (int)colCount, (int)tab.m_colCount);
  2258. for (unsigned j = 0; j < tab.m_colCount; j++) {
  2259.     Fld& fld = row.m_fldList[j];
  2260.     const Col& col = fld.m_col;
  2261.     test.run(HStmt(hStmt), SQLBindCol(hStmt, 1 + j, col.ctype(), fld.caddr(), col.csize(), fld.ind()));
  2262. }
  2263. // row for SQLGetData
  2264. Row rowGet(tab);
  2265. // reference row
  2266. Row rowRef(tab);
  2267. // execute
  2268. for (unsigned k = 0; k < opt.m_scale; k++) {
  2269.     if (k % 5 == 0) {
  2270. // rebind
  2271. unsigned j = 0;
  2272. Fld& fld = row.m_fldList[tab.m_pkIndex[j]];
  2273. const Col& col = fld.m_col;
  2274. test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + j, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, fld.caddr(), col.csize(), fld.ind()));
  2275.     }
  2276.     row.calcPk(test, k);
  2277.     test.run(HStmt(hStmt), SQLExecute(hStmt));
  2278.     test.chk(HStmt(hStmt), test.m_functionCode == SQL_DIAG_SELECT_CURSOR, "got %d != %d", test.m_functionCode, SQL_DIAG_SELECT_CURSOR);
  2279.     // fetch
  2280.     for (unsigned k2 = 0; ; k2++) {
  2281. if (k2 == 1)
  2282.     test.exp(SQL_NO_DATA, 0, 0, true);
  2283. test.run(HStmt(hStmt), SQLFetch(hStmt));
  2284. chkTuplesFetched(test, hStmt, 1);
  2285. if (k2 == 1)
  2286.     break;
  2287. rowRef.calcPk(test, k);
  2288. test.chk(HStmt(hStmt), row.verifyPk(test, rowRef), "verify row=%d", k);
  2289. if (test.m_const)
  2290.     rowRef.calcPk(test, 0);
  2291. rowRef.calcNk(test);
  2292. test.chk(HStmt(hStmt), row.verifyNk(test, rowRef), "verify row=%d", k);
  2293. // SQLGetData is supported independent of SQLBindCol
  2294. if (opt.m_nogetd)
  2295.     continue;
  2296. for (unsigned j = 0; j < tab.m_colCount; j++) {
  2297.     Fld& fld = rowGet.m_fldList[j];
  2298.     fld.zero();
  2299.     const Col& col = fld.m_col;
  2300.     // test both variants
  2301.     SQLSMALLINT ctype = k % 2 == 0 ? col.ctype() : SQL_ARD_TYPE;
  2302.     if (ctype != Col::CChar)
  2303. test.run(HStmt(hStmt), SQLGetData(hStmt, 1 + j, ctype, fld.caddr(), col.csize(), fld.ind()));
  2304.     else {
  2305. // get in pieces
  2306. unsigned size = col.csize() - 1; // omit null terminator
  2307. char* caddr = (char*)(fld.caddr());
  2308. unsigned off = 0;
  2309. while (off < size) {
  2310.     unsigned m = size / 3; // bytes to get
  2311.     if (m == 0)
  2312. m = 1;
  2313.     if (m > size - off)
  2314. m = size - off;
  2315.     bool getNull = (rowRef.m_fldList[j].m_ind == SQL_NULL_DATA);
  2316.     if (off + m < size && ! getNull)
  2317. test.exp(SQL_SUCCESS_WITH_INFO, "01004", -1, true);
  2318.     // include null terminator in buffer size
  2319.     test.run(HStmt(hStmt), SQLGetData(hStmt, 1 + j, ctype, caddr + off, m + 1, fld.ind()));
  2320.     int ind = *fld.ind();
  2321.     if (getNull) {
  2322. test.chk(HStmt(hStmt), ind == SQL_NULL_DATA, "got %d", ind);
  2323. break;
  2324.     }
  2325.     test.chk(HStmt(hStmt), ind == size - off, "got %d != %u", ind, size - off);
  2326.     off += m;
  2327. }
  2328.     }
  2329. }
  2330. rowRef.calcPk(test, k);
  2331. test.chk(HStmt(hStmt), rowGet.verifyPk(test, rowRef), "verify row=%d", k);
  2332. if (test.m_const)
  2333.     rowRef.calcPk(test, 0);
  2334. rowRef.calcNk(test);
  2335. test.chk(HStmt(hStmt), rowGet.verifyNk(test, rowRef), "verify row=%d", k);
  2336. // SQLGetData again
  2337. for (unsigned j = 0; j < tab.m_colCount; j++) {
  2338.     Fld& fld = rowGet.m_fldList[j];
  2339.     const Col& col = fld.m_col;
  2340.     // test both variants
  2341.     SQLSMALLINT ctype = k % 2 == 0 ? col.ctype() : SQL_ARD_TYPE;
  2342.     // expect no more data
  2343.     test.exp(SQL_NO_DATA, 0, 0, true);
  2344.     test.run(HStmt(hStmt), SQLGetData(hStmt, 1 + j, ctype, fld.caddr(), col.csize(), fld.ind()));
  2345. }
  2346.     }
  2347.     test.run(HStmt(hStmt), SQLCloseCursor(hStmt));
  2348. }
  2349. test.timerCnt(opt.m_scale);
  2350. if (opt.m_v >= 3)
  2351.     ndbout << "verified " << opt.m_scale <<  " from " << tab.m_name << endl;
  2352.     }
  2353.     freeAll(test, hEnv, hDbc, hStmtList, tabCount);
  2354. }
  2356. static void
  2357. testVerifyScan(Test& test)
  2358. {
  2359.     SQLHANDLE hEnv, hDbc, hStmtList[tabCount];
  2360.     allocAll(test, hEnv, hDbc, hStmtList, tabCount);
  2361.     char sql[MAX_SQL], *sqlptr;
  2362.     for (unsigned i = 0; i < tabCount; i++) {
  2363. SQLHANDLE& hStmt = hStmtList[i];
  2364. const Tab& tab = tabList[i];
  2365. if (! tab.optok())
  2366.     continue;
  2367. // prepare
  2368. tab.selectRange(sqlptr = sql, ! opt.m_nosort);
  2369. if (opt.m_v >= 2)
  2370.     ndbout << "SQL: " << sql << endl;
  2371. test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS));
  2372. // bind parameters
  2373. Row rowlo(tab); // use available PK fields..
  2374. Row rowhi(tab); // since we have no other way for now
  2375. SQLSMALLINT parCount = -1;
  2376. test.run(HStmt(hStmt), SQLNumParams(hStmt, &parCount));
  2377. test.chk(HStmt(hStmt), parCount == 2 * tab.m_pkCount, "got %d != %d", (int)parCount, 2 * (int)tab.m_pkCount);
  2378. for (unsigned j = 0; j < tab.m_pkCount; j++) {
  2379.     const Col& col = tab.m_colList[tab.m_pkIndex[j]];
  2380.     Fld& fldlo = rowlo.m_fldList[tab.m_pkIndex[j]];
  2381.     test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + 2 * j + 0, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, fldlo.caddr(), col.csize(), fldlo.ind()));
  2382.     Fld& fldhi = rowhi.m_fldList[tab.m_pkIndex[j]];
  2383.     test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + 2 * j + 1, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, fldhi.caddr(), col.csize(), fldhi.ind()));
  2384. }
  2385. // bind columns
  2386. Row row(tab);
  2387. SQLSMALLINT colCount = -1;
  2388. test.run(HStmt(hStmt), SQLNumResultCols(hStmt, &colCount));
  2389. test.chk(HStmt(hStmt), colCount == tab.m_colCount, "got %d != %d", (int)colCount, (int)tab.m_colCount);
  2390. for (unsigned j = 0; j < tab.m_colCount; j++) {
  2391.     Fld& fld = row.m_fldList[j];
  2392.     const Col& col = fld.m_col;
  2393.     test.run(HStmt(hStmt), SQLBindCol(hStmt, 1 + j, col.ctype(), fld.caddr(), col.csize(), fld.ind()));
  2394. }
  2395. // execute
  2396. rowlo.calcPk(test, 0);
  2397. rowhi.calcPk(test, test.m_mul); // sucks
  2398. test.run(HStmt(hStmt), SQLExecute(hStmt));
  2399.     test.chk(HStmt(hStmt), test.m_functionCode == SQL_DIAG_SELECT_CURSOR, "got %d != %d", test.m_functionCode, SQL_DIAG_SELECT_CURSOR);
  2400. // reference row
  2401. Row rowRef(tab);
  2402. // fetch
  2403. unsigned k = 0;
  2404. SQLUINTEGER rowCount1 = (SQLUINTEGER)-1;
  2405. test.run(HStmt(hStmt), SQLSetStmtAttr(hStmt, SQL_ATTR_ROWS_FETCHED_PTR, &rowCount1, SQL_IS_POINTER));
  2406. while (1) {
  2407.     unsigned countExp;
  2408.     if (k == opt.m_scale) {
  2409. countExp = k;
  2410. test.exp(SQL_NO_DATA, 0, 0, true);
  2411.     } else {
  2412. countExp = k + 1;
  2413.     }
  2414.     test.run(HStmt(hStmt), SQLFetch(hStmt));
  2415.     // let me count the ways..
  2416.     chkRowCount(test, hStmt, countExp);
  2417.     test.chk(HStmt(hStmt), rowCount1 == countExp, "got %lu != %u", rowCount1, countExp);
  2418.     SQLUINTEGER rowCount2 = (SQLUINTEGER)-1;
  2419.     test.run(HStmt(hStmt), SQLGetStmtAttr(hStmt, SQL_ATTR_ROW_NUMBER, &rowCount2, SQL_IS_POINTER, 0));
  2420.     test.chk(HStmt(hStmt), rowCount2 == countExp, "got %lu != %u", rowCount2, countExp);
  2421.     if (k == opt.m_scale)
  2422. break;
  2423.     if (! opt.m_nosort) {
  2424. // expecting k-th row
  2425. rowRef.calcPk(test, k);
  2426. test.chk(HStmt(hStmt), row.verifyPk(test, rowRef), "verify row=%d", k);
  2427. if (test.m_const)
  2428.     rowRef.calcPk(test, 0);
  2429. rowRef.calcNk(test);
  2430. test.chk(HStmt(hStmt), row.verifyNk(test, rowRef), "verify row=%d", k);
  2431.     } else {
  2432. // expecting random row
  2433. rowRef.copy(row);
  2434. test.chk(HStmt(hStmt), row.verifyNk(test, rowRef), "verify row=%d", k);
  2435.     }
  2436.     k++;
  2437. }
  2438. test.timerCnt(opt.m_scale);
  2439. if (opt.m_v >= 3)
  2440.     ndbout << "verified " << opt.m_scale <<  " from " << tab.m_name << endl;
  2441.     }
  2442.     freeAll(test, hEnv, hDbc, hStmtList, tabCount);
  2443. }
  2445. // self-join (scan followed by pk lookups)
  2447. static void
  2448. testJoin(Test& test)
  2449. {
  2450.     SQLHANDLE hEnv, hDbc, hStmtList[tabCount];
  2451.     allocAll(test, hEnv, hDbc, hStmtList, tabCount);
  2452.     char sql[MAX_SQL], *sqlptr;
  2453.     for (unsigned cnt = opt.m_depth; cnt <= opt.m_depth; cnt++) {
  2454. for (unsigned i = 0; i < tabCount; i++) {
  2455.     SQLHANDLE& hStmt = hStmtList[i];
  2456.     Tab& tab = tabList[i];
  2457.     if (! tab.optok())
  2458. continue;
  2459.     tab.selectJoin(sqlptr = sql, cnt);
  2460.     if (opt.m_v >= 2)
  2461. ndbout << "SQL: " << sql << endl;
  2462.     test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS));
  2463. }
  2464. unsigned k = 0;
  2465. while (1) {
  2466.     for (unsigned i = 0; i < tabCount; i++) {
  2467. SQLHANDLE& hStmt = hStmtList[i];
  2468. const Tab& tab = tabList[i];
  2469. if (! tab.optok())
  2470.     continue;
  2471. if (k == opt.m_scale * opt.m_threads)
  2472.     test.exp(SQL_NO_DATA, 0, 0, true);
  2473. test.run(HStmt(hStmt), SQLFetch(hStmt));
  2474. if (k == opt.m_scale * opt.m_threads) {
  2475.     chkTuplesFetched(test, hStmt, k * opt.m_depth);
  2476.     test.run(HStmt(hStmt), SQLCloseCursor(hStmt));
  2477. } else {
  2478.     chkTuplesFetched(test, hStmt, (k + 1) * opt.m_depth);
  2479.     test.timerCnt(1);
  2480. }
  2481.     }
  2482.     if (k == opt.m_scale * opt.m_threads)
  2483. break;