diff options
Diffstat (limited to 'storage/ndb/test/odbc/driver/testOdbcDriver.cpp')
| -rw-r--r-- | storage/ndb/test/odbc/driver/testOdbcDriver.cpp | 4964 |
1 files changed, 4964 insertions, 0 deletions
diff --git a/storage/ndb/test/odbc/driver/testOdbcDriver.cpp b/storage/ndb/test/odbc/driver/testOdbcDriver.cpp new file mode 100644 index 00000000000..d3b3802ebe1 --- /dev/null +++ b/storage/ndb/test/odbc/driver/testOdbcDriver.cpp @@ -0,0 +1,4964 @@ +/* Copyright (C) 2003 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* Copyright (C) 2003 MySQL AB & MySQL Finland AB & TCX DataKonsult AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +/* + * testOdbcDriver + * + * Test of ODBC and SQL using a fixed set of tables. + */ + +#include <ndb_global.h> +#undef test +#include <ndb_version.h> +#include <kernel/ndb_limits.h> +#include <Bitmask.hpp> +#include <kernel/AttributeList.hpp> +#ifdef ndbODBC +#include <NdbApi.hpp> +#endif +#include <sqlext.h> + +#undef BOOL + +#include <NdbMain.h> +#include <NdbOut.hpp> +#include <NdbThread.h> +#include <NdbMutex.h> +#include <NdbCondition.h> +#include <NdbTick.h> +#include <NdbSleep.h> + +#ifdef ndbODBC +#include <NdbTest.hpp> +#else +#define NDBT_OK 0 +#define NDBT_FAILED 1 +#define NDBT_WRONGARGS 2 +static int +NDBT_ProgramExit(int rcode) +{ + const char* rtext = "Unknown"; + switch (rcode) { + case NDBT_OK: + rtext = "OK"; + break; + case NDBT_FAILED: + rtext = "Failed"; + break; + case NDBT_WRONGARGS: + rtext = "Wrong arguments"; + break; + }; + ndbout_c("\nNDBT_ProgramExit: %d - %s\n", rcode, rtext); + return rcode; +} +#endif + +#ifdef DMALLOC +#include <dmalloc.h> +#endif + +#define arraySize(x) (sizeof(x)/sizeof(x[0])) + +#define SQL_ATTR_NDB_TUPLES_FETCHED 66601 + +// options + +#define MAX_THR 128 // max threads + +struct Opt { + const char* m_name[100]; + unsigned m_namecnt; + bool m_core; + unsigned m_depth; + const char* m_dsn; + unsigned m_errs; + const char* m_fragtype; + unsigned m_frob; + const char* m_home; + unsigned m_loop; + bool m_nogetd; + bool m_noputd; + bool m_nosort; + unsigned m_scale; + bool m_serial; + const char* m_skip[100]; + unsigned m_skipcnt; + unsigned m_subloop; + const char* m_table; + unsigned m_threads; + unsigned m_trace; + unsigned m_v; + Opt() : + m_namecnt(0), + m_core(false), + m_depth(5), + m_dsn("NDB"), + m_errs(0), + m_fragtype(0), + m_frob(0), + m_home(0), + m_loop(1), + m_nogetd(false), + m_noputd(false), + m_nosort(false), + m_scale(100), + m_serial(false), + m_skipcnt(0), + m_subloop(1), + m_table(0), + m_threads(1), + m_trace(0), + m_v(1) { + for (unsigned i = 0; i < arraySize(m_name); i++) + m_name[i] = 0; + for (unsigned i = 0; i < arraySize(m_skip); i++) + m_skip[i] = 0; + } +}; + +static Opt opt; + +static void listCases(); +static void listTables(); +static void printusage() +{ + Opt d; + ndbout + << "usage: testOdbcDriver [options]" << endl + << "-case name run only named tests (substring match - can be repeated)" << endl + << "-core dump core on failure" << endl + << "-depth N join depth - default " << d.m_depth << endl + << "-dsn string data source name - default " << d.m_dsn << endl + << "-errs N allow N errors before quitting - default " << d.m_errs << endl + << "-fragtype t fragment type single/small/medium/large" << d.m_errs << endl + << "-frob X case-dependent tweak (number)" << endl + << "-home dir set NDB_HOME (contains Ndb.cfg)" << endl + << "-loop N loop N times (0 = forever) - default " << d.m_loop << endl + << "-nogetd do not use SQLGetData - default " << d.m_nogetd << endl + << "-noputd do not use SQLPutData - default " << d.m_noputd << endl + << "-nosort no order-by in verify scan (checks non-Pk values only)" << endl + << "-scale N row count etc - default " << d.m_scale << endl + << "-serial run multi-threaded test cases one at a time" << endl + << "-skip name skip named tests (substring match - can be repeated)" << endl + << "-subloop N loop count per case (same threads) - default " << d.m_subloop << endl + << "-table T do only table T (table name on built-in list)" << endl + << "-threads N number of threads (max " << MAX_THR << ") - default " << d.m_threads << endl + << "-trace N trace in NDB ODBC driver - default " << d.m_trace << endl + << "-v N verbosity - default " << d.m_v << endl + ; + listCases(); + listTables(); +} + +static void +fatal(const char* fmt, ...) +{ + va_list ap; + char buf[200]; + va_start(ap, fmt); + vsnprintf(buf, sizeof(buf), fmt, ap); + va_end(ap); + ndbout << buf << endl; + if (opt.m_errs != 0) { + opt.m_errs--; + return; + } + if (opt.m_core) + abort(); + NDBT_ProgramExit(NDBT_FAILED); + exit(1); +} + +static void +cleanprint(const char* s, unsigned n) +{ + for (unsigned i = 0; i < n; i++) { + char b[10]; + if (0x20 < s[i] && s[i] <= 0x7e) + sprintf(b, "%c", s[i]); + else + sprintf(b, "\\%02x", (unsigned)s[i]); + ndbout << b; + } +} + +// global mutex +static NdbMutex my_mutex = NDB_MUTEX_INITIALIZER; +static void lock_mutex() { NdbMutex_Lock(&my_mutex); } +static void unlock_mutex() { NdbMutex_Unlock(&my_mutex); } + +// semaphore zeroed before each call to a test routine +static unsigned my_sema = 0; + +// print mutex +static NdbMutex out_mutex = NDB_MUTEX_INITIALIZER; +static NdbOut& lock(NdbOut& out) { NdbMutex_Lock(&out_mutex); return out; } +static NdbOut& unlock(NdbOut& out) { NdbMutex_Unlock(&out_mutex); return out; } + +static unsigned +urandom(unsigned n) +{ + assert(n != 0); + unsigned i = random(); + return i % n; +} + +// test cases + +struct Test; + +struct Case { + enum Mode { + Single = 1, // single thread + Serial = 2, // all threads but one at a time + Thread = 3 // all threads in parallel + }; + const char* m_name; + void (*m_func)(Test& test); + Mode m_mode; + unsigned m_stuff; + const char* m_desc; + Case(const char* name, void (*func)(Test& test), Mode mode, unsigned stuff, const char* desc) : + m_name(name), + m_func(func), + m_mode(mode), + m_stuff(stuff), + m_desc(desc) { + } + const char* modename() const { + const char* s = "?"; + if (m_mode == Case::Single) + return "Single"; + if (m_mode == Case::Serial) + return "Serial"; + if (m_mode == Case::Thread) + return "Thread"; + return "?"; + } + bool matchcase() const { + if (opt.m_namecnt == 0) + return ! skipcase(); + for (unsigned i = 0; i < opt.m_namecnt; i++) { + if (strstr(m_name, opt.m_name[i]) != 0) + return ! skipcase(); + } + return false; + } +private: + bool skipcase() const { + for (unsigned i = 0; i < opt.m_skipcnt; i++) { + if (strstr(m_name, opt.m_skip[i]) != 0) + return true; + } + return false; + } +}; + +// calculate values + +struct Calc { + enum { m_mul = 1000000 }; + unsigned m_no; + unsigned m_base; + unsigned m_salt; // modifies non-PK values + bool m_const; // base non-PK values on PK of row 0 + Calc(unsigned no) : + m_no(no), + m_salt(0), + m_const(false) { + m_base = m_no * m_mul; + } + void calcPk(unsigned rownum, char* v, unsigned n) const { + char b[10]; + sprintf(b, "%08x", m_base + rownum); + for (unsigned i = 0; i < n; i++) { + char c = i < n - 1 ? b[i % 8] : 0; + v[i] = c; + } + } + void calcPk(unsigned rownum, long* v) const { + *v = m_base + rownum; + } + void hashPk(unsigned* hash, const char* v, unsigned n) const { + for (unsigned i = 0; i < n; i++) { + *hash ^= (v[i] << i); + } + } + void hashPk(unsigned* hash, long v) const { + *hash ^= v; + } + void calcNk(unsigned hash, char* v, unsigned n, SQLINTEGER* ind, bool null) const { + unsigned m = hash % n; + for (unsigned i = 0; i < n; i++) { + char c = i < m ? 'a' + (hash + i) % ('z' - 'a' + 1) : i < n - 1 ? ' ' : 0; + v[i] = c; + } + *ind = null && hash % 9 == 0 ? SQL_NULL_DATA : SQL_NTS; + } + void calcNk(unsigned hash, long* v, SQLINTEGER* ind, bool null) const { + *v = long(hash); + *ind = null && hash % 7 == 0 ? SQL_NULL_DATA : 0; + } + void calcNk(unsigned hash, double* v, SQLINTEGER* ind, bool null) const { + *v = long(hash) / 1000.0; + *ind = null && hash % 5 == 0 ? SQL_NULL_DATA : 0; + } + bool verify(const char* v1, SQLINTEGER ind1, const char* v2, SQLINTEGER ind2, unsigned n) { + if (ind1 == SQL_NULL_DATA && ind2 == SQL_NULL_DATA) + return true; + if (ind1 != SQL_NULL_DATA && ind2 != SQL_NULL_DATA) + if (memcmp(v1, v2, n) == 0) + return true; + if (ind1 == SQL_NULL_DATA) + v1 = "NULL"; + if (ind2 == SQL_NULL_DATA) + v2 = "NULL"; + ndbout << "verify failed: got "; + if (ind1 == SQL_NULL_DATA) + ndbout << "NULL"; + else + cleanprint(v1, n); + ndbout << " != "; + if (ind2 == SQL_NULL_DATA) + ndbout << "NULL"; + else + cleanprint(v2, n); + ndbout << endl; + return false; + } + bool verify(long v1, SQLINTEGER ind1, long v2, SQLINTEGER ind2) { + char buf1[40], buf2[40]; + if (ind1 == SQL_NULL_DATA && ind2 == SQL_NULL_DATA) + return true; + if (ind1 != SQL_NULL_DATA && ind2 != SQL_NULL_DATA) + if (v1 == v2) + return true; + if (ind1 == SQL_NULL_DATA) + strcpy(buf1, "NULL"); + else + sprintf(buf1, "%ld", v1); + if (ind2 == SQL_NULL_DATA) + strcpy(buf2, "NULL"); + else + sprintf(buf2, "%ld", v2); + ndbout << "verify failed: got " << buf1 << " != " << buf2 << endl; + return false; + } + bool verify(double v1, SQLINTEGER ind1, double v2, SQLINTEGER ind2) { + char buf1[40], buf2[40]; + if (ind1 == SQL_NULL_DATA && ind2 == SQL_NULL_DATA) + return true; + if (ind1 != SQL_NULL_DATA && ind2 != SQL_NULL_DATA) + if (fabs(v1 - v2) < 1) // XXX + return true; + if (ind1 == SQL_NULL_DATA) + strcpy(buf1, "NULL"); + else + sprintf(buf1, "%.10f", v1); + if (ind2 == SQL_NULL_DATA) + strcpy(buf2, "NULL"); + else + sprintf(buf2, "%.10f", v2); + ndbout << "verify failed: got " << buf1 << " != " << buf2 << endl; + return false; + } +}; + +#if defined(NDB_SOLARIS) || defined(NDB_LINUX) || defined(NDB_MACOSX) +#define HAVE_SBRK +#else +#undef HAVE_SBRK +#endif + +struct Timer { + Timer() : + m_cnt(0), + m_calls(0), + m_on(0), + m_msec(0) +#ifndef NDB_WIN32 + , + m_brk(0), + m_incr(0) +#endif + { + } + void timerOn() { + m_cnt = 0; + m_calls = 0; + m_on = NdbTick_CurrentMillisecond(); +#ifdef HAVE_SBRK + m_brk = (int)sbrk(0); +#endif + } + void timerOff() { + m_msec = NdbTick_CurrentMillisecond() - m_on; + if (m_msec <= 0) + m_msec = 1; +#ifdef HAVE_SBRK + m_incr = (int)sbrk(0) - m_brk; + if (m_incr < 0) + m_incr = 0; +#endif + } + void timerCnt(unsigned cnt) { + m_cnt += cnt; + } + void timerCnt(const Timer& timer) { + m_cnt += timer.m_cnt; + m_calls += timer.m_calls; + } + friend NdbOut& operator<<(NdbOut& out, const Timer& timer) { + out << timer.m_cnt << " ( " << 1000 * timer.m_cnt / timer.m_msec << "/sec )"; +#ifdef HAVE_SBRK + out << " - " << timer.m_incr << " sbrk"; + if (opt.m_namecnt != 0) { // per case meaningless if many cases + if (timer.m_cnt > 0) + out << " ( " << timer.m_incr / timer.m_cnt << "/cnt )"; + } +#endif + out << " - " << timer.m_calls << " calls"; + return out; + } +protected: + unsigned m_cnt; // count rows or whatever + unsigned m_calls; // count ODBC function calls + NDB_TICKS m_on; + unsigned m_msec; +#ifdef HAVE_SBRK + int m_brk; + int m_incr; +#endif +}; + +#define MAX_MESSAGE 500 +#define MAX_DIAG 20 + +struct Diag { + char m_state[5+1]; + SQLINTEGER m_native; + char m_message[MAX_MESSAGE]; + unsigned m_flag; // temp use + Diag() { + strcpy(m_state, "00000"); + m_native = 0; + memset(m_message, 0, sizeof(m_message)); + m_flag = 0; + } + const char* text() { + snprintf(m_buf, sizeof(m_buf), "%s %d '%s'", m_state, (int)m_native, m_message); + return m_buf; + } + void getDiag(SQLSMALLINT type, SQLHANDLE handle, unsigned k, unsigned count) { + int ret; + SQLSMALLINT length = -1; + memset(m_message, 0, MAX_MESSAGE); + ret = SQLGetDiagRec(type, handle, k, (SQLCHAR*)m_state, &m_native, (SQLCHAR*)m_message, MAX_MESSAGE, &length); + if (k <= count && ret != SQL_SUCCESS) + fatal("SQLGetDiagRec %d of %d: return %d != SQL_SUCCESS", k, count, (int)ret); + if (k <= count && strlen(m_message) != length) + fatal("SQLGetDiagRec %d of %d: message length %d != %d", k, count, strlen(m_message), length); + if (k > count && ret != SQL_NO_DATA) + fatal("SQLGetDiagRec %d of %d: return %d != SQL_NO_DATA", k, count, (int)ret); + m_flag = 0; + } +private: + char m_buf[MAX_MESSAGE]; +}; + +struct Diags { + Diag m_diag[MAX_DIAG]; + SQLINTEGER m_diagCount; + SQLINTEGER m_rowCount; + SQLINTEGER m_functionCode; + void getDiags(SQLSMALLINT type, SQLHANDLE handle) { + int ret; + m_diagCount = -1; + ret = SQLGetDiagField(type, handle, 0, SQL_DIAG_NUMBER, &m_diagCount, SQL_IS_INTEGER, 0); + if (ret == SQL_INVALID_HANDLE) + return; + if (ret != SQL_SUCCESS) + fatal("SQLGetDiagField: return %d != SQL_SUCCESS", (int)ret); + if (m_diagCount < 0 || m_diagCount > MAX_DIAG) + fatal("SQLGetDiagField: count %d", (int)m_diagCount); + for (unsigned k = 0; k < MAX_DIAG; k++) { + m_diag[k].getDiag(type, handle, k + 1, m_diagCount); + if (k == m_diagCount + 1) + break; + } + m_rowCount = -1; + m_functionCode = SQL_DIAG_UNKNOWN_STATEMENT; + if (type == SQL_HANDLE_STMT) { + ret = SQLGetDiagField(type, handle, 0, SQL_DIAG_ROW_COUNT, &m_rowCount, SQL_IS_INTEGER, 0); +#ifndef iODBC + if (ret != SQL_SUCCESS) + fatal("SQLGetDiagField: return %d != SQL_SUCCESS", (int)ret); +#endif + ret = SQLGetDiagField(type, handle, 0, SQL_DIAG_DYNAMIC_FUNCTION_CODE, &m_functionCode, SQL_IS_INTEGER, 0); + } + } + void showDiags() { + for (unsigned k = 0; 0 <= m_diagCount && k < m_diagCount; k++) { + Diag& diag = m_diag[k]; + ndbout << "diag " << k + 1; + ndbout << (diag.m_flag ? " [*]" : " [ ]"); + ndbout << " " << diag.text() << endl; + if (k > 10) + abort(); + } + } +}; + +struct Exp { + int m_ret; + const char* m_state; + SQLINTEGER m_native; + Exp() : m_ret(SQL_SUCCESS), m_state(""), m_native(0) {} + Exp(int ret, const char* state) : m_ret(ret), m_state(state) {} +}; + +struct Test : Calc, Timer, Diags { + Test(unsigned no, unsigned loop) : + Calc(no), + m_loop(loop), + m_stuff(0), + m_perf(false), + ccp(0) { + exp(SQL_SUCCESS, 0, 0, true); + } + unsigned m_loop; // current loop + Exp m_expList[20]; // expected results + unsigned m_expCount; + int m_ret; // actual return code + int m_stuff; // the stuff of abuse + bool m_perf; // check no diags on success + const Case* ccp; // current case + void exp(int ret, const char* state, SQLINTEGER native, bool reset) { + if (reset) + m_expCount = 0; + unsigned i = m_expCount++; + assert(i < arraySize(m_expList) - 1); + m_expList[i].m_ret = ret; + m_expList[i].m_state = state == 0 ? "" : state; + m_expList[i].m_native = native; + } + void runCase(const Case& cc) { + ccp = &cc; + if (opt.m_v >= 3) + ndbout << cc.m_name << ": start" << endl; + m_rowCount = -1; + NDB_TICKS m_ms1 = NdbTick_CurrentMillisecond(); + m_salt = m_loop | (16 << cc.m_stuff); + m_const = cc.m_stuff == 0; + m_stuff = cc.m_stuff; + (*cc.m_func)(*this); + NDB_TICKS m_ms2 = NdbTick_CurrentMillisecond(); + } + void run(SQLSMALLINT type, SQLHANDLE handle, int line, int ret) { + m_calls++; + m_ret = ret; + if (m_perf && (m_ret == SQL_SUCCESS)) + return; + m_diagCount = 0; + if (handle != SQL_NULL_HANDLE) + getDiags(type, handle); + if (m_diagCount <= 0 && (ret != SQL_SUCCESS && ret != SQL_INVALID_HANDLE && ret != SQL_NEED_DATA && ret != SQL_NO_DATA)) { + fatal("%s: thr %d line %d: ret=%d but no diag records", ccp->m_name, m_no, line, ret); + } + for (unsigned k = 0; 0 <= m_diagCount && k < m_diagCount; k++) { + Diag& diag = m_diag[k]; + bool match = false; + for (unsigned i = 0; i < m_expCount; i++) { + 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)) { + match = true; + diag.m_flag = 0; + continue; + } + diag.m_flag = 1; // mark unexpected + } + if (! match) { + showDiags(); + fatal("%s: thr %d line %d: unexpected diag [*] ret=%d cnt=%d", ccp->m_name, m_no, line, (int)ret, (int)m_diagCount); + } + } + bool match = false; + for (unsigned i = 0; i < m_expCount; i++) { + if (ret == m_expList[i].m_ret) { + match = true; + break; + } + } + if (! match) { + showDiags(); + fatal("%s: thr %d line %d: ret=%d not expected", ccp->m_name, m_no, line, ret); + } + // reset expected to success + exp(SQL_SUCCESS, 0, 0, true); + } + void chk(SQLSMALLINT type, SQLHANDLE handle, int line, bool match, const char* fmt, ...) { + if (match) + return; + va_list ap; + va_start(ap, fmt); + char buf[500]; + vsnprintf(buf, sizeof(buf), fmt, ap); + va_end(ap); + fatal("%s: thr %d line %d: check failed - %s", ccp->m_name, m_no, line, buf); + } +}; + +#define HNull 0, SQL_NULL_HANDLE, __LINE__ +#define HEnv(h) SQL_HANDLE_ENV, h, __LINE__ +#define HDbc(h) SQL_HANDLE_DBC, h, __LINE__ +#define HStmt(h) SQL_HANDLE_STMT, h, __LINE__ +#define HDesc(h) SQL_HANDLE_DESC, h, __LINE__ + +// string support + +#define MAX_SQL 20000 + +static void +scopy(char*& ptr, const char* fmt, ...) +{ + va_list ap; + va_start(ap, fmt); + vsprintf(ptr, fmt, ap); + va_end(ap); + ptr += strlen(ptr); +} + +static bool +blankeq(const char* s1, const char* s2, bool caseSensitive = false) +{ + unsigned n1 = strlen(s1); + unsigned n2 = strlen(s2); + unsigned i = 0; + char c1 = 0; + char c2 = 0; + while (i < n1 || i < n2) { + c1 = i < n1 ? s1[i] : 0x20; + if (! caseSensitive && 'a' <= c1 && c1 <= 'z') + c1 -= 'a' - 'A'; + c2 = i < n2 ? s2[i] : 0x20; + if (! caseSensitive && 'a' <= c2 && c2 <= 'z') + c2 -= 'a' - 'A'; + if (c1 != c2) + break; + i++; + } + return c1 == c2; +} + +// columns and tables + +struct Col { + enum Type { + Char = SQL_CHAR, + Varchar = SQL_VARCHAR, + Int = SQL_INTEGER, + Bigint = SQL_BIGINT, + Real = SQL_REAL, + Double = SQL_DOUBLE + }; + enum CType { + CChar = SQL_C_CHAR, + CLong = SQL_C_SLONG, + CDouble = SQL_C_DOUBLE + }; + enum Cons { + Null, // nullable + NotNull, // not nullable + Pk // part of primary key + }; + const char* m_name; + Type m_type; + unsigned m_length; + Cons m_cons; + CType m_ctype; + Col() : + m_type((Type)999) { + } + Col(const char* name, Type type, unsigned length, Cons cons, CType ctype) : + m_name(name), + m_type(type), + m_length(length), + m_cons(cons), + m_ctype(ctype) { + } + unsigned size() const { + switch (m_type) { + case Char: + case Varchar: + return m_length; + case Int: + return 4; + case Bigint: + return 8; + case Real: + return 4; + case Double: + return 8; + } + assert(false); + return 0; + } + unsigned csize() const { // size as char plus terminating null + switch (m_ctype) { + case CChar: + return m_length + 1; + case CLong: + return 12; + case CDouble: + return 24; + } + assert(false); + return 0; + } + void typespec(char*& ptr) const { + switch (m_type) { + case Char: + scopy(ptr, "char(%d)", m_length); + return; + case Varchar: + scopy(ptr, "varchar(%d)", m_length); + return; + case Int: + scopy(ptr, "int"); + return; + case Bigint: + scopy(ptr, "bigint"); + return; + case Real: + scopy(ptr, "real"); + return; + case Double: + scopy(ptr, "float"); + return; + } + assert(false); + } + SQLSMALLINT type() const { + return (SQLSMALLINT)m_type; + } + SQLSMALLINT ctype() const { + return (SQLSMALLINT)m_ctype; + } + void create(char*& ptr, bool pk) const { + scopy(ptr, "%s", m_name); + scopy(ptr, " "); + typespec(ptr); + if (m_cons == Pk && pk) { + scopy(ptr, " primary key"); + } + if (m_cons == NotNull) { + scopy(ptr, " not null"); + } + } +}; + +static Col ColUndef; + +struct Tab { + const char* m_name; + const Col* m_colList; + unsigned m_colCount; + unsigned m_pkCount; + unsigned* m_pkIndex; + unsigned m_nkCount; + unsigned* m_nkIndex; + char m_upperName[20]; + Tab(const char* name, const Col* colList, unsigned colCount) : + m_name(name), + m_colList(colList), + m_colCount(colCount) { + m_pkCount = 0; + m_nkCount = 0; + for (unsigned i = 0; i < m_colCount; i++) { + const Col& col = m_colList[i]; + if (col.m_cons == Col::Pk) + m_pkCount++; + else + m_nkCount++; + } + m_pkIndex = new unsigned[m_pkCount]; + m_nkIndex = new unsigned[m_nkCount]; + unsigned pk = 0; + unsigned nk = 0; + for (unsigned i = 0; i < m_colCount; i++) { + const Col& col = m_colList[i]; + if (col.m_cons == Col::Pk) + m_pkIndex[pk++] = i; + else + m_nkIndex[nk++] = i; + } + assert(pk == m_pkCount && nk == m_nkCount); + strcpy(m_upperName, m_name); + for (char* p = m_upperName; *p != 0; p++) { + if ('a' <= *p && *p <= 'z') + *p -= 'a' - 'A'; + } + } + ~Tab() { + delete[] m_pkIndex; + delete[] m_nkIndex; + } + void drop(char*& ptr) const { + scopy(ptr, "drop table %s", m_name); + } + void create(char*& ptr) const { + scopy(ptr, "create table %s (", m_name); + for (unsigned i = 0; i < m_colCount; i++) { + if (i > 0) + scopy(ptr, ", "); + const Col& col = m_colList[i]; + col.create(ptr, m_pkCount == 1); + } + if (m_pkCount != 1) { + scopy(ptr, ", primary key ("); + for (unsigned i = 0; i < m_pkCount; i++) { + const Col& col = m_colList[m_pkIndex[i]]; + if (i > 0) + scopy(ptr, ", "); + scopy(ptr, "%s", col.m_name); + } + scopy(ptr, ")"); + } + scopy(ptr, ")"); + } + void wherePk(char*& ptr) const { + scopy(ptr, " where"); + for (unsigned i = 0; i < m_pkCount; i++) { + const Col& col = m_colList[m_pkIndex[i]]; + if (i > 0) + scopy(ptr, " and"); + scopy(ptr, " %s = ?", col.m_name); + } + } + void whereRange(char*& ptr) const { + scopy(ptr, " where"); + for (unsigned i = 0; i < m_pkCount; i++) { + const Col& col = m_colList[m_pkIndex[i]]; + if (i > 0) + scopy(ptr, " and"); + scopy(ptr, " ? <= %s", col.m_name); + scopy(ptr, " and "); + scopy(ptr, "%s < ?", col.m_name); + } + } + void orderPk(char*& ptr) const { + scopy(ptr, " order by"); + for (unsigned i = 0; i < m_pkCount; i++) { + const Col& col = m_colList[m_pkIndex[i]]; + if (i > 0) + scopy(ptr, ", "); + else + scopy(ptr, " "); + scopy(ptr, "%s", col.m_name); + } + } + void selectPk(char*& ptr) const { + scopy(ptr, "select * from %s", m_name); + wherePk(ptr); + } + void selectAll(char*& ptr) const { + scopy(ptr, "select * from %s", m_name); + } + void selectRange(char*& ptr, bool sort) const { + selectAll(ptr); + whereRange(ptr); + if (sort) + orderPk(ptr); + } + void selectCount(char*& ptr) const { + scopy(ptr, "select count(*) from %s", m_name); + } + void insertAll(char*& ptr) const { + scopy(ptr, "insert into %s values (", m_name); + for (unsigned i = 0; i < m_colCount; i++) { + if (i > 0) + scopy(ptr, ", "); + scopy(ptr, "?"); + } + scopy(ptr, ")"); + } + void updatePk(char*& ptr) const { + scopy(ptr, "update %s set", m_name); + for (unsigned i = 0; i < m_nkCount; i++) { + const Col& col = m_colList[m_nkIndex[i]]; + if (i > 0) + scopy(ptr, ", "); + else + scopy(ptr, " "); + scopy(ptr, "%s = ?", col.m_name); + } + wherePk(ptr); + } + void updateRange(char*& ptr) const { + scopy(ptr, "update %s set", m_name); + for (unsigned i = 0; i < m_nkCount; i++) { + const Col& col = m_colList[m_nkIndex[i]]; + if (i > 0) + scopy(ptr, ", "); + else + scopy(ptr, " "); + scopy(ptr, "%s = ?", col.m_name); // XXX constant for now + } + whereRange(ptr); + } + void deleteAll(char*& ptr) const { + scopy(ptr, "delete from %s", m_name); + } + void deletePk(char*& ptr) const { + scopy(ptr, "delete from %s", m_name); + wherePk(ptr); + } + void deleteRange(char*& ptr) const { + scopy(ptr, "delete from %s", m_name); + whereRange(ptr); + } + // simple + void insertDirect(char*& ptr, unsigned n) const { + scopy(ptr, "insert into %s values (", m_name); + for (unsigned i = 0; i < m_colCount; i++) { + const Col& col = m_colList[i]; + if (i > 0) + scopy(ptr, ", "); + if (col.m_type == Col::Char || col.m_type == Col::Varchar) { + scopy(ptr, "'"); + for (unsigned i = 0; i <= n % col.m_length; i++) + scopy(ptr, "%c", 'a' + (n + i) % 26); + scopy(ptr, "'"); + } else if (col.m_type == Col::Int || col.m_type == Col::Bigint) { + scopy(ptr, "%u", n); + } else if (col.m_type == Col::Real || col.m_type == Col::Double) { + scopy(ptr, "%.3f", n * 0.001); + } else { + assert(false); + } + } + scopy(ptr, ")"); + } + void whereDirect(char*& ptr, unsigned n) const { + scopy(ptr, " where"); + for (unsigned i = 0; i < m_pkCount; i++) { + const Col& col = m_colList[m_pkIndex[i]]; + if (i > 0) + scopy(ptr, ", "); + else + scopy(ptr, " "); + scopy(ptr, "%s = ", col.m_name); + if (col.m_type == Col::Char || col.m_type == Col::Varchar) { + scopy(ptr, "'"); + for (unsigned i = 0; i <= n % col.m_length; i++) + scopy(ptr, "%c", 'a' + (n + i) % 26); + scopy(ptr, "'"); + } else if (col.m_type == Col::Int || col.m_type == Col::Bigint) { + scopy(ptr, "%u", n); + } else { + assert(false); + } + } + } + void countDirect(char*& ptr, unsigned n) const { + scopy(ptr, "select count(*) from %s", m_name); + whereDirect(ptr, n); + } + void deleteDirect(char*& ptr, unsigned n) const { + scopy(ptr, "delete from %s", m_name); + whereDirect(ptr, n); + } + // joins + void selectCart(char*& ptr, unsigned cnt) const { + scopy(ptr, "select count(*) from"); + for (unsigned j = 0; j < cnt; j++) { + if (j > 0) + scopy(ptr, ","); + scopy(ptr, " %s", m_name); + scopy(ptr, " t%u", j); + } + } + void selectJoin(char*& ptr, unsigned cnt) const { + scopy(ptr, "select * from"); + for (unsigned j = 0; j < cnt; j++) { + if (j > 0) + scopy(ptr, ","); + scopy(ptr, " %s", m_name); + scopy(ptr, " t%u", j); + } + for (unsigned i = 0; i < m_pkCount; i++) { + const Col& col = m_colList[m_pkIndex[i]]; + for (unsigned j = 0; j < cnt - 1; j++) { + if (i == 0 && j == 0) + scopy(ptr, " where"); + else + scopy(ptr, " and"); + scopy(ptr, " t%u.%s = t%u.%s", j, col.m_name, j + 1, col.m_name); + } + } + } + // check if selected on command line + bool optok() const { + return opt.m_table == 0 || strcasecmp(m_name, opt.m_table) == 0; + } +}; + +// the test tables + +static Col col0[] = { + Col( "a", Col::Bigint, 0, Col::Pk, Col::CLong ), + Col( "b", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c", Col::Char, 4, Col::NotNull, Col::CChar ), + Col( "d", Col::Double, 0, Col::Null, Col::CDouble ), + Col( "e", Col::Char, 40, Col::Null, Col::CChar ), + Col( "f", Col::Char, 10, Col::Null, Col::CChar ) +}; + +static Col col1[] = { + Col( "c0", Col::Int, 0, Col::Pk, Col::CLong ), + Col( "c1", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c2", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c3", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c4", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c5", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c6", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c7", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c8", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c9", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c10", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c11", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c12", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c13", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c14", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c15", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c16", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c17", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c18", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c19", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c20", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c21", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c22", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c23", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c24", Col::Int, 0, Col::NotNull, Col::CLong ), + Col( "c25", Col::Int, 0, Col::NotNull, Col::CLong ) +}; + +static Col col2[] = { + Col( "a", Col::Int, 0, Col::Pk, Col::CLong ), + Col( "c", Col::Char, 8000, Col::NotNull, Col::CChar ) +}; + +static Col col3[] = { + Col( "a", Col::Int, 0, Col::Pk, Col::CLong ), + Col( "c1", Col::Varchar, 1, Col::Null, Col::CChar ), + Col( "c2", Col::Varchar, 2, Col::Null, Col::CChar ), + Col( "c3", Col::Varchar, 3, Col::Null, Col::CChar ), + Col( "c4", Col::Varchar, 4, Col::Null, Col::CChar ), + Col( "c5", Col::Varchar, 10, Col::Null, Col::CChar ), + Col( "c6", Col::Varchar, 40, Col::Null, Col::CChar ), + Col( "c7", Col::Varchar, 255, Col::Null, Col::CChar ), + Col( "c8", Col::Varchar, 4000, Col::Null, Col::CChar ) +}; + +static Col col4[] = { + Col( "a", Col::Char, 8, Col::Pk, Col::CChar ), + Col( "b", Col::Char, 8, Col::NotNull, Col::CChar ), +}; + +static Tab tabList[] = { +#define colList(x) x, arraySize(x) + Tab( "tt00", colList(col0) ), + Tab( "tt01", colList(col1) ), // fläskbench special + Tab( "tt02", colList(col2) ), + Tab( "tt03", colList(col3) ), + Tab( "tt04", colList(col4) ) +#undef colList +}; + +static const unsigned tabCount = arraySize(tabList); +static const unsigned maxColCount = 100; // per table - keep up to date + +static bool +findTable() +{ + for (unsigned i = 0; i < tabCount; i++) { + const Tab& tab = tabList[i]; + if (tab.optok()) + return true; + } + return false; +} + +static void +listTables() +{ + ndbout << "tables:" << endl; + for (unsigned i = 0; i < tabCount; i++) { + const Tab& tab = tabList[i]; + if (i > 0) + ndbout << " "; + ndbout << tab.m_name; + } + ndbout << endl; +} + +// data fields and rows + +struct Fld { + const Col& m_col; + union { + char* m_char; + long m_long; + double m_double; + }; + SQLINTEGER m_ind; + SQLINTEGER m_need; // constant + Fld() : + m_col(ColUndef), + m_need(0) { + } + Fld(const Col& col) : + m_col(col), + m_need(SQL_LEN_DATA_AT_EXEC(0)) { + switch (m_col.m_ctype) { + case Col::CChar: + m_char = new char[m_col.csize()]; + memset(m_char, 0, m_col.csize()); + break; + case Col::CLong: + m_long = 0; + break; + case Col::CDouble: + m_double = 0.0; + break; + } + m_ind = -1; + } + ~Fld() { + switch (m_col.m_ctype) { + case Col::CChar: + delete[] m_char; + break; + case Col::CLong: + break; + case Col::CDouble: + break; + } + } + void zero() { + switch (m_col.m_ctype) { + case Col::CChar: + memset(m_char, 0x1f, m_col.csize()); + break; + case Col::CLong: + m_long = 0x1f1f1f1f; + break; + case Col::CDouble: + m_double = 1111111.1111111; + break; + } + m_ind = -1; + } + // copy values from another field + void copy(const Fld& fld) { + assert(&m_col == &fld.m_col); + switch (m_col.m_ctype) { + case Col::CChar: + memcpy(m_char, fld.m_char, m_col.csize()); + break; + case Col::CLong: + m_long = fld.m_long; + break; + case Col::CDouble: + m_double = fld.m_double; + break; + default: + assert(false); + break; + } + m_ind = fld.m_ind; + } + SQLPOINTER caddr() { + switch (m_col.m_ctype) { + case Col::CChar: + return (SQLPOINTER)m_char; + case Col::CLong: + return (SQLPOINTER)&m_long; + case Col::CDouble: + return (SQLPOINTER)&m_double; + } + assert(false); + return 0; + } + SQLINTEGER* ind() { + return &m_ind; + } + SQLINTEGER* need() { + m_need = SQL_LEN_DATA_AT_EXEC(0); + return &m_need; + } + void calcPk(const Test& test, unsigned rownum) { + switch (m_col.m_ctype) { + case Col::CChar: + test.calcPk(rownum, m_char, m_col.csize()); + m_ind = SQL_NTS; + return; + case Col::CLong: + test.calcPk(rownum, &m_long); + m_ind = 0; + return; + case Col::CDouble: + assert(false); + return; + } + assert(false); + } + void hashPk(const Test& test, unsigned* hash) const { + switch (m_col.m_ctype) { + case Col::CChar: + test.hashPk(hash, m_char, m_col.csize()); + return; + case Col::CLong: + test.hashPk(hash, m_long); + return; + case Col::CDouble: + assert(false); + return; + } + assert(false); + } + void calcNk(const Test& test, unsigned hash) { + bool null = m_col.m_cons == Col::Null; + switch (m_col.m_ctype) { + case Col::CChar: + test.calcNk(hash, m_char, m_col.csize(), &m_ind, null); + return; + case Col::CLong: + test.calcNk(hash, &m_long, &m_ind, null); + return; + case Col::CDouble: + test.calcNk(hash, &m_double, &m_ind, null); + return; + } + assert(false); + } + bool verify(Test& test, const Fld& fld) { + assert(&m_col == &fld.m_col); + switch (m_col.m_ctype) { + case Col::CChar: + return test.verify(m_char, m_ind, fld.m_char, fld.m_ind, m_col.csize()); + case Col::CLong: + return test.verify(m_long, m_ind, fld.m_long, fld.m_ind); + case Col::CDouble: + return test.verify(m_double, m_ind, fld.m_double, fld.m_ind); + } + assert(false); + return false; + } + // debug + void print() const { + if (m_ind == SQL_NULL_DATA) + ndbout << "NULL"; + else { + switch (m_col.m_ctype) { + case Col::CChar: + ndbout << m_char; + break; + case Col::CLong: + ndbout << (int)m_long; + break; + case Col::CDouble: + ndbout << m_double; + break; + } + } + } +}; + +struct Row { + const Tab& m_tab; + Fld* m_fldList; + Row(const Tab& tab) : + m_tab(tab) { + m_fldList = new Fld[m_tab.m_colCount]; + for (unsigned i = 0; i < m_tab.m_colCount; i++) { + const Col& col = m_tab.m_colList[i]; + void* place = &m_fldList[i]; + new (place) Fld(col); + } + } + ~Row() { + delete[] m_fldList; + } + // copy values from another row + void copy(const Row& row) { + assert(&m_tab == &row.m_tab); + for (unsigned i = 0; i < m_tab.m_colCount; i++) { + Fld& fld = m_fldList[i]; + fld.copy(row.m_fldList[i]); + } + } + // primary key value is determined by row number + void calcPk(Test& test, unsigned rownum) { + for (unsigned i = 0; i < m_tab.m_pkCount; i++) { + Fld& fld = m_fldList[m_tab.m_pkIndex[i]]; + fld.calcPk(test, rownum); + } + } + // other fields are determined by primary key value + void calcNk(Test& test) { + unsigned hash = test.m_salt; + for (unsigned i = 0; i < m_tab.m_pkCount; i++) { + Fld& fld = m_fldList[m_tab.m_pkIndex[i]]; + fld.hashPk(test, &hash); + } + for (unsigned i = 0; i < m_tab.m_colCount; i++) { + const Col& col = m_tab.m_colList[i]; + if (col.m_cons == Col::Pk) + continue; + Fld& fld = m_fldList[i]; + fld.calcNk(test, hash); + } + } + // verify against another row + bool verifyPk(Test& test, const Row& row) const { + assert(&m_tab == &row.m_tab); + for (unsigned i = 0; i < m_tab.m_pkCount; i++) { + Fld& fld = m_fldList[m_tab.m_pkIndex[i]]; + if (! fld.verify(test, row.m_fldList[m_tab.m_pkIndex[i]])) { + ndbout << "verify failed: tab=" << m_tab.m_name << " col=" << fld.m_col.m_name << endl; + return false; + } + } + return true; + } + bool verifyNk(Test& test, const Row& row) const { + assert(&m_tab == &row.m_tab); + for (unsigned i = 0; i < m_tab.m_nkCount; i++) { + Fld& fld = m_fldList[m_tab.m_nkIndex[i]]; + if (! fld.verify(test, row.m_fldList[m_tab.m_nkIndex[i]])) { + ndbout << "verify failed: tab=" << m_tab.m_name << " col=" << fld.m_col.m_name << endl; + return false; + } + } + return true; + } + bool verify(Test& test, const Row& row) const { + return verifyPk(test, row) && verifyNk(test, row); + } + // debug + void print() const { + ndbout << "row"; + for (unsigned i = 0; i < m_tab.m_colCount; i++) { + ndbout << " " << i << "="; + Fld& fld = m_fldList[i]; + fld.print(); + } + ndbout << endl; + } +}; + +// set ODBC version - required + +static void +setVersion(Test& test, SQLHANDLE hEnv) +{ + test.run(HEnv(hEnv), SQLSetEnvAttr(hEnv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, SQL_IS_INTEGER)); +} + +// set autocommit + +static void +setAutocommit(Test& test, SQLHANDLE hDbc, bool on) +{ + SQLUINTEGER value = on ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF; + test.run(HDbc(hDbc), SQLSetConnectAttr(hDbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)value, SQL_IS_UINTEGER)); + SQLUINTEGER value2 = (SQLUINTEGER)-1; + test.run(HDbc(hDbc), SQLGetConnectAttr(hDbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)&value2, SQL_IS_UINTEGER, 0)); + test.chk(HDbc(hDbc), value2 == value, "got %u != %u", (unsigned)value2, (unsigned)value); +} + +// subroutines - migrate simple common routines here + +static void +allocEnv(Test& test, SQLHANDLE& hEnv) +{ + test.run(HNull, SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &hEnv)); + setVersion(test, hEnv); +} + +static void +allocDbc(Test& test, SQLHANDLE hEnv, SQLHANDLE& hDbc) +{ + test.run(HEnv(hEnv), SQLAllocHandle(SQL_HANDLE_DBC, hEnv, &hDbc)); +} + +static void +allocConn(Test& test, SQLHANDLE hEnv, SQLHANDLE& hDbc) +{ + allocDbc(test, hEnv, hDbc); +#ifdef unixODBC + test.exp(SQL_SUCCESS_WITH_INFO, "IM003", 0, false); // unicode?? + test.exp(SQL_SUCCESS_WITH_INFO, "01000", 0, false); // version?? +#endif + test.run(HDbc(hDbc), SQLConnect(hDbc, (SQLCHAR*)opt.m_dsn, SQL_NTS, (SQLCHAR*)"user", SQL_NTS, (SQLCHAR*)"pass", SQL_NTS)); +} + +static void +allocStmt(Test& test, SQLHANDLE hDbc, SQLHANDLE& hStmt) +{ + test.run(HDbc(hDbc), SQLAllocHandle(SQL_HANDLE_STMT, hDbc, &hStmt)); +} + +static void +allocAll(Test& test, SQLHANDLE& hEnv, SQLHANDLE& hDbc, SQLHANDLE& hStmt) +{ + allocEnv(test, hEnv); + allocConn(test, hEnv, hDbc); + allocStmt(test, hDbc, hStmt); +} + +static void +allocAll(Test& test, SQLHANDLE& hEnv, SQLHANDLE& hDbc, SQLHANDLE* hStmtList, unsigned nStmt) +{ + allocEnv(test, hEnv); + allocConn(test, hEnv, hDbc); + for (unsigned i = 0; i < nStmt; i++) + allocStmt(test, hDbc, hStmtList[i]); +} + +static void +freeEnv(Test& test, SQLHANDLE hEnv) +{ + test.run(HNull, SQLFreeHandle(SQL_HANDLE_ENV, hEnv)); +} + +static void +freeDbc(Test& test, SQLHANDLE hEnv, SQLHANDLE hDbc) +{ + test.run(HEnv(hEnv), SQLFreeHandle(SQL_HANDLE_DBC, hDbc)); +} + +static void +freeConn(Test& test, SQLHANDLE hEnv, SQLHANDLE hDbc) +{ + test.run(HDbc(hDbc), SQLDisconnect(hDbc)); + test.run(HEnv(hEnv), SQLFreeHandle(SQL_HANDLE_DBC, hDbc)); +} + +static void +freeStmt(Test& test, SQLHANDLE hDbc, SQLHANDLE hStmt) +{ + test.run(HDbc(hDbc), SQLFreeHandle(SQL_HANDLE_STMT, hStmt)); +} + +static void +freeAll(Test& test, SQLHANDLE hEnv, SQLHANDLE hDbc, SQLHANDLE hStmt) +{ + freeStmt(test, hDbc, hStmt); + freeConn(test, hEnv, hDbc); + freeEnv(test, hEnv); +} + +static void +freeAll(Test& test, SQLHANDLE hEnv, SQLHANDLE hDbc, SQLHANDLE* hStmtList, unsigned nStmt) +{ + for (unsigned i = 0; i < nStmt; i++) + freeStmt(test, hDbc, hStmtList[i]); + freeConn(test, hEnv, hDbc); + freeEnv(test, hEnv); +} + +#define chkTuplesFetched(/*Test&*/ _test, /*SQLHANDLE*/ _hStmt, /*SQLUINTEGER*/ _countExp) \ +do { \ + SQLUINTEGER _count = (SQLUINTEGER)-1; \ + getTuplesFetched(_test, _hStmt, &_count); \ + test.chk(HStmt(_hStmt), _count == _countExp, "tuples: got %ld != %ld", (long)_count, (long)_countExp); \ +} while (0) + +static void +getTuplesFetched(Test& test, SQLHANDLE hStmt, SQLUINTEGER* count) +{ + *count = (SQLUINTEGER)-1; + test.run(HStmt(hStmt), SQLGetStmtAttr(hStmt, SQL_ATTR_NDB_TUPLES_FETCHED, count, SQL_IS_POINTER, 0)); +} + +static void +selectCount(Test& test, SQLHANDLE hStmt, const char* sql, long* count) +{ + if (opt.m_v >= 3) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS)); + SQLINTEGER ind; + test.run(HStmt(hStmt), SQLBindCol(hStmt, 1, SQL_C_SLONG, count, 0, &ind)); + ind = -1; + *count = -1; + test.run(HStmt(hStmt), SQLExecute(hStmt)); + unsigned k = 0; + while (1) { + if (k == 1) + test.exp(SQL_NO_DATA, 0, 0, true); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + if (k == 1) + break; + k++; + } + test.chk(HStmt(hStmt), ind == sizeof(long), "got %d != %d", (int)ind, (int)sizeof(long)); + test.chk(HStmt(hStmt), *count >= 0, "got %ld < 0", *count); + chkTuplesFetched(test, hStmt, *count); +#ifndef iODBC + // + test.run(HStmt(hStmt), SQLCloseCursor(hStmt)); +#else + test.run(HStmt(hStmt), SQLFreeStmt(hStmt, SQL_CLOSE)); +#endif +} + +static void +selectCount(Test& test, SQLHANDLE hStmt, const Tab& tab, long* count) +{ + static char sql[MAX_SQL], *sqlptr; // XXX static or core + tab.selectCount(sqlptr = sql); + selectCount(test, hStmt, sql, count); +} + +static void +verifyCount(Test& test, SQLHANDLE hStmt, const Tab& tab, long countExp) +{ + long count = -1; + selectCount(test, hStmt, tab, &count); + test.chk(HStmt(hStmt), count == countExp, "got %ld != %ld", count, countExp); +} + +#define chkRowCount(/*Test&*/ _test, /*SQLHANDLE*/ _hStmt, /*SQLINTEGER*/ _countExp) \ +do { \ + SQLINTEGER _count = -1; \ + getRowCount(_test, _hStmt, &_count); \ + test.chk(HStmt(_hStmt), _count == _countExp, "rowcount: got %ld != %ld", (long)_count, (long)_countExp); \ +} while (0) + +static void +getRowCount(Test& test, SQLHANDLE hStmt, SQLINTEGER* count) +{ + *count = -1; + test.run(HStmt(hStmt), SQLRowCount(hStmt, count)); +} + +// handle allocation + +static void +testAlloc(Test& test) +{ + const unsigned n1 = (opt.m_scale >> 8) & 0xf; // default 500 = 0x1f4 + const unsigned n2 = (opt.m_scale >> 4) & 0xf; + const unsigned n3 = (opt.m_scale >> 0) & 0xf; + const unsigned count = n1 + n1 * n2 + n1 * n2 * n3; + SQLHANDLE hEnvList[0xf]; + SQLHANDLE hDbcList[0xf][0xf]; + SQLHANDLE hStmtList[0xf][0xf][0xf]; + for (unsigned i1 = 0; i1 < n1; i1++) { + SQLHANDLE& hEnv = hEnvList[i1]; + test.run(HNull, SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &hEnv)); + test.run(HEnv(hEnv), SQLSetEnvAttr(hEnv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, SQL_IS_INTEGER)); + for (unsigned i2 = 0; i2 < n2; i2++) { + SQLHANDLE& hDbc = hDbcList[i1][i2]; + test.run(HEnv(hEnv), SQLAllocHandle(SQL_HANDLE_DBC, hEnv, &hDbc)); +#ifdef unixODBC + test.exp(SQL_SUCCESS_WITH_INFO, "IM003", 0, false); // unicode?? + test.exp(SQL_SUCCESS_WITH_INFO, "01000", 0, false); // version?? +#endif + test.run(HDbc(hDbc), SQLConnect(hDbc, (SQLCHAR*)opt.m_dsn, SQL_NTS, (SQLCHAR*)"user", SQL_NTS, (SQLCHAR*)"pass", SQL_NTS)); + // some attributes + test.exp(SQL_ERROR, "HY092", -1, true); // read-only attribute + test.run(HDbc(hDbc), SQLSetConnectAttr(hDbc, SQL_ATTR_AUTO_IPD, (SQLPOINTER)SQL_TRUE, SQL_IS_UINTEGER)); + test.exp(SQL_ERROR, "HYC00", -1, true); // not supported + test.run(HDbc(hDbc), SQLSetConnectAttr(hDbc, SQL_ATTR_TXN_ISOLATION, (SQLPOINTER)SQL_TXN_SERIALIZABLE, SQL_IS_UINTEGER)); + test.run(HDbc(hDbc), SQLSetConnectAttr(hDbc, SQL_ATTR_CURRENT_CATALOG, (SQLPOINTER)"DEFAULT", strlen("DEFAULT"))); + for (unsigned i3 = 0; i3 < n3; i3++) { + SQLHANDLE& hStmt = hStmtList[i1][i2][i3]; + test.run(HDbc(hDbc), SQLAllocHandle(SQL_HANDLE_STMT, hDbc, &hStmt)); + SQLHANDLE ipd0, ipd1; + SQLHANDLE ird0, ird1; + SQLHANDLE apd0, apd1, apd2; + SQLHANDLE ard0, ard1, ard2; + // get + ipd0 = ird0 = apd0 = ard0 = 0; + test.run(HStmt(hStmt), SQLGetStmtAttr(hStmt, SQL_ATTR_IMP_PARAM_DESC, &ipd0, SQL_IS_POINTER, 0)); + test.run(HStmt(hStmt), SQLGetStmtAttr(hStmt, SQL_ATTR_IMP_ROW_DESC, &ird0, SQL_IS_POINTER, 0)); + test.run(HStmt(hStmt), SQLGetStmtAttr(hStmt, SQL_ATTR_APP_PARAM_DESC, &apd0, SQL_IS_POINTER, 0)); + test.run(HStmt(hStmt), SQLGetStmtAttr(hStmt, SQL_ATTR_APP_ROW_DESC, &ard0, SQL_IS_POINTER, 0)); +#ifndef unixODBC + test.chk(HStmt(hStmt), ipd0 != 0, "got 0"); + test.chk(HStmt(hStmt), ird0 != 0, "got 0"); + test.chk(HStmt(hStmt), apd0 != 0, "got 0"); + test.chk(HStmt(hStmt), ard0 != 0, "got 0"); +#endif + // alloc + ipd1 = ird1 = apd1 = ard1 = 0; + test.run(HDbc(hDbc), SQLAllocHandle(SQL_HANDLE_DESC, hDbc, &ipd1)); + test.run(HDbc(hDbc), SQLAllocHandle(SQL_HANDLE_DESC, hDbc, &ird1)); + test.run(HDbc(hDbc), SQLAllocHandle(SQL_HANDLE_DESC, hDbc, &apd1)); + test.run(HDbc(hDbc), SQLAllocHandle(SQL_HANDLE_DESC, hDbc, &ard1)); + test.chk(HDbc(hDbc), ipd1 != 0 && ird1 != 0 && apd1 != 0 && ard1 != 0, "got null"); + // set + test.exp(SQL_ERROR, "HY092", -1, true); // read-only attribute + test.run(HStmt(hStmt), SQLSetStmtAttr(hStmt, SQL_ATTR_IMP_PARAM_DESC, ipd1, SQL_IS_POINTER)); + test.exp(SQL_ERROR, "HY092", -1, true); // read-only attribute + test.run(HStmt(hStmt), SQLSetStmtAttr(hStmt, SQL_ATTR_IMP_ROW_DESC, ird1, SQL_IS_POINTER)); + test.run(HStmt(hStmt), SQLSetStmtAttr(hStmt, SQL_ATTR_APP_PARAM_DESC, apd1, SQL_IS_POINTER)); + test.run(HStmt(hStmt), SQLSetStmtAttr(hStmt, SQL_ATTR_APP_ROW_DESC, ard1, SQL_IS_POINTER)); + // get + + apd2 = ard2 = 0; + test.run(HStmt(hStmt), SQLGetStmtAttr(hStmt, SQL_ATTR_APP_PARAM_DESC, &apd2, SQL_IS_POINTER, 0)); + test.run(HStmt(hStmt), SQLGetStmtAttr(hStmt, SQL_ATTR_APP_ROW_DESC, &ard2, SQL_IS_POINTER, 0)); + test.chk(HStmt(hStmt), apd2 == apd1, "got %x != %x", (unsigned)apd2, (unsigned)apd1); + test.chk(HStmt(hStmt), ard2 == ard1, "got %x != %x", (unsigned)ard2, (unsigned)ard1); + // free + test.run(HDbc(hDbc), SQLFreeHandle(SQL_HANDLE_DESC, ipd1)); + test.run(HDbc(hDbc), SQLFreeHandle(SQL_HANDLE_DESC, ird1)); + test.run(HDbc(hDbc), SQLFreeHandle(SQL_HANDLE_DESC, apd1)); + test.run(HDbc(hDbc), SQLFreeHandle(SQL_HANDLE_DESC, ard1)); + } + } + } + test.timerCnt(count); + if (opt.m_v >= 3) + ndbout << "allocated " << count << endl; + for (unsigned i1 = 0; i1 < n1; i1++) { + SQLHANDLE& hEnv = hEnvList[i1]; + for (unsigned i2 = 0; i2 < n2; i2++) { + SQLHANDLE& hDbc = hDbcList[i1][i2]; + if (i2 % 2 == 0) { + for (unsigned i3 = 0; i3 < n3; i3++) { + SQLHANDLE& hStmt = hStmtList[i1][i2][i3]; + test.run(HDbc(hDbc), SQLFreeHandle(SQL_HANDLE_STMT, hStmt)); + } + } else { + // cleaned up by SQLDisconnect + } + test.run(HDbc(hDbc), SQLDisconnect(hDbc)); + test.run(HEnv(hEnv), SQLFreeHandle(SQL_HANDLE_DBC, hDbc)); + } + test.run(HNull, SQLFreeHandle(SQL_HANDLE_ENV, hEnv)); + } + test.timerCnt(count); + if (opt.m_v >= 3) + ndbout << "freed " << count << endl; +} + +// create tables + +static void +testCreate(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmt; + allocAll(test, hEnv, hDbc, hStmt); + char sql[MAX_SQL], *sqlptr; + for (unsigned i = 0; i < tabCount; i++) { + Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + // drop + tab.drop(sqlptr = sql); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS)); + test.exp(SQL_ERROR, "IM000", 2040709, false); + test.run(HStmt(hStmt), SQLExecute(hStmt)); + if (test.m_ret == SQL_SUCCESS) + test.chk(HStmt(hStmt), test.m_functionCode == SQL_DIAG_DROP_TABLE, "got %d != %d", test.m_functionCode, SQL_DIAG_DROP_TABLE); + if (test.m_ret == SQL_SUCCESS && opt.m_v >= 2) + ndbout << "table " << tab.m_name << " dropped" << endl; + if (test.m_ret != SQL_SUCCESS && opt.m_v >= 2) + ndbout << "table " << tab.m_name << " does not exist" << endl; + test.timerCnt(1); + // create + tab.create(sqlptr = sql); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS)); + test.exp(SQL_ERROR, "IM000", 2040721, false); + test.run(HStmt(hStmt), SQLExecute(hStmt)); + if (test.m_ret == SQL_SUCCESS) + test.chk(HStmt(hStmt), test.m_functionCode == SQL_DIAG_CREATE_TABLE, "got %d != %d", test.m_functionCode, SQL_DIAG_CREATE_TABLE); + if (test.m_ret == SQL_SUCCESS && opt.m_v >= 2) + ndbout << "table " << tab.m_name << " created" << endl; + if (test.m_ret != SQL_SUCCESS && opt.m_v >= 2) + ndbout << "table " << tab.m_name << " already exists" << endl; + test.timerCnt(1); + } + freeAll(test, hEnv, hDbc, hStmt); +} + +// prepare without execute + +static void +testPrepare(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmt; + allocAll(test, hEnv, hDbc, hStmt); + char sql[MAX_SQL], *sqlptr; + for (unsigned cnt = opt.m_depth; cnt <= opt.m_depth; cnt++) { + for (unsigned i = 0; i < tabCount; i++) { + Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + tab.selectJoin(sqlptr = sql, cnt); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS)); + SQLSMALLINT colCount = -1; + SQLSMALLINT colExp = cnt * tab.m_colCount; + test.run(HStmt(hStmt), SQLNumResultCols(hStmt, &colCount)); + test.chk(HStmt(hStmt), colCount == colExp, "got %d != %d", (int)colCount, (int)colExp); + test.timerCnt(1); + } + } + freeAll(test, hEnv, hDbc, hStmt); +} + +// catalog functions + +static void +testCatalog(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmt; + allocAll(test, hEnv, hDbc, hStmt); + odbc_typeinfo: { + long type[] = { + SQL_CHAR, SQL_VARCHAR, SQL_SMALLINT, SQL_INTEGER, SQL_BIGINT, SQL_REAL, SQL_DOUBLE + }; + unsigned rows[] = { + 1, 1, 2, 2, 2, 1, 1 // 2 for signed and unsigned + }; + for (unsigned i = 0; i < arraySize(type); i++) { + test.run(HStmt(hStmt), SQLGetTypeInfo(hStmt, type[i])); + long dataType = 0; + test.run(HStmt(hStmt), SQLBindCol(hStmt, 2, SQL_C_SLONG, &dataType, 0, 0)); + unsigned k = 0; + while (1) { + if (k == rows[i]) + test.exp(SQL_NO_DATA, 0, 0, true); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + if (k == rows[i]) + break; + test.chk(HStmt(hStmt), dataType == type[i], "got %ld != %ld", dataType, type[i]); + test.timerCnt(1); + k++; + } +#ifndef iODBC + test.run(HStmt(hStmt), SQLCloseCursor(hStmt)); +#else + freeStmt(test, hDbc, hStmt); + allocStmt(test, hDbc, hStmt); +#endif + } + if (opt.m_v >= 2) + ndbout << "found " << (UintPtr)arraySize(type) << " data types" << endl; + test.run(HStmt(hStmt), SQLFreeStmt(hStmt, SQL_UNBIND)); + } + odbc_tables: { + unsigned found[tabCount]; + for (unsigned i = 0; i < tabCount; i++) + found[i] = 0; + test.run(HStmt(hStmt), SQLTables(hStmt, (SQLCHAR*)0, 0, (SQLCHAR*)0, 0, (SQLCHAR*)0, 0, (SQLCHAR*)0, 0)); + char tableName[200] = ""; + char tableType[200] = ""; + test.run(HStmt(hStmt), SQLBindCol(hStmt, 3, SQL_C_CHAR, tableName, sizeof(tableName), 0)); + test.run(HStmt(hStmt), SQLBindCol(hStmt, 4, SQL_C_CHAR, tableType, sizeof(tableType), 0)); + unsigned cnt = 0; + while (1) { + test.exp(SQL_NO_DATA, 0, 0, false); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + if (test.m_ret == SQL_NO_DATA) + break; + test.timerCnt(1); + cnt++; + if (! blankeq(tableType, "TABLE")) + continue; + for (unsigned i = 0; i < tabCount; i++) { + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + if (! blankeq(tab.m_name, tableName)) + continue; + test.chk(HStmt(hStmt), found[i] == 0, "duplicate table %s", tab.m_name); + found[i]++; + } + } +#ifndef iODBC + test.run(HStmt(hStmt), SQLCloseCursor(hStmt)); +#else + freeStmt(test, hDbc, hStmt); + allocStmt(test, hDbc, hStmt); +#endif + for (unsigned i = 0; i < tabCount; i++) { + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + test.chk(HStmt(hStmt), found[i] == 1, "table %s not found", tab.m_name); + } + if (opt.m_v >= 2) + ndbout << "found " << cnt << " tables" << endl; + test.run(HStmt(hStmt), SQLFreeStmt(hStmt, SQL_UNBIND)); + } + odbc_columns: { + unsigned found[tabCount][maxColCount]; + for (unsigned i = 0; i < tabCount; i++) { + for (unsigned j = 0; j < maxColCount; j++) + found[i][j] = 0; + } + test.run(HStmt(hStmt), SQLColumns(hStmt, (SQLCHAR*)0, 0, (SQLCHAR*)0, 0, (SQLCHAR*)0, 0, (SQLCHAR*)0, 0)); + char tableName[200] = ""; + char columnName[200] = ""; + long dataType = 0; + test.run(HStmt(hStmt), SQLBindCol(hStmt, 3, SQL_C_CHAR, tableName, sizeof(tableName), 0)); + test.run(HStmt(hStmt), SQLBindCol(hStmt, 4, SQL_C_CHAR, columnName, sizeof(columnName), 0)); + test.run(HStmt(hStmt), SQLBindCol(hStmt, 5, SQL_C_SLONG, &dataType, 0, 0)); + unsigned cnt = 0; + while (1) { + test.exp(SQL_NO_DATA, 0, 0, false); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + if (test.m_ret == SQL_NO_DATA) + break; + test.timerCnt(1); + cnt++; + for (unsigned i = 0; i < tabCount; i++) { + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + if (! blankeq(tab.m_name, tableName)) + continue; + bool columnFound = false; + for (unsigned j = 0; j < tab.m_colCount; j++) { + const Col& col = tab.m_colList[j]; + if (! blankeq(col.m_name, columnName)) + continue; + test.chk(HStmt(hStmt), found[i][j] == 0, "duplicate column %s.%s", tableName, columnName); + found[i][j]++; + columnFound = true; + } + test.chk(HStmt(hStmt), columnFound, "unknown column %s.%s", tableName, columnName); + } + } +#ifndef iODBC + test.run(HStmt(hStmt), SQLCloseCursor(hStmt)); +#else + freeStmt(test, hDbc, hStmt); + allocStmt(test, hDbc, hStmt); +#endif + for (unsigned i = 0; i < tabCount; i++) { + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + for (unsigned j = 0; j < tab.m_colCount; j++) { + const Col& col = tab.m_colList[j]; + test.chk(HStmt(hStmt), found[i][j] == 1, "column %s.%s not found", tab.m_name, col.m_name); + } + } + if (opt.m_v >= 2) + ndbout << "found " << cnt << " columns" << endl; + test.run(HStmt(hStmt), SQLFreeStmt(hStmt, SQL_UNBIND)); + } + odbc_primarykeys: { + // table patterns are no allowed + for (unsigned i = 0; i < tabCount; i++) { + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + char tmp[200]; // p.i.t.a + strcpy(tmp, tab.m_name); + for (char* a = tmp; *a != 0; a++) { + if ('a' <= *a && *a <= 'z') + *a -= 'a' - 'A'; + } + test.run(HStmt(hStmt), SQLPrimaryKeys(hStmt, (SQLCHAR*)0, 0, (SQLCHAR*)0, 0, (SQLCHAR*)tmp, SQL_NTS)); + char tableName[200] = ""; + char columnName[200] = ""; + long keySeq = -1; + test.run(HStmt(hStmt), SQLBindCol(hStmt, 3, SQL_C_CHAR, tableName, sizeof(tableName), 0)); + test.run(HStmt(hStmt), SQLBindCol(hStmt, 4, SQL_C_CHAR, columnName, sizeof(columnName), 0)); + test.run(HStmt(hStmt), SQLBindCol(hStmt, 5, SQL_C_SLONG, &keySeq, 0, 0)); + unsigned cnt = 0; + while (1) { + if (cnt == tab.m_pkCount) + test.exp(SQL_NO_DATA, 0, 0, true); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + if (test.m_ret == SQL_NO_DATA) + break; + test.chk(HStmt(hStmt), keySeq == 1 + cnt, "got %ld != %u", keySeq, 1 + cnt); + const Col& col = tab.m_colList[tab.m_pkIndex[keySeq - 1]]; + test.chk(HStmt(hStmt), blankeq(columnName, col.m_name), "got %s != %s", columnName, col.m_name); + test.timerCnt(1); + cnt++; + } +#ifndef iODBC + test.run(HStmt(hStmt), SQLCloseCursor(hStmt)); +#else + freeStmt(test, hDbc, hStmt); + allocStmt(test, hDbc, hStmt); +#endif + } + test.run(HStmt(hStmt), SQLFreeStmt(hStmt, SQL_UNBIND)); + } + freeAll(test, hEnv, hDbc, hStmt); +} + +// insert + +static void +testInsert(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmtList[tabCount]; + allocAll(test, hEnv, hDbc, hStmtList, tabCount); + char sql[MAX_SQL], *sqlptr; + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + // prepare + tab.insertAll(sqlptr = sql); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS)); + SQLSMALLINT parCount = -1; + test.run(HStmt(hStmt), SQLNumParams(hStmt, &parCount)); + test.chk(HStmt(hStmt), parCount == tab.m_colCount, "got %d != %d", (int)parCount, (int)tab.m_colCount); + // bind parameters + Row row(tab); + for (unsigned j = 0; j < tab.m_colCount; j++) { + Fld& fld = row.m_fldList[j]; + const Col& col = fld.m_col; + // every other at-exec + SQLPOINTER caddr; + SQLINTEGER* ind; + if (opt.m_noputd || j % 2 == 0) { + caddr = fld.caddr(); + ind = fld.ind(); + } else { + caddr = (SQLPOINTER)j; + ind = fld.need(); + } + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + j, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, caddr, col.csize(), ind)); + } + // bind columns (none) + SQLSMALLINT colCount = -1; + test.run(HStmt(hStmt), SQLNumResultCols(hStmt, &colCount)); + test.chk(HStmt(hStmt), colCount == 0, "got %d != 0", (int)colCount); + // execute + for (unsigned k = 0; k < opt.m_scale; k++) { + if (k % 5 == 0) { + // rebind + unsigned j = 0; + Fld& fld = row.m_fldList[j]; + const Col& col = fld.m_col; + // every other at-exec + SQLPOINTER caddr; + SQLINTEGER* ind; + if (opt.m_noputd || j % 2 == 0) { + caddr = fld.caddr(); + ind = fld.ind(); + } else { + caddr = (SQLPOINTER)j; + ind = fld.need(); + } + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + j, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, caddr, col.csize(), ind)); + } + row.calcPk(test, k); + row.calcNk(test); + unsigned needData = opt.m_noputd ? 0 : tab.m_colCount / 2; + if (needData) + test.exp(SQL_NEED_DATA, 0, 0, true); + test.run(HStmt(hStmt), SQLExecute(hStmt)); + test.chk(HStmt(hStmt), test.m_functionCode == SQL_DIAG_INSERT, "got %d != %d", test.m_functionCode, SQL_DIAG_INSERT); + if (needData) { + while (1) { + SQLPOINTER jPtr = (SQLPOINTER)999; + if (needData) + test.exp(SQL_NEED_DATA, 0, 0, true); + // completes SQLExecute on success + test.run(HStmt(hStmt), SQLParamData(hStmt, &jPtr)); + if (! needData) + break; + unsigned j = (unsigned)jPtr; + test.chk(HStmt(hStmt), j < tab.m_colCount && j % 2 != 0, "got %u 0x%x", j, j); + Fld& fld = row.m_fldList[j]; + const Col& col = fld.m_col; + SQLSMALLINT ctype = col.ctype(); + if (k % 2 == 0 || ctype != Col::CChar) + test.run(HStmt(hStmt), SQLPutData(hStmt, fld.caddr(), *fld.ind())); + else { + // put in pieces + unsigned size = col.csize() - 1; // omit null terminator + char* caddr = (char*)(fld.caddr()); + unsigned off = 0; + while (off < size) { + unsigned m = size / 7; // bytes to put + if (m == 0) + m = 1; + if (m > size - off) + m = size - off; + bool putNull = (*fld.ind() == SQL_NULL_DATA); + // no null terminator + SQLINTEGER len = putNull ? SQL_NULL_DATA : (int)m; + test.run(HStmt(hStmt), SQLPutData(hStmt, caddr + off, len)); + if (putNull) + break; + off += m; + } + } + needData--; + } + } + chkRowCount(test, hStmt, 1); + chkTuplesFetched(test, hStmt, 0); + } + test.timerCnt(opt.m_scale); + if (opt.m_v >= 3) + ndbout << "inserted " << opt.m_scale << " into " << tab.m_name << endl; + } + freeAll(test, hEnv, hDbc, hStmtList, tabCount); +} + +// count + +static void +testCount(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmtList[tabCount]; + allocAll(test, hEnv, hDbc, hStmtList, tabCount); + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + long count = -1; + selectCount(test, hStmt, tab, &count); + test.chk(HStmt(hStmt), count == opt.m_scale * opt.m_threads, "got %ld != %u", count, opt.m_scale * opt.m_threads); + test.timerCnt(count); + if (opt.m_v >= 3) + ndbout << "counted " << (int)count << " rows in " << tab.m_name << endl; + } + // scan all at same time + char sql[MAX_SQL], *sqlptr; + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + tab.selectAll(sqlptr = sql); + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + } + unsigned k = 0; + while (1) { + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + if (k == opt.m_scale * opt.m_threads) + test.exp(SQL_NO_DATA, 0, 0, true); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + if (k != opt.m_scale * opt.m_threads) { + chkTuplesFetched(test, hStmt, k + 1); + test.timerCnt(1); + } else { + chkTuplesFetched(test, hStmt, k); + test.exp(SQL_NO_DATA, 0, 0, true); + test.run(HStmt(hStmt), SQLMoreResults(hStmt)); + } + } + if (k == opt.m_scale * opt.m_threads) + break; + k++; + } + if (opt.m_v >= 3) + ndbout << "scanned " << opt.m_scale << " rows from each table" << endl; + freeAll(test, hEnv, hDbc, hStmtList, tabCount); +} + +// update + +static void +testUpdatePk(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmtList[tabCount]; + allocAll(test, hEnv, hDbc, hStmtList, tabCount); + char sql[MAX_SQL], *sqlptr; + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + // prepare + tab.updatePk(sqlptr = sql); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS)); + // bind parameters + Row row(tab); + SQLSMALLINT parCount = -1; + test.run(HStmt(hStmt), SQLNumParams(hStmt, &parCount)); + test.chk(HStmt(hStmt), parCount == tab.m_colCount, "got %d != %d", (int)parCount, (int)tab.m_colCount); + for (unsigned j = 0; j < tab.m_nkCount; j++) { + Fld& fld = row.m_fldList[tab.m_nkIndex[j]]; + const Col& col = fld.m_col; + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + j, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, fld.caddr(), col.csize(), fld.ind())); + } + for (unsigned j = 0; j < tab.m_pkCount; j++) { + Fld& fld = row.m_fldList[tab.m_pkIndex[j]]; + const Col& col = fld.m_col; + 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())); + } + // bind columns (none) + SQLSMALLINT colCount = -1; + test.run(HStmt(hStmt), SQLNumResultCols(hStmt, &colCount)); + test.chk(HStmt(hStmt), colCount == 0, "got %d != 0", (int)colCount); + // execute + for (unsigned k = 0; k < opt.m_scale; k++) { + if (k % 5 == 0) { + unsigned j = 0; + Fld& fld = row.m_fldList[tab.m_nkIndex[j]]; + const Col& col = fld.m_col; + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + j, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, fld.caddr(), col.csize(), fld.ind())); + } + row.calcPk(test, k); + row.calcNk(test); + test.run(HStmt(hStmt), SQLExecute(hStmt)); + test.chk(HStmt(hStmt), test.m_functionCode == SQL_DIAG_UPDATE_WHERE, "got %d != %d", test.m_functionCode, SQL_DIAG_UPDATE_WHERE); + chkRowCount(test, hStmt, 1); + // direct update, no read has been necessary + chkTuplesFetched(test, hStmt, 0); + } + test.timerCnt(opt.m_scale); + if (opt.m_v >= 3) + ndbout << "updated " << opt.m_scale << " in " << tab.m_name << endl; + } + freeAll(test, hEnv, hDbc, hStmtList, tabCount); +} + +static void +testUpdateScan(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmtList[tabCount]; + allocAll(test, hEnv, hDbc, hStmtList, tabCount); + char sql[MAX_SQL], *sqlptr; + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + // prepare + tab.updateRange(sqlptr = sql); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS)); + // bind parameters + Row row(tab); // for set clause + Row rowlo(tab); // for pk ranges + Row rowhi(tab); + SQLSMALLINT parCount = -1; + test.run(HStmt(hStmt), SQLNumParams(hStmt, &parCount)); + 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); + for (unsigned j = 0; j < tab.m_nkCount; j++) { + const Col& col = tab.m_colList[tab.m_nkIndex[j]]; + Fld& fld = row.m_fldList[tab.m_nkIndex[j]]; + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + j, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, fld.caddr(), col.csize(), fld.ind())); + } + bool canInterp = true; + for (unsigned j = 0; j < tab.m_pkCount; j++) { + const Col& col = tab.m_colList[tab.m_pkIndex[j]]; + Fld& fldlo = rowlo.m_fldList[tab.m_pkIndex[j]]; + 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())); + Fld& fldhi = rowhi.m_fldList[tab.m_pkIndex[j]]; + 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())); + if (col.m_type != Col::Char) + canInterp = false; // XXX no unsigned yet + } + // execute + row.calcPk(test, 0); + row.calcNk(test); + rowlo.calcPk(test, 0); + rowhi.calcPk(test, test.m_mul); // sucks + test.run(HStmt(hStmt), SQLExecute(hStmt)); + test.chk(HStmt(hStmt), test.m_functionCode == SQL_DIAG_UPDATE_WHERE, "got %d != %d", test.m_functionCode, SQL_DIAG_UPDATE_WHERE); + chkRowCount(test, hStmt, opt.m_scale); + chkTuplesFetched(test, hStmt, canInterp ? opt.m_scale : opt.m_scale * opt.m_threads); + test.timerCnt(opt.m_scale); + if (opt.m_v >= 3) + ndbout << "updated " << opt.m_scale << " in " << tab.m_name << endl; + } + freeAll(test, hEnv, hDbc, hStmtList, tabCount); +} + +// verify + +static void +testVerifyPk(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmtList[tabCount]; + allocAll(test, hEnv, hDbc, hStmtList, tabCount); + char sql[MAX_SQL], *sqlptr; + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + // prepare + tab.selectPk(sqlptr = sql); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS)); + // use same row for input and output + Row row(tab); + // bind parameters + SQLSMALLINT parCount = -1; + test.run(HStmt(hStmt), SQLNumParams(hStmt, &parCount)); + test.chk(HStmt(hStmt), parCount == tab.m_pkCount, "got %d != %d", (int)parCount, (int)tab.m_pkCount); + for (unsigned j = 0; j < tab.m_pkCount; j++) { + Fld& fld = row.m_fldList[tab.m_pkIndex[j]]; + const Col& col = fld.m_col; + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + j, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, fld.caddr(), col.csize(), fld.ind())); + } + // bind columns + SQLSMALLINT colCount = -1; + test.run(HStmt(hStmt), SQLNumResultCols(hStmt, &colCount)); + test.chk(HStmt(hStmt), colCount == tab.m_colCount, "got %d != %d", (int)colCount, (int)tab.m_colCount); + for (unsigned j = 0; j < tab.m_colCount; j++) { + Fld& fld = row.m_fldList[j]; + const Col& col = fld.m_col; + test.run(HStmt(hStmt), SQLBindCol(hStmt, 1 + j, col.ctype(), fld.caddr(), col.csize(), fld.ind())); + } + // row for SQLGetData + Row rowGet(tab); + // reference row + Row rowRef(tab); + // execute + for (unsigned k = 0; k < opt.m_scale; k++) { + if (k % 5 == 0) { + // rebind + unsigned j = 0; + Fld& fld = row.m_fldList[tab.m_pkIndex[j]]; + const Col& col = fld.m_col; + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + j, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, fld.caddr(), col.csize(), fld.ind())); + } + row.calcPk(test, k); + test.run(HStmt(hStmt), SQLExecute(hStmt)); + test.chk(HStmt(hStmt), test.m_functionCode == SQL_DIAG_SELECT_CURSOR, "got %d != %d", test.m_functionCode, SQL_DIAG_SELECT_CURSOR); + // fetch + for (unsigned k2 = 0; ; k2++) { + if (k2 == 1) + test.exp(SQL_NO_DATA, 0, 0, true); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + chkTuplesFetched(test, hStmt, 1); + if (k2 == 1) + break; + rowRef.calcPk(test, k); + test.chk(HStmt(hStmt), row.verifyPk(test, rowRef), "verify row=%d", k); + if (test.m_const) + rowRef.calcPk(test, 0); + rowRef.calcNk(test); + test.chk(HStmt(hStmt), row.verifyNk(test, rowRef), "verify row=%d", k); + // SQLGetData is supported independent of SQLBindCol + if (opt.m_nogetd) + continue; + for (unsigned j = 0; j < tab.m_colCount; j++) { + Fld& fld = rowGet.m_fldList[j]; + fld.zero(); + const Col& col = fld.m_col; + // test both variants + SQLSMALLINT ctype = k % 2 == 0 ? col.ctype() : SQL_ARD_TYPE; + if (ctype != Col::CChar) + test.run(HStmt(hStmt), SQLGetData(hStmt, 1 + j, ctype, fld.caddr(), col.csize(), fld.ind())); + else { + // get in pieces + unsigned size = col.csize() - 1; // omit null terminator + char* caddr = (char*)(fld.caddr()); + unsigned off = 0; + while (off < size) { + unsigned m = size / 3; // bytes to get + if (m == 0) + m = 1; + if (m > size - off) + m = size - off; + bool getNull = (rowRef.m_fldList[j].m_ind == SQL_NULL_DATA); + if (off + m < size && ! getNull) + test.exp(SQL_SUCCESS_WITH_INFO, "01004", -1, true); + // include null terminator in buffer size + test.run(HStmt(hStmt), SQLGetData(hStmt, 1 + j, ctype, caddr + off, m + 1, fld.ind())); + int ind = *fld.ind(); + if (getNull) { + test.chk(HStmt(hStmt), ind == SQL_NULL_DATA, "got %d", ind); + break; + } + test.chk(HStmt(hStmt), ind == size - off, "got %d != %u", ind, size - off); + off += m; + } + } + } + rowRef.calcPk(test, k); + test.chk(HStmt(hStmt), rowGet.verifyPk(test, rowRef), "verify row=%d", k); + if (test.m_const) + rowRef.calcPk(test, 0); + rowRef.calcNk(test); + test.chk(HStmt(hStmt), rowGet.verifyNk(test, rowRef), "verify row=%d", k); + // SQLGetData again + for (unsigned j = 0; j < tab.m_colCount; j++) { + Fld& fld = rowGet.m_fldList[j]; + const Col& col = fld.m_col; + // test both variants + SQLSMALLINT ctype = k % 2 == 0 ? col.ctype() : SQL_ARD_TYPE; + // expect no more data + test.exp(SQL_NO_DATA, 0, 0, true); + test.run(HStmt(hStmt), SQLGetData(hStmt, 1 + j, ctype, fld.caddr(), col.csize(), fld.ind())); + } + } + test.run(HStmt(hStmt), SQLCloseCursor(hStmt)); + } + test.timerCnt(opt.m_scale); + if (opt.m_v >= 3) + ndbout << "verified " << opt.m_scale << " from " << tab.m_name << endl; + } + freeAll(test, hEnv, hDbc, hStmtList, tabCount); +} + +static void +testVerifyScan(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmtList[tabCount]; + allocAll(test, hEnv, hDbc, hStmtList, tabCount); + char sql[MAX_SQL], *sqlptr; + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + // prepare + tab.selectRange(sqlptr = sql, ! opt.m_nosort); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS)); + // bind parameters + Row rowlo(tab); // use available PK fields.. + Row rowhi(tab); // since we have no other way for now + SQLSMALLINT parCount = -1; + test.run(HStmt(hStmt), SQLNumParams(hStmt, &parCount)); + test.chk(HStmt(hStmt), parCount == 2 * tab.m_pkCount, "got %d != %d", (int)parCount, 2 * (int)tab.m_pkCount); + for (unsigned j = 0; j < tab.m_pkCount; j++) { + const Col& col = tab.m_colList[tab.m_pkIndex[j]]; + Fld& fldlo = rowlo.m_fldList[tab.m_pkIndex[j]]; + 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())); + Fld& fldhi = rowhi.m_fldList[tab.m_pkIndex[j]]; + 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())); + } + // bind columns + Row row(tab); + SQLSMALLINT colCount = -1; + test.run(HStmt(hStmt), SQLNumResultCols(hStmt, &colCount)); + test.chk(HStmt(hStmt), colCount == tab.m_colCount, "got %d != %d", (int)colCount, (int)tab.m_colCount); + for (unsigned j = 0; j < tab.m_colCount; j++) { + Fld& fld = row.m_fldList[j]; + const Col& col = fld.m_col; + test.run(HStmt(hStmt), SQLBindCol(hStmt, 1 + j, col.ctype(), fld.caddr(), col.csize(), fld.ind())); + } + // execute + rowlo.calcPk(test, 0); + rowhi.calcPk(test, test.m_mul); // sucks + test.run(HStmt(hStmt), SQLExecute(hStmt)); + test.chk(HStmt(hStmt), test.m_functionCode == SQL_DIAG_SELECT_CURSOR, "got %d != %d", test.m_functionCode, SQL_DIAG_SELECT_CURSOR); + // reference row + Row rowRef(tab); + // fetch + unsigned k = 0; + SQLUINTEGER rowCount1 = (SQLUINTEGER)-1; + test.run(HStmt(hStmt), SQLSetStmtAttr(hStmt, SQL_ATTR_ROWS_FETCHED_PTR, &rowCount1, SQL_IS_POINTER)); + while (1) { + unsigned countExp; + if (k == opt.m_scale) { + countExp = k; + test.exp(SQL_NO_DATA, 0, 0, true); + } else { + countExp = k + 1; + } + test.run(HStmt(hStmt), SQLFetch(hStmt)); + // let me count the ways.. + chkRowCount(test, hStmt, countExp); + test.chk(HStmt(hStmt), rowCount1 == countExp, "got %lu != %u", rowCount1, countExp); + SQLUINTEGER rowCount2 = (SQLUINTEGER)-1; + test.run(HStmt(hStmt), SQLGetStmtAttr(hStmt, SQL_ATTR_ROW_NUMBER, &rowCount2, SQL_IS_POINTER, 0)); + test.chk(HStmt(hStmt), rowCount2 == countExp, "got %lu != %u", rowCount2, countExp); + if (k == opt.m_scale) + break; + if (! opt.m_nosort) { + // expecting k-th row + rowRef.calcPk(test, k); + test.chk(HStmt(hStmt), row.verifyPk(test, rowRef), "verify row=%d", k); + if (test.m_const) + rowRef.calcPk(test, 0); + rowRef.calcNk(test); + test.chk(HStmt(hStmt), row.verifyNk(test, rowRef), "verify row=%d", k); + } else { + // expecting random row + rowRef.copy(row); + test.chk(HStmt(hStmt), row.verifyNk(test, rowRef), "verify row=%d", k); + } + k++; + } + test.timerCnt(opt.m_scale); + if (opt.m_v >= 3) + ndbout << "verified " << opt.m_scale << " from " << tab.m_name << endl; + } + freeAll(test, hEnv, hDbc, hStmtList, tabCount); +} + +// self-join (scan followed by pk lookups) + +static void +testJoin(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmtList[tabCount]; + allocAll(test, hEnv, hDbc, hStmtList, tabCount); + char sql[MAX_SQL], *sqlptr; + for (unsigned cnt = opt.m_depth; cnt <= opt.m_depth; cnt++) { + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + tab.selectJoin(sqlptr = sql, cnt); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + } + unsigned k = 0; + while (1) { + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + if (k == opt.m_scale * opt.m_threads) + test.exp(SQL_NO_DATA, 0, 0, true); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + if (k == opt.m_scale * opt.m_threads) { + chkTuplesFetched(test, hStmt, k * opt.m_depth); + test.run(HStmt(hStmt), SQLCloseCursor(hStmt)); + } else { + chkTuplesFetched(test, hStmt, (k + 1) * opt.m_depth); + test.timerCnt(1); + } + } + if (k == opt.m_scale * opt.m_threads) + break; + k++; + } + } + freeAll(test, hEnv, hDbc, hStmtList, tabCount); +} + +// cartesian join (multiple nested scans) + +static void +testCart(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmtList[tabCount]; + allocAll(test, hEnv, hDbc, hStmtList, tabCount); + char sql[MAX_SQL], *sqlptr; + for (unsigned cnt = 2; cnt <= 2; cnt++) { + unsigned rows = 1; + //for (unsigned k = 0; k < opt.m_depth; k++) { + //rows *= opt.m_scale * opt.m_threads; + //} + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + tab.selectCart(sqlptr = sql, cnt); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + } + unsigned k = 0; + while (1) { + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + if (k == rows) + test.exp(SQL_NO_DATA, 0, 0, true); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + if (k == rows) { + //chkTuplesFetched(test, hStmt, k); + test.run(HStmt(hStmt), SQLCloseCursor(hStmt)); + } else { + //chkTuplesFetched(test, hStmt, k + 1); + test.timerCnt(1); + } + } + if (k == rows) + break; + k++; + } + } + freeAll(test, hEnv, hDbc, hStmtList, tabCount); +} + +// delete + +static void +testDeleteAll(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmtList[tabCount]; + allocAll(test, hEnv, hDbc, hStmtList, tabCount); + char sql[MAX_SQL], *sqlptr; + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + long count0 = -1; + selectCount(test, hStmt, tab, &count0); + tab.deleteAll(sqlptr = sql); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS)); + if (count0 == 0) + test.exp(SQL_NO_DATA, 0, 0, true); + test.run(HStmt(hStmt), SQLExecute(hStmt)); +#ifndef iODBC + test.chk(HStmt(hStmt), test.m_functionCode == SQL_DIAG_DELETE_WHERE, "got %d != %d", test.m_functionCode, SQL_DIAG_DELETE_WHERE); +#endif + SQLINTEGER rowCount = -1; + getRowCount(test, hStmt, &rowCount); + test.timerCnt(rowCount); + test.chk(HStmt(hStmt), rowCount == count0, "got %d != %ld", (int)rowCount, count0); + chkTuplesFetched(test, hStmt, rowCount); + if (opt.m_v >= 3) + ndbout << "deleted " << (int)rowCount << " from " << tab.m_name << endl; + long count = -1; + selectCount(test, hStmt, tab, &count); + test.chk(HStmt(hStmt), count == 0, "got %ld != 0", count); + } + freeAll(test, hEnv, hDbc, hStmtList, tabCount); +} + +static void +testDeletePk(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmtList[tabCount]; + allocAll(test, hEnv, hDbc, hStmtList, tabCount); + char sql[MAX_SQL], *sqlptr; + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + // prepare + tab.deletePk(sqlptr = sql); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS)); + // bind parameters + Row row(tab); + SQLSMALLINT parCount = -1; + test.run(HStmt(hStmt), SQLNumParams(hStmt, &parCount)); + test.chk(HStmt(hStmt), parCount == tab.m_pkCount, "got %d != %d", (int)parCount, (int)tab.m_colCount); + for (unsigned j = 0; j < tab.m_pkCount; j++) { + Fld& fld = row.m_fldList[tab.m_pkIndex[j]]; + const Col& col = fld.m_col; + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + j, SQL_PARAM_INPUT, col.ctype(), col.type(), col.size(), 0, fld.caddr(), col.csize(), fld.ind())); + } + // bind columns (none) + SQLSMALLINT colCount = -1; + test.run(HStmt(hStmt), SQLNumResultCols(hStmt, &colCount)); + test.chk(HStmt(hStmt), colCount == 0, "got %d != 0", (int)colCount); + // execute + for (unsigned k = 0; k < opt.m_scale; k++) { + row.calcPk(test, k); + test.run(HStmt(hStmt), SQLExecute(hStmt)); + test.chk(HStmt(hStmt), test.m_functionCode == SQL_DIAG_DELETE_WHERE, "got %d != %d", test.m_functionCode, SQL_DIAG_DELETE_WHERE); + chkRowCount(test, hStmt, 1); + // direct delete, no fetch required + chkTuplesFetched(test, hStmt, 0); + } + test.timerCnt(opt.m_scale); + if (opt.m_v >= 3) + ndbout << "updated " << opt.m_scale << " in " << tab.m_name << endl; + } + freeAll(test, hEnv, hDbc, hStmtList, tabCount); +} + +static void +testTrans(Test& test) +{ +#ifdef unixODBC + if (opt.m_v >= 1) + ndbout << "unixODBC does not support transactions - test skipped" << endl; +#else + SQLHANDLE hEnv, hDbc, hStmtList[tabCount]; + allocAll(test, hEnv, hDbc, hStmtList, tabCount); + char sql[MAX_SQL], *sqlptr; + // delete all + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + tab.deleteAll(sqlptr = sql); + test.exp(SQL_NO_DATA, 0, 0, false); + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + SQLINTEGER rowCount = -1; + getRowCount(test, hStmt, &rowCount); + if (opt.m_v >= 3) + ndbout << "deleted " << (int)rowCount << " from " << tab.m_name << endl; + } + setAutocommit(test, hDbc, false); + if (opt.m_v >= 2) + ndbout << "set autocommit OFF" << endl; + for (int commit = 0; commit < opt.m_scale; commit += 1) { + bool rollback = (commit % 2 == 0); + // XXX delete with no data leaves trans in error state for 2nd table + if (commit > 0 && rollback) { // previous case was commit + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + tab.deleteDirect(sqlptr = sql, 0); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.exp(SQL_NO_DATA, 0, 0, false); + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + } + test.run(HDbc(hDbc), SQLEndTran(SQL_HANDLE_DBC, hDbc, SQL_COMMIT)); + } + // insert + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + tab.insertDirect(sqlptr = sql, 0); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + if (opt.m_v >= 2) + ndbout << tab.m_name << ": inserted 1 row" << endl; + } + // count them via pk + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + tab.countDirect(sqlptr = sql, 0); + long count = -1; + long countExp = 1; + selectCount(test, hStmt, sql, &count); + test.chk(HStmt(hStmt), count == countExp, "got %ld != %ld", count, countExp); + } + // count them via scan + for (unsigned i = 0; i < tabCount; i++) { + // XXX hupp no work + break; + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + long count = -1; + long countExp = 1; + selectCount(test, hStmt, tab, &count); + test.chk(HStmt(hStmt), count == countExp, "got %ld != %ld", count, countExp); + } + // rollback or commit + if (rollback) { + if (opt.m_v >= 2) + ndbout << "end trans ROLLBACK" << endl; + test.run(HDbc(hDbc), SQLEndTran(SQL_HANDLE_DBC, hDbc, SQL_ROLLBACK)); + } else { + if (opt.m_v >= 2) + ndbout << "end trans COMMIT" << endl; + test.run(HDbc(hDbc), SQLEndTran(SQL_HANDLE_DBC, hDbc, SQL_COMMIT)); + } + // count them via pk again + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + tab.countDirect(sqlptr = sql, 0); + long count = -1; + long countExp = rollback ? 0 : 1; + selectCount(test, hStmt, sql, &count); + test.chk(HStmt(hStmt), count == countExp, "got %ld != %ld", count, countExp); + } + // count them via scan again + for (unsigned i = 0; i < tabCount; i++) { + // XXX hupp no work + break; + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + long count = -1; + long countExp = rollback ? 0 : 1; + selectCount(test, hStmt, tab, &count); + test.chk(HStmt(hStmt), count == countExp, "got %ld != %ld", count, countExp); + } + } + freeAll(test, hEnv, hDbc, hStmtList, tabCount); +#endif +} + +static void +testConcur(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmtList[tabCount]; + allocAll(test, hEnv, hDbc, hStmtList, tabCount); + char sql[MAX_SQL], *sqlptr; + for (unsigned i = 0; i < tabCount; i++) { + SQLHANDLE& hStmt = hStmtList[i]; + const Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + // delete all + tab.deleteAll(sqlptr = sql); + test.exp(SQL_NO_DATA, 0, 0, false); + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + // insert some + unsigned rowcount = 10; + for (unsigned n = 0; n < rowcount; n++) { + tab.insertDirect(sqlptr = sql, n); + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + } + verifyCount(test, hStmt, tab, rowcount); + // start query scan followed by pk lookups + tab.selectJoin(sqlptr = sql, 2); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + // start fetch + unsigned k = 0; + while (1) { + if (k > 0) + test.exp(SQL_ERROR, "24000", -1, true); // commit closed cursor + test.run(HStmt(hStmt), SQLFetch(hStmt)); + if (k > 0) + break; + // delete some random row + tab.deleteDirect(sqlptr = sql, k); + // try using same statement + test.exp(SQL_ERROR, "24000", -1, true); // cursor is open + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + // try using different statement + SQLHANDLE hStmt2; + allocStmt(test, hDbc, hStmt2); + test.run(HStmt(hStmt2), SQLExecDirect(hStmt2, (SQLCHAR*)sql, SQL_NTS)); + k++; + } + test.exp(SQL_ERROR, "24000", -1, true); // cursor is not open + test.run(HStmt(hStmt), SQLCloseCursor(hStmt)); + test.timerCnt(rowcount); + } + freeAll(test, hEnv, hDbc, hStmtList, tabCount); +} + +static void +testReadcom(Test& test) +{ + testDeleteAll(test); + testInsert(test); + const unsigned nc = 3; + SQLHANDLE hEnv[nc], hDbc[nc], hStmt[nc]; + char sql[MAX_SQL], *sqlptr; + for (unsigned j = 0; j < nc; j++) + allocAll(test, hEnv[j], hDbc[j], hStmt[j]); + for (unsigned i = 0; i < tabCount; i++) { + Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + long count; + // check count + count = -1; + selectCount(test, hStmt[0], tab, &count); + test.chk(HStmt(hStmt[0]), count == opt.m_scale, "got %d != %d", (int)count, (int)opt.m_scale); + // scan delete uncommitted with handle 0 + setAutocommit(test, hDbc[0], false); + tab.deleteAll(sqlptr = sql); + if (opt.m_scale == 0) + test.exp(SQL_NO_DATA, 0, 0, false); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt[0]), SQLExecDirect(hStmt[0], (SQLCHAR*)sql, SQL_NTS)); + // scan via other tx should not hang and see all rows + for (unsigned j = 0; j < nc; j++) { + count = -1; + int want = j == 0 ? 0 : opt.m_scale; + selectCount(test, hStmt[j], tab, &count); + test.chk(HStmt(hStmt[j]), count == want, "tx %u: got %d != %d", j, (int)count, want); + if (opt.m_v >= 2) + ndbout << "tx " << j << " ok !" << endl; + } + // setting autocommit on commits the delete + setAutocommit(test, hDbc[0], true); + // check count + count = -1; + selectCount(test, hStmt[0], tab, &count); + test.chk(HStmt(hStmt[0]), count == 0, "got %d != 0", (int)count); + } + for (unsigned j = 0; j < nc; j++) + freeAll(test, hEnv[j], hDbc[j], hStmt[j]); +} + +static void +testPerf(Test& test) +{ + if (test.m_stuff == 0) { + SQLHANDLE hEnv, hDbc, hStmt; + allocAll(test, hEnv, hDbc, hStmt); + char sql[MAX_SQL], *sqlptr; + for (unsigned i = 0; i < tabCount; i++) { + Tab& tab = tabList[i]; + if (! tab.optok()) + continue; + test.exp(SQL_NO_DATA, 0, 0, false); + tab.deleteAll(sqlptr = sql); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + long count0 = -1; + // XXX triggers SEGV somewhere + //selectCount(test, hStmt, tab, &count0); + //test.chk(HStmt(hStmt), count0 == 0, "got %d != 0", (int)count0); + } + freeAll(test, hEnv, hDbc, hStmt); + return; + } + assert(test.m_stuff == 1 || test.m_stuff == 2); + bool ndbapi = (test.m_stuff == 1); + tt01: { + const unsigned OFF = 1000000; + const unsigned N = 25; + Tab& tab = tabList[1]; + if (! tab.optok()) + goto out; + if (ndbapi) { +#ifndef ndbODBC + if (opt.m_v >= 1) + ndbout << "running via DM - test skipped" << endl; +#else + Ndb* ndb = new Ndb("TEST_DB"); + ndb->init(); + if (ndb->waitUntilReady() != 0) { + ndbout << ndb->getNdbError() << endl; + fatal("waitUntilReady"); + } + Uint32 val[1+N]; + // insert + for (unsigned k = 1; k <= opt.m_scale; k++) { + NdbConnection* con = ndb->startTransaction(); + if (con == 0) { + ndbout << ndb->getNdbError() << endl; + fatal("startTransaction"); + } + NdbOperation* op = con->getNdbOperation(tab.m_upperName); + if (op == 0) { + ndbout << con->getNdbError() << endl; + fatal("getNdbOperation"); + } + if (op->insertTuple() == -1) { + ndbout << op->getNdbError() << endl; + fatal("insertTuple"); + } + for (unsigned j = 0; j <= N; j++) { + val[j] = (j == 0 ? k + test.m_no * OFF : k * j); + if (j == 0) { + if (op->equal(j, val[j]) == -1) { + ndbout << op->getNdbError() << endl; + fatal("equal"); + } + } else { + if (op->setValue(j, val[j]) == -1) { + ndbout << op->getNdbError() << endl; + fatal("setValue"); + } + } + } + if (con->execute(Commit) == -1) { + ndbout << con->getNdbError() << endl; + fatal("execute"); + } + ndb->closeTransaction(con); + } + test.timerCnt(opt.m_scale); + // select PK + for (unsigned k = 1; k <= opt.m_scale; k++) { + NdbConnection* con = ndb->startTransaction(); + if (con == 0) { + ndbout << ndb->getNdbError() << endl; + fatal("startTransaction"); + } + NdbOperation* op = con->getNdbOperation(tab.m_upperName); + if (op == 0) { + ndbout << con->getNdbError() << endl; + fatal("getNdbOperation"); + } + if (op->readTuple() == -1) { + ndbout << op->getNdbError() << endl; + fatal("insertTuple"); + } + for (unsigned j = 0; j <= N; j++) { + val[j] = (j == 0 ? k + test.m_no * OFF : 0); + if (j == 0) { + if (op->equal(j, val[j]) == -1) { + ndbout << op->getNdbError() << endl; + fatal("equal"); + } + } else { + if (op->getValue(j, (char*)&val[j]) == 0) { + ndbout << op->getNdbError() << endl; + fatal("getValue"); + } + } + } + if (con->execute(Commit) == -1) { + ndbout << con->getNdbError() << endl; + fatal("execute"); + } + for (unsigned j = 1; j <= N; j++) { + assert(val[j] == k * j); + } + ndb->closeTransaction(con); + } + test.timerCnt(opt.m_scale); + // delete PK + for (unsigned k = 1; k <= opt.m_scale; k++) { + NdbConnection* con = ndb->startTransaction(); + if (con == 0) { + ndbout << ndb->getNdbError() << endl; + fatal("startTransaction"); + } + NdbOperation* op = con->getNdbOperation(tab.m_upperName); + if (op == 0) { + ndbout << con->getNdbError() << endl; + fatal("getNdbOperation"); + } + if (op->deleteTuple() == -1) { + ndbout << op->getNdbError() << endl; + fatal("deleteTuple"); + } + unsigned j = 0; + val[j] = k + test.m_no * OFF; + if (op->equal(j, val[j]) == -1) { + ndbout << op->getNdbError() << endl; + fatal("equal"); + } + if (con->execute(Commit) == -1) { + ndbout << con->getNdbError() << endl; + fatal("execute"); + } + ndb->closeTransaction(con); + } + test.timerCnt(opt.m_scale); + delete ndb; +#endif + } else { + SQLHANDLE hEnv, hDbc, hStmt; + allocAll(test, hEnv, hDbc, hStmt); + long val[1+N]; + char sql[MAX_SQL], *sqlptr; + // insert + tab.insertAll(sqlptr = sql); + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS)); + for (unsigned j = 0; j <= N; j++) { + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + j, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &val[j], 0, 0)); + } + test.m_perf = true; + for (unsigned k = 1; k <= opt.m_scale; k++) { + for (unsigned j = 0; j <= N; j++) { + val[j] = (j == 0 ? k + test.m_no * OFF : k * j); + } + test.run(HStmt(hStmt), SQLExecute(hStmt)); + } + test.m_perf = false; + test.timerCnt(opt.m_scale); + // select PK + tab.selectPk(sqlptr = sql); + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS)); + for (unsigned j = 0; j <= N; j++) { + test.run(HStmt(hStmt), SQLBindCol(hStmt, 1 + j, SQL_C_SLONG, &val[j], 0, 0)); + } + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + N + 1, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &val[0], 0, 0)); + test.m_perf = true; + for (unsigned k = 1; k <= opt.m_scale; k++) { + val[0] = k + test.m_no * OFF; + test.run(HStmt(hStmt), SQLExecute(hStmt)); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + for (unsigned j = 1; j <= N; j++) { + assert(val[j] == k * j); + } + test.run(HStmt(hStmt), SQLCloseCursor(hStmt)); + } + test.m_perf = false; + test.timerCnt(opt.m_scale); + // delete PK + tab.deletePk(sqlptr = sql); + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS)); + unsigned j = 0; + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1 + j, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &val[j], 0, 0)); + test.m_perf = true; + for (unsigned k = 1; k <= opt.m_scale; k++) { + val[j] = k + test.m_no * OFF; + test.run(HStmt(hStmt), SQLExecute(hStmt)); + } + test.m_perf = false; + test.timerCnt(opt.m_scale); + freeAll(test, hEnv, hDbc, hStmt); + } + out: + ; + } +} + +struct Sql { + const char* m_sql; + int m_functionCode; + int m_rowCount; + int m_tuplesFetched; + long m_lastValue; + unsigned long m_bindValue; + int m_ret; + const char* m_state; + SQLINTEGER m_native; + bool m_reset; + // run this function instead + typedef void (*TestFunc)(Test& test); + TestFunc m_testFunc; + Sql() : + m_sql(0) { + } + Sql(const char* do_cmd) : + m_sql(do_cmd) { + } + Sql(const char* sql, int functionCode, int rowCount, int tuplesFetched, long lastValue, long bindValue) : + m_sql(sql), + m_functionCode(functionCode), + m_rowCount(rowCount), + m_tuplesFetched(tuplesFetched), + m_lastValue(lastValue), + m_bindValue(bindValue), + m_ret(SQL_SUCCESS), + m_state(0), + m_native(0), + m_reset(true), + m_testFunc(0) { + } + // the 4 numbers after SQL_DIAG... rowCount tuplesFetched lastValue bindValue + Sql(const char* sql, int functionCode, int rowCount, int tuplesFetched, long lastValue, long bindValue, int ret, const char* state, SQLINTEGER native, bool reset) : + m_sql(sql), + m_functionCode(functionCode), + m_rowCount(rowCount), + m_tuplesFetched(tuplesFetched), + m_lastValue(lastValue), + m_bindValue(bindValue), + m_ret(ret), + m_state(state), + m_native(native), + m_reset(reset), + m_testFunc(0) { + } + Sql(const char* text, TestFunc testFunc) : + m_sql(text), + m_testFunc(testFunc) { + } + static const char* set_autocommit_on() { + return "set autocommit on"; + } + static const char* set_autocommit_off() { + return "set autocommit off"; + } + static const char* do_commit() { + return "commit"; + } + static const char* do_rollback() { + return "rollback"; + } +}; + +// 90 + +static const Sql +miscSql90[] = { + Sql("select * from dual", + SQL_DIAG_SELECT_CURSOR, 1, 0, -1, -1), + Sql("drop table tt90a", + SQL_DIAG_DROP_TABLE, -1, 0, -1, -1, + SQL_ERROR, "IM000", 2040709, false), + Sql("create table tt90a (a int, b int, c int, primary key(b, c)) storage(large) logging", + SQL_DIAG_CREATE_TABLE, -1, 0, -1, -1), + Sql() +}; + +// 91 + +static const Sql +miscSql91[] = { + Sql("drop table tt91a", + SQL_DIAG_DROP_TABLE, -1, 0, -1, -1, + SQL_ERROR, "IM000", 2040709, false), + Sql("create table tt91a (a bigint unsigned primary key, b bigint unsigned not null, c varchar(10))", + SQL_DIAG_CREATE_TABLE, -1, 0, -1, -1), + Sql("insert into tt91a values (1, 111, 'aaa')", + SQL_DIAG_INSERT, 1, 0, -1, -1), + // fails + Sql("insert into tt91a values (2, null, 'ccc')", + SQL_DIAG_INSERT, -1, 0, -1, -1, + SQL_ERROR, "IM000", 2014203, true), + Sql("update tt91a set b = 222 where a = 2", + SQL_DIAG_UPDATE_WHERE, 0, 0, -1, -1, + SQL_NO_DATA, 0, 0, true), + // two more + Sql("insert into tt91a values (2, 222, 'ccc')", + SQL_DIAG_INSERT, 1, 0, -1, -1), + Sql("insert into tt91a values (3, 333, 'bbb')", + SQL_DIAG_INSERT, 1, 0, -1, -1), + // direct update + Sql("update tt91a set b = 112 where a = 1", + SQL_DIAG_UPDATE_WHERE, 1, 0, -1, -1), + Sql("update tt91a set b = 113 where a = 1 and b > 111", + SQL_DIAG_UPDATE_WHERE, 1, 1, -1, -1), + // update and delete with interpreted scan + Sql("update tt91a set b = 114 where b < 114", + SQL_DIAG_UPDATE_WHERE, 1, 1, -1, -1), + Sql("delete from tt91a where b < 115", + SQL_DIAG_DELETE_WHERE, 1, 1, -1, -1), + Sql("insert into tt91a values (1, 111, 'aaa')", + SQL_DIAG_INSERT, 1, 0, -1, -1), + // check rows: 1,111,aaa + 2,222,ccc + 3,333,bbb + Sql("select * from tt91a order by c", + SQL_DIAG_SELECT_CURSOR, 3, 3, 2, -1), + Sql("select * from tt91a order by c desc", + SQL_DIAG_SELECT_CURSOR, 3, 3, 1, -1), + Sql("select * from tt91a where a = 2", + SQL_DIAG_SELECT_CURSOR, 1, 1, -1, -1), + Sql("select * from tt91a where a + b = 224", + SQL_DIAG_SELECT_CURSOR, 1, 3, -1, -1), + Sql("select * from tt91a where a = 4", + SQL_DIAG_SELECT_CURSOR, 0, 0, -1, -1), + Sql("select b-a from tt91a order by a-b", + SQL_DIAG_SELECT_CURSOR, 3, 3, 110, -1), + Sql("select sum(a+b) from tt91a", + SQL_DIAG_SELECT_CURSOR, 1, 3, 672, -1), + Sql("select x.b, y.b, z.b from tt91a x, tt91a y, tt91a z where x.b <= y.b and y.b < z.b order by x.b", + SQL_DIAG_SELECT_CURSOR, 4, 13, 222, -1), + Sql("select x.b, y.b, z.b from tt91a x, tt91a y, tt91a z where x.b + y.b = z.b order by x.b", + SQL_DIAG_SELECT_CURSOR, 3, 15, 222, -1), + // tmp index + Sql("create unique hash index xx91a on tt91a(b)", + SQL_DIAG_CREATE_INDEX, -1, -1, -1, -1), + Sql("select x.b, y.b, z.b from tt91a x, tt91a y, tt91a z where x.b + y.b = z.b order by x.b", + SQL_DIAG_SELECT_CURSOR, 3, 15, 222, -1), + Sql("drop index xx91a on tt91a", + SQL_DIAG_DROP_INDEX, -1, -1, -1, -1), + // add some duplicates + Sql("insert into tt91a values (4, 222, 'ccc')", + SQL_DIAG_INSERT, 1, -1, -1, -1), + Sql("insert into tt91a values (5, 333, 'bbb')", + SQL_DIAG_INSERT, 1, -1, -1, -1), + Sql("insert into tt91a values (6, 333, 'bbb')", + SQL_DIAG_INSERT, 1, -1, -1, -1), + // check rows: 1,111,aaa + 2 * 2,222,ccc + 3 * 3,333,bbb + Sql("select count(*) from tt91a", + SQL_DIAG_SELECT_CURSOR, 1, -1, 6, -1), + Sql("select a+b from tt91a where (b = 111 or b = 222 ) and (b = 222 or b = 333) and a > 1 and a < 3", + SQL_DIAG_SELECT_CURSOR, 1, -1, 224, -1), + Sql("select sum(a) from tt91a having min(a) = 1 and max(a) = 6", + SQL_DIAG_SELECT_CURSOR, 1, -1, 21, -1), + Sql("select sum(a) from tt91a where a = 2 or a = 4 having min(a) = 2 and max(a) = 4", + SQL_DIAG_SELECT_CURSOR, 1, -1, 6, -1), + Sql("select sum(a) from tt91a having min(a) = 1 and max(a) = 5", + SQL_DIAG_SELECT_CURSOR, 0, -1, -1, -1), + Sql("select sum(a), b from tt91a group by b order by b", + SQL_DIAG_SELECT_CURSOR, 3, -1, 14, -1), + Sql("select sum(a), b, c from tt91a group by b, c order by c", + SQL_DIAG_SELECT_CURSOR, 3, -1, 6, -1), + Sql("select b, sum(a) from tt91a group by b having b = 37 * sum(a)", + SQL_DIAG_SELECT_CURSOR, 1, -1, 222, -1), + // simple varchar vs interpreter test + Sql("select count(*) from tt91a where c = 'ccc'", + SQL_DIAG_SELECT_CURSOR, 1, 2, 2, -1), + Sql("select count(*) from tt91a where c like '%b%'", + SQL_DIAG_SELECT_CURSOR, 1, 3, 3, -1), + // interpreter limits (crashes in api on v211) +#if NDB_VERSION_MAJOR >= 3 + Sql("select count(*) from tt91a where a in (99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2)", + SQL_DIAG_SELECT_CURSOR, 1, 5, 5, -1), + Sql("select count(*) from tt91a where c in ('xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','bbb','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy','zzzzz','xxxxx','yyyyy')", + SQL_DIAG_SELECT_CURSOR, 1, 3, 3, -1), +#endif + // distinct + Sql("select distinct b from tt91a order by b", + SQL_DIAG_SELECT_CURSOR, 3, -1, 333, -1), + // some illegal groupings + Sql("select a from tt91a group by b", + -1, -1, -1, -1, -1, + SQL_ERROR, "IM000", -1, -1), + Sql("select sum(a) from tt91a group by b having a = 2", + -1, -1, -1, -1, -1, + SQL_ERROR, "IM000", -1, -1), + Sql("select sum(a) from tt91a group by b order by a", + -1, -1, -1, -1, -1, + SQL_ERROR, "IM000", -1, -1), + // string functions + Sql("insert into tt91a (c, b, a) values ('abcdef', 999, 9)", + SQL_DIAG_INSERT, 1, -1, -1, -1), + Sql("select count(*) from tt91a where left(c, 2) = 'ab' and substr(c, 3, 2) = 'cd' and right(c, 2) = 'ef'", + SQL_DIAG_SELECT_CURSOR, 1, -1, 1, -1), + // nulls + Sql("update tt91a set c = null where a > 8", + SQL_DIAG_UPDATE_WHERE, 1, -1, -1, -1), + Sql("select a from tt91a where c is null and b is not null order by a", + SQL_DIAG_SELECT_CURSOR, 1, -1, 9, -1), + Sql("select a from tt91a where not (c is not null or b is null) order by a", + SQL_DIAG_SELECT_CURSOR, 1, -1, 9, -1), + // null value guard in interpreter + Sql("select count(*) from tt91a where c < 'x' or c > 'x' or c != 'x' or c = 'x'", + SQL_DIAG_SELECT_CURSOR, 1, 6, 6, -1), + Sql("delete from tt91a where c is null", + SQL_DIAG_DELETE_WHERE, 1, -1, -1, -1), + // indexes + Sql("update tt91a set b = a + 5", + SQL_DIAG_UPDATE_WHERE, 6, 6, -1, -1), + Sql("create unique hash index xx91a on tt91a(b)", + SQL_DIAG_CREATE_INDEX, -1, -1, -1, -1), + // scan y primary key x + Sql("select x.b from tt91a x, tt91a y where x.a = y.b + 0", + SQL_DIAG_SELECT_CURSOR, 1, 7, 11, -1), + // scan x index y + Sql("select x.b from tt91a x, tt91a y where x.a + 0 = y.b", + SQL_DIAG_SELECT_CURSOR, 1, -1, 11, -1), + // scan x scan y + Sql("select x.b from tt91a x, tt91a y where x.a + 0 = y.b + 0", + SQL_DIAG_SELECT_CURSOR, 1, -1, 11, -1), + // dml ops + Sql("delete from tt91a where b = 11 and a > 999", + SQL_DIAG_DELETE_WHERE, 0, 1, -1, -1, + SQL_NO_DATA, 0, 0, true), + Sql("delete from tt91a where b = 11", + SQL_DIAG_DELETE_WHERE, 1, 0, -1, -1), + Sql("delete from tt91a where b = 11", + SQL_DIAG_DELETE_WHERE, 0, 0, -1, -1, + SQL_NO_DATA, 0, 0, true), + Sql("update tt91a set b = 10*10 where b = 10", + SQL_DIAG_UPDATE_WHERE, 1, 0, -1, -1), + Sql("update tt91a set b = 10 where b = 10*10", + SQL_DIAG_UPDATE_WHERE, 1, 0, -1, -1), + Sql("update tt91a set b = 10*10 where b = 10 and b >= 10", + SQL_DIAG_UPDATE_WHERE, 1, 1, -1, -1), + Sql("update tt91a set b = 10 where b = 10*10 and b >= 10*10", + SQL_DIAG_UPDATE_WHERE, 1, 1, -1, -1), + // char vs varchar + Sql("drop table tt91b", + SQL_DIAG_DROP_TABLE, -1, -1, -1, -1, + SQL_ERROR, "IM000", 2040709, false), + Sql("create table tt91b (a int primary key, b char(5), c varchar(5))", + SQL_DIAG_CREATE_TABLE, -1, -1, -1, -1), + Sql("insert into tt91b values (1, 'abc', 'abc')", + SQL_DIAG_INSERT, 1, -1, -1, -1), + Sql("insert into tt91b values (2, 'xyz', 'xyz')", + SQL_DIAG_INSERT, 1, -1, -1, -1), + Sql("insert into tt91b values (3, 'xyz', 'xyz ')", + SQL_DIAG_INSERT, 1, -1, -1, -1), + // char = char strips blanks + Sql("select count(*) from tt91b x where (x.b = 'abc') or x.a = x.a+1", + SQL_DIAG_SELECT_CURSOR, 1, 3, 1, -1), + Sql("select count(*) from tt91b x where (x.b = 'abc')", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1, -1), + Sql("select count(*) from tt91b x where (x.b = 'abc ') or x.a = x.a+1", + SQL_DIAG_SELECT_CURSOR, 1, 3, 1, -1), + Sql("select count(*) from tt91b x where (x.b = 'abc ')", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1, -1), + // varchar = char + Sql("select count(*) from tt91b x where (x.c = 'abc') or x.a = x.a+1", + SQL_DIAG_SELECT_CURSOR, 1, 3, 1, -1), + Sql("select count(*) from tt91b x where (x.c = 'abc')", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1, -1), + Sql("select count(*) from tt91b x where (x.c = 'abc ') or x.a = x.a+1", + SQL_DIAG_SELECT_CURSOR, 1, 3, 0, -1), + Sql("select count(*) from tt91b x where (x.c = 'abc ')", + SQL_DIAG_SELECT_CURSOR, 1, 0, 0, -1), + // char = varchar + Sql("select count(*) from tt91b x, tt91b y where (x.b = y.c) or x.a = x.a+1 or y.a = y.a+1", + SQL_DIAG_SELECT_CURSOR, 1, -1, 2, -1), + Sql("select count(*) from tt91b x, tt91b y where (x.b = y.c)", + SQL_DIAG_SELECT_CURSOR, 1, -1, 2, -1), + // varchar = varchar + Sql("select count(*) from tt91b x, tt91b y where (x.c = y.c) or x.a = x.a+1 or y.a = y.a+1", + SQL_DIAG_SELECT_CURSOR, 1, -1, 3, -1), + Sql("select count(*) from tt91b x, tt91b y where (x.c = y.c)", + SQL_DIAG_SELECT_CURSOR, 1, -1, 3, -1), + // less + Sql("select 10 * x.a + y.a from tt91b x, tt91b y where (x.b < y.b) or x.a = x.a+1 or y.a = y.a+1 order by x.a, y.a", + SQL_DIAG_SELECT_CURSOR, 2, -1, 13, -1), + Sql("select 10 * x.a + y.a from tt91b x, tt91b y where (x.b < y.b) order by x.a, y.a", + SQL_DIAG_SELECT_CURSOR, 2, -1, 13, -1), + Sql("select 10 * x.a + y.a from tt91b x, tt91b y where (x.c < y.c) or x.a = x.a+1 or y.a = y.a+1 order by x.a, y.a", + SQL_DIAG_SELECT_CURSOR, 3, -1, 23, -1), + Sql("select 10 * x.a + y.a from tt91b x, tt91b y where (x.c < y.c) order by x.a, y.a", + SQL_DIAG_SELECT_CURSOR, 3, -1, 23, -1), + // like + Sql("select count(*) from tt91b x where (x.b like 'a%') or x.a = x.a+1", + SQL_DIAG_SELECT_CURSOR, 1, 3, 1, -1), + Sql("select count(*) from tt91b x where (x.b like 'a%')", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1, -1), + Sql("select count(*) from tt91b x where (x.b like 'x%z') or x.a = x.a+1", + SQL_DIAG_SELECT_CURSOR, 1, 3, 0, -1), + Sql("select count(*) from tt91b x where (x.b like 'x%z')", + SQL_DIAG_SELECT_CURSOR, 1, 0, 0, -1), + Sql("select count(*) from tt91b x where (x.a+0 = 2 and x.c like 'x%z') or x.a = x.a+1", + SQL_DIAG_SELECT_CURSOR, 1, 3, 1, -1), + Sql("select count(*) from tt91b x where (x.a+0 = 2 and x.c like 'x%z')", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1, -1), + Sql("select count(*) from tt91b x where (x.a+0 = 3 and x.c like 'x%z ') or x.a = x.a+1", + SQL_DIAG_SELECT_CURSOR, 1, 3, 1, -1), + Sql("select count(*) from tt91b x where (x.a+0 = 3 and x.c like 'x%z ')", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1, -1), + Sql() +}; + +// 92 + +static void +testMisc92a(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmt; + allocAll(test, hEnv, hDbc, hStmt); + char sql[MAX_SQL]; + char tname[20]; + sprintf(tname, "tt92%c", 0140 + test.m_no); + if (test.m_loop == 1) { + lock_mutex(); + sprintf(sql, "drop table %s", tname); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.exp(SQL_ERROR, "IM000", 2040709, false); + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + sprintf(sql, "create table %s (a int unsigned primary key, b int unsigned not null)", tname); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + unlock_mutex(); + } else { + sprintf(sql, "delete from %s", tname); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.exp(SQL_NO_DATA, 0, 0, false); + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + test.run(HStmt(hStmt), SQLEndTran(SQL_HANDLE_DBC, hDbc, SQL_COMMIT)); + } + for (int on = true; on >= false; on--) { + if (opt.m_v >= 2) + ndbout << "set autocommit " << (on ? "ON" : "OFF") << endl; + setAutocommit(test, hDbc, on); + // insert rows + if (opt.m_v >= 2) + ndbout << "SQL: insert into " << tname << " ..." << opt.m_scale << endl; + for (unsigned k = 0; k < opt.m_scale; k++) { + sprintf(sql, "insert into %s values (%u, %u)", tname, k, 10 * k); + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + } + // commit always + test.run(HStmt(hStmt), SQLEndTran(SQL_HANDLE_DBC, hDbc, SQL_COMMIT)); + // scan delete + sprintf(sql, "delete from %s", tname); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + // rollback or commit + test.run(HStmt(hStmt), SQLEndTran(SQL_HANDLE_DBC, hDbc, on ? SQL_COMMIT : SQL_ROLLBACK)); + // count + long count = -1; + sprintf(sql, "select count(*) from %s", tname); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + selectCount(test, hStmt, sql, &count); + test.chk(HStmt(hStmt), count == on ? 0 : opt.m_scale, "%s: got %d != %d", tname, (int)count, (int)opt.m_scale); + } + freeAll(test, hEnv, hDbc, hStmt); +} + +static const Sql +miscSql92[] = { + // create in C func + Sql("testMisc92a", testMisc92a), + Sql() +}; + +// 93 + +static void +testMisc93a(Test& test) +{ + SQLHANDLE hEnv[2], hDbc[2], hStmt[2]; + allocAll(test, hEnv[0], hDbc[0], hStmt[0]); + allocAll(test, hEnv[1], hDbc[1], hStmt[1]); + char sql[MAX_SQL]; + // select via primary key + setAutocommit(test, hDbc[0], false); + sprintf(sql, "select c1 from tt93a where c0 = 1"); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt[0]), SQLExecDirect(hStmt[0], (SQLCHAR*)sql, SQL_NTS)); + // update via another trans must time out + sprintf(sql, "update tt93a set c1 = 'b' where c0 = 1"); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt[1]), SQLExecDirect(hStmt[1], (SQLCHAR*)sql, SQL_NTS)); + freeAll(test, hEnv[0], hDbc[0], hStmt[0]); + freeAll(test, hEnv[1], hDbc[1], hStmt[1]); +} + +static const Sql +miscSql93[] = { + // create in C func + Sql("drop table tt93a", + SQL_DIAG_DROP_TABLE, -1, 0, -1, -1, + SQL_ERROR, "IM000", 2040709, false), + Sql("create table tt93a (c0 int primary key, c1 char(10))", + SQL_DIAG_CREATE_TABLE, -1, 0, -1, -1), + Sql("insert into tt93a values(1, 'a')", + SQL_DIAG_INSERT, 1, 0, -1, -1), + Sql("testMisc93a", testMisc93a), + Sql() +}; + +// 95 + +static const Sql +miscSql95[] = { + Sql("drop table tt95a", + SQL_DIAG_DROP_TABLE, -1, 0, -1, -1, + SQL_ERROR, "IM000", 2040709, false), + Sql("create table tt95a (a int not null, b char(10) not null, c int not null, d char(10), primary key(a, b)) storage(small)", + SQL_DIAG_CREATE_TABLE, -1, 0, -1, -1), + // ordered index create and drop + Sql("create index xx95a on tt95a (c, d) nologging", + SQL_DIAG_CREATE_INDEX, -1, -1, -1, -1), + Sql("drop index xx95a on tt95a", + SQL_DIAG_DROP_INDEX, -1, -1, -1, -1), + Sql("create index xx95a on tt95a (c) nologging", + SQL_DIAG_CREATE_INDEX, -1, -1, -1, -1), + Sql("insert into tt95a values(1, 'a', 10, 'b')", + SQL_DIAG_INSERT, 1, -1, -1, -1), + Sql("insert into tt95a values(2, 'a', 20, 'b')", + SQL_DIAG_INSERT, 1, -1, -1, -1), + Sql("insert into tt95a values(3, 'a', 30, 'b')", + SQL_DIAG_INSERT, 1, -1, -1, -1), + Sql("select a from tt95a where c = 20", + SQL_DIAG_SELECT_CURSOR, 1, 1, 2, -1), + Sql("delete from tt95a where c = 10", + SQL_DIAG_DELETE_WHERE, 1, 1, -1, -1), + Sql("update tt95a set c = 300 where c = 30", + SQL_DIAG_UPDATE_WHERE, 1, 1, -1, -1), + Sql("delete from tt95a where c = 300", + SQL_DIAG_DELETE_WHERE, 1, 1, -1, -1), + Sql("delete from tt95a", + SQL_DIAG_DELETE_WHERE, 1, 1, -1, -1), + // simple insert and rollback + Sql("-- simple insert and rollback"), + Sql(Sql::set_autocommit_off()), + Sql("insert into tt95a values(1, 'a', 10, 'b')", + SQL_DIAG_INSERT, 1, -1, -1, -1), + Sql("select count(*) from tt95a", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1, -1), + Sql("select count(*) from tt95a where c = 10", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1, -1), + Sql(Sql::do_rollback()), + Sql(Sql::set_autocommit_on()), + Sql("select count(*) from tt95a", + SQL_DIAG_SELECT_CURSOR, 1, 0, 0, -1), + // simple update and rollback + Sql("-- simple update and rollback"), + Sql("insert into tt95a values(1, 'a', 10, 'b')", + SQL_DIAG_INSERT, 1, -1, -1, -1), + Sql(Sql::set_autocommit_off()), + Sql("update tt95a set c = 20 where c = 10", + SQL_DIAG_UPDATE_WHERE, 1, 1, -1, -1), + Sql("select count(*) from tt95a", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1, -1), + Sql("select count(*) from tt95a where c = 20", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1, -1), + Sql(Sql::do_rollback()), + Sql(Sql::set_autocommit_on()), + Sql("select count(*) from tt95a where c = 10", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1, -1), + // simple delete and rollback + Sql("-- simple delete and rollback"), + Sql(Sql::set_autocommit_off()), + Sql("delete from tt95a where c = 10", + SQL_DIAG_DELETE_WHERE, 1, 1, -1, -1), + Sql("select count(*) from tt95a", + SQL_DIAG_SELECT_CURSOR, 0, 0, 0, -1), + Sql("select count(*) from tt95a where c = 10", + SQL_DIAG_SELECT_CURSOR, 0, 0, 0, -1), + Sql(Sql::do_rollback()), + Sql(Sql::set_autocommit_on()), + Sql("select count(*) from tt95a where c = 10", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1, -1), + // multiple update + Sql("-- multiple update and rollback"), + Sql(Sql::set_autocommit_off()), + Sql("update tt95a set c = 20 where c = 10", + SQL_DIAG_UPDATE_WHERE, 1, 1, -1, -1), + Sql("select count(*) from tt95a where c = 20", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1, -1), + Sql("update tt95a set c = 30 where c = 20", + SQL_DIAG_UPDATE_WHERE, 1, 1, -1, -1), + Sql("select count(*) from tt95a where c = 30", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1, -1), + Sql("update tt95a set c = 40 where c = 30", + SQL_DIAG_UPDATE_WHERE, 1, 1, -1, -1), + Sql("select count(*) from tt95a where c = 40", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1, -1), + Sql("update tt95a set c = 50 where c = 40", + SQL_DIAG_UPDATE_WHERE, 1, 1, -1, -1), + Sql("select count(*) from tt95a where c = 50", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1, -1), + Sql(Sql::do_rollback()), + Sql(Sql::set_autocommit_on()), + Sql("select count(*) from tt95a where c = 10", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1, -1), + // another variant which found no tuple via index (aligment issue) + Sql("drop table tt95b", + SQL_DIAG_DROP_TABLE, -1, 0, -1, -1, + SQL_ERROR, "IM000", 2040709, false), + Sql("create table tt95b (a int primary key, b char(10) not null, c int not null)", + SQL_DIAG_CREATE_TABLE, -1, 0, -1, -1), + Sql("create index xx95b on tt95b (b, c) nologging", + SQL_DIAG_CREATE_INDEX, -1, -1, -1, -1), + Sql("insert into tt95b values(0,'0123456789',1)", + SQL_DIAG_INSERT, 1, -1, -1, -1), + Sql("select a from tt95b where b='0123456789'", + SQL_DIAG_SELECT_CURSOR, 1, 1, 0, -1), + // update index key to different value + Sql("update tt95b set b = '9876543210' where b = '0123456789'", + SQL_DIAG_UPDATE_WHERE, 1, 1, -1, -1), + // same value goes nuts... + Sql("update tt95b set b = '9876543210'", + SQL_DIAG_UPDATE_WHERE, 1, 1, -1, -1), +#if 0 + // ...if done via index key (variant of halloween problem) + Sql("update tt95b set b = '9876543210' where b = '9876543210'", + SQL_DIAG_UPDATE_WHERE, 1, 1, -1, -1), +#endif + Sql() +}; + +// 96 + +static void +testMisc96a(Test& test) +{ + // single thread + if (test.m_no != 1) + return; + SQLHANDLE hEnv, hDbc, hStmt; + allocAll(test, hEnv, hDbc, hStmt); + char sql[MAX_SQL], *sqlptr; + char tname[20]; + strcpy(tname, "tt96a"); + // drop table + scopy(sqlptr = sql, "drop table %s", tname); + test.exp(SQL_ERROR, "IM000", 2040709, false); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + // create table with many attributes + unsigned attrs = 1 + opt.m_scale; + if (attrs > MAX_ATTRIBUTES_IN_TABLE) + attrs = MAX_ATTRIBUTES_IN_TABLE; + if (attrs > 64) + attrs = 64; + scopy(sqlptr = sql, "create table %s (c0 int primary key", tname); + for (unsigned j = 1; j < attrs; j++) { + if (j % 2 == 0) + scopy(sqlptr, ", c%d int unsigned not null", j); + else + scopy(sqlptr, ", c%d char(10) not null", j); + } + scopy(sqlptr, ")"); + if (opt.m_fragtype != 0) + scopy(sqlptr, " storage(%s)", opt.m_fragtype); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + // create or drop indexes + const unsigned seed = 1000037 * test.m_loop + 1000039 * opt.m_scale; + srandom(seed); + const unsigned imax = opt.m_scale < 20 ? opt.m_scale : 20; + AttributeMask* imasks = new AttributeMask[imax]; + unsigned ccnt = 0; + unsigned dcnt = 0; + for (unsigned n = 0; n < imax; n++) + imasks[n].clear(); + while (ccnt + dcnt < opt.m_scale) { + char iname[20]; + unsigned n = urandom(imax); + sprintf(iname, "xx96a%02d", n); + AttributeMask& imask = imasks[n]; + unsigned sel = urandom(10); + if (imask.isclear()) { + // create one + unsigned ncol = 0; + unsigned cols[MAX_ATTRIBUTES_IN_INDEX]; + unsigned cnum = urandom(attrs); + cols[ncol++] = cnum; + while (ncol < MAX_ATTRIBUTES_IN_INDEX) { + unsigned sel2 = urandom(10); + if (sel2 < 2) + break; + unsigned cnum2 = urandom(attrs); + if (sel2 < 9 && cnum2 == 0) + continue; + unsigned j; + for (j = 0; j < ncol; j++) { + if (cols[j] == cnum2) + break; + } + if (j == ncol) + cols[ncol++] = cnum2; + } + if (sel < 3) { + scopy(sqlptr = sql, "create unique hash index %s on %s (", iname, tname); + for (unsigned j = 0; j < ncol; j++) + scopy(sqlptr, "%sc%d", j == 0 ? "" : ", ", cols[j]); + scopy(sqlptr, ")"); + } else { + scopy(sqlptr = sql, "create index %s on %s (", iname, tname); + for (unsigned j = 0; j < ncol; j++) + scopy(sqlptr, "%sc%d", j == 0 ? "" : ", ", cols[j]); + scopy(sqlptr, ") nologging"); + } + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + for (unsigned j = 0; j < ncol; j++) + imask.set(cols[j]); + ccnt++; + } else if (sel < 5 && ccnt > dcnt + 1) { + scopy(sqlptr = sql, "drop index %s on %s", iname, tname); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + imask.clear(); + dcnt++; + } + } + // insert unique data + unsigned rows = opt.m_scale; + unsigned* uval = new unsigned[rows]; + for (unsigned i = 0; i < rows; i++) { + uval[i] = urandom(4); + scopy(sqlptr = sql, "insert into %s values(", tname); + for (unsigned j = 0; j < attrs; j++) { + if (j != 0) + scopy(sqlptr, ","); + unsigned v = (i << 10) | (j << 2) | uval[i]; + if (j == 0) + scopy(sqlptr, "%u", i); + else if (j % 2 == 0) + scopy(sqlptr, "%u", v); + else + scopy(sqlptr, "'%010u'", v); + } + scopy(sqlptr, ")"); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + } + // update each row via random index + for (unsigned i = 0; i < rows; i++) { + unsigned uold = uval[i]; + uval[i] = 3 - uval[i]; + AttributeMask imask; + do { + unsigned j = urandom(imax); + imask = imasks[j]; + } while (imask.isclear()); + scopy(sqlptr = sql, "update %s set", tname); + for (unsigned j = 1; j < attrs; j++) { + if (j != 1) + scopy(sqlptr, ","); + /* + * Equality update is just barely doable before savepoints + * provided we change value of keys in every index. + */ + unsigned v = (i << 10) | (j << 2) | uval[i]; + if (j == 0) + ; + else if (j % 2 == 0) + scopy(sqlptr, " c%d=%u", j, v); + else + scopy(sqlptr, " c%d='%010u'", j, v); + } + scopy(sqlptr, " where 1=1"); + while (! imask.isclear()) { + unsigned j = urandom(attrs); + if (imask.get(j)) { + unsigned v = (i << 10) | (j << 2) | uold; + scopy(sqlptr, " and c%d=", j); + if (j == 0) + scopy(sqlptr, "%u", i); + else if (j % 2 == 0) + scopy(sqlptr, "%u", v); + else + scopy(sqlptr, "'%010u'", v); + imask.clear(j); + } + } + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + chkRowCount(test, hStmt, 1); + } + // delete all + scopy(sqlptr = sql, "delete from %s", tname); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + // + if (opt.m_v >= 2) + ndbout << tname << ": creates " << ccnt << " drops " << dcnt << endl; + delete [] imasks; + delete [] uval; + freeAll(test, hEnv, hDbc, hStmt); +} + +static const Sql +miscSql96[] = { + Sql("testMisc96a", testMisc96a), + Sql() +}; + +// 97 + +static void +testMisc97a(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmt; + allocAll(test, hEnv, hDbc, hStmt); + const char* tname = "TT97A"; + const char* iname = "XX97A"; + char sql[MAX_SQL]; + // create in some thread + lock_mutex(); + if (my_sema == 0) { + if (opt.m_v >= 1) + ndbout << "thread " << test.m_no << " does setup" << endl; + sprintf(sql, "drop table %s", tname); + if (opt.m_v >= 2) + ndbout << "SQL[" << test.m_no << "]: " << sql << endl; + test.exp(SQL_ERROR, "IM000", 2040709, false); + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + // a-pk b-index c-counter + sprintf(sql, "create table %s (a int primary key, b int, c int) storage(small)", tname); + if (opt.m_v >= 2) + ndbout << "SQL[" << test.m_no << "]: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + for (unsigned i = 0; i < opt.m_scale; i++) { + sprintf(sql, "insert into %s values (%d, %d, %d)", tname, i, 10 * i, 0); + if (opt.m_v >= 3) + ndbout << "SQL[" << test.m_no << "]: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + } + sprintf(sql, "create index %s on %s (b) nologging", iname, tname); + if (opt.m_v >= 2) + ndbout << "SQL[" << test.m_no << "]: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + my_sema = 1; + } + unlock_mutex(); + assert(my_sema == 1); + // parallel run - default rotating pk, ts, is + // frob: low 3 hex digits give alt sequence e.g. 0x311 = pk, pk, is + // frob: 4-th hex digit non-zero says use NDB API e.g. 0x1000 + unsigned typelist[3] = { 1, 2, 3 }; + for (unsigned i = 0; i < 3; i++) { + unsigned t = (opt.m_frob >> (i * 4)) & 0xf; + if (t != 0) + typelist[i] = t; + } + unsigned type = typelist[(test.m_no - 1) % 3]; + if ((opt.m_frob & 0xf000) == 0) { + for (unsigned i = 0; i < opt.m_scale; i++) { + if (type == 1) { + // pk update + sprintf(sql, "update %s set c = c + 1 where a = %d", tname, i % opt.m_scale); + if (opt.m_v >= 3) + ndbout << lock << "SQL[" << test.m_no << "]: " << sql << endl << unlock; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + } + if (type == 2) { + // table scan update + sprintf(sql, "update %s set c = c + 1 where b + 0 = %d", tname, 10 * i); + if (opt.m_v >= 3) + ndbout << lock << "SQL[" << test.m_no << "]: " << sql << endl << unlock; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + } + if (type == 3) { + // index scan update + sprintf(sql, "update %s set c = c + 1 where b = %d", tname, 10 * i); + if (opt.m_v >= 3) + ndbout << lock << "SQL[" << test.m_no << "]: " << sql << endl << unlock; + test.exp(SQL_NO_DATA, 0, 0, false); + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + } + } + } else { +#ifdef ndbODBC +#define CHK(o, x) do { if (! (x)) { fatal("line %d: %d %s", __LINE__, o->getNdbError().code, o->getNdbError().message); } } while (0) + Ndb* ndb = new Ndb("TEST_DB"); + ndb->init(); + CHK(ndb, ndb->waitUntilReady() == 0); + Int32 a, b, c; + for (unsigned i = 0; i < opt.m_scale; i++) { + if (type == 1) { + // pk update with exclusive read + NdbConnection* con; + NdbOperation* op; + CHK(ndb, (con = ndb->startTransaction()) != 0); + a = i; + c = -1; + CHK(con, (op = con->getNdbOperation(tname)) != 0); + CHK(op, op->readTupleExclusive() == 0); + CHK(op, op->equal((unsigned)0, (char*)&a, 0) == 0); + CHK(op, op->getValue(2, (char*)&c) != 0); + CHK(con, con->execute(NoCommit) == 0); + c = c + 1; + CHK(con, (op = con->getNdbOperation(tname)) != 0); + CHK(op, op->updateTuple() == 0); + CHK(op, op->equal((unsigned)0, (char*)&a, 0) == 0); + CHK(op, op->setValue(2, (char*)&c) == 0); + CHK(con, con->execute(Commit) == 0); + ndb->closeTransaction(con); + if (opt.m_v >= 3) + ndbout << lock << "thr " << test.m_no << " pk a=" << i << " c=" << c << endl << unlock; + } + if (type == 2) { + // table scan update + NdbConnection* con; + NdbOperation* op; + CHK(ndb, (con = ndb->startTransaction()) != 0); + CHK(con, (op = con->getNdbOperation(tname)) != 0); + CHK(con, op->openScanExclusive(240) == 0); + CHK(op, op->getValue((unsigned)0, (char*)&a) != 0); + CHK(op, op->getValue(2, (char*)&c) != 0); + CHK(con, con->executeScan() == 0); + unsigned rows = 0; + unsigned updates = 0; + while (1) { + int ret; + a = -1; + c = -1; + CHK(con, (ret = con->nextScanResult()) == 0 || ret == 1); + if (ret == 1) + break; + rows++; + if (a == i) { + NdbConnection* con2; + NdbOperation* op2; + CHK(ndb, (con2 = ndb->startTransaction()) != 0); + CHK(op, (op2 = op->takeOverForUpdate(con2)) != 0); + c = c + 1; + CHK(op2, op2->setValue(2, (char*)&c) == 0); + CHK(con2, con2->execute(Commit) == 0); + ndb->closeTransaction(con2); + updates++; + if (opt.m_v >= 3) + ndbout << lock << "thr " << test.m_no << " ts rows=" << rows << " a=" << i << " c=" << c << endl << unlock; + // test stop scan too + CHK(con, con->stopScan() == 0); + break; + } + } + ndb->closeTransaction(con); + test.chk(HStmt(hStmt), updates == 1, "got %u != 1", updates); + } + if (type == 3) { + // index scan update + NdbConnection* con; + NdbOperation* op; + CHK(ndb, (con = ndb->startTransaction()) != 0); + CHK(con, (op = con->getNdbOperation(iname, tname)) != 0); + CHK(con, op->openScanExclusive(240) == 0); + b = 10 * i; + CHK(con, op->setBound((unsigned)0, 4, &b, sizeof(b)) == 0); + CHK(op, op->getValue((unsigned)0, (char*)&a) != 0); + CHK(op, op->getValue(2, (char*)&c) != 0); + CHK(con, con->executeScan() == 0); + unsigned rows = 0; + unsigned updates = 0; + while (1) { + int ret; + a = -1; + c = -1; + CHK(con, (ret = con->nextScanResult()) == 0 || ret == 1); + if (ret == 1) + break; + rows++; + if (a == i) { + NdbConnection* con2; + NdbOperation* op2; + CHK(ndb, (con2 = ndb->startTransaction()) != 0); + CHK(op, (op2 = op->takeOverForUpdate(con2)) != 0); + c = c + 1; + CHK(op2, op2->setValue(2, (char*)&c) == 0); + CHK(con2, con2->execute(Commit) == 0); + ndb->closeTransaction(con2); + updates++; + if (opt.m_v >= 3) + ndbout << lock << "thr " << test.m_no << " is rows=" << rows << " a=" << i << " c=" << c << endl << unlock; + // test stop scan too + CHK(con, con->stopScan() == 0); + break; + } + } + ndb->closeTransaction(con); + test.chk(HStmt(hStmt), rows == 1, "got %u != 1", rows); + test.chk(HStmt(hStmt), updates == 1, "got %u != 1", updates); + } + } + delete ndb; +#undef CHK +#endif + } + // verify result + lock_mutex(); + if (++my_sema == 1 + opt.m_threads) { + if (opt.m_v >= 1) + ndbout << "thread " << test.m_no << " does verification" << endl; + sprintf(sql, "select * from %s order by a", tname); + if (opt.m_v >= 2) + ndbout << "SQL[" << test.m_no << "]: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + long a, b, c; + test.run(HStmt(hStmt), SQLBindCol(hStmt, 1, SQL_C_SLONG, &a, 0, 0)); + test.run(HStmt(hStmt), SQLBindCol(hStmt, 2, SQL_C_SLONG, &b, 0, 0)); + test.run(HStmt(hStmt), SQLBindCol(hStmt, 3, SQL_C_SLONG, &c, 0, 0)); + for (unsigned i = 0; i < opt.m_scale; i++) { + a = b = c = -1; + test.run(HStmt(hStmt), SQLFetch(hStmt)); + test.chk(HStmt(hStmt), a == i, "a: got %ld != %u", a, i); + test.chk(HStmt(hStmt), b == 10 * i, "b: got %ld != %u", b, 10 * i); + test.chk(HStmt(hStmt), c == opt.m_threads, "c: got %ld != %u", c, opt.m_threads); + if (opt.m_v >= 4) + ndbout << "verified " << i << endl; + } + test.exp(SQL_NO_DATA, 0, 0, true); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + if (opt.m_v >= 2) + ndbout << "thr " << test.m_no << " verified " << opt.m_scale << " rows" << endl; + my_sema = 0; + } + unlock_mutex(); + freeAll(test, hEnv, hDbc, hStmt); +} + +static const Sql +miscSql97[] = { + Sql("testMisc97a", testMisc97a), + Sql() +}; + +// 99 + +static void +testMisc99a(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmt; + allocAll(test, hEnv, hDbc, hStmt); + // bad + const char* sqlInsertBad = "insert into tt99a values(?, ?, ?, ?, ?)"; + test.exp(SQL_ERROR, "21S01", -1, true); + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sqlInsertBad, SQL_NTS)); + // good + const char* sqlInsert = "insert into tt99a (col1, col2, col3, col4, col5) values(?, ?, ?, ?, ?)"; + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sqlInsert, SQL_NTS)); + unsigned long value; + for (unsigned i = 1; i <= 5; i++) { + test.run(HStmt(hStmt), SQLBindParameter(hStmt, i, SQL_PARAM_INPUT, SQL_C_ULONG, SQL_INTEGER, 0, 0, &value, 0, 0)); + } + const unsigned long base = 1000000000; + const unsigned long scale = 10; + for (value = base; value < base + scale; value++) { + test.run(HStmt(hStmt), SQLExecute(hStmt)); + } + // bug1: re-analyze of converted expression... + const char* sqlSelect = "select col5 from tt99a where col2 + 0 = ?"; + unsigned long output; + test.run(HStmt(hStmt), SQLBindCol(hStmt, 1, SQL_C_ULONG, &output, 0, 0)); + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sqlSelect, SQL_NTS)); + // bug2: previous bind must survive a new SQLPrepare + if (0) { + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1, SQL_PARAM_INPUT, SQL_C_ULONG, SQL_INTEGER, 0, 0, &value, 0, 0)); + } + for (value = base; value < base + scale; value++) { + if (value > base + 4) { + // bug1: ...when IPD changed by JDBC + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1, SQL_PARAM_INPUT, SQL_C_ULONG, SQL_INTEGER, 0, 0, &value, 0, 0)); + } + test.run(HStmt(hStmt), SQLExecute(hStmt)); + output = (unsigned long)-1; + test.run(HStmt(hStmt), SQLFetch(hStmt)); + test.chk(HStmt(hStmt), output == value, "got %lu != %lu", output, value); + test.exp(SQL_NO_DATA, 0, 0, true); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + test.run(HStmt(hStmt), SQLCloseCursor(hStmt)); + test.timerCnt(1); + } + freeAll(test, hEnv, hDbc, hStmt); +} + +static void +testMisc99c(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmt; + allocAll(test, hEnv, hDbc, hStmt); + const char* sql = "select b from tt99c where a = ?"; + const unsigned long c1 = 2100000000U; + const unsigned long c2 = 4100000000U; + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS)); + unsigned long aval, bval; + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1, SQL_PARAM_INPUT, SQL_C_ULONG, SQL_INTEGER, 0, 0, &aval, 0, 0)); + test.run(HStmt(hStmt), SQLBindCol(hStmt, 1, SQL_C_ULONG, &bval, 0, 0)); + // uno + for (unsigned i = 0; i < opt.m_scale; i++) { + aval = c1; + bval = (unsigned long)-1; + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << " [?=" << (Uint64)aval << "]" << endl; + test.run(HStmt(hStmt), SQLExecute(hStmt)); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + test.chk(HStmt(hStmt), bval == c2, "got %lu != %lu", bval, c2); + //test.exp(SQL_NO_DATA, 0, 0, true); + //test.run(HStmt(hStmt), SQLFetch(hStmt)); + test.run(HStmt(hStmt), SQLCloseCursor(hStmt)); + } + // dos + for (unsigned i = 0; i < opt.m_scale; i++) { + break; // XXX not yet, hangs in NDB ?!? + aval = c2; + bval = (unsigned long)-1; + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << " [?=" << (Uint64)aval << "]" << endl; + test.run(HStmt(hStmt), SQLExecute(hStmt)); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + test.chk(HStmt(hStmt), bval == c1, "got %lu != %lu", bval, c2); + //test.exp(SQL_NO_DATA, 0, 0, true); + //test.run(HStmt(hStmt), SQLFetch(hStmt)); + test.run(HStmt(hStmt), SQLCloseCursor(hStmt)); + } + freeAll(test, hEnv, hDbc, hStmt); +} + +static void +testMisc99d(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmt; + allocAll(test, hEnv, hDbc, hStmt); + const char* tname = "TT99D"; + char sql[MAX_SQL]; + sprintf(sql, "drop table %s", tname); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.exp(SQL_ERROR, "IM000", 2040709, false); + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + sprintf(sql, "create table %s (a bigint unsigned, b bigint, primary key (a))", tname); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLExecDirect(hStmt, (SQLCHAR*)sql, SQL_NTS)); + sprintf(sql, "insert into %s values (?, ?)", tname); + if (opt.m_v >= 2) + ndbout << "SQL: " << sql << endl; + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS)); + // XXX replace by 100 when signed vs unsigned resolved + const unsigned num = 78; + SQLUBIGINT aval; + SQLBIGINT bval; + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1, SQL_PARAM_INPUT, SQL_C_UBIGINT, SQL_BIGINT, 0, 0, &aval, 0, 0)); + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 2, SQL_PARAM_INPUT, SQL_C_SBIGINT, SQL_BIGINT, 0, 0, &bval, 0, 0)); + for (SQLBIGINT i = 0; i < num; i++) { + if (opt.m_v >= 3) + ndbout << "insert " << i << endl; + aval = i * i * i * i * i * i * i * i * i * i; // 10 + bval = -aval; + test.run(HStmt(hStmt), SQLExecute(hStmt)); + } + sprintf(sql, "select a, b from tt99d where a = ?"); + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql, SQL_NTS)); + SQLUBIGINT kval; + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1, SQL_PARAM_INPUT, SQL_C_UBIGINT, SQL_BIGINT, 0, 0, &kval, 0, 0)); + test.run(HStmt(hStmt), SQLBindCol(hStmt, 1, SQL_C_UBIGINT, &aval, 0, 0)); + test.run(HStmt(hStmt), SQLBindCol(hStmt, 2, SQL_C_SBIGINT, &bval, 0, 0)); + for (SQLBIGINT i = 0; i < num; i++) { + kval = i * i * i * i * i * i * i * i * i * i; // 10 + if (opt.m_v >= 3) + ndbout << "fetch " << i << " key " << kval << endl; + test.run(HStmt(hStmt), SQLExecute(hStmt)); + aval = bval = 0; + test.run(HStmt(hStmt), SQLFetch(hStmt)); + test.chk(HStmt(hStmt), aval == kval && bval == -kval, "got %llu, %lld != %llu, %lld", aval, bval, kval, -kval); + test.exp(SQL_NO_DATA, 0, 0, true); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + test.run(HStmt(hStmt), SQLCloseCursor(hStmt)); + } + freeAll(test, hEnv, hDbc, hStmt); +} + +static void +testMiscC2(Test& test) +{ + SQLHANDLE hEnv, hDbc, hStmt; + allocAll(test, hEnv, hDbc, hStmt); +#if 0 + { + char POP[255]; + char PORT[255]; + char ACCESSNODE[255]; + + const char* sqlSelect = "select PORT from AAA where POP=? and ACCESSNODE=?"; + + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sqlSelect, SQL_NTS)); + + for (int j=0; j<5; j++) { + printf("Loop %u\n", j); + printf("LINE %u\n", __LINE__); + + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, 255, 0, POP, 255, 0)); + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, 255, 0, ACCESSNODE, 255, 0)); + test.run(HStmt(hStmt), SQLBindCol(hStmt, 1, SQL_C_CHAR, PORT, 255, 0)); + + sprintf(POP, "a"); + sprintf(ACCESSNODE, "b"); + + test.run(HStmt(hStmt), SQLExecute(hStmt)); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + printf("got %s\n", PORT); + printf("LINE %u\n", __LINE__); + test.exp(SQL_NO_DATA, 0, 0, true); + printf("LINE %u\n", __LINE__); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + printf("LINE %u\n", __LINE__); + test.run(HStmt(hStmt), SQLCloseCursor(hStmt)); + printf("LINE %u\n", __LINE__); + } + } + return; +#endif + + char POP[255]; + char PORT[255]; + char ACCESSNODE[255]; + unsigned long VLAN = 0; + unsigned long SNMP_INDEX = 0; + unsigned long PORT_STATE = 0; + unsigned long STATIC_PORT = 0; + unsigned long COMMENT = 0; + + const char* sqlSelect = "select PORT, PORT_STATE from PORTS where POP=? and ACCESSNODE=?"; + + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sqlSelect, SQL_NTS)); + + for (int j=0; j<5; j++) { + printf("Loop %u\n", j); + printf("LINE %u\n", __LINE__); + + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, 255, 0, POP, 255, 0)); + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, 255, 0, ACCESSNODE, 255, 0)); + test.run(HStmt(hStmt), SQLBindCol(hStmt, 1, SQL_C_CHAR, PORT, 255, 0)); + test.run(HStmt(hStmt), SQLBindCol(hStmt, 2, SQL_C_ULONG, &PORT_STATE, 0, 0)); + + sprintf(POP, "row%u.i%u.bredband.com", 2, 3); + sprintf(ACCESSNODE, "as%u", 2); + + test.run(HStmt(hStmt), SQLExecute(hStmt)); + for (int i=0; i < 3; i++) { + PORT_STATE=0; + sprintf(PORT, "XXXXXXXXXXXXXXXXXXXXX"); + + test.run(HStmt(hStmt), SQLFetch(hStmt)); + printf("got %s %lu\n", PORT, PORT_STATE); + // test.chk(HStmt(hStmt), false, "got %s != %s", "xxx", PORT); + } + printf("LINE %u\n", __LINE__); + test.exp(SQL_NO_DATA, 0, 0, true); + printf("LINE %u\n", __LINE__); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + printf("LINE %u\n", __LINE__); + test.run(HStmt(hStmt), SQLCloseCursor(hStmt)); + printf("LINE %u\n", __LINE__); + } +} + +static const Sql +miscSqlC2[] = { + Sql("drop table PORTS", + SQL_DIAG_DROP_TABLE, -1, 0, -1, -1, + SQL_ERROR, "IM000", 2040709, false), + Sql("create table PORTS (POP varchar(200) not null, ACCESSNODE varchar(200) not null, PORT varchar(200) not null, VLAN int unsigned, SNMP_INDEX int unsigned, PORT_STATE int unsigned, STATIC_PORT int unsigned, COMMENT int unsigned, primary key (POP,ACCESSNODE,PORT))", + SQL_DIAG_CREATE_TABLE, -1, 0, -1, -1), + Sql("create index xxPORTS on PORTS (POP, ACCESSNODE) nologging", + SQL_DIAG_CREATE_INDEX, -1, -1, -1, -1), + Sql("insert into PORTS values ('row2.i3.bredband.com','as2','Fa0/0',0,1,2,3,4)", + SQL_DIAG_INSERT, 1, 0, -1, -1), + Sql("insert into PORTS values ('row2.i3.bredband.com','as2','Fa0/1',1,2,3,4,5)", + SQL_DIAG_INSERT, 1, 0, -1, -1), + Sql("insert into PORTS values ('row2.i3.bredband.com','as2','Fa0/2',2,3,4,5,6)", + SQL_DIAG_INSERT, 1, 0, -1, -1), + Sql("select PORT, PORT_STATE from PORTS where POP='row2.i3.bredband.com' and ACCESSNODE='as2'", + SQL_DIAG_SELECT_CURSOR, 3, 3, -1, -1), + + Sql("drop table AAA", + SQL_DIAG_DROP_TABLE, -1, 0, -1, -1, + SQL_ERROR, "IM000", 2040709, false), + Sql("create table AAA (POP varchar(200), ACCESSNODE varchar(200) not null, PORT varchar(200) not null, primary key (POP,ACCESSNODE,PORT))", + SQL_DIAG_CREATE_TABLE, -1, 0, -1, -1), + Sql("create index xxAAA on AAA (POP, ACCESSNODE) nologging", + SQL_DIAG_CREATE_INDEX, -1, -1, -1, -1), + Sql("insert into AAA values ('a','b','A')", + SQL_DIAG_INSERT, 1, 0, -1, -1), + + Sql("testMiscC2", testMiscC2), + Sql() +}; + +/* +> SELECT PORT, PORT_STATE FROM PORTS where pop=? and accessnode=? +> SELECT VLAN, SNMP_INDEX, PORT_STATE, STATIC_PORT, COMMENT FROM PORTS WHERE POP=? AND ACCESSNODE=? AND PORT=? +> select count(*) from ports +> select snmp_index from ports where pop='row2.i3.bredband.com' and accessnode='as2' and port='Fa0/2' + +> SELECT MAC, MAC_EXPIRE, IP, IP_EXPIRE, HOSTNAME, DETECTED, STATUS, STATIC_DNS, BLOCKED, NUM_REQUESTS, ACCESSTYPE, OS_TYPE, GATE_WAY, DIRTY_FLAG, LOCKED_IP FROM CLIENTS WHERE PORT=? AND ACCESSNODE=? AND POP=? +> SELECT SERVICES.ACCESSTYPE, SERVICES.NUM_IP, SERVICES.TEXPIRE, SERVICES.CUSTOMER_ID, SERVICES.LEASED_NUM_IP, SERVICES.PROVIDER, SERVICES.LOCKED_IP, SERVICES.STATIC_DNS, SERVICES.SUSPENDED_SERVICE FROM SERVICES , ACCESSTYPES WHERE SERVICES.PORT = ? AND SERVICES.ACCESSNODE = ? AND SERVICES.POP = ? AND SERVICES.ACCESSTYPE=ACCESSTYPES.ACCESSTYPE +*/ + +static const Sql +miscSql99[] = { + Sql("drop table tt99a", + SQL_DIAG_DROP_TABLE, -1, 0, -1, -1, + SQL_ERROR, "IM000", 2040709, false), + Sql("create table tt99a (col1 int unsigned primary key, col2 int unsigned, col3 int unsigned, col4 int unsigned, col5 int unsigned, col6 varchar(7) default 'abc123')", + SQL_DIAG_CREATE_TABLE, -1, 0, -1, -1), + // inserts 10 rows, all same, start value 1000000000 + Sql("testMisc99a", testMisc99a), + // interpreted scan plus bind parameter + Sql("select col1 from tt99a where col2 = ?", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1000000004, 1000000004), + Sql("select col1 from tt99a where col2 = 1000000000 + ?", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1000000004, 4), + Sql("select col1 from tt99a where col2 = ? + 1000000000", + SQL_DIAG_SELECT_CURSOR, 1, 1, 1000000004, 4), + // same not interpreted, tuple count 10 + Sql("select col1 from tt99a where col2 + 0 = 1000000000 + ?", + SQL_DIAG_SELECT_CURSOR, 1, 10, 1000000004, 4), + // varchar variations + Sql("select count(*) from tt99a where col6 = 'abc123'", + SQL_DIAG_SELECT_CURSOR, 1, 10, 10, -1), + Sql("select count(*) from tt99a where left(col6, ?) = 'abc1'", + SQL_DIAG_SELECT_CURSOR, 1, 10, 10, 4), + Sql("select count(*) from tt99a where left(col6, ?) = 'abc1'", + SQL_DIAG_SELECT_CURSOR, 1, 10, 0, 3), + // tpc-b inspired, wrong optimization to direct update + Sql("drop table tt99b", + SQL_DIAG_DROP_TABLE, -1, 0, -1, -1, + SQL_ERROR, "IM000", 2040709, false), + Sql("create table tt99b(a int primary key, b int not null, c double precision)", + SQL_DIAG_CREATE_TABLE, -1, 0, -1, -1), + Sql("insert into tt99b values(1, 10, 100.0)", + SQL_DIAG_INSERT, 1, 0, -1, -1), + Sql("insert into tt99b values(9, 90, 900.0)", + SQL_DIAG_INSERT, 1, 0, -1, -1), + Sql("create unique hash index tt99y on tt99b (b)", + SQL_DIAG_CREATE_INDEX, -1, 0, -1, -1), + // first scan update.. + Sql("update tt99b set c = c + ? where a+0 = 1", + SQL_DIAG_UPDATE_WHERE, 1, 2, -1, 10), + Sql("update tt99b set c = c + ? where b+0 = 10", + SQL_DIAG_UPDATE_WHERE, 1, 2, -1, 10), + // then optimized.. + Sql("update tt99b set c = c + ? where a = 1", + SQL_DIAG_UPDATE_WHERE, 1, 1, -1, 10), + Sql("update tt99b set c = c + ? where b = 10", + SQL_DIAG_UPDATE_WHERE, 1, 1, -1, 10), + // verify.. + Sql("select count(*) from tt99b where 100-1 < c and c < 140-1", + SQL_DIAG_SELECT_CURSOR, 1, 2, 0, -1), + Sql("select count(*) from tt99b where 140-.001 < c and c < 140+.001", + SQL_DIAG_SELECT_CURSOR, 1, 2, 1, -1), + // unsigned test + Sql("drop table tt99c", + SQL_DIAG_DROP_TABLE, -1, 0, -1, -1, + SQL_ERROR, "IM000", 2040709, false), + Sql("create table tt99c(a int unsigned primary key, b int unsigned)", + SQL_DIAG_CREATE_TABLE, -1, 0, -1, -1), + Sql("insert into tt99c values(2100000000, 4100000000)", + SQL_DIAG_INSERT, 1, 0, -1, -1), + Sql("insert into tt99c (a, b) select b, a from tt99c", + SQL_DIAG_INSERT, 1, 1, -1, -1), + Sql("testMisc99c", testMisc99c), + // new external type SQL_C_[SU]BIGINT + Sql("testMisc99d", testMisc99d), + Sql() +}; + +static const struct { const Sql* sql; int minscale; } +miscSql[11] = { + { miscSql90, 0 }, + { miscSql91, 0 }, + { miscSql92, 0 }, + { miscSql93, 0 }, + { 0, 0 }, // 94 + { miscSql95, 0 }, + { miscSql96, 0 }, + { miscSql97, 0 }, + { 0, 0 }, // 98 + { miscSql99, 0 }, + { miscSqlC2, 0 } +}; + +static void +testSql(Test& test) +{ + const unsigned salt = test.m_stuff; // mess + if (opt.m_scale < miscSql[salt].minscale) { + if (opt.m_v >= 1) + ndbout << "skip - requires scale >= " << miscSql[salt].minscale << endl; + return; + } + assert(0 <= salt && salt < 11 && miscSql[salt].sql != 0); + SQLHANDLE hEnv, hDbc, hStmt; + allocAll(test, hEnv, hDbc, hStmt); + for (unsigned i = 0; ; i++) { + const Sql& sql = miscSql[salt].sql[i]; + if (sql.m_sql == 0) + break; + if (opt.m_v >= 2) + ndbout << "SQL: " << sql.m_sql << endl; + if (sql.m_testFunc != 0) { + (*sql.m_testFunc)(test); + continue; + } + if (strncmp(sql.m_sql, "--", 2) == 0) { + continue; + } + if (strcmp(sql.m_sql, Sql::set_autocommit_on()) == 0) { + setAutocommit(test, hDbc, true); + continue; + } + if (strcmp(sql.m_sql, Sql::set_autocommit_off()) == 0) { + setAutocommit(test, hDbc, false); + continue; + } + if (strcmp(sql.m_sql, Sql::do_commit()) == 0) { + test.run(HDbc(hDbc), SQLEndTran(SQL_HANDLE_DBC, hDbc, SQL_COMMIT)); + continue; + } + if (strcmp(sql.m_sql, Sql::do_rollback()) == 0) { + test.run(HDbc(hDbc), SQLEndTran(SQL_HANDLE_DBC, hDbc, SQL_ROLLBACK)); + continue; + } + if (opt.m_v >= 3) { + ndbout << "expect:"; + ndbout << " ret=" << sql.m_ret; + ndbout << " rows=" << sql.m_rowCount; + ndbout << " tuples=" << sql.m_tuplesFetched; + ndbout << endl; + } + test.run(HStmt(hStmt), SQLFreeStmt(hStmt, SQL_UNBIND)); + test.run(HStmt(hStmt), SQLFreeStmt(hStmt, SQL_RESET_PARAMS)); + // prep + test.exp(sql.m_ret, sql.m_state, sql.m_native, false); + test.run(HStmt(hStmt), SQLPrepare(hStmt, (SQLCHAR*)sql.m_sql, SQL_NTS)); + if (test.m_ret != SQL_SUCCESS) + continue; + // bind between prep and exec like JDBC + unsigned long bindValue = sql.m_bindValue; + for (int k = 0; k <= 1; k++) { + if (bindValue != -1) { + assert(strchr(sql.m_sql, '?') != 0); + test.run(HStmt(hStmt), SQLBindParameter(hStmt, 1, SQL_PARAM_INPUT, SQL_C_ULONG, SQL_INTEGER, 0, 0, &bindValue, 0, 0)); + } + if (k == 0) { + if (bindValue != -1) { + test.run(HStmt(hStmt), SQLFreeStmt(hStmt, SQL_RESET_PARAMS)); + // exec with unbound parameter + test.exp(SQL_ERROR, "HY010", -1, true); + test.run(HStmt(hStmt), SQLExecute(hStmt)); + test.chk(HStmt(hStmt), test.m_functionCode == sql.m_functionCode || sql.m_functionCode == -1, "func: got %d != %d", (int)test.m_functionCode, (int)sql.m_functionCode); + } + } else { + // exec + test.exp(sql.m_ret, sql.m_state, sql.m_native, sql.m_reset); + test.run(HStmt(hStmt), SQLExecute(hStmt)); + test.chk(HStmt(hStmt), test.m_functionCode == sql.m_functionCode || sql.m_functionCode == -1, "func: got %d != %d", (int)test.m_functionCode, (int)sql.m_functionCode); + } + } + if (sql.m_rowCount != -1) { + if (sql.m_functionCode == SQL_DIAG_SELECT_CURSOR) { + long lastValue; + if (sql.m_lastValue != -1) + test.run(HStmt(hStmt), SQLBindCol(hStmt, 1, SQL_C_SLONG, &lastValue, 0, 0)); + unsigned k = 0; + do { + int rowCount = 0; + lastValue = -1; + while (1) { + test.exp(SQL_NO_DATA, 0, 0, false); + test.run(HStmt(hStmt), SQLFetch(hStmt)); + if (test.m_ret == SQL_NO_DATA) + break; + rowCount++; + } + test.chk(HStmt(hStmt), rowCount == sql.m_rowCount, "rowCount: got %d != %d", (int)rowCount, (int)sql.m_rowCount); + if (sql.m_tuplesFetched != -1) + chkTuplesFetched(test, hStmt, sql.m_tuplesFetched); + if (rowCount > 0 && sql.m_lastValue != -1) + test.chk(HStmt(hStmt), lastValue == sql.m_lastValue, "lastValue: got %ld != %ld", (long)lastValue, (long)sql.m_lastValue); + test.run(HStmt(hStmt), SQLCloseCursor(hStmt)); + if (++k >= opt.m_scale) + break; + test.run(HStmt(hStmt), SQLExecute(hStmt)); + } while (1); + test.timerCnt(opt.m_scale); + } else { + assert(sql.m_lastValue == -1); + chkRowCount(test, hStmt, sql.m_rowCount); + if (sql.m_tuplesFetched != -1) + chkTuplesFetched(test, hStmt, sql.m_tuplesFetched); + test.timerCnt(1); + } + } + } + freeAll(test, hEnv, hDbc, hStmt); +} + +// name, function, runmode, salt (0=const or n/a), description +static const Case caseList[] = { + Case( "00alloc", testAlloc, Case::Thread, 0, "allocate handles" ), + Case( "01create", testCreate, Case::Single, 0, "create tables for the test" ), + Case( "02prepare", testPrepare, Case::Thread, 0, "prepare without execute" ), + Case( "03catalog", testCatalog, Case::Thread, 0, "catalog functions" ), + Case( "10insert", testInsert, Case::Thread, 1, "insert computed rows" ), + Case( "11delall", testDeleteAll, Case::Single, 0, "delete all rows via scan" ), + Case( "12insert", testInsert, Case::Thread, 1, "insert computed rows again" ), + Case( "13count", testCount, Case::Single, 0, "count rows" ), + Case( "14verpk", testVerifyPk, Case::Thread, 1, "verify via primary key" ), + Case( "15verscan", testVerifyScan, Case::Serial, 1, "verify via range scans" ), + Case( "16join", testJoin, Case::Single, 0, "multiple self-join" ), + Case( "17cart", testCart, Case::Single, 0, "cartesian join" ), + Case( "20updpk", testUpdatePk, Case::Thread, 2, "update via primary key" ), + Case( "21verpk", testVerifyPk, Case::Thread, 2, "verify via primary key" ), + Case( "22verscan", testVerifyScan, Case::Serial, 2, "verify via range scans" ), + Case( "23updscan", testUpdateScan, Case::Serial, 0, "update via scan" ), + Case( "24verpk", testVerifyPk, Case::Thread, 0, "verify via primary key" ), + Case( "25verscan", testVerifyScan, Case::Serial, 0, "verify via range scans" ), + Case( "26delpk", testDeletePk, Case::Thread, 0, "delete via primary key" ), + Case( "30trans", testTrans, Case::Single, 3, "rollback and commit" ), + Case( "31concur", testConcur, Case::Single, 0, "commit across open cursor" ), + Case( "32readcom", testReadcom, Case::Single, 0, "read committed" ), + Case( "40perf", testPerf, Case::Single, 0, "perf test prepare" ), + Case( "41perf", testPerf, Case::Thread, 1, "perf test NDB API" ), + Case( "42perf", testPerf, Case::Thread, 2, "perf test NDB ODBC" ), + Case( "90sql", testSql, Case::Single, 0, "misc SQL: metadata" ), + Case( "91sql", testSql, Case::Single, 1, "misc SQL: misc" ), + Case( "92sql", testSql, Case::Thread, 2, "misc SQL: scan rollback" ), + Case( "93sql", testSql, Case::Single, 3, "misc SQL: locking" ), + Case( "95sql", testSql, Case::Single, 5, "misc SQL: indexes (simple)" ), + Case( "96sql", testSql, Case::Single, 6, "misc SQL: indexes" ), + Case( "97sql", testSql, Case::Thread, 7, "misc SQL: indexes" ), + Case( "99sql", testSql, Case::Single, 9, "misc SQL: bug du jour" ), + Case( "C2", testSql, Case::Single, 10, "misc SQL: C2" ) +}; + +static const unsigned caseCount = arraySize(caseList); + +static bool +findCase(const char* name) +{ + for (unsigned i = 0; i < caseCount; i++) { + const Case& cc = caseList[i]; + if (strstr(cc.m_name, name) != 0) + return true; + } + return false; +} + +static void +listCases() +{ + ndbout << "cases:" << endl; + unsigned m = 0; + for (unsigned i = 0; i < caseCount; i++) { + const Case& cc = caseList[i]; + if (m < strlen(cc.m_name)) + m = strlen(cc.m_name); + } + for (unsigned i = 0; i < caseCount; i++) { + const Case& cc = caseList[i]; + char buf[200]; + sprintf(buf, "%-*s [%-6s] %s", m, cc.m_name, cc.modename(), cc.m_desc); + ndbout << buf << endl; + } +} + +// threads + +extern "C" { static void* testThr(void* arg); } + +struct Thr { + enum State { + Wait = 1, // wait for test case + Run = 2, // run the test case + Done = 3, // done with the case + Exit = 4 // exit thread + }; + unsigned m_no; // thread number 1 .. max + NdbThread* m_thr; // thread id etc + const Case* m_case; // current case + State m_state; // condition variable + NdbMutex* m_mutex; // condition guard + NdbCondition* m_cond; + void* m_status; // exit status (not used) + Test m_test; // test runner + Thr(unsigned no, unsigned loop) : + m_no(no), + m_thr(0), + m_case(0), + m_state(Wait), + m_mutex(NdbMutex_Create()), + m_cond(NdbCondition_Create()), + m_status(0), + m_test(no, loop) { + } + ~Thr() { + destroy(); + NdbCondition_Destroy(m_cond); + NdbMutex_Destroy(m_mutex); + } + void create() { + assert(m_thr == 0); + m_thr = NdbThread_Create(testThr, (void**)this, 64*1024, "test", NDB_THREAD_PRIO_LOW); + } + void destroy() { + if (m_thr != 0) + NdbThread_Destroy(&m_thr); + m_thr = 0; + } + void lock() { + NdbMutex_Lock(m_mutex); + } + void unlock() { + NdbMutex_Unlock(m_mutex); + } + void wait() { + NdbCondition_Wait(m_cond, m_mutex); + } + void signal() { + NdbCondition_Signal(m_cond); + } + void join() { + NdbThread_WaitFor(m_thr, &m_status); + m_thr = 0; + } + // called from main + void mainStart(const Case& cc) { + lock(); + m_case = &cc; + m_state = Run; + signal(); + unlock(); + } + void mainStop() { + lock(); + while (m_state != Done) { + if (opt.m_v >= 4) + ndbout << ::lock << "thr " << m_no << " [main] wait state=" << m_state << endl << ::unlock; + wait(); + } + if (opt.m_v >= 4) + ndbout << ::lock << "thr " << m_no << " [main] done" << endl << ::unlock; + m_state = Wait; + unlock(); + } + // run in thread + void testSelf() { + while (1) { + lock(); + while (m_state != Run && m_state != Exit) { + if (opt.m_v >= 4) + ndbout << ::lock << "thr " << m_no << " [self] wait state=" << m_state << endl << ::unlock; + wait(); + } + if (m_state == Run) { + if (opt.m_v >= 4) + ndbout << ::lock << "thr " << m_no << " [self] run" << endl << ::unlock; + assert(m_case != 0); + m_test.timerOn(); + m_test.runCase(*m_case); + m_test.timerOff(); + m_state = Done; + if (opt.m_v >= 4) + ndbout << ::lock << "thr " << m_no << " [self] done" << endl << ::unlock; + signal(); + unlock(); + } else if (m_state == Exit) { + unlock(); + break; + } else { + assert(false); + } + } + if (opt.m_v >= 4) + ndbout << ::lock << "thr " << m_no << " [self] exit" << endl << ::unlock; + } +}; + +static void* +testThr(void* arg) +{ + Thr& thr = *(Thr*)arg; + thr.testSelf(); + return 0; +} + +#ifdef DMALLOC +extern "C" { + +static int malloc_bytes = 0; +static int free_bytes = 0; + +static void +malloc_track(const char *file, const unsigned int line, const int func_id, const DMALLOC_SIZE byte_size, const DMALLOC_SIZE alignment, const DMALLOC_PNT old_addr, const DMALLOC_PNT new_addr) +{ + if (func_id == DMALLOC_FUNC_MALLOC) { + malloc_bytes += byte_size; + return; + } + if (func_id == DMALLOC_FUNC_FREE) { + DMALLOC_SIZE size = 0; + dmalloc_examine(old_addr, &size, 0, 0, 0); + free_bytes += size; + // XXX useless - byte_size and size are 0 + return; + } +} + +} +#endif /* DMALLOC */ + +static void +testMain() +{ +#ifndef NDB_LINUX /* valgrind-1.0.3 does not support */ + NdbThread_SetConcurrencyLevel(opt.m_threads + 2); +#endif +#ifdef DMALLOC + dmalloc_track(malloc_track); +#endif + Test test(0, 0); +#ifdef ndbODBC + Ndb* ndb = 0; + if (1) { // pre-alloc one Ndb object + ndb = new Ndb("TEST_DB"); + ndb->init(); + if (ndb->waitUntilReady() != 0) { + ndbout << ndb->getNdbError() << endl; + fatal("waitUntilReady"); + } + } +#endif + for (unsigned loop = 1; opt.m_loop == 0 || loop <= opt.m_loop; loop++) { + if (opt.m_v >= 2) + ndbout << "loop " << loop << endl; + // create new set of threads in each loop + Thr** thrList = new Thr* [1 + opt.m_threads]; + for (unsigned n = 1; n <= opt.m_threads; n++) { + Thr& thr = *(thrList[n] = new Thr(n, loop)); + thr.create(); + if (opt.m_v >= 4) + ndbout << "thr " << n << " [main] created" << endl; + } +#ifdef DMALLOC + malloc_bytes = free_bytes = 0; +#endif + for (unsigned i = 0; i < caseCount; i++) { + const Case& cc = caseList[i]; + if (! cc.matchcase()) + continue; + if (opt.m_v >= 2) + ndbout << "RUN: " << cc.m_name << " - " << cc.m_desc << endl; + test.timerOn(); + for (unsigned subloop = 1; subloop <= opt.m_subloop; subloop++) { + my_sema = 0; + if (opt.m_v >= 3) + ndbout << "subloop " << subloop << endl; + if (cc.m_mode == Case::Single) { + Thr& thr = *thrList[1]; + thr.mainStart(cc); + thr.mainStop(); + test.timerCnt(thr.m_test); + } else if (cc.m_mode == Case::Serial) { + for (unsigned n = 1; n <= opt.m_threads; n++) { + Thr& thr = *thrList[n]; + thr.mainStart(cc); + thr.mainStop(); + test.timerCnt(thr.m_test); + } + } else if (cc.m_mode == Case::Thread) { + for (unsigned n = 1; n <= opt.m_threads; n++) { + Thr& thr = *thrList[n]; + thr.mainStart(cc); + } + for (unsigned n = 1; n <= opt.m_threads; n++) { + Thr& thr = *thrList[n]; + thr.mainStop(); + test.timerCnt(thr.m_test); + } + } else { + assert(false); + } + } + test.timerOff(); + if (opt.m_v >= 1) + ndbout << cc.m_name << " total " << test << endl; + } +#ifdef DMALLOC + if (opt.m_v >= 9) // XXX useless now + ndbout << "malloc " << malloc_bytes << " free " << free_bytes << " lost " << malloc_bytes - free_bytes << endl; +#endif + // tell threads to exit + for (unsigned n = 1; n <= opt.m_threads; n++) { + Thr& thr = *thrList[n]; + thr.lock(); + thr.m_state = Thr::Exit; + thr.signal(); + thr.unlock(); + if (opt.m_v >= 4) + ndbout << "thr " << n << " [main] told to exit" << endl; + } + for (unsigned n = 1; n <= opt.m_threads; n++) { + Thr& thr = *thrList[n]; + thr.join(); + if (opt.m_v >= 4) + ndbout << "thr " << n << " [main] joined" << endl; + delete &thr; + } + delete[] thrList; + } +#ifdef ndbODBC + delete ndb; +#endif +} + +static bool +str2num(const char* arg, const char* str, unsigned* num, unsigned lo = 0, unsigned hi = 0) +{ + char* end = 0; + long n = strtol(str, &end, 0); + if (end == 0 || *end != 0 || n < 0) { + ndbout << arg << " " << str << " is invalid number" << endl; + return false; + } + if (lo != 0 && n < lo) { + ndbout << arg << " " << str << " is too small min = " << lo << endl; + return false; + } + if (hi != 0 && n > hi) { + ndbout << arg << " " << str << " is too large max = " << hi << endl; + return false; + } + *num = n; + return true; +} + +NDB_COMMAND(testOdbcDriver, "testOdbcDriver", "testOdbcDriver", "testOdbcDriver", 65535) +{ + while (++argv, --argc > 0) { + const char* arg = argv[0]; + if (strcmp(arg, "-case") == 0) { + if (++argv, --argc > 0) { + assert(opt.m_namecnt < arraySize(opt.m_name)); + opt.m_name[opt.m_namecnt++] = argv[0]; + if (findCase(argv[0])) + continue; + } + } + if (strcmp(arg, "-core") == 0) { + opt.m_core = true; + continue; + } + if (strcmp(arg, "-depth") == 0) { + if (++argv, --argc > 0) { + if (str2num(arg, argv[0], &opt.m_depth)) + continue; + } + } + if (strcmp(arg, "-dsn") == 0) { + if (++argv, --argc > 0) { + opt.m_dsn = argv[0]; + continue; + } + } + if (strcmp(arg, "-frob") == 0) { + if (++argv, --argc > 0) { + if (str2num(arg, argv[0], &opt.m_frob)) + continue; + } + } + if (strcmp(arg, "-errs") == 0) { + if (++argv, --argc > 0) { + if (str2num(arg, argv[0], &opt.m_errs)) + continue; + } + } + if (strcmp(arg, "-fragtype") == 0) { + if (++argv, --argc > 0) { + opt.m_fragtype = argv[0]; + continue; + } + } + if (strcmp(arg, "-home") == 0) { + if (++argv, --argc > 0) { + opt.m_home = argv[0]; + continue; + } + } + if (strcmp(arg, "-loop") == 0) { + if (++argv, --argc > 0) { + if (str2num(arg, argv[0], &opt.m_loop)) + continue; + } + } + if (strcmp(arg, "-nogetd") == 0) { + opt.m_nogetd = true; + continue; + } + if (strcmp(arg, "-noputd") == 0) { + opt.m_noputd = true; + continue; + } + if (strcmp(arg, "-nosort") == 0) { + opt.m_nosort = true; + continue; + } + if (strcmp(arg, "-scale") == 0) { + if (++argv, --argc > 0) { + if (str2num(arg, argv[0], &opt.m_scale)) + continue; + } + } + if (strcmp(arg, "-serial") == 0) { + opt.m_serial = true; + continue; + } + if (strcmp(arg, "-skip") == 0) { + if (++argv, --argc > 0) { + assert(opt.m_skipcnt < arraySize(opt.m_skip)); + opt.m_skip[opt.m_skipcnt++] = argv[0]; + if (findCase(argv[0])) + continue; + } + } + if (strcmp(arg, "-subloop") == 0) { + if (++argv, --argc > 0) { + if (str2num(arg, argv[0], &opt.m_subloop)) + continue; + } + } + if (strcmp(arg, "-table") == 0) { + if (++argv, --argc > 0) { + opt.m_table = argv[0]; + if (findTable()) + continue; + } + } + if (strcmp(arg, "-threads") == 0) { + if (++argv, --argc > 0) { + if (str2num(arg, argv[0], &opt.m_threads, 1, MAX_THR)) + continue; + } + } + if (strcmp(arg, "-trace") == 0) { + if (++argv, --argc > 0) { + if (str2num(arg, argv[0], &opt.m_trace)) + continue; + } + } + if (strcmp(arg, "-v") == 0) { + if (++argv, --argc > 0) { + if (str2num(arg, argv[0], &opt.m_v)) + continue; + } + } + if (strncmp(arg, "-v", 2) == 0 && isdigit(arg[2])) { + if (str2num(arg, &arg[2], &opt.m_v)) + continue; + } + printusage(); + return NDBT_ProgramExit(NDBT_WRONGARGS); + } + homeEnv: { + static char env[1000]; + if (opt.m_home != 0) { + sprintf(env, "NDB_HOME=%s", opt.m_home); + putenv(env); + } + } + traceEnv: { + static char env[40]; + sprintf(env, "NDB_ODBC_TRACE=%u", opt.m_trace); + putenv(env); + } + debugEnv: { + static char env[40]; + sprintf(env, "NDB_ODBC_DEBUG=%d", 1); + putenv(env); + } + testMain(); + return NDBT_ProgramExit(NDBT_OK); +} + +// vim: set sw=4: |