int
main(int argc, char *argv[])
{
char int_buf[32];
odbc_use_version3 = 0;
odbc_connect();
TestProc("DATETIME", STR(SQL_TIMESTAMP));
TestTable("DATETIME", STR(SQL_TIMESTAMP));
odbc_disconnect();
odbc_use_version3 = 1;
odbc_connect();
TestProc("DATETIME", STR(SQL_TYPE_TIMESTAMP));
TestTable("DATETIME", STR(SQL_TYPE_TIMESTAMP));
odbc_disconnect();
printf("Done.\n");
return 0;
}
int
main(int argc, char *argv[])
{
odbc_use_version3 = 1;
odbc_connect();
odbc_check_cursor();
Init();
#define ALL(n) for (n = 0; n < 2; ++n)
ALL(use_cursors)
ALL(bind_all)
ALL(normal_fetch)
Test();
odbc_disconnect();
odbc_use_version3 = 0;
odbc_connect();
Init();
ALL(use_cursors)
ALL(bind_all)
ALL(normal_fetch)
Test();
odbc_disconnect();
return 0;
}
int
main(int argc, char *argv[])
{
char buf[102];
SQLLEN ind;
int failed = 0;
odbc_use_version3 = 1;
odbc_connect();
CHKBindCol(1, SQL_C_DEFAULT, buf, 100, &ind, "S");
odbc_command("SELECT CONVERT(NCHAR(10), 'Pippo 123')");
/* get data */
memset(buf, 0, sizeof(buf));
CHKFetch("S");
SQLMoreResults(odbc_stmt);
SQLMoreResults(odbc_stmt);
odbc_disconnect();
if (strcmp(buf, "Pippo 123 ") != 0) {
fprintf(stderr, "Wrong results '%s'\n", buf);
failed = 1;
}
return failed ? 1 : 0;
}
int
main(void)
{
int i;
char cmd[128 + 110*10];
printf("SQLWCHAR size is: %d\n", (int) sizeof(SQLWCHAR));
odbc_use_version3 = 1;
odbc_connect();
/* this test do not work with Sybase */
if (!odbc_db_is_microsoft()) {
odbc_disconnect();
return 0;
}
strcpy(cmd, "create procedure #proc_longerror as\nbegin\nraiserror('");
for (i = 0; i < 110; ++i)
strcat(cmd, "reallylong");
strcat(cmd, " error', 16, 1)\nend\n");
odbc_command(cmd);
CHKR2(SQLExecDirectW,
(odbc_stmt, odbc_get_sqlwchar(&odbc_buf, "{CALL #proc_longerror}"), SQL_NTS),
SQL_HANDLE_STMT, odbc_stmt, "E");
extract_error(odbc_stmt, SQL_HANDLE_STMT);
odbc_disconnect();
return 0;
}
int
main(int argc, char *argv[])
{
SQLSMALLINT num_params, cols;
SQLLEN count;
SQLINTEGER id;
odbc_use_version3 = 1;
odbc_connect();
odbc_command("create table #tester (id int not null, name varchar(20) not null)");
odbc_command("insert into #tester(id, name) values(1, 'abc')");
odbc_command("insert into #tester(id, name) values(2, 'duck')");
CHKPrepare(T("SELECT * FROM #tester WHERE id = ?"), SQL_NTS, "S");
CHKR(SQLNumParams, (odbc_stmt, &num_params), "S");
assert(num_params == 1);
id = 1;
CHKBindParameter(1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, 0, 0, &id, sizeof(id), NULL, "S");
CHKExecute("S");
CHKR(SQLFreeStmt, (odbc_stmt, SQL_RESET_PARAMS), "S");
CHKRowCount(&count, "S");
CHKNumResultCols(&cols, "S");
assert(cols == 2);
odbc_disconnect();
return 0;
}
int
main(void)
{
SQLHDESC Descriptor;
SQLINTEGER ind;
SQLTCHAR name[128];
SQLSMALLINT si;
odbc_use_version3 = 1;
odbc_connect();
odbc_command("create table #tmp1 (i int)");
/* get IRD */
CHKGetStmtAttr(SQL_ATTR_IMP_ROW_DESC, &Descriptor, sizeof(Descriptor), &ind, "S");
CHKGetDescRec(-1, name, ODBC_VECTOR_SIZE(name), &si, NULL, NULL, NULL, NULL, NULL, NULL, "E");
/* TODO here should be NO_DATA cause we are requesting bookmark */
/* CHKGetDescRec(0, name, sizeof(name), &si, NULL, NULL, NULL, NULL, NULL, NULL, "No"); */
CHKGetDescRec(1, name, ODBC_VECTOR_SIZE(name), &si, NULL /*Type*/, NULL /*SubType*/, NULL /*Length*/, NULL/*Precision*/,
NULL /*Scale*/, NULL /*Nullable*/, "No");
odbc_command("SELECT name FROM sysobjects");
CHKGetDescRec(1, name, ODBC_VECTOR_SIZE(name), &si, NULL /*Type*/, NULL /*SubType*/, NULL /*Length*/, NULL/*Precision*/,
NULL /*Scale*/, NULL /*Nullable*/, "S");
odbc_disconnect();
ODBC_FREE();
return 0;
}
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;
}
int
main(int argc, char *argv[])
{
odbc_use_version3 = 1;
odbc_connect();
if (((char *) &big_endian)[0] == 1)
big_endian = 0;
for (use_cursors = 0; use_cursors <= 1; ++use_cursors) {
if (use_cursors) {
if (!tds_no_dm || !odbc_driver_is_freetds())
odbc_reset_statement();
odbc_check_cursor();
}
exec_direct = 1;
AllTests();
exec_direct = 0;
prepare_before = 1;
AllTests();
prepare_before = 0;
AllTests();
}
odbc_disconnect();
printf("Done successfully!\n");
return 0;
}
int
main(int argc, char **argv)
{
odbc_use_version3 = 1;
odbc_connect();
odbc_command("create table #test_output (id int, msg text)");
Test("?", SQL_INTEGER, "?", SQL_LONGVARCHAR);
Test("123", SQL_INTEGER, "?", SQL_LONGVARCHAR);
Test("?", SQL_INTEGER, "'foo'", SQL_LONGVARCHAR);
Test("?", SQL_INTEGER, "?", SQL_VARCHAR);
/*
* Sybase cannot pass this test without complicated query parsing.
* Query with blob columns cannot be prepared so prepared query must
* be emulated loosing column informations from server and Sybase do
* not convert implicitly VARCHAR to INT
*/
if (odbc_db_is_microsoft())
Test("?", SQL_VARCHAR, "?", SQL_LONGVARCHAR);
else
++test_num;
odbc_disconnect();
return 0;
}
int
main(void)
{
odbc_use_version3 = 1;
odbc_mark_sockets_opened();
odbc_connect();
CHKSetConnectAttr(SQL_ATTR_AUTOCOMMIT, (void *) SQL_AUTOCOMMIT_OFF, 0, "S");
odbc_command("SELECT 1");
CHKMoreResults("No");
if (!close_last_socket()) {
fprintf(stderr, "Error closing connection\n");
return 1;
}
CHKEndTran(SQL_HANDLE_DBC, odbc_conn, SQL_ROLLBACK, "E");
/* the error should be written in the connection, not in the statement */
ReadErrorConn();
if (strcmp(odbc_sqlstate, "08S01") != 0 || strstr(odbc_err, "Write to the server") == NULL) {
odbc_disconnect();
fprintf(stderr, "Unexpected error message %s %s\n", odbc_sqlstate, odbc_err);
return 1;
}
odbc_disconnect();
return 0;
}
static void
ConnectWithTxn(int txn)
{
global_txn = txn;
odbc_set_conn_attr = my_attrs;
odbc_connect();
odbc_set_conn_attr = NULL;
}
static int
Test(int bind_before)
{
SQLSMALLINT ReturnCode = 0;
SQLSMALLINT InParam = 5;
SQLSMALLINT OutParam = 1;
char OutString[OUTSTRING_LEN];
SQLLEN cbReturnCode = 0, cbInParam = 0, cbOutParam = 0;
SQLLEN cbOutString = SQL_NTS;
odbc_connect();
/* drop proc */
odbc_command("IF OBJECT_ID('spTestProc') IS NOT NULL DROP PROC spTestProc");
/* create proc */
odbc_command(sp_define);
if (!bind_before)
CHKPrepare(T(SP_TEXT), strlen(SP_TEXT), "S");
CHKBindParameter(1, SQL_PARAM_OUTPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &ReturnCode, 0, &cbReturnCode, "S");
CHKBindParameter(2, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &InParam, 0, &cbInParam, "S");
CHKBindParameter(3, SQL_PARAM_OUTPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &OutParam, 0, &cbOutParam, "S");
OutString[0] = '\0';
strcpy(OutString, "Test"); /* Comment this line and we get an error! Why? */
CHKBindParameter(4, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_VARCHAR, OUTSTRING_LEN, 0, OutString,
OUTSTRING_LEN, &cbOutString, "S");
if (bind_before)
CHKPrepare(T(SP_TEXT), strlen(SP_TEXT), "S");
CHKExecute("S");
odbc_command("DROP PROC spTestProc");
printf("Output:\n");
printf(" Return Code = %d\n", (int) ReturnCode);
printf(" InParam = %d\n", (int) InParam);
printf(" OutParam = %d\n", (int) OutParam);
printf(" OutString = %s\n", OutString);
if (InParam != OutParam) {
fprintf(stderr, "InParam != OutParam\n");
return 1;
}
if (strcmp(OutString, "This is cool!") != 0) {
fprintf(stderr, "Bad string returned\n");
return 1;
}
odbc_disconnect();
ODBC_FREE();
return 0;
}
int
main(int argc, char **argv)
{
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\nThreading = 0\n", odbc_driver);
fclose(f);
/* force iODBC */
setenv("ODBCINSTINI", "./odbcinst.ini", 1);
setenv("SYSODBCINSTINI", "./odbcinst.ini", 1);
/* force unixODBC (only directory) */
setenv("ODBCSYSINI", ".", 1);
}
}
odbc_use_version3 = 1;
odbc_connect();
odbc_command("IF OBJECT_ID('tab1') IS NOT NULL DROP TABLE tab1");
odbc_command("CREATE TABLE tab1 ( k INT, vc VARCHAR(200) )");
printf(">> Creating tab1...\n");
odbc_command("DECLARE @i INT\n"
"SET @i = 1\n"
"WHILE @i <= 2000 BEGIN\n"
"INSERT INTO tab1 VALUES ( @i, 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' )\n"
"SET @i = @i + 1\n"
"END");
while (CHKMoreResults("SNo") == SQL_SUCCESS)
continue;
printf(">> ...done.\n");
odbc_reset_statement();
Test(0, 0);
Test(1, 0);
Test(0, 1);
Test(1, 1);
odbc_command("DROP TABLE tab1");
odbc_disconnect();
return 0;
}
int
main(int argc, char *argv[])
{
odbc_use_version3 = 1;
odbc_connect();
if (odbc_db_is_microsoft()) {
/* all successes */
test_query = T("INSERT INTO #tmp1 (id, value) VALUES (?, ?)");
multiply = 1;
query_test(0, SQL_SUCCESS, "VVVVVVVVVV");
multiply = 1;
query_test(1, SQL_SUCCESS, "VVVVVVVVVV");
/* all errors */
test_query = T("INSERT INTO #tmp1 (id, value) VALUES (?, ?)");
multiply = 257;
query_test(0, SQL_ERROR, "!!!!!!!!!!");
multiply = 257;
query_test(1, SQL_SUCCESS_WITH_INFO, "!!!!!!!!!!");
test_query = T("INSERT INTO #tmp1 (id, value) VALUES (?, ?)");
query_test(0, SQL_ERROR, "VV!!!!!!!!");
query_test(1, SQL_SUCCESS_WITH_INFO, "VV!!!!!!!!");
test_query = T("INSERT INTO #tmp1 (id, value) VALUES (900-?, ?)");
query_test(0, SQL_SUCCESS_WITH_INFO, "!!!!!!!VVV");
query_test(1, SQL_SUCCESS_WITH_INFO, "!!!!!!!VVV");
test_query = T("INSERT INTO #tmp1 (id) VALUES (?) UPDATE #tmp1 SET value = ?");
query_test(0, SQL_SUCCESS_WITH_INFO, "VVVV!V!V!V");
query_test(1, SQL_SUCCESS_WITH_INFO, "VV!!!!!!!!");
#ifdef ENABLE_DEVELOPING
/* with result, see how SQLMoreResult work */
test_query = T("INSERT INTO #tmp1 (id) VALUES (?) SELECT * FROM #tmp1 UPDATE #tmp1 SET value = ?");
/* IMHO our driver is better here -- freddy77 */
query_test(0, SQL_SUCCESS, odbc_driver_is_freetds() ? "VVVVV!V!V!" : "VVVVVV!VVV");
query_test(1, SQL_SUCCESS, "VVVVVVVVVV");
#endif
} else {
/* Sybase test for conversions before executing */
test_query = T("INSERT INTO #tmp1 (id, value) VALUES (?/8, ?)");
query_test(0, SQL_SUCCESS, "VVVVVVVVVV");
}
/* TODO record binding, array fetch, sqlputdata */
odbc_disconnect();
printf(failure ? "Failed :(\n" : "Success!\n");
return failure;
}
int
main(int argc, char **argv)
{
int i;
SQLLEN bytes_returned;
/* do not allocate so big memory in stack */
buf = (unsigned char *) malloc(TEST_BUF_LEN);
odbc_connect();
odbc_command("create table " TEST_TABLE_NAME " (im IMAGE)");
odbc_command("SET TEXTSIZE 1000000");
/* populate test buffer with ramp */
for (i = 0; i < TEST_BUF_LEN; i++) {
buf[i] = BYTE_AT(i);
}
/* insert test pattern into database */
if (test_insert(buf, TEST_BUF_LEN) == -1) {
clean_up();
return -1;
}
memset(buf, 0, TEST_BUF_LEN);
/* read test pattern from database */
if (test_select(buf, TEST_BUF_LEN, &bytes_returned) == -1) {
clean_up();
return -1;
}
/* compare inserted and read back test patterns */
if (bytes_returned != TEST_BUF_LEN) {
show_error("main(): comparing buffers", "Mismatch in input and output pattern sizes.");
clean_up();
return -1;
}
for (i = 0; i < TEST_BUF_LEN; ++i) {
if (buf[i] != BYTE_AT(i)) {
printf("mismatch at pos %d %d != %d\n", i, buf[i], BYTE_AT(i));
show_error("main(): comparing buffers", "Mismatch in input and output patterns.");
clean_up();
return -1;
}
}
printf("Input and output buffers of length %d match.\nTest passed.\n", TEST_BUF_LEN);
clean_up();
return 0;
}
int
main(int argc, char **argv)
{
#define ARRAY_SIZE 10
SQLCHAR v_dec[ARRAY_SIZE][21];
SQLLEN v_ind[ARRAY_SIZE];
SQLULEN nrows;
odbc_use_version3 = 1;
odbc_connect();
odbc_check_cursor();
odbc_command("IF OBJECT_ID('mytab1') IS NOT NULL DROP TABLE mytab1");
odbc_command("CREATE TABLE mytab1 ( k INT, d DECIMAL(10,2))");
odbc_command("INSERT INTO mytab1 VALUES ( 201, 111.11 )");
/*SQLExecDirect(m_hstmt, (SQLCHAR *) "insert into mytab1 values ( 202, 222.22 )", SQL_NTS); */
odbc_command("INSERT INTO mytab1 VALUES ( 202, null )");
odbc_reset_statement();
CHKSetStmtAttr(SQL_ATTR_CURSOR_SCROLLABLE, (SQLPOINTER) SQL_NONSCROLLABLE, SQL_IS_UINTEGER, "S");
CHKSetStmtAttr(SQL_ATTR_CURSOR_SENSITIVITY, (SQLPOINTER) SQL_SENSITIVE, SQL_IS_UINTEGER, "S");
CHKSetStmtAttr(SQL_ATTR_ROW_BIND_TYPE, (SQLPOINTER) SQL_BIND_BY_COLUMN, SQL_IS_UINTEGER, "S");
CHKSetStmtAttr(SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER) ARRAY_SIZE, SQL_IS_UINTEGER, "S");
CHKSetStmtAttr(SQL_ATTR_ROWS_FETCHED_PTR, (SQLPOINTER) & (nrows), SQL_IS_UINTEGER, "S");
CHKPrepare(T("SELECT SUM(d) FROM mytab1"), SQL_NTS, "S");
CHKExecute("I");
#if 0
CHKMoreResults("S"); /* skip warning*/
#endif
CHKBindCol(1, SQL_C_CHAR, v_dec, 21, v_ind, "S");
CHKFetch("S");
printf("fetch 1: rows fetched = %d\n", (int) nrows);
printf("fetch 1: value = [%s]\n", v_dec[0]);
CHKFetch("No");
CHKMoreResults("No");
odbc_command("drop table mytab1");
odbc_disconnect();
return 0;
}
int
main(int argc, char *argv[])
{
odbc_connect();
DoTest(0);
DoTest(1);
odbc_disconnect();
printf("Done.\n");
return 0;
}
int
main(int argc, char *argv[])
{
odbc_connect();
/* issue print statement and test message returned */
odbc_command2("SELECT DATEADD(dd,-100000,getdate())", "E");
odbc_disconnect();
printf("Done.\n");
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;
}
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;
}
int
main(int argc, char *argv[])
{
SQLLEN cb = SQL_NTS;
odbc_use_version3 = 1;
odbc_connect();
odbc_command_with_result(odbc_stmt, "drop proc sp_paramcore_test");
odbc_command("create proc sp_paramcore_test @s varchar(100) output as select @s = '12345'");
/* here we pass a NULL buffer for input SQL_NTS */
CHKBindParameter(1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, OUTSTRING_LEN, 0, NULL, OUTSTRING_LEN, &cb, "S");
cb = SQL_NTS;
CHKExecDirect(T(SP_TEXT), SQL_NTS, "E");
odbc_reset_statement();
/* here we pass a NULL buffer for input */
CHKBindParameter(1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_VARCHAR, 18, 0, NULL, OUTSTRING_LEN, &cb, "S");
cb = 1;
CHKExecDirect(T(SP_TEXT), SQL_NTS, "E");
odbc_reset_statement();
odbc_command("drop proc sp_paramcore_test");
odbc_command("create proc sp_paramcore_test @s numeric(10,2) output as select @s = 12345.6");
odbc_reset_statement();
#if 0 /* this fails even on native platforms */
/* here we pass a NULL buffer for output */
cb = sizeof(SQL_NUMERIC_STRUCT);
SQLBindParameter(odbc_stmt, 1, SQL_PARAM_OUTPUT, SQL_C_NUMERIC, SQL_NUMERIC, 18, 0, NULL, OUTSTRING_LEN, &cb);
odbc_read_error();
cb = 1;
odbc_command_with_result(odbc_stmt, SP_TEXT);
odbc_read_error();
odbc_reset_statement();
#endif
odbc_command("drop proc sp_paramcore_test");
odbc_disconnect();
printf("Done successfully!\n");
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;
}
int
main(int argc, char *argv[])
{
odbc_connect();
odbc_command("CREATE TABLE #tmp1 (c VARCHAR(200))");
Test(1);
Test(0);
odbc_disconnect();
printf("Done.\n");
return 0;
}
int
main(int argc, char *argv[])
{
odbc_connect();
odbc_check_cursor();
if (odbc_db_is_microsoft() && odbc_db_version_int() >= 0x09000000u)
mssql2005 = 1;
Test(1);
Test(0);
odbc_disconnect();
return 0;
}
int
main(void)
{
odbc_connect();
odbc_command("CREATE TABLE #warning(name varchar(20), value int null)");
odbc_command("INSERT INTO #warning VALUES('a', NULL)");
Test(one_null_with_warning);
Test("SELECT SUM(value) FROM #warning");
odbc_disconnect();
printf("Done.\n");
return 0;
}
int
main(int argc, char *argv[])
{
SQLSMALLINT len, type;
SQLTCHAR name[128];
odbc_connect();
odbc_command("create table #dc (col_name int, name2 varchar(100))");
odbc_command("select * from #dc");
len = 0x1234;
CHKDescribeCol(1, NULL, 0, &len, &type, NULL, NULL, NULL, "S");
check(len == 8);
len = 0x1234;
CHKDescribeCol(2, name, 0, &len, &type, NULL, NULL, NULL, "I");
check(len == 5);
len = 0x1234;
CHKDescribeCol(1, NULL, 2, &len, &type, NULL, NULL, NULL, "S");
check(len == 8);
len = 0x1234;
strcpy((char *) name, "xxx");
CHKDescribeCol(2, name, 3, &len, &type, NULL, NULL, NULL, "I");
check(len == 5 && strcmp(C(name), "na") == 0);
len = 0x1234;
strcpy((char *) name, "xxx");
CHKDescribeCol(1, name, 1, &len, &type, NULL, NULL, NULL, "I");
check(len == 8 && strcmp(C(name), "") == 0);
len = 0x1234;
strcpy((char *) name, "xxx");
CHKDescribeCol(2, name, 6, &len, &type, NULL, NULL, NULL, "S");
check(len == 5 && strcmp(C(name), "name2") == 0);
odbc_disconnect();
if (g_result == 0)
printf("Done.\n");
return g_result;
}
int
main(int argc, char *argv[])
{
int i;
odbc_use_version3 = 1;
odbc_connect();
odbc_command("CREATE TABLE #odbc_test(i INT, t TEXT)");
for (i = 0; i < 10; ++i) {
char buf[128];
sprintf(buf, "INSERT INTO #odbc_test(i, t) VALUES(%d, '%crow number %d')", i + 1, 'a' + i, i * 13);
odbc_command(buf);
}
odbc_reset_statement();
test_query = "SELECT * FROM #odbc_test ORDER BY i";
printf("test line %d\n", __LINE__);
query_test("S", "VVVVVVVVVV");
test_query = "SELECT * FROM #odbc_test WHERE i < 7 ORDER BY i";
printf("test line %d\n", __LINE__);
query_test("S", "VVVVVV");
/* binding row */
test_query = "SELECT * FROM #odbc_test ORDER BY i";
record_bind = 1;
printf("test line %d\n", __LINE__);
query_test("S", "VVVVVVVVVV");
/* row and truncation */
trunc = 1;
printf("test line %d\n", __LINE__);
query_test("I", "!!!!!!!!!!");
/* TODO bind offset, SQLGetData, no bind, error */
odbc_disconnect();
printf("Success!.\n");
return 0;
}
int
main(int argc, char **argv)
{
odbc_connect();
odbc_command_with_result(odbc_stmt, "DROP TABLE test");
odbc_command("CREATE TABLE test(i int, c varchar(40))");
insert_test_man();
odbc_command("DELETE FROM test");
insert_test_auto();
odbc_command("DROP TABLE test");
odbc_disconnect();
return 0;
}
int
main(void)
{
if (sizeof(SQLLEN) != 8) {
printf("Not possible for this platform.\n");
odbc_test_skipped();
return 0;
}
odbc_use_version3 = 1;
odbc_connect();
odbc_command("create table #tmp1 (i int)");
test_params();
test_rows();
odbc_disconnect();
printf("Done\n");
return 0;
}
int
main(int argc, char *argv[])
{
odbc_connect();
Test2(0, 1);
Test2(1, 1);
odbc_disconnect();
odbc_use_version3 = 1;
odbc_connect();
Test2(0, 1);
Test2(1, 1);
Test2(0, 0);
Test2(1, 0);
odbc_disconnect();
printf("Done.\n");
return 0;
}
