/* <odbc::set-connect-option db fInfoType value>
Performs ODBC SetInfo call. Returns true if successful. */
static void
pf_odbc_set_connect_option (PFunArgs)
{
char *finfo = mhtml_evaluate_string (get_positional_arg (vars, 1));
char *val = mhtml_evaluate_string (get_positional_arg (vars, 2));
/* No errors yet! */
gsql_clear_error_message ();
if (database_environment_level != 0)
{
Database *db = get_dbref (vars);
if ((db != (Database *)NULL) && gsql_database_connected (db))
{
RETCODE status = SQL_ERROR;
int numval;
ODBC_option opt;
if (find_odbc_option (finfo, &opt) != 0)
{
switch (opt.type)
{
case ODBC_OPT_STRING:
status = SQLSetConnectOption
(db->hdbc, opt.code, (UDWORD) val);
break;
case ODBC_OPT_INT32:
numval = atoi (val);
status = SQLSetConnectOption
(db->hdbc, opt.code, (UDWORD) numval);
break;
case ODBC_OPT_INT16:
numval = 0xffff & atoi (val);
status = SQLSetConnectOption
(db->hdbc, opt.code, (UDWORD) numval);
break;
}
}
if (status == SQL_SUCCESS)
{
bprintf_insert (page, start, "true");
*newstart += strlen ("true");
}
else
gsql_save_error_message (db, GSQL_DEFAULT_ERRMSG);
}
}
else
page_debug ("<odbc::set-connect-option ...>: Not within open-database!");
xfree (val);
xfree (finfo);
}
SQLRETURN SQL_API
SQLSetConnectOptionA(SQLHDBC ConnectionHandle,
SQLUSMALLINT Option,
SQLULEN ValuePtr)
{
return SQLSetConnectOption(ConnectionHandle, Option, ValuePtr);
}
void
tsc_fwd_ext_fetch (int ctype, int ac, char * text)
{
long count = 0;
int rc = SQL_SUCCESS;
long t1 = get_msec_count ();
long last_row_no = 0;
int do_testing = (strcmp(text, T1_BASE_TEXT) == 0);
SQLSetConnectOption (hdbc1, SQL_AUTOCOMMIT, ac);
t1_window (&tw1, "CR1", hdbc1, text, ctype, 0, 20, SQL_CONCUR_READ_ONLY, NULL);
for (;;)
{
rc = SQLExtendedFetch (tw1.tw_stmt, SQL_FETCH_NEXT, 0, &tw1.tw_fill, tw1.tw_stat);
if (rc == SQL_NO_DATA_FOUND || rc == SQL_ERROR)
break;
if (do_testing)
{
if (count && tw1.tw_set[0].t1_row_no <= last_row_no)
fprintf (stderr, "*** Error : Overlapping rowsets in SQL_FETCH_NEXT : mode = %s\n", cr_type_name (ctype));
last_row_no = tw1.tw_set[tw1.tw_fill - 1].t1_row_no;
}
count += tw1.tw_fill;
}
if (SQL_ERROR == rc)
print_error (SQL_NULL_HENV, SQL_NULL_HDBC, tw1.tw_stmt);
tw_close (&tw1);
printf ("SQLExtendedFetch: %ld msec, mode = %s, AC=%d, %ld row\n", get_msec_count () - t1, cr_type_name (ctype), ac, count);
}
int
main (int ac, char *av[])
{
SQLRETURN rc;
if (ac < 3)
{
err_printf ("***FAILED: usage : %s dsn uid pwd\n", av[0]);
return (-1);
}
dsn = av[1];
uid = av[2];
pwd = av[3];
rc = SQLAllocHandle (SQL_HANDLE_ENV, SQL_NULL_HANDLE, (SQLHANDLE *) & henv);
if (rc != SQL_SUCCESS)
{
err_printf ("SQLAllocHandle() failed.\n");
return 1;
}
rc = SQLSetEnvAttr (henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER) SQL_OV_ODBC3,
SQL_IS_INTEGER);
if (rc != SQL_SUCCESS)
{
err_printf ("SQLSetEnvAttr() failed.\n");
return 1;
}
rc = SQLAllocHandle (SQL_HANDLE_DBC, (SQLHANDLE) henv,
(SQLHANDLE *) & hdbc);
if (rc != SQL_SUCCESS)
{
err_printf ("SQLAllocHandle() failed.\n");
return 1;
}
rc = SQLConnect (hdbc, dsn, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS);
if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO)
{
err_printf ("SQLConnect() failed.\n");
error (SQL_HANDLE_DBC, (SQLHANDLE) hdbc);
return 1;
}
rc = SQLSetConnectOption (hdbc, SQL_AUTOCOMMIT, 0);
if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO)
{
err_printf ("autocommit off() failed.\n");
error (SQL_HANDLE_DBC, (SQLHANDLE) hdbc);
return 1;
}
create_proc ();
printf ("=====================================================\n");
printf ("starting test\n");
test ();
printf ("test1 done\n");
printf ("=====================================================\n");
return 0;
}
void
t1_init ()
{
SQLSetConnectOption (hdbc1, SQL_AUTOCOMMIT, 1);
tw1.tw_hdbc = hdbc1;
tw_exec (&tw1, "delete from T1");
t1_lines (&tw1, 100, 1100, 100);
}
SQLRETURN SQLSetConnectOptionA( SQLHDBC connection_handle,
SQLUSMALLINT option,
SQLULEN value )
{
return SQLSetConnectOption( connection_handle,
option,
value );
}
void
tsc_scroll (int ctype, int kssz, int commit_each, int del_bounds,
int n_windows, char * text)
{
int inx;
printf ("Scroll Test, commit = %d, del = %d\n", commit_each, del_bounds);
SQLSetConnectOption (hdbc1, SQL_AUTOCOMMIT, 0);
fprintf (stdout, "\n========== Scroll Test\n\n");
t1_window (&tw1, "CR1", hdbc1, text, ctype, kssz, 5, SQL_CONCUR_READ_ONLY, NULL);
tw_fetch (&tw1, SQL_FETCH_LAST, 0);
T_ICOL (&tw1, 4, t1_row_no, 1099);
tw_fetch (&tw1, SQL_FETCH_ABSOLUTE, -3);
T_ICOL (&tw1, 2, t1_row_no, 1099);
T_RSTAT (&tw1, 3, SQL_ROW_NOROW);
tw_fetch (&tw1, SQL_FETCH_FIRST, 0);
T_ICOL (&tw1, 0, t1_row_no, 100);
for (inx = 0; inx < n_windows; inx++)
{
if (commit_each)
IF_CERR_GO (tw1.tw_hdbc, err, SQLTransact (SQL_NULL_HENV, tw1.tw_hdbc, SQL_COMMIT));
tw_fetch (&tw1, SQL_FETCH_NEXT, 0);
T_ICOL (&tw1, 0, t1_row_no, 100 + (inx + 1) * 5);
}
tw_fetch (&tw1, SQL_FETCH_RELATIVE, -1);
T_ICOL (&tw1, 0, t1_row_no, 109);
T_ICOL (&tw1, 4, t1_row_no, 113);
for (inx = 0; inx < n_windows + 2; inx++)
{
if (commit_each)
IF_CERR_GO (tw1.tw_hdbc, err, SQLTransact (SQL_NULL_HENV, tw1.tw_hdbc, SQL_COMMIT));
tw_fetch (&tw1, SQL_FETCH_PRIOR, 0);
if (inx > 2)
{
T_RC (&tw1, SQL_NO_DATA_FOUND);
T_ICOL (&tw1, 0, t1_row_no, -1);
}
}
tw_fetch (&tw1, SQL_FETCH_NEXT, 0);
T_ICOL (&tw1, 0, t1_row_no, 100);
T_ICOL (&tw1, 4, t1_row_no, 104);
err:
SQLSetConnectOption (tw1.tw_hdbc, SQL_AUTOCOMMIT, 1);
tw_close (&tw1);
}
void
tsc_pos (int ctype,
char * text)
{
int inx;
printf ("========== Positioned ops test\n");
SQLSetConnectOption (hdbc1, SQL_AUTOCOMMIT, 1);
t1_window (&tw1, "CR1", hdbc1, text, ctype, 00, 5, SQL_CONCUR_READ_ONLY, NULL);
tw_fetch (&tw1, SQL_FETCH_FIRST, 0);
for (inx = 0; inx < 5; inx++)
{
tw1.tw_set[inx].t1_row_no = inx;
tw1.tw_set[inx].t1_row_no = inx;
sprintf (tw1.tw_set[inx].t1_string1, "%d", inx);
sprintf (tw1.tw_set[inx].t1_string2, "%d", 300 - inx);
tw1.tw_set[inx].t1_fi2 = 11;
strcpy (tw1.tw_set[inx].t1_fs1, "ins");
TW_DEFAULT_LEN (tw1.tw_set[inx]);
}
tw_set_pos (&tw1, 0, SQL_ADD);
CK_ROWCNT (tw1.tw_stmt, 5);
ERRORS_OFF;
tw_set_pos (&tw1, 0, SQL_ADD);
ERRORS_ON;
CK_ROWCNT (tw1.tw_stmt, 0);
T_RSTAT (&tw1, 2, SQL_ROW_ERROR);
if (ctype != SQL_CURSOR_DYNAMIC)
{
/* need reopen to show added if cr not dynamic */
tw_close (&tw1);
t1_window (&tw1, "CR1", hdbc1, text, ctype, 00, 5, SQL_CONCUR_READ_ONLY, NULL);
}
tw_fetch (&tw1, SQL_FETCH_FIRST, 0);
strcpy (tw1.tw_set[1].t1_fs1, "upd");
tw_set_pos (&tw1, 2, SQL_UPDATE);
CK_ROWCNT (tw1.tw_stmt, 1);
memset (tw1.tw_set, 0, sizeof (t1_t) * 5);
tw_set_pos (&tw1, 0, SQL_REFRESH);
tw_print (&tw1);
tw1.tw_set[3].t1_row_no = -2;
tw1.tw_set[3].t1_row_no_len = SQL_IGNORE;
strcpy (tw1.tw_set[3].t1_fs1, "NNN");
tw1.tw_set[3].t1_fs1_len = SQL_NTS;
tw_set_pos (&tw1, 4, SQL_UPDATE);
tw_set_pos (&tw1, 4, SQL_REFRESH);
T_CCOL (&tw1, 3, t1_fs1, "NNN");
tw_print (&tw1);
tw_set_pos (&tw1, 0, SQL_DELETE);
CK_ROWCNT (tw1.tw_stmt, 5);
tw_close (&tw1);
}
void
tsc_co (int ctype, int kssz, int ac)
{
int rc;
char * text = "select ROW_NO, STRING1, STRING2, FS1, FI2 from T1 where ROW_NO >= 3000";
printf ("\n========== WHERE CURRENT OF Test, type = %d, AC=%d\n", ctype, ac);
SQLSetConnectOption (hdbc1, SQL_AUTOCOMMIT, ac);
t1_lines (&tw1, 3000, 4000, 5);
t1_window (&tw1, "CR1", hdbc1, text, SQL_CURSOR_DYNAMIC, kssz, 5, SQL_CONCUR_READ_ONLY, NULL);
tw_fetch (&tw1, SQL_FETCH_NEXT, 0);
tw_set_pos (&tw1, 3, SQL_POSITION);
tw_exec (&tw1, "update T1 set FS1 = 'UUU' where current of CR1");
tw_set_pos (&tw1, 3, SQL_REFRESH);
T_CCOL (&tw1, 2, t1_fs1, "UUU");
tw_exec (&tw1, "delete from T1 where current of CR1");
tw_set_pos (&tw1, 3, SQL_REFRESH);
T_RSTAT (&tw1, 2, SQL_ROW_DELETED);
ERRORS_OFF;
tw_exec (&tw1, "delete from T1 where current of CR1");
ERRORS_ON;
T_RC (&tw1, SQL_ERROR);
tw_close (&tw1);
t1_window (&tw1, "CR1", hdbc1, text, ctype, 0, 5, SQL_CONCUR_READ_ONLY, NULL);
QUIET;
for (;;)
{
rc = SQLExtendedFetch (tw1.tw_stmt, SQL_FETCH_NEXT, 0, &tw1.tw_fill, tw1.tw_stat);
if (SQL_NO_DATA_FOUND == rc)
break;
IF_ERR_GO (tw1.tw_stmt, err, rc);
tw_set_pos (&tw1, 1, SQL_POSITION);
tw_exec (&tw1, "delete from T1 where current of CR1");
if (tw1.tw_fill < 5)
{
ERRORS_OFF;
tw_set_pos (&tw1, 5, SQL_POSITION);
T_RC (&tw1, SQL_ERROR);
tw_exec (&tw1, "delete from T1 where current of CR1");
ERRORS_ON;
}
else
{
tw_set_pos (&tw1, 5, SQL_POSITION);
tw_exec (&tw1, "delete from T1 where current of CR1");
}
}
err:
QUIET_OFF;
tw_exec (&tw1, "delete from T1 where ROW_NO >= 3000");
T_ROWCNT (&tw1, 600); /* 1000 rows - 1+199*2+1 deletes */
if (!ac)
SQLTransact (SQL_NULL_HENV, tw1.tw_hdbc, SQL_ROLLBACK);
tw_close (&tw1);
}
bool CSQLEx::Connect()
{
if(this->m_bConnected == 1)
{
return false;
}
if(SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV,SQL_NULL_HANDLE,&this->m_SQLEnvironment)) == 0)
{
return false;
}
if(SQL_SUCCEEDED(SQLSetEnvAttr(this->m_SQLEnvironment,SQL_ATTR_ODBC_VERSION,(void *)SQL_OV_ODBC3,0)) == 0)
{
this->FreeHandle();
return false;
}
if(SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC,this->m_SQLEnvironment,&this->m_SQLConnection)) == 0)
{
this->FreeHandle();
return false;
}
SQLSetConnectOption(this->m_SQLConnection,SQL_LOGIN_TIMEOUT,5);
SQLSetConnectOption(this->m_SQLConnection,SQL_CURSOR_TYPE,SQL_CURSOR_STATIC);
SQLCHAR szConStrIn[1024],szConStrOut[1024];
SQLSMALLINT iConOutSize = 0;
sprintf((char*)szConStrIn,"DRIVER=%s; SERVER=%s; UID=%s; PWD=%s; DATABASE=%s;",szDriver,szServer2,szUser,szPassword,szDatabase);
SQLRETURN Connect = SQLDriverConnect(this->m_SQLConnection,NULL,szConStrIn,SQL_NTS,szConStrOut,sizeof(szConStrOut),&iConOutSize,SQL_DRIVER_NOPROMPT);
if(SQL_SUCCEEDED(Connect) == 0)
{
this->FreeHandle();
return false;
}
this->m_bConnected = 1;
return true;
}
void
tsc_lock (int ctype)
{
char * text = T1_BASE_TEXT;
printf ("\n========== Locking,Cursors, type %s\n", cr_type_name (ctype));
SQLSetConnectOption (hdbc1, SQL_AUTOCOMMIT, 0);
SQLSetConnectOption (hdbc2, SQL_AUTOCOMMIT, 0);
t1_window (&tw1, "CR1", hdbc1, text, ctype, 0, 5, SQL_CONCUR_READ_ONLY, c_opts);
t1_window (&tw2, "CR2", hdbc2, text, ctype, 0, 5, SQL_CONCUR_LOCK, c_opts);
tw_fetch (&tw1, SQL_FETCH_NEXT, 0);
ERRORS_OFF;
tw_fetch (&tw2, SQL_FETCH_NEXT, 0);
T_RC (&tw2, SQL_ERROR);
ERRORS_ON;
SQLTransact (SQL_NULL_HENV, hdbc1, SQL_ROLLBACK);
SQLTransact (SQL_NULL_HENV, hdbc2, SQL_ROLLBACK);
tw_close (&tw1);
tw_close (&tw2);
t1_window (&tw1, "CR1", hdbc1, text, ctype, 0, 5, SQL_CONCUR_READ_ONLY, c_opts);
t1_window (&tw2, "CR2", hdbc2, text, ctype, 0, 5, SQL_CONCUR_READ_ONLY, c_opts);
tw_fetch (&tw1, SQL_FETCH_NEXT, 0);
tw_fetch (&tw2, SQL_FETCH_NEXT, 0);
ERRORS_OFF;
tw_set_pos (&tw2, 0, SQL_UPDATE);
/* tw_set_pos (&tw2, 0, SQL_UPDATE);
* deadlock. First a 2r1w deadlock. Then the updating tx gets rb. Then the next just waits for the read that is by the same thread. Bad test. */
T_RC (&tw2, SQL_ERROR);
ERRORS_ON;
tw_close (&tw1);
tw_close (&tw2);
SQLTransact (SQL_NULL_HENV, hdbc1, SQL_ROLLBACK);
SQLTransact (SQL_NULL_HENV, hdbc2, SQL_ROLLBACK);
SQLSetConnectOption (hdbc1, SQL_AUTOCOMMIT, 1);
SQLSetConnectOption (hdbc2, SQL_AUTOCOMMIT, 1);
}
RETCODE SQL_API
SQLFreeConnect (HDBC hdbc)
{
GENV_t FAR *genv;
DBC_t FAR *pdbc = (DBC_t FAR *) hdbc;
DBC_t FAR *tpdbc;
if (hdbc == SQL_NULL_HDBC)
{
return SQL_INVALID_HANDLE;
}
/* check state */
if (pdbc->state != en_dbc_allocated)
{
PUSHSQLERR (pdbc->herr, en_S1010);
return SQL_ERROR;
}
genv = (GENV_t FAR *) pdbc->genv;
for (tpdbc = (DBC_t FAR *) genv->hdbc;
tpdbc != NULL;
tpdbc = tpdbc->next)
{
if (pdbc == tpdbc)
{
genv->hdbc = pdbc->next;
break;
}
if (pdbc == tpdbc->next)
{
tpdbc->next = pdbc->next;
break;
}
}
/* free this dbc */
_iodbcdm_driverunload (pdbc);
_iodbcdm_freesqlerrlist (pdbc->herr);
if (pdbc->tfile)
{
MEM_FREE (pdbc->tfile);
}
SQLSetConnectOption (pdbc, SQL_OPT_TRACE, SQL_OPT_TRACE_OFF);
MEM_FREE (pdbc);
return SQL_SUCCESS;
}
void
tsc_values (int ctype)
{
char * text = T1_BASE_TEXT;
int conc = SQL_CONCUR_VALUES;
printf ("\n========== Optimistic Concurrency, type %s\n", cr_type_name (ctype));
SQLSetConnectOption (hdbc1, SQL_AUTOCOMMIT, 1);
SQLSetConnectOption (hdbc2, SQL_AUTOCOMMIT, 1);
t1_window (&tw1, "CR1", hdbc1, text, ctype, 0, 5, conc, NULL);
t1_window (&tw2, "CR2", hdbc2, text, ctype, 0, 5, conc, NULL);
tw_fetch (&tw1, SQL_FETCH_NEXT, 0);
tw_fetch (&tw2, SQL_FETCH_NEXT, 0);
strcpy (tw2.tw_set[1].t1_fs1, "VAL");
tw_set_pos (&tw2, 2, SQL_UPDATE);
strcpy (tw1.tw_set[1].t1_fs1, "BAD");
ERRORS_OFF;
tw_set_pos (&tw1, 0, SQL_UPDATE);
T_RC (&tw1, SQL_SUCCESS_WITH_INFO);
T_RSTAT (&tw1, 1, SQL_ROW_ERROR);
ERRORS_ON;
tw_set_pos (&tw1, 0, SQL_REFRESH);
T_CCOL (&tw1, 1, t1_fs1, "VAL");
strcpy (tw2.tw_set[1].t1_fs1, "VA2");
tw_set_pos (&tw2, 2, SQL_UPDATE);
T_RC (&tw2, SQL_SUCCESS);
tw_set_pos (&tw2, 2, SQL_REFRESH);
T_CCOL (&tw2, 1, t1_fs1, "VA2");
tw_set_pos (&tw1, 2, SQL_REFRESH);
T_CCOL (&tw1, 1, t1_fs1, "VA2");
T_RSTAT (&tw1, 1, SQL_ROW_UPDATED);
tw_close (&tw1);
tw_close (&tw2);
}
Transaction::Transaction(Connection &conn)
: Conn(conn)
, SavedOption(0)
, Commited(false)
{
SQLRETURN Ret = SQLGetConnectOption(Conn.GetHolder().GetHandle(), SQL_AUTOCOMMIT, reinterpret_cast<SQLPOINTER *>(&SavedOption));
if (Ret != SQL_SUCCESS)
throw TransactionException("Error save options", teErrorSaveOptions);
Ret = SQLSetConnectOption(Conn.GetHolder().GetHandle(), SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF);
if (Ret != SQL_SUCCESS)
throw TransactionException("Error get init transaction", teErrorInitTransactio);
}
void
tsc_readtable (int ctype, int kssz, int commit_each, int del_bounds,
int n_windows, char * text)
{
int inx;
printf ("Scroll Fetch pb Test, commit = %d, del = %d\n", commit_each, del_bounds);
SQLSetConnectOption (hdbc1, SQL_AUTOCOMMIT, 0);
fprintf (stdout, "\n========== Scroll Fetch pb Test\n\n");
t1_window (&tw1, "CR1", hdbc1, text, ctype, kssz, 5, SQL_CONCUR_READ_ONLY, NULL);
tw_fetch (&tw1, SQL_FETCH_FIRST, 0);
for (inx = 0; inx < n_windows; inx++)
{
if (commit_each)
IF_CERR_GO (tw1.tw_hdbc, err, SQLTransact (SQL_NULL_HENV, tw1.tw_hdbc, SQL_COMMIT));
tw_fetch (&tw1, SQL_FETCH_NEXT, 0);
T_ICOL (&tw1, 0, t1_row_no, (inx+1) * 5);
}
err:
SQLSetConnectOption (tw1.tw_hdbc, SQL_AUTOCOMMIT, 1);
tw_close (&tw1);
}
Transaction::~Transaction()
{
if (!Commited)
{
try
{
Rollback();
}
catch (std::exception &)
{
}
}
SQLSetConnectOption(Conn.GetHolder().GetHandle(), SQL_AUTOCOMMIT, SavedOption);
}
TF EXPFUNC p_db_connect(ENGid eid)
{
HDBC hdbc;
char szDataSource[80];
char szUserID[40];
char szPassword[40];
if (pVAR != lsGetParmType(eid, 1))
{
lsErrRaise(eid, "db_connect instantiation error: arg 1 must be var");
return FALSE;
}
g_lsRC = lsGetParm(eid, 2, cSTR, szDataSource);
if (g_lsRC != OK) goto LS_ERROR;
g_lsRC = lsGetParm(eid, 3, cSTR, szUserID);
if (g_lsRC != OK) goto LS_ERROR;
g_lsRC = lsGetParm(eid, 4, cSTR, szPassword);
if (g_lsRC != OK) goto LS_ERROR;
g_RC = SQLAllocConnect(g_hEnv, &hdbc);
/* set up error handler */
g_hDBC = hdbc;
g_hSTMT = SQL_NULL_HSTMT;
g_eid = eid;
ERROR_CHK("SQLAllocConnect");
// Added this line to get around erroneous messages:
// S1010:[Microsoft][ODBC SQL Server Driver]Function sequence error
// Fix from MS Knowledge Article 179226
// SQL_PRESERVE_CURSORS - note new name in actual call
// This only applies to SQL Server, so hopefully, nothing bad will
// happen if it fails.
g_RC = SQLSetConnectOption(hdbc, SQL_COPT_SS_PRESERVE_CURSORS, NULL);
g_RC = SQLConnect(hdbc,
(UCHAR*)szDataSource, SQL_NTS,
(UCHAR*)szUserID, SQL_NTS,
(UCHAR*)szPassword, SQL_NTS);
ERROR_CHK("SQLConnect");
lsUnifyParm(eid, 1, cADDR, &hdbc);
return TRUE;
LS_ERROR:
return(lserror());
ODBC_ERROR:
return FALSE;
}
/*-----------------------------------------------------------------------------*/
void ODBCConnectOption()
{
HDBC hdbc = (HDBC)ptoc_int(2);
int set = ptoc_int(3);
long value = 0;
RETCODE rc;
if (set) {
rc = SQLSetConnectOption(hdbc,(UWORD)ptoc_int(4),(UDWORD)ptoc_int(5));
} else {
rc = SQLGetConnectOption(hdbc,(UWORD)ptoc_int(4),(PTR)&value);
ctop_int(5,value);
}
if ((rc == SQL_SUCCESS) || (rc == SQL_SUCCESS_WITH_INFO))
ctop_int(6,0);
else ctop_int(6,PrintErrorMsg(NULL));
}
void
tsc_bm (int ctype, int kssz, int ac)
{
long bm1;
int bmfill = 0;
int bm_no;
int c;
option_t opts [] = {{SQL_USE_BOOKMARKS, 1}, {-1, 0L}};
long bm[N_BMS];
long a_row_no[N_BMS + 10];
long b_row_no[N_BMS + 10];
char * t = "select A.ROW_NO, A.STRING1, B.STRING1, '--', B.ROW_NO "
"from T1 A join T1 B on B.ROW_NO between A.ROW_NO - 2 and A.ROW_NO + 2 order by a.row_no, b.row_no";
printf ("========== Bookmark Fetch cr=%s, keyset=%d AC=%d\n", cr_type_name (ctype), kssz, ac);
bm_expected (a_row_no, b_row_no);
SQLSetConnectOption (hdbc1, SQL_AUTOCOMMIT, ac);
t1_window (&tw1, "CR1", hdbc1, t, ctype, kssz, 3, SQL_CONCUR_READ_ONLY,
opts);
tw_fetch (&tw1, SQL_FETCH_NEXT, 0);
for (c = 0; c < N_BMS / 3; c++)
{
SQLGetStmtOption (tw1.tw_stmt, SQL_GET_BOOKMARK, &bm[bmfill]);
SQLGetStmtOption (tw1.tw_stmt, SQL_GET_BOOKMARK, &bm1);
if (bm1 != bm[bmfill])
fprintf (stderr, "Two consecutive bookmarks different for same row\n");
tw_set_pos (&tw1, 2, SQL_POSITION);
SQLGetStmtOption (tw1.tw_stmt, SQL_GET_BOOKMARK, &bm[bmfill + 1]);
tw_set_pos (&tw1, 3, SQL_POSITION);
SQLGetStmtOption (tw1.tw_stmt, SQL_GET_BOOKMARK, &bm[bmfill + 2]);
T_ICOL (&tw1, 0, t1_row_no, a_row_no[bmfill]);
T_ICOL (&tw1, 0, t1_fi2, b_row_no[bmfill]);
bmfill += 3;
tw_fetch (&tw1, SQL_FETCH_NEXT, 0);
}
for (bm_no = 2; bm_no < bmfill; bm_no += 2)
{
tw_fetch (&tw1, SQL_FETCH_BOOKMARK, bm[bm_no]);
T_ICOL (&tw1, 0, t1_row_no, a_row_no[bm_no]);
T_ICOL (&tw1, 0, t1_fi2, b_row_no[bm_no]);
}
SQLTransact (SQL_NULL_HENV, tw1.tw_hdbc, SQL_COMMIT);
tw_close (&tw1);
}
RETCODE ODBC_connect( /* Perform Driver Connection */
HENV henv, /* ODBC Environment Handle */
HDBC hdbc, /* ODBC Connection Handle */
UCHAR *driver, /* Data Source Name */
UCHAR *uid, /* User ID */
UCHAR *pwd) /* User Password */
{
RETCODE rc;
int retries;
#if defined(TRACING)
rc = SQLSetConnectOption (hdbc, SQL_OPT_TRACE, 1);
if ((rc != SQL_SUCCESS) && (rc != SQL_SUCCESS_WITH_INFO))
return (rc);
#endif
/*
** try connecting up to 3 times
*/
printf("\nPlease wait . . .\n");
printf("Establishing a connection to '%s' . . .\n", driver);
for (retries = 1; retries <= 3; retries++)
{
printf("Attempt connecting %d of 3 . . .\n", retries );
rc = SQLConnect (hdbc, driver, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS);
if ((rc == SQL_SUCCESS) || (rc == SQL_SUCCESS_WITH_INFO))
{
printf("Successfully, connected to '%s'.\n", driver);
return (rc);
}
else
{
printf("Unable to establish a connection to '%s'.\n", driver);
ODBC_getErrorInfo (henv, hdbc, SQL_NULL_HSTMT);
if(retries < 3)
printf("Retrying connect . . .\n");
}
}
/*
** Attempt to obtain a meaningful error as to why connect failed.
*/
printf("No connection could be established.\n");
ODBC_getErrorInfo(henv, hdbc, SQL_NULL_HSTMT);
return (SQL_INVALID_HANDLE);
}
void
tsc_fwd_fetch (int ctype, int ac, char * text)
{
long count = 0;
int rc;
long t1 = get_msec_count ();
SQLSetConnectOption (hdbc1, SQL_AUTOCOMMIT, ac);
t1_window (&tw1, "CR1", hdbc1, text, ctype, 0, 20, SQL_CONCUR_READ_ONLY, NULL);
for (;;)
{
rc = SQLFetch (tw1.tw_stmt);
if (rc == SQL_NO_DATA_FOUND || rc == SQL_ERROR)
break;
count++;
}
if (SQL_ERROR == rc)
print_error (SQL_NULL_HENV, SQL_NULL_HDBC, tw1.tw_stmt);
tw_close (&tw1);
printf ("SQLFetch: %ld msec, mode = %s, AC=%d, %ld row\n", get_msec_count () - t1, cr_type_name (ctype), ac, count);
}
/* begin a transaction */
void
sql_begTrans(void)
{
checkConnect();
stmt_text = 0;
hstmt = SQL_NULL_HSTMT;
rv_lastStatus = 0; /* might never call errorTrap(0) */
/* count the nesting level of transactions. */
if(!translevel) {
badtrans = false;
stmt_text = "begin work";
debugStatement();
rc = SQLSetConnectOption(hdbc, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF);
if(errorTrap(0))
return;
}
++translevel;
exclist = 0;
} /* sql_begTrans */
void
tsc_commit_cursor (t1_window_t * tw, int ctype, int commit)
{
long count = 0;
int rc = SQL_SUCCESS;
long last_row_no = 0;
printf ("STARTED: %s on open autocommit %s cursor\n",
commit == SQL_COMMIT ? "commit" : "rollback", cr_type_name (ctype));
SQLSetConnectOption (tw->tw_hdbc, SQL_AUTOCOMMIT, 1);
t1_window (tw, "CR1", tw->tw_hdbc, T1_BASE_TEXT, ctype, 0, 20, SQL_CONCUR_READ_ONLY, NULL);
for (count = 0; count < tw->tw_fill * 2; count += tw->tw_fill)
{
rc = SQLExtendedFetch (tw->tw_stmt, SQL_FETCH_NEXT, 0, &tw->tw_fill, tw->tw_stat);
if (rc == SQL_NO_DATA_FOUND || rc == SQL_ERROR)
break;
if (count && tw->tw_set[0].t1_row_no <= last_row_no)
fprintf (stderr,
"*** Error : Overlapping rowsets in SQL_FETCH_NEXT : mode = %s\n",
cr_type_name (ctype));
last_row_no = tw->tw_set[tw->tw_fill - 1].t1_row_no;
if (!count)
{
printf ("SQLTransact (%s) on open autocommit %s cursor\n",
commit == SQL_COMMIT ? "commit" : "rollback", cr_type_name (ctype));
rc = SQLTransact (SQL_NULL_HENV, tw->tw_hdbc, commit);
if (rc == SQL_ERROR)
break;
}
}
if (SQL_ERROR == rc)
print_error (SQL_NULL_HENV, SQL_NULL_HDBC, tw->tw_stmt);
tw_close (tw);
printf ("DONE: %s on open autocommit %s cursor\n\n",
commit == SQL_COMMIT ? "commit" : "rollback", cr_type_name (ctype));
}
int CSQLDirect::Connect( LPCSTR svSource , LPCSTR svUser, LPCSTR svPassword)
{
int nConnect=SQLAllocEnv( &m_hEnv );
if( nConnect==SQL_SUCCESS ) {
nConnect=SQLAllocConnect( m_hEnv,&m_hDBC );
if( nConnect==SQL_SUCCESS ) {
SQLSetConnectOption( m_hDBC,SQL_LOGIN_TIMEOUT,5 );
// Connect to the datasource.
_TUCHAR *psvSource=new _TUCHAR[ strlen( svSource )+1 ];
_TUCHAR *psvUser=new _TUCHAR[ strlen( svUser )+1 ];
_TUCHAR *psvPassword=new _TUCHAR[ strlen( svPassword )+1 ];
strcpy( (char*)psvSource,svSource );
strcpy( (char*)psvUser,svUser );
strcpy( (char*)psvPassword,svPassword );
nConnect=SQLConnect( m_hDBC,psvSource,SQL_NTS,psvUser,SQL_NTS,psvPassword,SQL_NTS );
if( nConnect==SQL_SUCCESS || nConnect==SQL_SUCCESS_WITH_INFO ) {
// Now that the datasource is open, get our SQL statement handle.
nConnect=SQLAllocStmt( m_hDBC,&m_hStmt );
}
SAFE_DELETE(psvSource);///modified by xizheng
SAFE_DELETE(psvUser);///modified by xizheng
SAFE_DELETE(psvPassword);///modified by xizheng
}
else
DisplayError();
}
else
DisplayError();
return nConnect;
}
int
ODBC_Connect (char *connStr)
{
short buflen;
SQLCHAR dataSource[1024];
SQLTCHAR dsn[33];
SQLTCHAR desc[255];
SQLTCHAR driverInfo[255];
SQLSMALLINT len1, len2;
int status;
#ifdef UNICODE
SQLWCHAR wdataSource[1024];
#endif
#if (ODBCVER < 0x0300)
if (SQLAllocEnv (&henv) != SQL_SUCCESS)
return -1;
if (SQLAllocConnect (henv, &hdbc) != SQL_SUCCESS)
return -1;
#else
if (SQLAllocHandle (SQL_HANDLE_ENV, NULL, &henv) != SQL_SUCCESS)
return -1;
SQLSetEnvAttr (henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER) SQL_OV_ODBC3,
SQL_IS_UINTEGER);
if (SQLAllocHandle (SQL_HANDLE_DBC, henv, &hdbc) != SQL_SUCCESS)
return -1;
#endif
/*
* Set the application name
*/
SQLSetConnectOption (hdbc, SQL_APPLICATION_NAME,
(SQLULEN) TEXT ("odbctest"));
/*
* Show the version number of the driver manager
*/
status = SQLGetInfo (hdbc, SQL_DM_VER,
driverInfo, sizeof (driverInfo), &len1);
if (status == SQL_SUCCESS)
{
#ifdef UNICODE
printf ("Driver Manager: %S\n", driverInfo);
#else
printf ("Driver Manager: %s\n", driverInfo);
#endif
}
/*
* Either use the connect string provided on the command line or
* ask for one. If an empty string or a ? is given, show a nice
* list of options
*/
if (connStr && *connStr)
strcpy ((char *) dataSource, connStr);
else
while (1)
{
/*
* Ask for the connect string
*/
printf ("\nEnter ODBC connect string (? shows list): ");
if (fgets ((char *) dataSource, sizeof (dataSource), stdin) == NULL)
return 1;
/*
* Remove trailing '\n'
*/
dataSource[strlen ((char *) dataSource) - 1] = '\0';
/*
* Check if the user wants to quit
*/
if (!strcmp ((char *)dataSource, "quit") || !strcmp ((char *)dataSource, "exit"))
return -1;
/*
* If the user entered something other than a ?
* break out of the while loop
*/
if (*dataSource && *dataSource != '?')
break;
/*
* Print headers
*/
fprintf (stderr, "\n%-32s | %-40s\n", "DSN", "Driver");
fprintf (stderr,
"------------------------------------------------------------------------------\n");
/*
* Goto the first record
*/
if (SQLDataSources (henv, SQL_FETCH_FIRST,
dsn, NUMTCHAR (dsn), &len1,
desc, NUMTCHAR (desc), &len2) != SQL_SUCCESS)
continue;
/*
* Show all records
*/
do
{
#ifdef UNICODE
fprintf (stderr, "%-32S | %-40S\n", dsn, desc);
#else
fprintf (stderr, "%-32s | %-40s\n", dsn, desc);
#endif
}
while (SQLDataSources (henv, SQL_FETCH_NEXT,
dsn, NUMTCHAR (dsn), &len1,
desc, NUMTCHAR (desc), &len2) == SQL_SUCCESS);
}
#ifdef UNICODE
strcpy_A2W (wdataSource, (char *) dataSource);
status = SQLDriverConnectW (hdbc, 0, (SQLWCHAR *) wdataSource, SQL_NTS,
(SQLWCHAR *) outdsn, NUMTCHAR (outdsn), &buflen, SQL_DRIVER_COMPLETE);
if (status != SQL_SUCCESS)
ODBC_Errors ("SQLDriverConnectW");
#else
status = SQLDriverConnect (hdbc, 0, (SQLCHAR *) dataSource, SQL_NTS,
(SQLCHAR *) outdsn, NUMTCHAR (outdsn), &buflen, SQL_DRIVER_COMPLETE);
if (status != SQL_SUCCESS)
ODBC_Errors ("SQLDriverConnect");
#endif
if (status != SQL_SUCCESS && status != SQL_SUCCESS_WITH_INFO)
return -1;
connected = 1;
/*
* Print out the version number and the name of the connected driver
*/
status = SQLGetInfo (hdbc, SQL_DRIVER_VER,
driverInfo, NUMTCHAR (driverInfo), &len1);
if (status == SQL_SUCCESS)
{
#ifdef UNICODE
printf ("Driver: %S", driverInfo);
#else
printf ("Driver: %s", driverInfo);
#endif
status = SQLGetInfo (hdbc, SQL_DRIVER_NAME,
driverInfo, NUMTCHAR (driverInfo), &len1);
if (status == SQL_SUCCESS)
{
#ifdef UNICODE
printf (" (%S)", driverInfo);
#else
printf (" (%s)", driverInfo);
#endif
}
printf ("\n");
}
/*
* Show the list of supported functions in trace log
*/
#if (ODBCVER < 0x0300)
{
SQLUSMALLINT exists[100];
SQLGetFunctions (hdbc, SQL_API_ALL_FUNCTIONS, exists);
}
#else
{
SQLUSMALLINT exists[SQL_API_ODBC3_ALL_FUNCTIONS_SIZE];
SQLGetFunctions (hdbc, SQL_API_ODBC3_ALL_FUNCTIONS, exists);
}
#endif
/*
* Allocate statement handle
*/
#if (ODBCVER < 0x0300)
if (SQLAllocStmt (hdbc, &hstmt) != SQL_SUCCESS)
return -1;
#else
if (SQLAllocHandle (SQL_HANDLE_STMT, hdbc, &hstmt) != SQL_SUCCESS)
return -1;
#endif
return 0;
}
/************************************************************************
* name: SQLSetConnectOptionW
* arguments:
* returns/side-effects:
* description:
* NOTE:
************************************************************************/
ODBC_INTERFACE RETCODE SQL_API
SQLSetConnectOptionW (SQLHDBC hdbc, SQLUSMALLINT option, SQLULEN param)
{
OutputDebugString ("SQLSetConnectOptionW called.\n");
return SQLSetConnectOption (hdbc, option, param);
}
STDMETHODIMP CComSpySqlAudit::Init(LPCWSTR pwszDSN, LPCWSTR pwszUser, LPCWSTR pwszPw)
{
WCHAR wszBuffer[1024];
SQLRETURN rc;
if (m_henv || m_hstmt || m_hdbc)
return E_UNEXPECTED; //did you call Init() twice?
rc = SQLAllocEnv( &m_henv );
if (!SQL_SUCCEEDED(rc))
{
ATLTRACE(L"CComSpySqlAudit::Init() - SQLAllocEnv failed with code %d\n", rc);
goto Error;
}
//Allocate the Connection handle
rc = SQLAllocConnect( m_henv, &m_hdbc );
if (!SQL_SUCCEEDED(rc))
{
ATLTRACE(L"CComSpySqlAudit::Init() - SQLAllocConnect failed with code %d\n", rc);
goto Error;
}
SQLSetConnectOption(m_hdbc, SQL_LOGIN_TIMEOUT, 5);
rc = SQLConnect( m_hdbc, SqlStringArg(pwszDSN), SQL_NTS,
SqlStringArg(pwszUser), SQL_NTS,
SqlStringArg(pwszPw), SQL_NTS);
if (!SQL_SUCCEEDED(rc))
{
ATLTRACE(L"CComSpySqlAudit::Init() - SQLConnect failed with code %d\n", rc);
goto Error;
}
//Allocate the statement handle
rc = SQLAllocStmt( m_hdbc, &m_hstmt);
if (!SQL_SUCCEEDED(rc))
{
ATLTRACE(L"CComSpySqlAudit::Init() - SQLAllocStmt failed with code %d\n", rc);
goto Error;
}
//
// verify the table existence
//
{
for (int i=0; i < ARRAYSIZE(pwszTables); i++)
{
HRESULT hrString = StringCchPrintfEx(
wszBuffer, ARRAYSIZE(wszBuffer),
NULL, NULL, STRSAFE_NO_TRUNCATION,
L"CREATE TABLE dbo.%s (Ct int NOT NULL )", pwszTables[i]);
_ASSERTE(SUCCEEDED(hrString));
rc = SQLExecDirect(m_hstmt, SqlStringArg(wszBuffer), SQL_NTS);
if (SQL_SUCCEEDED(rc))
{
// this means the table is not in the db
//Clean up the table just created and exit
hrString = StringCchPrintfEx(wszBuffer, ARRAYSIZE(wszBuffer),
NULL, NULL, STRSAFE_NO_TRUNCATION,
L"drop table %s", pwszTables[i]);
_ASSERTE(SUCCEEDED(hrString));
rc = SQLExecDirect(m_hstmt, SqlStringArg(wszBuffer), SQL_NTS);
ATLTRACE(L"Table %s is not in the Database.\n", pwszTables[i]);
goto Error;
}
}
}
return S_OK;
Error:
if (m_hstmt)
{
SQLFreeStmt( m_hstmt, SQL_DROP );
}
if (m_hdbc)
{
rc = SQLDisconnect( m_hdbc);
SQLFreeConnect( m_hdbc);
if (m_henv)
SQLFreeEnv( m_henv );
}
m_hdbc = m_hstmt = m_henv = NULL;
return E_FAIL;
}
int main()
{
int i;
retcode = SQLAllocEnv(&henv);
if (SQLAllocConnect(henv, &hdbc) != SQL_SUCCESS)
{
UCHAR szSqlState[6];
UCHAR szErrorMsg[SQL_MAX_MESSAGE_LENGTH];
SQLINTEGER dwNativeError;
SWORD wErrorMsg;
SQLError(henv, SQL_NULL_HDBC, SQL_NULL_HSTMT,
szSqlState, &dwNativeError, szErrorMsg,
SQL_MAX_MESSAGE_LENGTH-1, &wErrorMsg);
fprintf(stderr,"problem with SQLAllocConnect\n%s\n%s\n",
szSqlState, szErrorMsg);
return 1;
}
retcode = SQLSetConnectOption(hdbc, SQL_ACCESS_MODE, SQL_MODE_READ_ONLY);
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
UCHAR szSqlState[6];
UCHAR szErrorMsg[SQL_MAX_MESSAGE_LENGTH];
SQLINTEGER dwNativeError;
SWORD wErrorMsg;
SQLError(SQL_NULL_HENV, hdbc, SQL_NULL_HSTMT,
szSqlState, &dwNativeError, szErrorMsg,
SQL_MAX_MESSAGE_LENGTH-1, &wErrorMsg);
fprintf(stderr,"problem with SQLSetConnectOption\n%s\n%s\n",
szSqlState, szErrorMsg);
return 1;
}
retcode = SQLSetConnectOption(hdbc, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_ON);
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
UCHAR szSqlState[6];
UCHAR szErrorMsg[SQL_MAX_MESSAGE_LENGTH];
SQLINTEGER dwNativeError;
SWORD wErrorMsg;
SQLError(SQL_NULL_HENV, hdbc, SQL_NULL_HSTMT,
szSqlState, &dwNativeError, szErrorMsg,
SQL_MAX_MESSAGE_LENGTH-1, &wErrorMsg);
fprintf(stderr,"problem with SQLSetConnectOption\n%s\n%s\n",
szSqlState, szErrorMsg);
return 1;
}
retcode = SQLConnect(hdbc,
(UCHAR *)"Northwind", SQL_NTS,
(UCHAR *)"", SQL_NTS,
(UCHAR *)"", SQL_NTS);
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
UCHAR szSqlState[6];
UCHAR szErrorMsg[SQL_MAX_MESSAGE_LENGTH];
SQLINTEGER dwNativeError;
SWORD wErrorMsg;
SQLError(SQL_NULL_HENV, hdbc, SQL_NULL_HSTMT,
szSqlState, &dwNativeError, szErrorMsg,
SQL_MAX_MESSAGE_LENGTH-1, &wErrorMsg);
fprintf(stderr,"problem with SQLConnect\n%s\n%s\n",
szSqlState, szErrorMsg);
return 1;
}
if (SQLAllocStmt(hdbc, &hstmt)!= SQL_SUCCESS)
{
UCHAR szSqlState[6];
UCHAR szErrorMsg[SQL_MAX_MESSAGE_LENGTH];
SQLINTEGER dwNativeError;
SWORD wErrorMsg;
SQLError(SQL_NULL_HENV, hdbc, SQL_NULL_HSTMT,
szSqlState, &dwNativeError, szErrorMsg,
SQL_MAX_MESSAGE_LENGTH-1, &wErrorMsg);
fprintf(stderr,"problem with SQLAllocStmt\n%s\n%s\n",
szSqlState, szErrorMsg);
return 1;
}
/* Prepare the SQL statement with parameter markers. */
retcode = SQLPrepare(hstmt,
(unsigned char *)"select * from Shippers",
SQL_NTS);
if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO)
{
long p1;
long p1Len = sizeof(p1);
long sAge = 1023;
long cbAge = sizeof(long);
UCHAR szCol1[60];
SQLINTEGER length;
printf("excecuting first statement\n");
retcode = SQLExecute(hstmt);
if (retcode != SQL_SUCCESS) {
UCHAR szSqlState[6];
UCHAR szErrorMsg[SQL_MAX_MESSAGE_LENGTH];
SQLINTEGER dwNativeError;
SWORD wErrorMsg;
SQLError(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
szSqlState, &dwNativeError, szErrorMsg,
SQL_MAX_MESSAGE_LENGTH-1, &wErrorMsg);
fprintf(stderr,"problem with SQLExecute\n%s\n%s\n",
szSqlState, szErrorMsg);
return 1;
}
SQLBindCol(hstmt, 3, SQL_CHAR, szCol1, 60, &length);
//SQLBindCol(hstmt, 1, SQL_CHAR, szCol1, 60, NULL);
/* Execute statement with first row. */
i=0;
while ((retcode = SQLFetch(hstmt)) == SQL_SUCCESS)
{
i++;
printf("%d: szCol1 = %s (%d)\n",i,szCol1, length);
}
if (retcode != SQL_NO_DATA_FOUND)
{
printStatementError(hstmt, "problem with SQLFetch");
return 1;
}
}
printf("Done\n");
return 1;
}
static int
backsql_open_db_handle(
backsql_info *bi,
SQLHDBC *dbhp )
{
/* TimesTen */
char DBMSName[ 32 ];
int rc;
assert( dbhp != NULL );
*dbhp = SQL_NULL_HDBC;
Debug( LDAP_DEBUG_TRACE, "==>backsql_open_db_handle()\n",
0, 0, 0 );
rc = SQLAllocConnect( bi->sql_db_env, dbhp );
if ( !BACKSQL_SUCCESS( rc ) ) {
Debug( LDAP_DEBUG_TRACE, "backsql_open_db_handle(): "
"SQLAllocConnect() failed:\n",
0, 0, 0 );
backsql_PrintErrors( bi->sql_db_env, SQL_NULL_HDBC,
SQL_NULL_HENV, rc );
return LDAP_UNAVAILABLE;
}
rc = SQLConnect( *dbhp,
(SQLCHAR*)bi->sql_dbname, SQL_NTS,
(SQLCHAR*)bi->sql_dbuser, SQL_NTS,
(SQLCHAR*)bi->sql_dbpasswd, SQL_NTS );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, "backsql_open_db_handle(): "
"SQLConnect() to database \"%s\" %s.\n",
bi->sql_dbname,
rc == SQL_SUCCESS_WITH_INFO ?
"succeeded with info" : "failed",
0 );
backsql_PrintErrors( bi->sql_db_env, *dbhp, SQL_NULL_HENV, rc );
if ( rc != SQL_SUCCESS_WITH_INFO ) {
SQLFreeConnect( *dbhp );
return LDAP_UNAVAILABLE;
}
}
/*
* TimesTen : Turn off autocommit. We must explicitly
* commit any transactions.
*/
SQLSetConnectOption( *dbhp, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF );
/*
* See if this connection is to TimesTen. If it is,
* remember that fact for later use.
*/
/* Assume until proven otherwise */
bi->sql_flags &= ~BSQLF_USE_REVERSE_DN;
DBMSName[ 0 ] = '\0';
rc = SQLGetInfo( *dbhp, SQL_DBMS_NAME, (PTR)&DBMSName,
sizeof( DBMSName ), NULL );
if ( rc == SQL_SUCCESS ) {
if ( strcmp( DBMSName, "TimesTen" ) == 0 ||
strcmp( DBMSName, "Front-Tier" ) == 0 )
{
Debug( LDAP_DEBUG_TRACE, "backsql_open_db_handle(): "
"TimesTen database!\n",
0, 0, 0 );
bi->sql_flags |= BSQLF_USE_REVERSE_DN;
}
} else {
Debug( LDAP_DEBUG_TRACE, "backsql_open_db_handle(): "
"SQLGetInfo() failed.\n",
0, 0, 0 );
backsql_PrintErrors( bi->sql_db_env, *dbhp, SQL_NULL_HENV, rc );
SQLDisconnect( *dbhp );
SQLFreeConnect( *dbhp );
return LDAP_UNAVAILABLE;
}
/* end TimesTen */
Debug( LDAP_DEBUG_TRACE, "<==backsql_open_db_handle()\n",
0, 0, 0 );
return LDAP_SUCCESS;
}
/*
---------------------------------------------------------
TestSQLTransact
---------------------------------------------------------
*/
PassFail TestSQLTransact(TestInfo *pTestInfo)
{
TEST_DECLARE;
RETCODE returncode;
TCHAR Heading[MAX_STRING_SIZE];
SQLHANDLE henv;
SQLHANDLE hdbc;
SQLHANDLE hstmt;
TCHAR *ExecDirStr[6];
UWORD fType[] = { SQL_ROLLBACK,SQL_COMMIT };
TCHAR *TypeDesc[] = { _T("SQL_ROLLBACK"),_T("SQL_COMMIT") };
TCHAR *Output;
SQLLEN OutputLen;
struct
{
SWORD ExeRes[2];
SWORD FetchRes[2];
TCHAR *DataRes[2];
} CheckRes[] =
{
{SQL_ERROR,SQL_SUCCESS,SQL_NO_DATA_FOUND,SQL_NO_DATA_FOUND,_T(""),_T("")},
{SQL_SUCCESS,SQL_SUCCESS,SQL_NO_DATA_FOUND,SQL_SUCCESS,_T(""),_T("--")},
{SQL_SUCCESS,SQL_SUCCESS,SQL_SUCCESS,SQL_SUCCESS,_T("--"),_T("--")},
{SQL_SUCCESS,SQL_SUCCESS,SQL_SUCCESS,SQL_NO_DATA_FOUND,_T("--"),_T("")},
{SQL_SUCCESS,SQL_ERROR,SQL_NO_DATA_FOUND,SQL_NO_DATA_FOUND,_T(""),_T("")}
};
int i = 0, j = 0, iend = 5, jend = 1, commit_on_off = 0;
//===========================================================================================================
var_list_t *var_list;
var_list = load_api_vars(_T("SQLTransact"), charset_file);
if (var_list == NULL) return FAILED;
ExecDirStr[0] = var_mapping(_T("SQLTransact_ExecDirStr_0"), var_list);
ExecDirStr[1] = var_mapping(_T("SQLTransact_ExecDirStr_1"), var_list);
ExecDirStr[2] = var_mapping(_T("SQLTransact_ExecDirStr_2"), var_list);
ExecDirStr[3] = var_mapping(_T("SQLTransact_ExecDirStr_3"), var_list);
ExecDirStr[4] = var_mapping(_T("SQLTransact_ExecDirStr_4"), var_list);
ExecDirStr[5] = var_mapping(_T("SQLTransact_ExecDirStr_5"), var_list);
CheckRes[1].DataRes[1] = var_mapping(_T("SQLTransact_Insert"), var_list);
CheckRes[2].DataRes[0] = var_mapping(_T("SQLTransact_Insert"), var_list);
CheckRes[2].DataRes[1] = var_mapping(_T("SQLTransact_Update"), var_list);
CheckRes[3].DataRes[0] = var_mapping(_T("SQLTransact_Update"), var_list);
//========================================================================================================
LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API => SQLTransact.\n"));
TEST_INIT;
TESTCASE_BEGIN("Initializing SQLTransact test environment\n");
//
if(!FullConnect(pTestInfo))
{
LogMsg(NONE,_T("Unable to connect\n"));
TEST_FAILED;
TEST_RETURN;
}
henv = pTestInfo->henv;
hdbc = pTestInfo->hdbc;
hstmt = (SQLHANDLE)pTestInfo->hstmt;
returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt"))
{
LogAllErrors(henv,hdbc,hstmt);
FullDisconnect(pTestInfo);
TEST_FAILED;
TEST_RETURN;
}
for (commit_on_off = 0; commit_on_off < 10; commit_on_off++)
{
returncode = SQLSetConnectOption((SQLHANDLE)hdbc,SQL_AUTOCOMMIT,SQL_AUTOCOMMIT_ON);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnectOption"))
{
LogAllErrors(henv,hdbc,hstmt);
FullDisconnect(pTestInfo);
TEST_FAILED;
TEST_RETURN;
}
TESTCASE_END;
SQLExecDirect(hstmt, (SQLTCHAR*)ExecDirStr[4], SQL_NTS); /* CLEANUP */
for (i = 0; i <= (iend-1); i++)
{
_stprintf(Heading,_T("Test Positive Functionality of SQLTransact while Autocommit is ON and executing\n"));
_tcscat(Heading, ExecDirStr[i]);
_tcscat(Heading, _T("\n"));
TESTCASE_BEGINW(Heading);
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
}
SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[4],SQL_NTS); /* CLEANUP */
returncode = SQLSetConnectOption((SQLHANDLE)hdbc,SQL_AUTOCOMMIT,SQL_AUTOCOMMIT_OFF);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnectOption"))
{
LogAllErrors(henv,hdbc,hstmt);
FullDisconnect(pTestInfo);
TEST_FAILED;
TEST_RETURN;
}
TESTCASE_END;
for (i = 0; i <= (iend-1); i++)
{
for (j = 0; j <= jend; j++)
{
_stprintf(Heading,_T("Test Positive Functionality of SQLTransact while Autocommit is OFF and executing\n"));
_tcscat(Heading, ExecDirStr[i]);
_tcscat(Heading, _T(" & "));
_tcscat(Heading, TypeDesc[j]);
_tcscat(Heading, _T("\n"));
TESTCASE_BEGINW(Heading);
//MAY 9, 2014 - TURNING AUTOCOMMIT ON FOR DDLs FOR TRAF, AS DDLs ARE NOT SUPPORTED WITH AUTOCOMMIT OFF
if (i == 4 || i == 0)
SQLSetConnectOption((SQLHANDLE)hdbc, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_ON);
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS);
SQLSetConnectOption((SQLHANDLE)hdbc, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF);
if (!CHECKRC(SQL_SUCCESS, returncode, "SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode=SQLTransact((SQLHANDLE)henv,(SQLHANDLE)hdbc,fType[j]);
Sleep(2); // tmf rollback is slower.
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLTransact"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[iend],SQL_NTS);
if(!CHECKRC(CheckRes[i].ExeRes[j],returncode,"SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
if (returncode == SQL_SUCCESS || returncode == SQL_SUCCESS_WITH_INFO)
{
Output = (TCHAR *)malloc(NAME_LEN);
returncode=SQLBindCol(hstmt,1,SQL_C_TCHAR,Output,NAME_LEN,&OutputLen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLFetch(hstmt);
if(!CHECKRC(CheckRes[i].FetchRes[j],returncode,"SQLFetch"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
if (returncode != SQL_NO_DATA_FOUND && returncode != SQL_ERROR)
{
if (_tcscspn(CheckRes[i].DataRes[j],Output) == 0)
{
LogMsg(NONE,_T("expect: %s and actual: %s are matched\n"),Output,CheckRes[i].DataRes[j]);
}
else
{
LogMsg(NONE,_T("expect: %s and actual: %s are not matched\n"),Output,CheckRes[i].DataRes[j]);
TEST_FAILED;
}
}
}
free(Output);
SQLFreeStmt(hstmt,SQL_CLOSE);
}
}
}
}
TESTCASE_END;
}/* end j loop */
}/* end i loop */
}
//========================================================================================================
SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[4],SQL_NTS); /* CLEANUP */
returncode = SQLDisconnect((SQLHANDLE)hdbc);
if(!CHECKRC(SQL_ERROR,returncode,"SQLDisconnect"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
// Free the open transactions.
returncode=SQLTransact((SQLHANDLE)henv,(SQLHANDLE)hdbc,SQL_ROLLBACK);
Sleep(2);
returncode=FullDisconnect(pTestInfo);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFullDisconnect"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => SQLTransact.\n"));
free_list(var_list);
TEST_RETURN;
}
