static int
Test(int direct)
{
SQLTCHAR buf[256];
SQLTCHAR sqlstate[6];
odbc_connect();
if (!close_last_socket()) {
fprintf(stderr, "Error closing connection\n");
return 1;
}
/* force disconnection closing socket */
if (direct) {
CHKExecDirect(T("SELECT 1"), SQL_NTS, "E");
} else {
SQLSMALLINT cols;
/* use prepare, force dialog with server */
if (CHKPrepare(T("SELECT 1"), SQL_NTS, "SE") == SQL_SUCCESS)
CHKNumResultCols(&cols, "E");
}
CHKGetDiagRec(SQL_HANDLE_STMT, odbc_stmt, 1, sqlstate, NULL, buf, ODBC_VECTOR_SIZE(buf), NULL, "SI");
sqlstate[5] = 0;
printf("state=%s err=%s\n", C(sqlstate), C(buf));
odbc_disconnect();
printf("Done.\n");
return 0;
}
static void
Test(const char *query)
{
CHKPrepare(T(query), SQL_NTS, "S");
CHKExecute("S");
CHKFetch("SI");
CHKFetch("No");
/*
* Microsoft SQL Server 2000 provides a diagnostic record
* associated with the second SQLFetch (which returns
* SQL_NO_DATA) saying "Warning: Null value is eliminated by
* an aggregate or other SET operation."
* We check for "NO DM" cause unixODBC till 2.2.11 do not read
* errors on SQL_NO_DATA
*/
if (odbc_db_is_microsoft() && tds_no_dm) {
SQLTCHAR output[256];
CHKGetDiagRec(SQL_HANDLE_STMT, odbc_stmt, 1, NULL, NULL, output, ODBC_VECTOR_SIZE(output), NULL, "SI");
printf("Message: %s\n", C(output));
}
odbc_reset_statement();
}
void
odbc_read_error(void)
{
memset(odbc_err, 0, sizeof(odbc_err));
memset(odbc_sqlstate, 0, sizeof(odbc_sqlstate));
CHKGetDiagRec(SQL_HANDLE_STMT, odbc_stmt, 1, (SQLCHAR *) odbc_sqlstate, NULL, (SQLCHAR *) odbc_err, sizeof(odbc_err), NULL, "SI");
printf("Message: '%s' %s\n", odbc_sqlstate, odbc_err);
}
static int
Test(int direct)
{
SQLTCHAR buf[256];
SQLTCHAR sqlstate[6];
time_t start_time, end_time;
odbc_mark_sockets_opened();
odbc_connect();
if (!shutdown_last_socket()) {
fprintf(stderr, "Error shutting down connection\n");
return 1;
}
CHKSetStmtAttr(SQL_ATTR_QUERY_TIMEOUT, (SQLPOINTER) 10, SQL_IS_UINTEGER, "S");
alarm(30);
start_time = time(NULL);
if (direct) {
CHKExecDirect(T("SELECT 1"), SQL_NTS, "E");
} else {
SQLSMALLINT cols;
/* force dialog with server */
if (CHKPrepare(T("SELECT 1"), SQL_NTS, "SE") == SQL_SUCCESS)
CHKNumResultCols(&cols, "E");
}
end_time = time(NULL);
alarm(0);
memset(sqlstate, 'X', sizeof(sqlstate));
CHKGetDiagRec(SQL_HANDLE_STMT, odbc_stmt, 1, sqlstate, NULL, buf, ODBC_VECTOR_SIZE(buf), NULL, "SI");
sqlstate[5] = 0;
printf("Message: %s - %s\n", C(sqlstate), C(buf));
if (strcmp(C(sqlstate), "HYT00") || !strstr(C(buf), "Timeout")) {
fprintf(stderr, "Invalid timeout message\n");
return 1;
}
if (end_time - start_time < 10 || end_time - start_time > 26) {
fprintf(stderr, "Unexpected connect timeout (%d)\n", (int) (end_time - start_time));
return 1;
}
odbc_disconnect();
if (end_socket >= 0)
close(end_socket);
printf("Done.\n");
return 0;
}
static void
ReadErrorConn(void)
{
ODBC_BUF *odbc_buf = NULL;
SQLTCHAR *err = (SQLTCHAR *) ODBC_GET(sizeof(odbc_err)*sizeof(SQLTCHAR));
SQLTCHAR *state = (SQLTCHAR *) ODBC_GET(sizeof(odbc_sqlstate)*sizeof(SQLTCHAR));
memset(odbc_err, 0, sizeof(odbc_err));
memset(odbc_sqlstate, 0, sizeof(odbc_sqlstate));
CHKGetDiagRec(SQL_HANDLE_DBC, odbc_conn, 1, state, NULL, err, sizeof(odbc_err), NULL, "SI");
strcpy(odbc_err, C(err));
strcpy(odbc_sqlstate, C(state));
ODBC_FREE();
printf("Message: '%s' %s\n", odbc_sqlstate, odbc_err);
}
void
odbc_read_error(void)
{
ODBC_BUF *odbc_buf = NULL;
SQLTCHAR *err = ODBC_GET(sizeof(odbc_err)*sizeof(SQLTCHAR));
SQLTCHAR *state = ODBC_GET(sizeof(odbc_sqlstate)*sizeof(SQLTCHAR));
memset(odbc_err, 0, sizeof(odbc_err));
memset(odbc_sqlstate, 0, sizeof(odbc_sqlstate));
CHKGetDiagRec(SQL_HANDLE_STMT, odbc_stmt, 1, state, NULL, err, sizeof(odbc_err), NULL, "SI");
strcpy(odbc_err, C(err));
strcpy(odbc_sqlstate, C(state));
ODBC_FREE();
printf("Message: '%s' %s\n", odbc_sqlstate, odbc_err);
}
static void
extract_error(SQLHANDLE handle, SQLSMALLINT type)
{
SQLINTEGER i = 0;
SQLINTEGER native;
SQLTCHAR state[7];
SQLTCHAR text[256];
SQLSMALLINT len;
SQLRETURN ret;
fprintf(stderr, "\n" "The driver reported the following diagnostics\n");
do {
ret = CHKGetDiagRec(type, handle, ++i, state, &native, text, 256, &len, "SINo");
state[5] = 0;
if (SQL_SUCCEEDED(ret))
printf("%s:%ld:%ld:%s\n", C(state), (long) i,
(long) native, C(text));
}
while (ret == SQL_SUCCESS);
}
void
odbc_check_cursor(void)
{
SQLRETURN retcode;
retcode = SQLSetStmtAttr(odbc_stmt, SQL_ATTR_CONCURRENCY, (SQLPOINTER) SQL_CONCUR_ROWVER, 0);
if (retcode != SQL_SUCCESS) {
char output[256];
unsigned char sqlstate[6];
CHKGetDiagRec(SQL_HANDLE_STMT, odbc_stmt, 1, sqlstate, NULL, (SQLCHAR *) output, sizeof(output), NULL, "S");
sqlstate[5] = 0;
if (strcmp((const char*) sqlstate, "01S02") == 0) {
printf("Your connection seems to not support cursors, probably you are using wrong protocol version or Sybase\n");
odbc_disconnect();
exit(0);
}
ReportODBCError("SQLSetStmtAttr", SQL_HANDLE_STMT, odbc_stmt, retcode, __LINE__, __FILE__);
}
odbc_reset_statement();
}
static void
TestResult(SQLRETURN result0, int level, const char *func)
{
ODBC_BUF *odbc_buf = NULL;
SQLTCHAR SqlState[6];
SQLINTEGER NativeError;
SQLTCHAR MessageText[1000];
SQLSMALLINT TextLength;
SQLRETURN result = result0, rc;
if (result == SQL_NO_DATA && strcmp(func, "SQLFetch") == 0)
result = SQL_SUCCESS_WITH_INFO;
if ((level <= 10 && result != SQL_SUCCESS_WITH_INFO) || (level > 10 && result != SQL_ERROR) || ReturnCode != INVALID_RETURN) {
fprintf(stderr, "%s failed!\n", func);
exit(1);
}
/*
* unixODBC till 2.2.11 do not support getting error if SQL_NO_DATA
*/
if (!tds_no_dm && result0 == SQL_NO_DATA && strcmp(func, "SQLFetch") == 0)
return;
SqlState[0] = 0;
MessageText[0] = 0;
NativeError = 0;
rc = CHKGetDiagRec(SQL_HANDLE_STMT, odbc_stmt, 1, SqlState, &NativeError, MessageText, ODBC_VECTOR_SIZE(MessageText), &TextLength, "SI");
printf("Func=%s Result=%d DIAG REC 1: State=%s Error=%d: %s\n", func, (int) rc, C(SqlState), (int) NativeError, C(MessageText));
if (strstr(C(MessageText), "An error occurred") == NULL) {
fprintf(stderr, "Wrong error returned!\n");
fprintf(stderr, "Error returned: %s\n", C(MessageText));
exit(1);
}
ODBC_FREE();
}
void
odbc_check_cursor(void)
{
SQLRETURN retcode;
ODBC_BUF *odbc_buf = NULL;
retcode = SQLSetStmtAttr(odbc_stmt, SQL_ATTR_CONCURRENCY, (SQLPOINTER) SQL_CONCUR_ROWVER, 0);
if (retcode != SQL_SUCCESS) {
SQLTCHAR output[256];
SQLTCHAR sqlstate[6];
CHKGetDiagRec(SQL_HANDLE_STMT, odbc_stmt, 1, sqlstate, NULL, output, ODBC_VECTOR_SIZE(output), NULL, "S");
sqlstate[5] = 0;
if (strcmp(C(sqlstate), "01S02") == 0) {
printf("Your connection seems to not support cursors, probably you are using wrong protocol version or Sybase\n");
odbc_disconnect();
ODBC_FREE();
exit(0);
}
ReportODBCError("SQLSetStmtAttr", SQL_HANDLE_STMT, odbc_stmt, retcode, __LINE__, __FILE__);
}
odbc_reset_statement();
ODBC_FREE();
}
static void
Test0(int use_sql, const char *create_sql, const char *insert_sql, const char *select_sql)
{
#define ROWS 4
#define C_LEN 10
SQLUINTEGER n[ROWS];
char c[ROWS][C_LEN];
SQLLEN c_len[ROWS], n_len[ROWS];
SQLUSMALLINT statuses[ROWS];
SQLUSMALLINT i;
SQLULEN num_row;
SQLHSTMT stmt2;
/* create test table */
odbc_command("IF OBJECT_ID('tempdb..#test') IS NOT NULL DROP TABLE #test");
odbc_command(create_sql);
for (i = 1; i <= 6; ++i) {
char sql_buf[80], data[10];
memset(data, 'a' + (i - 1), sizeof(data));
data[i] = 0;
sprintf(sql_buf, insert_sql, data, i);
odbc_command(sql_buf);
}
/* set cursor options */
odbc_reset_statement();
CHKSetStmtAttr(SQL_ATTR_CONCURRENCY, (SQLPOINTER) SQL_CONCUR_ROWVER, 0, "S");
CHKSetStmtAttr(SQL_ATTR_CURSOR_TYPE, (SQLPOINTER) SQL_CURSOR_DYNAMIC, 0, "S");
CHKSetStmtAttr(SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER) ROWS, 0, "S");
CHKSetStmtAttr(SQL_ATTR_ROW_STATUS_PTR, (SQLPOINTER) statuses, 0, "S");
CHKSetStmtAttr(SQL_ATTR_ROWS_FETCHED_PTR, &num_row, 0, "S");
CHKSetCursorName(T("C1"), SQL_NTS, "S");
/* */
CHKExecDirect(T(select_sql), SQL_NTS, "S");
/* bind some rows at a time */
CHKBindCol(1, SQL_C_ULONG, n, 0, n_len, "S");
CHKBindCol(2, SQL_C_CHAR, c, C_LEN, c_len, "S");
/* allocate an additional statement */
CHKAllocStmt(&stmt2, "S");
while (CHKFetchScroll(SQL_FETCH_NEXT, 0, "SNo") == SQL_SUCCESS) {
/* print, just for debug */
for (i = 0; i < num_row; ++i)
printf("row %d i %d c %s\n", (int) (i + 1), (int) n[i], c[i]);
printf("---\n");
/* delete a row */
i = 1;
if (i > 0 && i <= num_row) {
if (mssql2005)
CHKSetPos(i, use_sql ? SQL_POSITION : SQL_DELETE, SQL_LOCK_NO_CHANGE, "SI");
else
CHKSetPos(i, use_sql ? SQL_POSITION : SQL_DELETE, SQL_LOCK_NO_CHANGE, "S");
if (use_sql) {
SWAP_STMT(stmt2);
CHKPrepare(T("DELETE FROM #test WHERE CURRENT OF C1"), SQL_NTS, "S");
CHKExecute("S");
SWAP_STMT(stmt2);
}
}
/* update another row */
i = 2;
if (i > 0 && i <= num_row) {
strcpy(c[i - 1], "foo");
c_len[i - 1] = 3;
if (strstr(select_sql, "#a") == NULL || use_sql) {
CHKSetPos(i, use_sql ? SQL_POSITION : SQL_UPDATE, SQL_LOCK_NO_CHANGE, "S");
} else {
SQLTCHAR sqlstate[6];
SQLTCHAR msg[256];
n[i - 1] = 321;
CHKSetPos(i, use_sql ? SQL_POSITION : SQL_UPDATE, SQL_LOCK_NO_CHANGE, "E");
CHKGetDiagRec(SQL_HANDLE_STMT, odbc_stmt, 1, sqlstate, NULL, msg, ODBC_VECTOR_SIZE(msg), NULL, "S");
if (strstr(C(msg), "Invalid column name 'c'") == NULL) {
fprintf(stderr, "Expected message not found at line %d\n", __LINE__);
exit(1);
}
}
if (use_sql) {
SWAP_STMT(stmt2);
CHKPrepare(T("UPDATE #test SET c=? WHERE CURRENT OF C1"), SQL_NTS, "S");
CHKBindParameter(1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, C_LEN, 0, c[i - 1], 0, NULL, "S");
CHKExecute("S");
/* FIXME this is not necessary for mssql driver */
SQLMoreResults(odbc_stmt);
SWAP_STMT(stmt2);
}
}
}
SWAP_STMT(stmt2);
CHKFreeStmt(SQL_DROP, "S");
SWAP_STMT(stmt2);
odbc_reset_statement();
/* test values */
CheckNoRow("IF (SELECT COUNT(*) FROM #test) <> 4 SELECT 1");
CheckNoRow("IF NOT EXISTS(SELECT * FROM #test WHERE i = 3 AND c = 'ccc') SELECT 1");
CheckNoRow("IF NOT EXISTS(SELECT * FROM #test WHERE i = 4 AND c = 'dddd') SELECT 1");
if (strstr(select_sql, "#a") == NULL || use_sql) {
CheckNoRow("IF NOT EXISTS(SELECT * FROM #test WHERE i = 2 AND c = 'foo') SELECT 1");
CheckNoRow("IF NOT EXISTS(SELECT * FROM #test WHERE i = 6 AND c = 'foo') SELECT 1");
}
}
static void
Test(int level)
{
SQLRETURN result;
SQLSMALLINT InParam = level;
SQLSMALLINT OutParam = 1;
SQLLEN cbReturnCode = 0, cbInParam = 0, cbOutParam = 0;
SQLLEN cbOutString = SQL_NTS;
char sql[80];
printf("ODBC %d nocount %s select %s level %d\n", odbc_use_version3 ? 3 : 2,
g_nocount ? "yes" : "no", g_second_select ? "yes" : "no", level);
ReturnCode = INVALID_RETURN;
memset(&OutString, 0, sizeof(OutString));
/* test with SQLExecDirect */
sprintf(sql, "RAISERROR('An error occurred.', %d, 1)", level);
result = odbc_command_with_result(odbc_stmt, sql);
TestResult(result, level, "SQLExecDirect");
/* test with SQLPrepare/SQLExecute */
if (!SQL_SUCCEEDED(SQLPrepare(odbc_stmt, T(SP_TEXT), strlen(SP_TEXT)))) {
fprintf(stderr, "SQLPrepare failure!\n");
exit(1);
}
SQLBindParameter(odbc_stmt, 1, SQL_PARAM_OUTPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &ReturnCode, 0, &cbReturnCode);
SQLBindParameter(odbc_stmt, 2, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &InParam, 0, &cbInParam);
SQLBindParameter(odbc_stmt, 3, SQL_PARAM_OUTPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &OutParam, 0, &cbOutParam);
strcpy(OutString, "Invalid!");
SQLBindParameter(odbc_stmt, 4, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_VARCHAR, OUTSTRING_LEN, 0, OutString, OUTSTRING_LEN,
&cbOutString);
CHKExecute("S");
/* first select, check data are returned.
* SET statements before does not affect results
*/
CheckData("");
CHKFetch("S");
CheckData("Here is the first row");
result = SQLFetch(odbc_stmt);
if (odbc_use_version3) {
SQLTCHAR SqlState[6];
SQLINTEGER NativeError;
SQLTCHAR MessageText[1000];
SQLSMALLINT TextLength;
SQLRETURN expected;
SQLLEN rows;
if (result != SQL_NO_DATA)
ODBC_REPORT_ERROR("SQLFetch should return NO DATA");
CHKGetDiagRec(SQL_HANDLE_STMT, odbc_stmt, 1, SqlState, &NativeError, MessageText,
ODBC_VECTOR_SIZE(MessageText), &TextLength, "No");
result = SQLMoreResults(odbc_stmt);
expected = level > 10 ? SQL_ERROR : SQL_SUCCESS_WITH_INFO;
if (result != expected)
ODBC_REPORT_ERROR("SQLMoreResults returned unexpected result");
if (!g_second_select && g_nocount) {
if (ReturnCode == INVALID_RETURN) {
result = SQLMoreResults(odbc_stmt);
} else {
CheckReturnCode(result, 0);
ReturnCode = INVALID_RETURN;
TestResult(result, level, "SQLMoreResults");
ReturnCode = 0;
}
} else {
TestResult(result, level, "SQLMoreResults");
}
/* a recordset with only warnings/errors do not contains rows */
if (CHKRowCount(&rows, "SE") == SQL_SUCCESS && rows != -1)
ODBC_REPORT_ERROR("SQLRowCount returned some rows");
} else {
/* in ODBC 2 errors/warnings are not handled as different recordset */
TestResult(result, level, "SQLFetch");
}
if (odbc_driver_is_freetds())
CheckData("");
if (!g_second_select) {
SQLLEN rows;
if (CHKRowCount(&rows, "SE") == SQL_SUCCESS && rows != -1)
ODBC_REPORT_ERROR("SQLRowCount returned some rows");
CheckReturnCode(result, g_nocount ? 0 : INVALID_RETURN);
result = SQLMoreResults(odbc_stmt);
#ifdef ENABLE_DEVELOPING
if (result != SQL_NO_DATA)
ODBC_REPORT_ERROR("SQLMoreResults should return NO DATA");
ODBC_CHECK_ROWS(-2);
#endif
CheckReturnCode(result, 0);
return;
}
if (!odbc_use_version3 || !g_nocount) {
/* mssql 2008 return SUCCESS_WITH_INFO with previous error */
CHKMoreResults("S");
result = SQL_SUCCESS;
}
CheckReturnCode(result, INVALID_RETURN);
CheckData("");
if (g_nocount && odbc_use_version3 && g_second_select && level >= 10) {
if (CHKFetch("SE") == SQL_ERROR) {
SQLMoreResults(odbc_stmt);
CHKFetch("S");
}
} else {
CHKFetch("S");
}
CheckData("Here is the last row");
CHKFetch("No");
CheckData("");
if (!odbc_use_version3 || g_nocount)
CheckReturnCode(result, 0);
#ifdef ENABLE_DEVELOPING
else
CheckReturnCode(result, INVALID_RETURN);
#endif
/* FIXME how to handle return in store procedure ?? */
result = SQLMoreResults(odbc_stmt);
#ifdef ENABLE_DEVELOPING
if (result != SQL_NO_DATA)
ODBC_REPORT_ERROR("SQLMoreResults return other data");
#endif
CheckReturnCode(result, 0);
CheckData("");
ODBC_FREE();
}
int
main(int argc, char *argv[])
{
SQLTCHAR tmp[2048];
char conn[128];
SQLTCHAR sqlstate[6];
SQLSMALLINT len;
int port;
time_t start_time, end_time;
#ifdef _WIN32
WSADATA wsaData;
WSAStartup(MAKEWORD(1, 1), &wsaData);
#endif
if (tds_mutex_init(&mtx))
return 1;
if (odbc_read_login_info())
exit(1);
/*
* prepare our odbcinst.ini
* is better to do it before connect cause uniODBC cache INIs
* the name must be odbcinst.ini cause unixODBC accept only this name
*/
if (odbc_driver[0]) {
FILE *f = fopen("odbcinst.ini", "w");
if (f) {
fprintf(f, "[FreeTDS]\nDriver = %s\n", odbc_driver);
fclose(f);
/* force iODBC */
setenv("ODBCINSTINI", "./odbcinst.ini", 1);
setenv("SYSODBCINSTINI", "./odbcinst.ini", 1);
/* force unixODBC (only directory) */
setenv("ODBCSYSINI", ".", 1);
}
}
for (port = 12340; port < 12350; ++port)
if (!init_fake_server(port))
break;
if (port == 12350) {
fprintf(stderr, "Cannot bind to a port\n");
return 1;
}
printf("Fake server bound at port %d\n", port);
init_connect();
CHKSetConnectAttr(SQL_ATTR_CONNECTION_TIMEOUT, (SQLPOINTER) 10, sizeof(SQLINTEGER), "SI");
CHKSetConnectAttr(SQL_ATTR_LOGIN_TIMEOUT, (SQLPOINTER) 10, SQL_IS_UINTEGER, "SI");
/* this is expected to work with unixODBC */
printf("try to connect to our port just to check connection timeout\n");
sprintf(conn, "DRIVER=FreeTDS;SERVER=127.0.0.1;Port=%d;TDS_Version=7.0;UID=test;PWD=test;DATABASE=tempdb;", port);
start_time = time(NULL);
CHKDriverConnect(NULL, T(conn), SQL_NTS, tmp, ODBC_VECTOR_SIZE(tmp), &len, SQL_DRIVER_NOPROMPT, "E");
end_time = time(NULL);
memset(sqlstate, 'X', sizeof(sqlstate));
tmp[0] = 0;
CHKGetDiagRec(SQL_HANDLE_DBC, odbc_conn, 1, sqlstate, NULL, tmp, ODBC_VECTOR_SIZE(tmp), NULL, "SI");
odbc_disconnect();
tds_mutex_lock(&mtx);
CLOSESOCKET(fake_sock);
tds_mutex_unlock(&mtx);
tds_thread_join(fake_thread, NULL);
printf("Message: %s - %s\n", C(sqlstate), C(tmp));
if (strcmp(C(sqlstate), "HYT00") || !strstr(C(tmp), "Timeout")) {
fprintf(stderr, "Invalid timeout message\n");
return 1;
}
if (end_time - start_time < 10 || end_time - start_time > 16) {
fprintf(stderr, "Unexpected connect timeout (%d)\n", (int) (end_time - start_time));
return 1;
}
printf("Done.\n");
ODBC_FREE();
return 0;
}
static void
query_test(int prepare, SQLRETURN expected, const char *expected_status)
{
#define DESC_LEN 51
#define ARRAY_SIZE 10
SQLUINTEGER *ids = XMALLOC_N(SQLUINTEGER,ARRAY_SIZE);
typedef SQLCHAR desc_t[DESC_LEN];
desc_t *descs = XMALLOC_N(desc_t, ARRAY_SIZE);
SQLLEN *id_lens = XMALLOC_N(SQLLEN,ARRAY_SIZE), *desc_lens = XMALLOC_N(SQLLEN,ARRAY_SIZE);
SQLUSMALLINT i, *statuses = XMALLOC_N(SQLUSMALLINT,ARRAY_SIZE);
unsigned *num_errors = XMALLOC_N(unsigned, ARRAY_SIZE);
SQLULEN processed;
RETCODE ret;
char status[20];
SQLTCHAR *err = ODBC_GET(sizeof(odbc_err)*sizeof(SQLTCHAR));
SQLTCHAR *state = ODBC_GET(sizeof(odbc_sqlstate)*sizeof(SQLTCHAR));
assert(odbc_stmt != SQL_NULL_HSTMT);
odbc_reset_statement();
odbc_command_with_result(odbc_stmt, "drop table #tmp1");
odbc_command("create table #tmp1 (id tinyint, value char(20))");
SQLSetStmtAttr(odbc_stmt, SQL_ATTR_PARAM_BIND_TYPE, SQL_PARAM_BIND_BY_COLUMN, 0);
SQLSetStmtAttr(odbc_stmt, SQL_ATTR_PARAMSET_SIZE, (void *) ARRAY_SIZE, 0);
SQLSetStmtAttr(odbc_stmt, SQL_ATTR_PARAM_STATUS_PTR, statuses, 0);
SQLSetStmtAttr(odbc_stmt, SQL_ATTR_PARAMS_PROCESSED_PTR, &processed, 0);
SQLBindParameter(odbc_stmt, 1, SQL_PARAM_INPUT, SQL_C_ULONG, SQL_INTEGER, 5, 0, ids, 0, id_lens);
SQLBindParameter(odbc_stmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, DESC_LEN - 1, 0, descs, DESC_LEN, desc_lens);
processed = ARRAY_SIZE + 1;
for (i = 0; i < ARRAY_SIZE; i++) {
statuses[i] = SQL_PARAM_DIAG_UNAVAILABLE;
ids[i] = (i + 1) * multiply;
sprintf((char *) descs[i], "data %d", i * 7);
id_lens[i] = 0;
desc_lens[i] = SQL_NTS;
num_errors[i] = 0;
}
multiply = 90;
if (!prepare) {
ret = SQLExecDirect(odbc_stmt, test_query, SQL_NTS);
} else {
SQLPrepare(odbc_stmt, test_query, SQL_NTS);
ret = SQLExecute(odbc_stmt);
}
if (processed > ARRAY_SIZE) {
char buf[256];
sprintf(buf, "Invalid processed number: %d", (int) processed);
ODBC_REPORT_ERROR(buf);
}
for (i = 1; CHKGetDiagRec(SQL_HANDLE_STMT, odbc_stmt, i, state, NULL, err, sizeof(odbc_err), NULL, "SINo") != SQL_NO_DATA; ++i) {
SQLINTEGER row;
strcpy(odbc_err, C(err));
strcpy(odbc_sqlstate, C(state));
CHKGetDiagField(SQL_HANDLE_STMT, odbc_stmt, i, SQL_DIAG_ROW_NUMBER, &row, sizeof(row), NULL, "S");
if (row == SQL_ROW_NUMBER_UNKNOWN) continue;
if (row < 1 || row > ARRAY_SIZE) {
fprintf(stderr, "invalid row %d returned reading error number %d\n", (int) row, i);
exit(1);
}
++num_errors[row-1];
printf("for row %2d returned '%s' %s\n", (int) row, odbc_sqlstate, odbc_err);
}
for (i = 0; i < processed; ++i) {
int has_diag = 0;
switch (statuses[i]) {
case SQL_PARAM_SUCCESS_WITH_INFO:
has_diag = 1;
case SQL_PARAM_SUCCESS:
status[i] = 'V';
break;
case SQL_PARAM_ERROR:
has_diag = 1;
status[i] = '!';
break;
case SQL_PARAM_UNUSED:
status[i] = ' ';
break;
case SQL_PARAM_DIAG_UNAVAILABLE:
status[i] = '?';
break;
default:
fprintf(stderr, "Invalid status returned %d\n", statuses[i]);
exit(1);
}
if (has_diag) {
if (!num_errors[i]) {
fprintf(stderr, "Diagnostics not returned for status %d\n", i);
failure = 1;
}
} else {
if (num_errors[i]) {
fprintf(stderr, "Diagnostics returned for status %d\n", i);
failure = 1;
}
}
}
status[i] = 0;
if (ret != expected || strcmp(expected_status, status) != 0) {
fprintf(stderr, "Invalid result: got %d \"%s\" expected %d \"%s\" processed %d\n",
ret, status, expected, expected_status, (int) processed);
if (ret != SQL_SUCCESS)
odbc_read_error();
failure = 1;
odbc_reset_statement();
return;
}
odbc_reset_statement();
}
