/* <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; }