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[])
{
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(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;
}
int
main(int argc, char *argv[])
{
SQLSMALLINT len;
const char * const*p;
SQLINTEGER n;
if (odbc_read_login_info())
exit(1);
/* connect string using DSN */
init_connect();
sprintf(tmp, "DSN=%s;UID=%s;PWD=%s;DATABASE=%s;ClientCharset=UTF-8;", odbc_server, odbc_user, odbc_password, odbc_database);
CHKDriverConnect(NULL, T(tmp), SQL_NTS, (SQLTCHAR *) tmp, sizeof(tmp)/sizeof(SQLTCHAR), &len, SQL_DRIVER_NOPROMPT, "SI");
if (!odbc_driver_is_freetds()) {
odbc_disconnect();
printf("Driver is not FreeTDS, exiting\n");
return 0;
}
if (!odbc_db_is_microsoft() || odbc_db_version_int() < 0x08000000u) {
odbc_disconnect();
printf("Test for MSSQL only\n");
return 0;
}
CHKAllocStmt(&odbc_stmt, "S");
/* create test table */
sprintf(tmp, "IF OBJECT_ID(N'%s') IS NOT NULL DROP TABLE %s", table_name, table_name);
odbc_command(tmp);
sprintf(tmp, "CREATE TABLE %s (k int, c NCHAR(10), vc NVARCHAR(10))", table_name);
odbc_command(tmp);
/* insert with INSERT statements */
for (n = 1, p = strings; p[0] && p[1]; p += 2, ++n) {
sprintf(tmp, "INSERT INTO %s VALUES (%d,N'%s',N'%s')", table_name, (int) n, p[0], p[1]);
odbc_command(tmp);
}
/* check rows */
for (n = 1, p = strings_hex; p[0] && p[1]; p += 2, ++n) {
sprintf(tmp, "IF NOT EXISTS(SELECT * FROM %s WHERE k = %d AND c = %s AND vc = %s) SELECT 1", table_name, (int) n, p[0], p[1]);
CheckNoRow(tmp);
}
TestBinding(0);
TestBinding(1);
/* cleanup */
sprintf(tmp, "IF OBJECT_ID(N'%s') IS NOT NULL DROP TABLE %s", table_name, table_name);
odbc_command(tmp);
odbc_disconnect();
printf("Done.\n");
return 0;
}
void
odbc_report_error(const char *errmsg, int line, const char *file)
{
SQLSMALLINT handletype;
SQLHANDLE handle;
SQLRETURN ret;
SQLTCHAR sqlstate[6];
SQLTCHAR msg[256];
ODBC_BUF *odbc_buf = NULL;
if (odbc_stmt) {
handletype = SQL_HANDLE_STMT;
handle = odbc_stmt;
} else if (odbc_conn) {
handletype = SQL_HANDLE_DBC;
handle = odbc_conn;
} else {
handletype = SQL_HANDLE_ENV;
handle = odbc_env;
}
if (errmsg[0]) {
if (line)
fprintf(stderr, "%s:%d %s\n", file, line, errmsg);
else
fprintf(stderr, "%s\n", errmsg);
}
ret = SQLGetDiagRec(handletype, handle, 1, sqlstate, NULL, msg, ODBC_VECTOR_SIZE(msg), NULL);
if (ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO)
fprintf(stderr, "SQL error %s -- %s\n", C(sqlstate), C(msg));
odbc_disconnect();
ODBC_FREE();
exit(1);
}
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;
}
void
odbc_report_error(const char *errmsg, int line, const char *file)
{
SQLSMALLINT handletype;
SQLHANDLE handle;
SQLRETURN ret;
unsigned char sqlstate[6];
unsigned char msg[256];
if (odbc_stmt) {
handletype = SQL_HANDLE_STMT;
handle = odbc_stmt;
} else if (odbc_conn) {
handletype = SQL_HANDLE_DBC;
handle = odbc_conn;
} else {
handletype = SQL_HANDLE_ENV;
handle = odbc_env;
}
if (errmsg[0]) {
if (line)
fprintf(stderr, "%s:%d %s\n", file, line, errmsg);
else
fprintf(stderr, "%s\n", errmsg);
}
ret = SQLGetDiagRec(handletype, handle, 1, sqlstate, NULL, msg, sizeof(msg), NULL);
if (ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO)
fprintf(stderr, "SQL error %s -- %s\n", sqlstate, msg);
odbc_disconnect();
exit(1);
}
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;
}
static void
TestProc(const char *type, const char *expected)
{
char sql[256];
odbc_command("IF OBJECT_ID('stat_proc') IS NOT NULL DROP PROC stat_proc");
sprintf(sql, "CREATE PROC stat_proc(@t %s) AS RETURN 0", type);
odbc_command(sql);
column = "@t";
CHKProcedureColumns(T(catalog), LEN(catalog), T(schema), LEN(schema), T(proc), LEN(proc), T(column), LEN(column), "SI");
CHKFetch("SI");
ReadCol(6);
if (strcmp(output, expected) != 0) {
fprintf(stderr, "Got \"%s\" expected \"%s\"\n", output, expected);
odbc_disconnect();
exit(1);
}
CHKCloseCursor("SI");
ODBC_FREE();
}
static void
TestTable(const char *type, const char *expected)
{
char sql[256];
odbc_command("IF OBJECT_ID('stat_t') IS NOT NULL DROP TABLE stat_t");
sprintf(sql, "CREATE TABLE stat_t(t %s)", type);
odbc_command(sql);
column = "t";
table = "stat_t";
CHKColumns(T(catalog), LEN(catalog), T(schema), LEN(schema), T(table), LEN(table), T(column), LEN(column), "SI");
CHKFetch("SI");
ReadCol(5);
if (strcmp(output, expected) != 0) {
fprintf(stderr, "Got \"%s\" expected \"%s\"\n", output, expected);
odbc_disconnect();
exit(1);
}
CHKCloseCursor("SI");
ODBC_FREE();
}
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;
}
static int
Test(int txn, const char *expected)
{
int dirty, repeatable, phantom;
char buf[128];
SWAP_CONN();
if (test_with_connect) {
odbc_disconnect();
ConnectWithTxn(txn);
CHKSetStmtAttr(SQL_ATTR_QUERY_TIMEOUT, (SQLPOINTER) 2, 0, "S");
} else {
CHKSetConnectAttr(SQL_ATTR_TXN_ISOLATION, int2ptr(txn), 0, "S");
}
SWAP_CONN();
dirty = CheckDirtyRead();
repeatable = CheckNonrepeatableRead();
phantom = CheckPhantom();
sprintf(buf, "dirty %d non repeatable %d phantom %d", dirty, repeatable, phantom);
if (strcmp(buf, expected) != 0) {
if (hide_error) {
hide_error = 0;
return 0;
}
fprintf(stderr, "detected wrong TXN\nexpected '%s' got '%s'\n", expected, buf);
exit(1);
}
hide_error = 0;
return 1;
}
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;
}
static int odbc_unload_module(void)
{
ast_mutex_lock(&odbc_lock);
if (connected) {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Disconnecting from %s\n", dsn);
SQLFreeHandle(SQL_HANDLE_STMT, ODBC_stmt);
odbc_disconnect();
}
if (dsn) {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: free dsn\n");
free(dsn);
}
if (username) {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: free username\n");
free(username);
}
if (password) {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: free password\n");
free(password);
}
if (table) {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: free table\n");
free(table);
}
ast_cdr_unregister(name);
ast_mutex_unlock(&odbc_lock);
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[])
{
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(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;
}
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;
}
static void
test_err(int n)
{
CHKSetStmtAttr(SQL_ROWSET_SIZE, (SQLPOINTER) int2ptr(n), 0, "E");
odbc_read_error();
if (strcmp(odbc_sqlstate, "HY024") != 0) {
fprintf(stderr, "Unexpected sql state returned\n");
odbc_disconnect();
exit(1);
}
}
unsigned int odbc_db_version_int(void)
{
unsigned int h, l;
if (sscanf(odbc_db_version(), "%u.%u.", &h, &l) != 2) {
fprintf(stderr, "Wrong db version: %s\n", odbc_db_version());
odbc_disconnect();
exit(1);
}
return (h << 24) | ((l & 0xFFu) << 16);
}
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)
{
#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;
}
static int odbc_log(struct ast_cdr *cdr)
{
int res = 0;
char timestr[150];
ast_mutex_lock(&odbc_lock);
build_query(cdr, timestr, sizeof(timestr));
if (connected) {
res = odbc_do_query();
if (res < 0) {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Reconnecting to dsn %s\n", dsn);
odbc_disconnect();
res = odbc_init();
if (res < 0) {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: %s has gone away!\n", dsn);
odbc_disconnect();
} else {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Trying Query again!\n");
SQLFreeHandle(SQL_HANDLE_STMT, ODBC_stmt);
build_query(cdr, timestr, sizeof(timestr)); /* what a waste. If we have to reconnect, we have to build a new query */
res = odbc_do_query();
if (res < 0) {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Query FAILED Call not logged!\n");
}
}
}
} else {
if (option_verbose > 10)
ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Query FAILED Call not logged!\n");
}
SQLFreeHandle(SQL_HANDLE_STMT, ODBC_stmt);
ast_mutex_unlock(&odbc_lock);
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;
}
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)
{
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 void
CheckType(SQLSMALLINT type, SQLSMALLINT expected, const char *string_type, int line)
{
SQLSMALLINT out_type;
SQLLEN ind;
SQLRETURN RetCode;
printf("CheckType %d\n", line);
CHKBindCol(2, SQL_C_SSHORT, &out_type, 0, &ind, "SI");
CHKGetTypeInfo(type, "SI");
RetCode = CHKFetch("SNo");
switch (RetCode) {
case SQL_SUCCESS:
if (expected == SQL_UNKNOWN_TYPE) {
fprintf(stderr, "Data not expected (type %d - %s) line %d\n", type, string_type, line);
odbc_disconnect();
exit(1);
}
if (expected != out_type) {
fprintf(stderr, "Got type %d expected %d. Input type %d - %s line %d\n", out_type, expected, type, string_type, line);
odbc_disconnect();
exit(1);
}
break;
case SQL_NO_DATA:
if (expected != SQL_UNKNOWN_TYPE) {
fprintf(stderr, "Data expected. Inpute type %d - %s line %d\n", type, string_type, line);
odbc_disconnect();
exit(1);
}
break;
}
SQLFreeStmt(odbc_stmt, SQL_UNBIND);
Flushodbc_stmt();
}
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;
}