static void
DoTest(int n)
{
SQLCHAR output[256];
SQLSMALLINT colType;
SQLULEN colSize;
SQLSMALLINT colScale, colNullable;
SQLLEN dataSize;
TIMESTAMP_STRUCT ts;
odbc_command("select convert(datetime, '2002-12-27 18:43:21')");
CHKFetch("SI");
CHKDescribeCol(1, (SQLTCHAR*)output, sizeof(output)/sizeof(SQLWCHAR), NULL, &colType, &colSize, &colScale, &colNullable, "S");
if (n == 0) {
memset(&ts, 0, sizeof(ts));
CHKGetData(1, SQL_C_TIMESTAMP, &ts, sizeof(ts), &dataSize, "S");
sprintf((char *) output, "%04d-%02d-%02d %02d:%02d:%02d.000", ts.year, ts.month, ts.day, ts.hour, ts.minute, ts.second);
} else {
CHKGetData(1, SQL_C_CHAR, output, sizeof(output), &dataSize, "S");
}
printf("Date returned: %s\n", output);
if (strcmp((char *) output, "2002-12-27 18:43:21.000") != 0) {
fprintf(stderr, "Invalid returned date\n");
exit(1);
}
CHKFetch("No");
CHKCloseCursor("SI");
}
static void
readBlobAsChar(test_info *t, int step, int wide)
{
SQLRETURN rc = SQL_SUCCESS_WITH_INFO;
char buf[8192];
SQLLEN len, total = 0, len2;
int i = 0;
int check;
int bufsize;
SQLSMALLINT type = SQL_C_CHAR;
unsigned int char_len = 1;
if (wide) {
char_len = sizeof(SQLWCHAR);
type = SQL_C_WCHAR;
}
if (step%2) bufsize = sizeof(buf) - char_len;
else bufsize = sizeof(buf);
printf(">> readBlobAsChar field %d\n", t->num);
while (rc == SQL_SUCCESS_WITH_INFO) {
i++;
rc = CHKGetData(t->num, type, (SQLPOINTER) buf, (SQLINTEGER) bufsize, &len, "SINo");
if (rc == SQL_SUCCESS_WITH_INFO && len == SQL_NO_TOTAL) {
len = bufsize - char_len;
rc = SQL_SUCCESS;
}
if (rc == SQL_NO_DATA || len <= 0)
break;
rc = CHKGetData(t->num, type, (SQLPOINTER) buf, 0, &len2, "SINo");
if (rc == SQL_SUCCESS_WITH_INFO && len2 != SQL_NO_TOTAL)
len = len - len2;
#if 0
if (len > (SQLLEN) (bufsize - char_len))
len = (SQLLEN) (bufsize - char_len);
len -= len % (2u * char_len);
#endif
printf(">> step %d: %d bytes readed\n", i, (int) len);
if (wide) {
len /= sizeof(SQLWCHAR);
odbc_from_sqlwchar((char *) buf, (SQLWCHAR *) buf, len + 1);
}
check = check_hex(buf, len, 2*t->gen1 + total, t->gen2);
if (!check) {
fprintf(stderr, "Wrong buffer content\n");
dump(stderr, " buf ", buf, len);
failed = 1;
}
total += len;
}
printf(">> total bytes read = %d \n", (int) total);
if (total != 20000) {
fprintf(stderr, "Wrong buffer length, expected 20000\n");
failed = 1;
}
}
static void
ReadCol(int i)
{
memset(output, 'x', sizeof(output));
strcpy(output, "NULL");
CHKGetData(i, SQL_C_CHAR, output, sizeof(output), &cnamesize, "S");
}
static void
readBlob(test_info *t)
{
SQLRETURN rc;
char buf[4096];
SQLLEN len, total = 0;
int i = 0;
int check;
printf(">> readBlob field %d\n", t->num);
while (1) {
i++;
rc = CHKGetData(t->num, SQL_C_BINARY, (SQLPOINTER) buf, (SQLINTEGER) sizeof(buf), &len, "SINo");
if (rc == SQL_NO_DATA || len <= 0)
break;
if (len > (SQLLEN) sizeof(buf))
len = (SQLLEN) sizeof(buf);
printf(">> step %d: %d bytes readed\n", i, (int) len);
check = check_chars(buf, len, t->gen1 + total, t->gen2);
if (!check) {
fprintf(stderr, "Wrong buffer content\n");
dump(stderr, " buf ", buf, len);
failed = 1;
}
total += len;
}
printf(">> total bytes read = %d \n", (int) total);
if (total != 10000) {
fprintf(stderr, "Wrong buffer length, expected 20000\n");
failed = 1;
}
}
static int
test_select(void *buf, SQLINTEGER buflen, SQLLEN * bytes_returned)
{
SQLHSTMT odbc_stmt = SQL_NULL_HSTMT;
SQLLEN strlen_or_ind = 0;
const char *qstr = "select * from " TEST_TABLE_NAME;
assert(odbc_conn);
assert(odbc_env);
/* allocate new statement handle */
CHKAllocHandle(SQL_HANDLE_STMT, odbc_conn, &odbc_stmt, "SI");
/* execute query */
CHKExecDirect(T(qstr), SQL_NTS, "SINo");
/* fetch first page of first result row of unbound column */
CHKFetch("S");
strlen_or_ind = 0;
CHKGetData(1, SQL_C_BINARY, buf, buflen, &strlen_or_ind, "SINo");
*bytes_returned = ((strlen_or_ind > buflen || (strlen_or_ind == SQL_NO_TOTAL)) ? buflen : strlen_or_ind);
/* ensure that this was the only row */
CHKFetch("No");
SQLFreeHandle(SQL_HANDLE_STMT, odbc_stmt);
ODBC_FREE();
return 0;
}
int
main(int argc, char **argv)
{
char buff[64];
SQLLEN ind;
odbc_use_version3 = 1;
odbc_connect();
odbc_check_cursor();
exec_direct("CREATE TABLE #t1 ( k INT, c VARCHAR(20))");
exec_direct("INSERT INTO #t1 VALUES (1, 'aaa')");
odbc_reset_statement();
CHKSetStmtAttr(SQL_ATTR_CONCURRENCY, (SQLPOINTER) SQL_CONCUR_LOCK, SQL_IS_UINTEGER, "S");
CHKSetCursorName(T("c112"), SQL_NTS, "S");
CHKSetConnectAttr(SQL_ATTR_AUTOCOMMIT, int2ptr(SQL_AUTOCOMMIT_OFF), 0, "S");
CHKPrepare(T("SELECT * FROM #t1 FOR UPDATE"), SQL_NTS, "S");
CHKExecute("S");
CHKFetch("S");
exec_direct("UPDATE #t1 SET c = 'xxx' WHERE CURRENT OF c112");
CHKCloseCursor("SI");
CHKEndTran(SQL_HANDLE_DBC, odbc_conn, SQL_COMMIT, "S");
CHKSetConnectAttr(SQL_ATTR_AUTOCOMMIT, int2ptr(SQL_AUTOCOMMIT_ON), 0, "S");
CHKExecDirect(T("SELECT c FROM #t1 WHERE k = 1"), SQL_NTS, "S");
CHKFetch("S");
CHKGetData(1, SQL_C_CHAR, buff, sizeof(buff), &ind, "S");
printf(">> New value after update = [%s] (should be [xxx]) \n", buff);
CHKFreeHandle(SQL_HANDLE_STMT, (SQLHANDLE) odbc_stmt, "S");
odbc_stmt = SQL_NULL_HSTMT;
odbc_disconnect();
return 0;
}
int
main(int argc, char *argv[])
{
int i;
SQLLEN cnamesize;
const char *command;
SQLCHAR output[256];
odbc_connect();
odbc_command("if object_id('tempdb..#odbctestdata') is not null drop table #odbctestdata");
command = "create table #odbctestdata ("
"col1 varchar(30) not null,"
"col2 int not null,"
"col3 float not null," "col4 numeric(18,6) not null," "col5 datetime not null," "col6 text not null)";
odbc_command(command);
command = "insert #odbctestdata values ("
"'ABCDEFGHIJKLMNOP',"
"123456," "1234.56," "123456.78," "'Sep 11 2001 10:00AM'," "'just to check returned length...')";
odbc_command(command);
odbc_command("select * from #odbctestdata");
CHKFetch("SI");
for (i = 1; i <= 6; i++) {
CHKGetData(i, SQL_C_CHAR, output, sizeof(output), &cnamesize, "S");
printf("output data >%s< len_or_ind = %d\n", output, (int) cnamesize);
if (cnamesize != strlen((char *) output))
return 1;
}
CHKFetch("No");
CHKCloseCursor("SI");
odbc_command("drop table #odbctestdata");
odbc_disconnect();
printf("Done.\n");
return 0;
}
static void
CheckData(const char *s, int line)
{
char buf[80];
SQLLEN ind;
SQLRETURN rc;
rc = CHKGetData(1, SQL_C_CHAR, buf, sizeof(buf), &ind, "SE");
if (rc == SQL_ERROR) {
buf[0] = 0;
ind = 0;
}
if (strlen(s) != ind || strcmp(buf, s) != 0)
MY_ERROR("Invalid result");
}
static void
test_err(const char *data, int c_type, const char *state)
{
char sql[128];
SQLLEN ind;
const unsigned int buf_size = 128;
char *buf = (char *) malloc(buf_size);
sprintf(sql, "SELECT '%s'", data);
odbc_command(sql);
SQLFetch(odbc_stmt);
CHKGetData(1, c_type, buf, buf_size, &ind, "E");
free(buf);
odbc_read_error();
if (strcmp(odbc_sqlstate, state) != 0) {
fprintf(stderr, "Unexpected sql state returned\n");
odbc_disconnect();
exit(1);
}
odbc_reset_statement();
}
int
main(int argc, char *argv[])
{
char output[256];
SQLLEN dataSize;
odbc_connect();
odbc_command_with_result(odbc_stmt, "drop proc sp_norowset_test");
odbc_command("create proc sp_norowset_test as begin declare @i int end");
odbc_command("exec sp_norowset_test");
/* note, mssql 2005 seems to not return row for tempdb, use always master */
odbc_command("select name from master..sysobjects where name = 'sysobjects'");
CHKFetch("S");
CHKGetData(1, SQL_C_CHAR, output, sizeof(output), &dataSize, "S");
if (strcmp(output, "sysobjects") != 0) {
printf("Unexpected result\n");
exit(1);
}
CHKFetch("No");
CHKMoreResults("No");
odbc_command("drop proc sp_norowset_test");
odbc_disconnect();
printf("Done.\n");
return 0;
}
static void
test_split(const char *n_flag)
{
#define CheckLen(x) do { \
if (len != (x)) { \
fprintf(stderr, "Wrong len %ld at line %d expected %d\n", (long int) len, __LINE__, (x)); \
exit(1); \
} \
} while(0)
char sql[80];
char *buf = NULL;
SQLLEN len;
/* TODO test with VARCHAR too */
sprintf(sql, "SELECT CONVERT(%sTEXT,'Prova' + REPLICATE('x',500))", n_flag);
odbc_command(sql);
CHKFetch("S");
/* these 2 tests test an old severe BUG in FreeTDS */
buf = ODBC_GET(1);
CHKGetData(1, type, buf, 0, &len, "I");
if (len != SQL_NO_TOTAL)
CheckLen(505*lc);
CHKGetData(1, type, buf, 0, &len, "I");
if (len != SQL_NO_TOTAL)
CheckLen(505*lc);
buf = ODBC_GET(3*lc);
CHKGetData(1, type, buf, 3 * lc, &len, "I");
if (len != SQL_NO_TOTAL)
CheckLen(505*lc);
if (mycmp(buf, "Pr") != 0) {
printf("Wrong data result 1\n");
exit(1);
}
buf = ODBC_GET(16*lc);
CHKGetData(1, type, buf, 16 * lc, &len, "I");
if (len != SQL_NO_TOTAL)
CheckLen(503*lc);
if (mycmp(buf, "ovaxxxxxxxxxxxx") != 0) {
printf("Wrong data result 2 res = '%s'\n", buf);
exit(1);
}
buf = ODBC_GET(256*lc);
CHKGetData(1, type, buf, 256 * lc, &len, "I");
if (len != SQL_NO_TOTAL)
CheckLen(488*lc);
CHKGetData(1, type, buf, 256 * lc, &len, "S");
CheckLen(233*lc);
CHKGetData(1, type, buf, 256 * lc, &len, "No");
odbc_reset_statement();
/* test with varchar, not blob but variable */
sprintf(sql, "SELECT CONVERT(%sVARCHAR(100), 'Other test')", n_flag);
odbc_command(sql);
CHKFetch("S");
buf = ODBC_GET(7*lc);
CHKGetData(1, type, buf, 7 * lc, NULL, "I");
if (mycmp(buf, "Other ") != 0) {
printf("Wrong data result 1\n");
exit(1);
}
buf = ODBC_GET(5*lc);
CHKGetData(1, type, buf, 20, NULL, "S");
if (mycmp(buf, "test") != 0) {
printf("Wrong data result 2 res = '%s'\n", buf);
exit(1);
}
ODBC_FREE();
odbc_reset_statement();
}
int
main(int argc, char *argv[])
{
char buf[32];
SQLINTEGER int_buf;
SQLLEN len;
SQLRETURN rc;
odbc_connect();
lc = 1;
type = SQL_C_CHAR;
test_split("");
lc = sizeof(SQLWCHAR);
type = SQL_C_WCHAR;
test_split("");
if (odbc_db_is_microsoft() && odbc_db_version_int() >= 0x07000000u) {
lc = 1;
type = SQL_C_CHAR;
test_split("N");
lc = sizeof(SQLWCHAR);
type = SQL_C_WCHAR;
test_split("N");
}
/* test with fixed length */
odbc_command("SELECT CONVERT(INT, 12345)");
CHKFetch("S");
int_buf = 0xdeadbeef;
CHKGetData(1, SQL_C_SLONG, &int_buf, 0, NULL, "S");
if (int_buf != 12345) {
printf("Wrong data result\n");
exit(1);
}
CHKGetData(1, SQL_C_SLONG, &int_buf, 0, NULL, "No");
if (int_buf != 12345) {
printf("Wrong data result 2 res = %d\n", (int) int_buf);
exit(1);
}
odbc_reset_statement();
/* test with numeric */
odbc_command("SELECT CONVERT(NUMERIC(18,5), 1850000000000)");
CHKFetch("S");
memset(buf, 'x', sizeof(buf));
CHKGetData(1, SQL_C_CHAR, buf, 14, NULL, "S");
buf[sizeof(buf)-1] = 0;
if (strcmp(buf, "1850000000000") != 0) {
printf("Wrong data result: %s\n", buf);
exit(1);
}
/* should give NO DATA */
CHKGetData(1, SQL_C_CHAR, buf, 14, NULL, "No");
buf[sizeof(buf)-1] = 0;
if (strcmp(buf, "1850000000000") != 0) {
printf("Wrong data result 3 res = %s\n", buf);
exit(1);
}
odbc_reset_statement();
/* test int to truncated string */
odbc_command("SELECT CONVERT(INTEGER, 12345)");
CHKFetch("S");
/* error 22003 */
memset(buf, 'x', sizeof(buf));
CHKGetData(1, SQL_C_CHAR, buf, 4, NULL, "E");
#ifdef ENABLE_DEVELOPING
buf[4] = 0;
if (strcmp(buf, "xxxx") != 0) {
fprintf(stderr, "Wrong buffer result buf = %s\n", buf);
exit(1);
}
#endif
odbc_read_error();
if (strcmp(odbc_sqlstate, "22003") != 0) {
fprintf(stderr, "Unexpected sql state %s returned\n", odbc_sqlstate);
odbc_disconnect();
exit(1);
}
CHKGetData(1, SQL_C_CHAR, buf, 2, NULL, "No");
odbc_reset_statement();
/* test unique identifier to truncated string */
rc = odbc_command2("SELECT CONVERT(UNIQUEIDENTIFIER, 'AA7DF450-F119-11CD-8465-00AA00425D90')", "SENo");
if (rc != SQL_ERROR) {
CHKFetch("S");
/* error 22003 */
CHKGetData(1, SQL_C_CHAR, buf, 17, NULL, "E");
odbc_read_error();
if (strcmp(odbc_sqlstate, "22003") != 0) {
fprintf(stderr, "Unexpected sql state %s returned\n", odbc_sqlstate);
odbc_disconnect();
exit(1);
}
CHKGetData(1, SQL_C_CHAR, buf, 2, NULL, "No");
}
odbc_reset_statement();
odbc_disconnect();
odbc_use_version3 = 1;
odbc_connect();
/* test error from SQLGetData */
/* wrong constant, SQL_VARCHAR is invalid as C type */
test_err("prova 123", SQL_VARCHAR, "HY003");
/* use ARD but no ARD data column */
test_err("prova 123", SQL_ARD_TYPE, "07009");
/* wrong conversion, int */
test_err("prova 123", SQL_C_LONG, "22018");
/* wrong conversion, date */
test_err("prova 123", SQL_C_TIMESTAMP, "22018");
/* overflow */
test_err("1234567890123456789", SQL_C_LONG, "22003");
/* test for empty string from mssql */
if (odbc_db_is_microsoft()) {
lc = 1;
type = SQL_C_CHAR;
for (;;) {
void *buf = ODBC_GET(lc);
odbc_command("SELECT CONVERT(TEXT,'')");
CHKFetch("S");
len = 1234;
CHKGetData(1, type, buf, lc, &len, "S");
if (len != 0) {
fprintf(stderr, "Wrong len returned, returned %ld\n", (long) len);
return 1;
}
CHKGetData(1, type, buf, lc, NULL, "No");
odbc_reset_statement();
ODBC_FREE();
buf = ODBC_GET(4096*lc);
odbc_command("SELECT CONVERT(TEXT,'')");
CHKFetch("S");
len = 1234;
CHKGetData(1, type, buf, lc*4096, &len, "S");
if (len != 0) {
fprintf(stderr, "Wrong len returned, returned %ld\n", (long) len);
return 1;
}
CHKGetData(1, type, buf, lc*4096, NULL, "No");
odbc_reset_statement();
ODBC_FREE();
if (type != SQL_C_CHAR)
break;
lc = sizeof(SQLWCHAR);
type = SQL_C_WCHAR;
}
odbc_command("SELECT CONVERT(TEXT,'')");
CHKFetch("S");
len = 1234;
CHKGetData(1, SQL_C_BINARY, buf, 1, &len, "S");
if (len != 0) {
fprintf(stderr, "Wrong len returned, returned %ld\n", (long) len);
return 1;
}
CHKGetData(1, SQL_C_BINARY, buf, 1, NULL, "No");
}
odbc_disconnect();
printf("Done.\n");
return 0;
}
static int
test(int odbc3)
{
SQLLEN cnamesize;
const char *query;
odbc_use_version3 = odbc3;
odbc_connect();
/* issue print statement and test message returned */
output[0] = 0;
query = "print 'START' select count(*) from sysobjects where name='sysobjects' print 'END'";
odbc_command2(query, "I");
odbc_read_error();
if (!strstr(odbc_err, "START")) {
printf("Message invalid\n");
return 1;
}
odbc_err[0] = 0;
if (odbc3) {
ODBC_CHECK_COLS(0);
ODBC_CHECK_ROWS(-1);
CHKFetch("E");
CHKMoreResults("S");
}
ODBC_CHECK_COLS(1);
ODBC_CHECK_ROWS(-1);
CHKFetch("S");
ODBC_CHECK_COLS(1);
ODBC_CHECK_ROWS(-1);
/* check no data */
CHKFetch("No");
ODBC_CHECK_COLS(1);
ODBC_CHECK_ROWS(1);
/* SQLMoreResults return NO DATA or SUCCESS WITH INFO ... */
if (tds_no_dm && !odbc3)
CHKMoreResults("No");
else if (odbc3)
CHKMoreResults("I");
else
CHKMoreResults("INo");
/*
* ... but read error
* (unixODBC till 2.2.11 do not read errors on NO DATA, skip test)
*/
if (tds_no_dm || odbc3) {
odbc_read_error();
if (!strstr(odbc_err, "END")) {
printf("Message invalid\n");
return 1;
}
odbc_err[0] = 0;
}
if (odbc3) {
ODBC_CHECK_COLS(0);
ODBC_CHECK_ROWS(-1);
CHKMoreResults("No");
}
/* issue invalid command and test error */
odbc_command2("SELECT donotexistsfield FROM donotexiststable", "E");
odbc_read_error();
/* test no data returned */
CHKFetch("E");
odbc_read_error();
CHKGetData(1, SQL_C_CHAR, output, sizeof(output), &cnamesize, "E");
odbc_read_error();
odbc_disconnect();
return 0;
}
