static SqlServer_T doConnect(URL_T url, char **error) { RETCODE retcode; SqlServer_T db = (SqlServer_T)malloc(sizeof(struct SqlServer_S)); /*retcode = SQLAllocHandle (SQL_HANDLE_ENV, NULL, &db->henv); retcode = SQLSetEnvAttr(db->henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, SQL_IS_INTEGER); */ retcode = SQLAllocEnv(&db->henv); //2.Á¬½Ó¾ä±ú retcode = SQLAllocConnect(db->henv, &db->hdbc); //retcode = SQLAllocHandle(SQL_HANDLE_DBC, db->henv, &db->hdbc); retcode = SQLConnect(db->hdbc, URL_getParameter(url, "db"), strlen( URL_getParameter(url, "db") ), URL_getUser(url), strlen(URL_getUser(url)), URL_getPassword(url), strlen(URL_getPassword(url))); if (SQLSERVERSUCCESS(retcode)) { return db; } else { SQLFreeHandle(SQL_HANDLE_DBC, db->hdbc); SQLFreeHandle(SQL_HANDLE_ENV, db->henv); free(db); return NULL; } }
// Allocate environment handle, allocate connection handle, // connect to data source, and allocate statement handle. bool direxec::sqlconn(FILE* file) { logFile = file; unsigned int timeout = 10; // seconds SQLAllocEnv(&henv); SQLAllocConnect(henv,&hdbc); SQLSetConnectAttr(hdbc, SQL_LOGIN_TIMEOUT, &timeout, 0); rc=SQLConnect(hdbc,chr_ds_name,SQL_NTS,NULL,0,NULL,0); // Deallocate handles, display error message, and exit. if (!MYSQLSUCCESS(rc)) { SQLCHAR SqlState[6]; SQLINTEGER NativeError; SQLSMALLINT MsgLen; SQLGetDiagRec(SQL_HANDLE_DBC, hdbc, 1, SqlState, &NativeError, (unsigned char *) szData, 2048, &MsgLen); SQLFreeEnv(henv); SQLFreeConnect(hdbc); fprintf(logFile, "! Error while connecting to database: %s\n", szData); errorstate = TRUE; return FALSE; } rc=SQLAllocStmt(hdbc,&hstmt); errorstate = FALSE; return TRUE; }
static SQLRETURN init(char *dbalias, SQLHENV *henv, SQLHDBC *hdbc) { SQLHSTMT hstmt; /* statement handle */ SQLRETURN rc; *henv = 0; rc = SQLAllocEnv(henv); CHECK_HANDLE(SQL_HANDLE_ENV, *henv, rc, "SQLAllocEnv", (SQLCHAR *) ""); rc = SQLAllocConnect(*henv, hdbc); CHECK_HANDLE(SQL_HANDLE_DBC, *hdbc, rc, "SQLAllocConnect", (SQLCHAR *) ""); rc = SQLConnect(*hdbc, (SQLCHAR *) dbalias, SQL_NTS, NULL, SQL_NTS, NULL, SQL_NTS); CHECK_HANDLE(SQL_HANDLE_DBC, *hdbc, rc, "SQLConnect", (SQLCHAR *) ""); rc = SQLAllocHandle(SQL_HANDLE_STMT, *hdbc, &hstmt); CHECK_HANDLE(SQL_HANDLE_STMT, hstmt, rc, "SQLAllocHandle", (SQLCHAR *) ""); (void) SQLExecDirect(hstmt, CTSQL, SQL_NTS); /*CHECK_HANDLE(SQL_HANDLE_STMT, hstmt, rc, "SQLExecDirect", CTSQL);*/ (void) SQLFreeStmt(hstmt, SQL_DROP); return rc; }
static void gsql_connect (char *dsn, Database *db) { RETCODE status; db->connected = 0; if (dsn != (char *) NULL) { char buf[257]; short buflen; if (strchr (dsn, '=') == (char *)NULL) { db->dsn = (char *)xmalloc (5 + strlen (dsn)); sprintf (db->dsn, "DSN=%s", dsn); } else db->dsn = strdup (dsn); if (SQLAllocEnv (&(db->henv)) == SQL_SUCCESS) if (SQLAllocConnect (db->henv, &(db->hdbc)) == SQL_SUCCESS) { status = SQLDriverConnect (db->hdbc, 0, (UCHAR *) db->dsn, SQL_NTS, (UCHAR *) buf, sizeof (buf), &buflen, SQL_DRIVER_COMPLETE); if ((status == SQL_SUCCESS) || (status == SQL_SUCCESS_WITH_INFO)) db->connected = 1; } } }
static int odbc_dispatch9(void) { unsigned long retval; PWord rval; int rtype; PWord arg1; int type1; PWord arg2; int type2; PWord arg3; int type3; PI_getan(&arg1,&type1,1); if (type1 != PI_INT) if (!CI_get_integer((unsigned long *)&arg1,type1)) PI_FAIL; PI_getan(&arg2,&type2,2); if (type2 != PI_INT) if (!CI_get_integer((unsigned long *)&arg2,type2)) PI_FAIL; PI_getan(&arg3,&type3,3); switch(arg1) { case 0: retval = (unsigned long) SQLMoreResults(((SQLHSTMT ) arg2)); break; case 1: retval = (unsigned long) SQLFreeEnv(((SQLHENV ) arg2)); break; case 2: retval = (unsigned long) SQLFreeConnect(((SQLHDBC ) arg2)); break; case 3: retval = (unsigned long) SQLFetch(((SQLHSTMT ) arg2)); break; case 4: retval = (unsigned long) SQLExecute(((SQLHSTMT ) arg2)); break; case 5: retval = (unsigned long) SQLDisconnect(((SQLHDBC ) arg2)); break; case 6: retval = (unsigned long) SQLCloseCursor(((SQLHSTMT ) arg2)); break; case 7: retval = (unsigned long) SQLCancel(((SQLHSTMT ) arg2)); break; case 8: retval = (unsigned long) SQLAllocEnv(((SQLHENV * ) arg2)); break; default: PI_FAIL; } PI_makedouble(&rval,&rtype,(double) retval); if (PI_unify(arg3,type3,rval,rtype)) PI_SUCCEED; PI_FAIL; }
static BOOL test_driver_connect (TDSNCHOOSER *choose_t, char *connstr) { HENV henv; HDBC hdbc; #if (ODBCVER < 0x300) if (SQLAllocEnv (&henv) != SQL_SUCCESS) #else if (SQLAllocHandle (SQL_HANDLE_ENV, NULL, &henv) != SQL_SUCCESS) #endif { _iodbcdm_nativeerrorbox (choose_t->mainwnd, henv, SQL_NULL_HDBC, SQL_NULL_HSTMT); return FALSE; } #if (ODBCVER < 0x300) if (SQLAllocConnect (henv, &hdbc) != SQL_SUCCESS) #else SQLSetEnvAttr (henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER); if (SQLAllocHandle (SQL_HANDLE_DBC, henv, &hdbc) != SQL_SUCCESS) #endif { _iodbcdm_nativeerrorbox (choose_t->mainwnd, henv, hdbc, SQL_NULL_HSTMT); SQLFreeEnv (henv); return FALSE; } SQLSetConfigMode (ODBC_BOTH_DSN); if (SQLDriverConnect (hdbc, choose_t->mainwnd, connstr, SQL_NTS, NULL, 0, NULL, SQL_DRIVER_PROMPT) != SQL_SUCCESS) { _iodbcdm_nativeerrorbox (choose_t->mainwnd, henv, hdbc, SQL_NULL_HSTMT); SQLFreeEnv (henv); return FALSE; } else { SQLDisconnect (hdbc); } #if (ODBCVER < 0x300) SQLFreeConnect (hdbc); SQLFreeEnv (henv); #else SQLFreeHandle (SQL_HANDLE_DBC, hdbc); SQLFreeHandle (SQL_HANDLE_ENV, henv); #endif return TRUE; }
TF EXPFUNC p_db_init(ENGid eid) { if (g_bEnvOpen) return TRUE; g_RC = SQLAllocEnv(&g_hEnv); g_hDBC = SQL_NULL_HDBC; g_hSTMT = SQL_NULL_HSTMT; ERROR_CHK("SQLAllocEnv"); g_bEnvOpen = TRUE; return TRUE; ODBC_ERROR: return FALSE; }
/* Allocate the environment structure for use by the SQL routines. */ int cllOpenEnv(icatSessionStruct *icss) { RETCODE stat; HENV myHenv; stat = SQLAllocEnv(&myHenv); if (stat != SQL_SUCCESS) { rodsLog(LOG_ERROR, "cllOpenEnv: SQLAllocEnv failed"); return (-1); } icss->environPtr=myHenv; return(0); }
/* --------------------------------------------------------- TestSQLDataSources No negative tests since this functionality is done at driver manager level. --------------------------------------------------------- */ PassFail TestSQLDataSources(TestInfo *pTestInfo) { TEST_DECLARE; RETCODE returncode; SQLHANDLE henv; char szDSN[DSRC_LEN], szDESC[DSRC_LEN]; SWORD cbDSN, pcbDESC; LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API => SQLDataSources | SQLDataSources | datasrc.c\n"); TEST_INIT; //========================================================================================== TESTCASE_BEGIN("Test the positive functionality of SQLDataSources\n"); returncode = SQLAllocEnv(&henv); /* Environment handle */ if (returncode == SQL_SUCCESS) { returncode = SQLDataSources(henv, SQL_FETCH_FIRST, (SQLCHAR*)szDSN, DSRC_LEN, &cbDSN, (SQLCHAR*)szDESC, DSRC_LEN, &pcbDESC); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLDataSources")) { TEST_FAILED; LogMsg(ERRMSG,"Test SQLDataSources => SQL_FETCH_FIRST #1 failed.\n"); } while (returncode == SQL_SUCCESS) { returncode = SQLDataSources(henv, SQL_FETCH_NEXT, (SQLCHAR*)szDSN, DSRC_LEN, &cbDSN, (SQLCHAR*)szDESC, DSRC_LEN, &pcbDESC); if((returncode != SQL_SUCCESS) && (returncode != SQL_NO_DATA_FOUND)) { TEST_FAILED; LogMsg(ERRMSG,"Test SQLDataSources => SQL_FETCH_NEXT failed.\n"); } } returncode = SQLDataSources(henv, SQL_FETCH_FIRST, (SQLCHAR*)szDSN, DSRC_LEN, &cbDSN, (SQLCHAR*)szDESC, DSRC_LEN, &pcbDESC); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLDataSources")) { TEST_FAILED; LogMsg(ERRMSG,"Test SQLDataSources => SQL_FETCH_FIRST #2 failed.\n"); } } SQLFreeEnv(henv); TESTCASE_END; //========================================================================================== LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => SQLDataSources.\n"); TEST_RETURN; }
int backsql_init_db_env( backsql_info *si ) { RETCODE rc; Debug( LDAP_DEBUG_TRACE, "==>backsql_init_db_env()\n", 0, 0, 0 ); rc = SQLAllocEnv( &si->db_env ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, "init_db_env: SQLAllocEnv failed:\n", 0, 0, 0 ); backsql_PrintErrors( SQL_NULL_HENV, SQL_NULL_HDBC, SQL_NULL_HENV, rc ); } Debug( LDAP_DEBUG_TRACE, "<==backsql_init_db_env()\n", 0, 0, 0 ); return SQL_SUCCESS; }
SQLRETURN alloc_handle(SQLHENV &env, SQLHDBC &dbc) { /* allocate Environment handle */ if (SQLAllocEnv(&env) != SQL_SUCCESS) { printf("SQLAllocEnv error!!\n"); return SQL_ERROR; } /* allocate Connection handle */ if (SQLAllocConnect(env, &dbc) != SQL_SUCCESS) { printf("SQLAllocConnect error!!\n"); return SQL_ERROR; } return SQL_SUCCESS; }
static int sql_odbc_init(const char *host, const char *port, const char *socket, const char *name, const char *user, const char *pass) { /* Create environment. */ if(odbc_Result(SQLAllocEnv(&env)) && odbc_Result(SQLAllocConnect(env, &con))) { eventlog(eventlog_level_debug, __FUNCTION__, "Created ODBC environment."); } else { eventlog(eventlog_level_error, __FUNCTION__, "Unable to allocate ODBC environment."); return odbc_Fail(); } if(odbc_Result(SQLConnect(con, (SQLCHAR*)name, SQL_NTS, (SQLCHAR*)user, SQL_NTS, (SQLCHAR*)pass, SQL_NTS))) { eventlog(eventlog_level_debug, __FUNCTION__, "Connected to ODBC datasource \"%s\".", name); } else { eventlog(eventlog_level_error, __FUNCTION__, "Unable to connect to ODBC datasource \"%s\".", name); odbc_Error(SQL_HANDLE_DBC, con, eventlog_level_error, __FUNCTION__); return odbc_Fail(); } return 0; }
/************************************************************************* * * Function: sql_socket_init * * Purpose: Establish connection to the db * *************************************************************************/ static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t *config) { rlm_sql_iodbc_conn_t *conn; SQLRETURN rcode; MEM(conn = handle->conn = talloc_zero(handle, rlm_sql_iodbc_conn_t)); talloc_set_destructor((void *) conn, sql_socket_destructor); rcode = SQLAllocEnv(&conn->env_handle); if (!SQL_SUCCEEDED(rcode)) { ERROR("sql_create_socket: SQLAllocEnv failed: %s", sql_error(handle, config)); return -1; } rcode = SQLAllocConnect(conn->env_handle, &conn->dbc_handle); if (!SQL_SUCCEEDED(rcode)) { ERROR("sql_create_socket: SQLAllocConnect failed: %s", sql_error(handle, config)); return -1; } /* * The iodbc API doesn't qualify arguments as const even when they should be. */ { SQLCHAR *server, *login, *password; memcpy(&server, &config->sql_server, sizeof(server)); memcpy(&login, &config->sql_login, sizeof(login)); memcpy(&password, &config->sql_password, sizeof(password)); rcode = SQLConnect(conn->dbc_handle, server, SQL_NTS, login, SQL_NTS, password, SQL_NTS); } if (!SQL_SUCCEEDED(rcode)) { ERROR("sql_create_socket: SQLConnectfailed: %s", sql_error(handle, config)); return -1; } return 0; }
int backsql_init_db_env( backsql_info *bi ) { RETCODE rc; int ret = SQL_SUCCESS; Debug( LDAP_DEBUG_TRACE, "==>backsql_init_db_env()\n", 0, 0, 0 ); rc = SQLAllocEnv( &bi->sql_db_env ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, "init_db_env: SQLAllocEnv failed:\n", 0, 0, 0 ); backsql_PrintErrors( SQL_NULL_HENV, SQL_NULL_HDBC, SQL_NULL_HENV, rc ); ret = SQL_ERROR; } Debug( LDAP_DEBUG_TRACE, "<==backsql_init_db_env()=%d\n", ret, 0, 0 ); return ret; }
int main (int argc, char *argv[]) { rc = SQLAllocEnv (&henv); IF_EERR_EXIT (henv, rc); rc = SQLAllocConnect (henv, &hdbc); IF_CERR_EXIT (hdbc, rc); rc = SQLConnect (hdbc, argc > 1 ? argv[1] : "1111", SQL_NTS, argc > 2 ? argv[2] : "dba", SQL_NTS, argc > 3 ? argv[3] : "dba", SQL_NTS); IF_CERR_EXIT (hdbc, rc); rc = SQLAllocStmt (hdbc, &hstmt); IF_CERR_EXIT (hdbc, rc); rc = SQLSetStmtOption (hstmt, SQL_ROWSET_SIZE, 10); rc = SQLSetStmtOption (hstmt, SQL_CURSOR_TYPE, SQL_CURSOR_KEYSET_DRIVEN); rc = SQLExecDirect (hstmt, "select distinct name_part (KEY_TABLE, 0) as DB from DB.DBA.SYS_KEYS", SQL_NTS); while (SQL_SUCCESS == (rc = SQLFetch (hstmt))) { char data[128]; SDWORD len = sizeof (data); IF_ERR_EXIT (hstmt, rc); rc = SQLGetData (hstmt, 1, SQL_C_CHAR, data, sizeof (data), &len); IF_ERR_EXIT (hstmt, rc); if (rc == SQL_SUCCESS) fprintf (stdout, "%s\n", data); } IF_ERR_EXIT (hstmt, rc); SQLDisconnect (hdbc); SQLFreeConnect (hdbc); SQLFreeEnv (henv); return 0; }
cezdb::cezdb( void ) { RETCODE res; flag = CEZDB_MODE_NONE; henv = NULL; StringOut = NULL; ResultOut = NULL; sepchr = ','; res = SQLAllocEnv( &henv ); if ( res != SQL_SUCCESS ) { flag = CEZDB_MODE_ERROR; return; } // Env Ready // StringOut = (unsigned char *)malloc ( CEZDB_OUTBUFSIZE ); if ( StringOut == NULL ) return; ResultOut = (unsigned char *)malloc ( CEZDB_OUTBUFSIZE ); if ( ResultOut == NULL ) return; // flag = CEZDB_MODE_ENVREADY; }
/*Function to connect a DB using ODBC*/ void connectDB(HENV *henv,HDBC *hdbc){ SSchar ODBC_database_name[80]; SSchar ODBC_database_user_id[80]; SSchar ODBC_database_passwd[80]; SQLRETURN return_code; return_code = SQLAllocEnv ((SQLHENV *)henv); if ((return_code == SQL_SUCCESS) || (return_code == SQL_SUCCESS_WITH_INFO)) return_code = SQLAllocConnect ((SQLHENV)*henv, (SQLHDBC *)hdbc); printf("This program attempts to connect to an ODBC database.\n"); printf("Enter the ODBC database name: "); SSgets (ODBC_database_name); if (ODBC_database_name[0] == NULL_CHAR) { printf("ODBC_database_name can't be null\n"); exit(1); } printf("Enter the user ID: "); SSgets(ODBC_database_user_id); printf("Enter the DB password: "******"Successful connection to database\n"); } else{ printf("Connection to database failed.\n"); ODBC_error (NULL, (HDBC)hdbc, NULL) ; exit(1); } }
int odbc_createconn(ClipMachine * cm) { int dbl,userl,passwdl; char* db = _clip_parcl(cm,2,&dbl); char* user = _clip_parcl(cm,3,&userl); char* passwd = _clip_parcl(cm,4,&passwdl); ODBC_CONN *conn = NULL; SQLHDBC tmpconn; SQLRETURN er; SQLHENV henv; char dbms[30]; if(!user) userl = 0; if(!passwd) passwdl = 0; if((er = SQLAllocEnv(&henv))) goto err; if((er = SQLAllocConnect(henv,&tmpconn))) goto err; if((er = SQLConnect(tmpconn,db,dbl,user,userl,passwd,passwdl))) goto err; /* silly PostgreSQL's ODBC driver */ if((er = SQLGetInfo(tmpconn,SQL_DBMS_NAME,dbms,sizeof(dbms),0))) goto err; conn = calloc(sizeof(ODBC_CONN),1); conn->conn = tmpconn; conn->vtbl = &vtbl; conn->henv = henv; if(strcmp(dbms,"PostgreSQL")==0) conn->postgres = 1; return _clip_store_c_item(cm, (void *) conn, _C_ITEM_TYPE_SQL, destroy_odbc_conn); err: odbc_error(cm,(conn?conn->loc:0),henv,tmpconn,0,__LINE__,er_connect); if(conn) free(conn); return -1; }
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 CDBConnection::AllocEnv() { TCHAR keyname[256]; ::LoadString (_Module.GetModuleInstance(), IDS_KEYNAME, keyname, sizeof (keyname)); if (ERROR_SUCCESS != key.Open (HKEY_LOCAL_MACHINE, keyname)) { if (ERROR_SUCCESS != key.Create (HKEY_LOCAL_MACHINE, keyname)) { _Module.LogEvent ("Can't create the data key"); } else { key.SetValue (szUID, _T("User")); key.SetValue (szPWD, _T("Password")); key.SetValue (szDSN, _T("DSN")); } } else { DWORD len; len = sizeof (szDSN); key.QueryValue (szDSN, _T("DSN"), &len); len = sizeof (szUID); key.QueryValue (szUID, _T("User"), &len); len = sizeof (szPWD); key.QueryValue (szPWD, _T("Password"), &len); } if (henv == SQL_NULL_HENV) { if (SQL_SUCCESS != SQLAllocEnv (&henv)) { _Module.LogFatal ("Can\'t allocate the environment"); throw -1; } } RegisterSinks(); return 1; }
BOOL CODBC::Connect(char* DSN, int timeout) { SQLAllocEnv (&henv); SQLAllocConnect (henv,&hdbc); SQLSetConnectAttr (hdbc, SQL_LOGIN_TIMEOUT, &timeout, 0); rc = SQLConnect (hdbc, (unsigned char*)DSN, SQL_NTS, NULL, 0, NULL, 0); // On error: deallocate handles, display error message, and exit. if (!MYSQLSUCCESS(rc)) { SQLCHAR SqlState[6]; SQLINTEGER NativeError; SQLSMALLINT MsgLen; SQLGetDiagRec(SQL_HANDLE_DBC, hdbc, 1, SqlState, &NativeError, (unsigned char *)lastError, 2048, &MsgLen); SQLFreeEnv(henv); SQLFreeConnect(hdbc); return FALSE; } // connecting was succesfull rc=SQLAllocStmt(hdbc, &hstmt); return TRUE; }
// ------------------------------------------------------------------------------------- SQLRETURN SQL_API SQLAllocHandle(SQLSMALLINT HandleType, SQLHANDLE InputHandle, _Out_ SQLHANDLE *OutputHandle) { AQ_ODBC_LOG("%s called\n", __FUNCTION__); switch ( HandleType ) { case SQL_HANDLE_ENV: return SQLAllocEnv ( OutputHandle ); case SQL_HANDLE_DBC: return SQLAllocConnect ( InputHandle, OutputHandle ); case SQL_HANDLE_STMT: return SQLAllocStmt ( InputHandle, OutputHandle ); case SQL_HANDLE_DESC: AQ_ODBC_LOG("SQLAllocHandle - Explicit descriptor requested - not supported\n"); return SQL_SUCCESS; } return SQL_ERROR; }
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; }
void CODBCCreate::accept() { if ( fds->isOn()) { QString conn_str; char out_str[ 4095 ]; const char *in_str; SQLHENV henv; SQLHDBC hdbc; SQLSMALLINT len; SQLRETURN ret; QString fname = file_edit->text(); // Make sure it ends with .dsn if ( fname.right( 4 ).lower().compare( ".dsn" )) { fname.append( ".dsn" ); file_edit->setText( fname ); } conn_str = "DRIVER={" + current_driver + "};SAVEFILE=" + fname + ";"; if ( extra_keywords.length() > 0 ) { int start = 0; int end = 0; while( start < extra_keywords.length() ) { end = extra_keywords.find( '\n', start ); if ( end == -1 ) { end = extra_keywords.length(); } conn_str += extra_keywords.mid( start, end-start ) + ";"; start = end + 1; } } in_str = (const char*)conn_str; if ( verify ) { SQLAllocEnv( &henv ); SQLAllocConnect( henv, &hdbc ); ret = SQLDriverConnect( hdbc, (SQLHWND)1, (SQLCHAR*)in_str, strlen( in_str ), (SQLCHAR*)out_str, sizeof( out_str ), &len, SQL_DRIVER_COMPLETE ); SQLFreeConnect( hdbc ); SQLFreeEnv( henv ); if ( ret != SQL_SUCCESS ) { int create = QMessageBox::No; create = QMessageBox::information( NULL, "Create Data Source", "A connection could not be made using the file data source parameters entered. Save non-verified file DSN?", QMessageBox::Yes, QMessageBox::No ); if ( create == QMessageBox::No ) { inst_logPushMsg( __FILE__, __FILE__, __LINE__, LOG_CRITICAL, ODBC_ERROR_CREATE_DSN_FAILED, "" ); ret_code = false; #ifdef QT_V4LAYOUT Q3Wizard::reject(); #else QWizard::reject(); #endif return; } else { strcpy( out_str, in_str ); if ( !createDsn()) { ret_code = false; #ifdef QT_V4LAYOUT Q3Wizard::reject(); #else QWizard::reject(); #endif return; } } } } else { strcpy( out_str, in_str ); if ( !createDsn()) { ret_code = false; #ifdef QT_V4LAYOUT Q3Wizard::reject(); #else QWizard::reject(); #endif return; } } ret_code = true; } else { int mode; if ( sds -> isOn()) { mode = ODBC_ADD_SYS_DSN; } else { mode = ODBC_ADD_DSN; } if ( dsn.length() > 0 ) { ret_code = SQLConfigDataSource((HWND) 1, mode, current_driver, dsn.prepend( "DSN=" )); } else { ret_code = SQLConfigDataSource((HWND) 1, mode, current_driver, "" ); } } #ifdef QT_V4LAYOUT Q3Wizard::accept(); #else QWizard::accept(); #endif }
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; }
/**************************** * OpenDatabase - do everything we have to do to get a viable connection to szDSN ***************************/ static int OpenDatabase( SQLHENV *phEnv, SQLHDBC *phDbc, char *szDSN, char *szUID, char *szPWD ) { if ( version3 ) { if ( SQLAllocHandle( SQL_HANDLE_ENV, NULL, phEnv ) != SQL_SUCCESS ) { fprintf( stderr, "[ISQL]ERROR: Could not SQLAllocHandle( SQL_HANDLE_ENV )\n" ); return 0; } if ( SQLSetEnvAttr( *phEnv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER) 3, 0 ) != SQL_SUCCESS ) { if ( bVerbose ) DumpODBCLog( hEnv, 0, 0 ); fprintf( stderr, "[ISQL]ERROR: Could not SQLSetEnvAttr( SQL_HANDLE_DBC )\n" ); SQLFreeHandle( SQL_HANDLE_ENV, *phEnv ); return 0; } if ( SQLAllocHandle( SQL_HANDLE_DBC, *phEnv, phDbc ) != SQL_SUCCESS ) { if ( bVerbose ) DumpODBCLog( hEnv, 0, 0 ); fprintf( stderr, "[ISQL]ERROR: Could not SQLAllocHandle( SQL_HANDLE_DBC )\n" ); SQLFreeHandle( SQL_HANDLE_ENV, *phEnv ); return 0; } if ( !SQL_SUCCEEDED( SQLConnect( *phDbc, (SQLCHAR*)szDSN, SQL_NTS, (SQLCHAR*)szUID, SQL_NTS, (SQLCHAR*)szPWD, SQL_NTS ))) { if ( bVerbose ) DumpODBCLog( hEnv, hDbc, 0 ); fprintf( stderr, "[ISQL]ERROR: Could not SQLConnect\n" ); SQLFreeHandle( SQL_HANDLE_DBC, *phDbc ); SQLFreeHandle( SQL_HANDLE_ENV, *phEnv ); return 0; } } else { if ( SQLAllocEnv( phEnv ) != SQL_SUCCESS ) { fprintf( stderr, "[ISQL]ERROR: Could not SQLAllocEnv\n" ); return 0; } if ( SQLAllocConnect( *phEnv, phDbc ) != SQL_SUCCESS ) { if ( bVerbose ) DumpODBCLog( hEnv, 0, 0 ); fprintf( stderr, "[ISQL]ERROR: Could not SQLAllocConnect\n" ); SQLFreeEnv( *phEnv ); return 0; } if ( !SQL_SUCCEEDED( SQLConnect( *phDbc, (SQLCHAR*)szDSN, SQL_NTS, (SQLCHAR*)szUID, SQL_NTS, (SQLCHAR*)szPWD, SQL_NTS ))) { if ( bVerbose ) DumpODBCLog( hEnv, hDbc, 0 ); fprintf( stderr, "[ISQL]ERROR: Could not SQLConnect\n" ); SQLFreeConnect( *phDbc ); SQLFreeEnv( *phEnv ); return 0; } } /* * does the driver support SQLMoreResults */ if ( !SQL_SUCCEEDED( SQLGetFunctions( *phDbc, SQL_API_SQLMORERESULTS, &has_moreresults ))) { has_moreresults = 0; } return 1; }
int main (int argc, char *argv[]) { if (argc < 4) { fprintf (stderr, "ERR : called as setcurs <dsn> <uid> <pwd> [<scroll>=1]\n"); exit (-3); } rc = SQLAllocEnv (&henv); if (rc != SQL_SUCCESS) { fprintf (stderr, "ERR : cannot alloc ODBC environment\n"); exit (-3); } rc = SQLAllocConnect (henv, &hdbc); CHK_ERR (SQL_NULL_HSTMT); rc = SQLConnect (hdbc, argv[1], SQL_NTS, argv[2], SQL_NTS, argv[3], SQL_NTS); CHK_ERR (SQL_NULL_HSTMT); /* Allocate the statements and set the cursor name. */ rc = SQLAllocStmt (hdbc, &hstmtSelect); CHK_ERR (SQL_NULL_HSTMT); rc = SQLAllocStmt (hdbc, &hstmtUpdate); CHK_ERR (SQL_NULL_HSTMT); if (argc <= 4 || atoi (argv[4]) != 0) { rc = SQLSetStmtOption (hstmtSelect, SQL_CURSOR_TYPE, SQL_CURSOR_STATIC); CHK_ERR (hstmtSelect); rc = SQLSetScrollOptions (hstmtSelect, SQL_CONCUR_READ_ONLY, 1, 1); CHK_ERR (hstmtSelect); } rc = SQLSetCursorName (hstmtSelect, "C1", SQL_NTS); CHK_ERR (hstmtSelect); /* SELECT the result set and bind its columns to local buffers. */ rc = SQLExecDirect (hstmtSelect, "SELECT NAME,PHONE from GOGO", SQL_NTS); CHK_ERR (hstmtSelect); rc = SQLBindCol (hstmtSelect, 1, SQL_C_CHAR, szName, NAME_LEN, &cbName); CHK_ERR (hstmtSelect); rc = SQLBindCol (hstmtSelect, 2, SQL_C_CHAR, szPhone, PHONE_LEN, &cbPhone); CHK_ERR (hstmtSelect); /* Read through the result set until the cursor is */ /* positioned on the row for John Smith. */ do retcode = SQLFetch (hstmtSelect); while ((retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) && (strcmp (szName, "Smith, John") != 0)); rc = retcode; CHK_ERR (hstmtSelect); /* Perform a positioned update of John Smith's name. */ if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) { rc = SQLExecDirect (hstmtUpdate, "UPDATE GOGO SET PHONE='2064890154' WHERE CURRENT OF C1", SQL_NTS); CHK_ERR (hstmtUpdate); } #if 0 SQLFreeStmt (hstmtUpdate, SQL_DROP); SQLFreeStmt (hstmtSelect, SQL_DROP); SQLDisconnect (hdbc); SQLFreeConnect (hdbc); #endif printf ("PASSED: SetCursorName Test\n"); exit (0); }
int main(int argc, char** argv) { char buffer[BUFSIZE]; char result[BUFSIZE]; char *dsn = getenv("DSN"); char *uid = getenv("UID"); char *pwd = getenv("PWD"); if (SQL_SUCCESS != (rc = SQLAllocEnv (&henv))) { odbc_error (); return -1; } if (SQL_SUCCESS != (rc = SQLAllocConnect (henv, &hdbc))) { odbc_error (); return -1; } if (SQL_SUCCESS != (rc = SQLConnect (hdbc, dsn ? dsn : "1111", SQL_NTS, uid ? uid : "dba", SQL_NTS, pwd ? pwd : "dba", SQL_NTS))) { odbc_error (); return -1; } if (SQL_SUCCESS != (rc = SQLAllocStmt (hdbc, &hstmt))) { odbc_error (); return -1; } while (NULL != fgets (buffer, BUFSIZE, stdin)) { if (SQL_SUCCESS != (rc = SQLBindParameter (hstmt, 3, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_CHAR, sizeof (result), 0, result, sizeof (result), NULL))) { odbc_error (); break; } if (0 == strncmp ("chdir", buffer, 5)) { if (SQL_SUCCESS != (rc = SQLSetParam (hstmt, 1, SQL_C_CHAR, SQL_CHAR, 0, 0, replace_newline (buffer + 6), NULL))) { odbc_error (); break; } if (SQL_SUCCESS != (rc = SQLSetParam (hstmt, 2, SQL_C_CHAR, SQL_CHAR, 0, 0, "", NULL))) { odbc_error (); break; } if (SQL_SUCCESS != (rc = SQLExecDirect (hstmt, "XSLT_CHDIR (?, ?, ?)", SQL_NTS))) { odbc_error (); break; } /*change directory:*/ printf ("%s\n", result); fflush (stdout); } else if (0 == strncmp ("stylesheet", buffer, 10)) { /*load stylesheet: */ if (SQL_SUCCESS != (rc = SQLSetParam (hstmt, 1, SQL_C_CHAR, SQL_CHAR, 0, 0, replace_newline (&buffer[11]), NULL))) { odbc_error (); break; } if (SQL_SUCCESS != (rc = SQLSetParam (hstmt, 2, SQL_C_CHAR, SQL_CHAR, 0, 0, "", NULL))) { odbc_error (); break; } if (SQL_SUCCESS != (rc = SQLExecDirect (hstmt, "XSLT_STYLESHEET (?, ?, ?)", SQL_NTS))) { odbc_error (); break; } printf ("%s\n", result); fflush (stdout); } else if (0 == strncmp ("input", buffer, 5)) { if (SQL_SUCCESS != (rc = SQLSetParam (hstmt, 1, SQL_C_CHAR, SQL_CHAR, 0, 0, replace_newline (&buffer[6]), NULL))) { odbc_error (); break; } if (SQL_SUCCESS != (rc = SQLSetParam (hstmt, 2, SQL_C_CHAR, SQL_CHAR, 0, 0, "", NULL))) { odbc_error (); break; } if (SQL_SUCCESS != (rc = SQLExecDirect (hstmt, "XSLT_INPUT (?, ?, ?)", SQL_NTS))) { odbc_error (); break; } printf ("%s\n", result); fflush (stdout); } else if (0 == strncmp ("transform", buffer, 9)) { short iter = 1; char * c = buffer+10; char *filename; timer_account_t ta; /* get output filename */ while (*c != '\n' && *c != '\0' && *c != ' ') { c++; } if (*c == ' ') { *c = 0; c++; filename = buffer + 10; } /* get # of iterations */ iter = atoi(c); if (iter <= 0) iter = 1; /* printf ("file: %s iter : %d buffer %s\n", filename, iter, buffer); */ ta_init (&ta, "test"); ta_enter (&ta); if (SQL_SUCCESS != (rc = SQLSetParam (hstmt, 1, SQL_C_CHAR, SQL_CHAR, 0, 0, filename, NULL))) { odbc_error (); break; } if (SQL_SUCCESS != (rc = SQLSetParam (hstmt, 2, SQL_C_SHORT, SQL_INTEGER, 0, 0, &iter, NULL))) { odbc_error (); break; } if (SQL_SUCCESS != (rc = SQLExecDirect (hstmt, "XSLT_TRANSFORM (?, ?, ?)", SQL_NTS))) { odbc_error (); break; } ta_leave (&ta); printf ("OK wallclock: %06ld ms; cpuclock: %06ld'\n", ta.ta_total, ta.ta_total); fflush (stdout); } else if (0 == strncmp ("terminate", buffer, 9)) { printf ("OK\n"); break; } if (SQL_SUCCESS != (rc = SQLFreeStmt (hstmt, SQL_CLOSE))) { odbc_error (); return -1; } if (SQL_SUCCESS != (rc = SQLFreeStmt (hstmt, SQL_RESET_PARAMS))) { odbc_error (); return -1; } } if (SQL_SUCCESS != (rc = SQLFreeStmt (hstmt, SQL_DROP))) return -1; if (SQL_SUCCESS != (rc = SQLDisconnect (hdbc))) return -1; if (SQL_SUCCESS != (rc = SQLFreeConnect (hdbc))) return -1; if (SQL_SUCCESS != (rc = SQLFreeEnv (henv))) return -1; return 0; }
int main (int argc, char ** argv) { char* uid = "dba", * pwd = "dba"; if (argc < 2) { printf ("Usage: scroll dsn delete-n [user] [password]\n"); exit (1); } if (argc > 2) { uid = argv [3]; pwd = argv [4]; } SQLAllocEnv (& henv); SQLAllocConnect (henv, &hdbc1); SQLAllocConnect (henv, &hdbc2); if (SQL_ERROR == SQLConnect (hdbc1, (UCHAR *) argv [1], SQL_NTS, (UCHAR *) uid, SQL_NTS, (UCHAR *) pwd, SQL_NTS)) { print_error (SQL_NULL_HENV, hdbc1, SQL_NULL_HSTMT); exit (1); } if (SQL_ERROR == SQLConnect (hdbc2, (UCHAR *) argv [1], SQL_NTS, (UCHAR *) uid, SQL_NTS, (UCHAR *) pwd, SQL_NTS)) { print_error (SQL_NULL_HENV, hdbc2, SQL_NULL_HSTMT); exit (1); } t1_init (); tsc_lock (SQL_CURSOR_DYNAMIC); tsc_bm (SQL_CURSOR_STATIC, 0, 1); tsc_bm (SQL_CURSOR_KEYSET_DRIVEN, 5, 1); tsc_bm (SQL_CURSOR_KEYSET_DRIVEN, 0, 1); tsc_bm (SQL_CURSOR_DYNAMIC, 0, 1); tsc_values (SQL_CURSOR_DYNAMIC); tsc_values (SQL_CURSOR_KEYSET_DRIVEN); tsc_pos (SQL_CURSOR_KEYSET_DRIVEN, T1_BASE_TEXT); tsc_pos (SQL_CURSOR_DYNAMIC, T1_BASE_TEXT); #if 0 tsc_co (SQL_CURSOR_DYNAMIC, 0, SQL_AUTOCOMMIT_ON); tsc_co (SQL_CURSOR_DYNAMIC, 0, 0); tsc_co (SQL_CURSOR_FORWARD_ONLY, 0, 0); #endif tsc_fwd (); tsc_scroll (SQL_CURSOR_STATIC, 0, 1, 0, 2, T1_BASE_TEXT); tsc_scroll (SQL_CURSOR_DYNAMIC, 0, 1, 0, 2, T1_BASE_TEXT); tsc_scroll (SQL_CURSOR_DYNAMIC, 0, 0, 0, 2, T1_BASE_TEXT); tsc_scroll (SQL_CURSOR_KEYSET_DRIVEN, 7, 1, 0, 2, T1_BASE_TEXT); tsc_scroll (SQL_CURSOR_KEYSET_DRIVEN, 5, 1, 0, 2, T1_BASE_TEXT); tsc_scroll (SQL_CURSOR_KEYSET_DRIVEN, 2000, 1, 0, 2, T1_BASE_TEXT); tw_exec (&tw1, "delete from T1"); t1_lines (&tw1, 0, 1100, 100); tsc_readtable (SQL_CURSOR_STATIC,0,1,0,2,T1_BASE_TEXT); tsc_readtable (SQL_CURSOR_DYNAMIC,0,1,0,2,T1_BASE_TEXT); /* tsc_update (SQL_CURSOR_KEYSET_DRIVEN, SQL_CONCUR_VALUES, T1_BASE_TEXT); */ tsc_commit_cursor (&tw1, SQL_CURSOR_FORWARD_ONLY, SQL_COMMIT); tsc_commit_cursor (&tw2, SQL_CURSOR_FORWARD_ONLY, SQL_ROLLBACK); tsc_commit_cursor (&tw1, SQL_CURSOR_STATIC, SQL_COMMIT); tsc_commit_cursor (&tw1, SQL_CURSOR_STATIC, SQL_ROLLBACK); tsc_commit_cursor (&tw1, SQL_CURSOR_DYNAMIC, SQL_COMMIT); tsc_commit_cursor (&tw2, SQL_CURSOR_DYNAMIC, SQL_ROLLBACK); printf ("========== SCROLL TEST COMPLETE\n"); SQLDisconnect (hdbc1); SQLDisconnect (hdbc2); SQLFreeConnect (hdbc1); SQLFreeConnect (hdbc2); return 0; }