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; }
/* * Disconnect from the database */ int ODBC_Disconnect (void) { #if (ODBCVER < 0x0300) if (hstmt) SQLFreeStmt (hstmt, SQL_DROP); if (connected) SQLDisconnect (hdbc); if (hdbc) SQLFreeConnect (hdbc); if (henv) SQLFreeEnv (henv); #else if (hstmt) { SQLCloseCursor (hstmt); SQLFreeHandle (SQL_HANDLE_STMT, hstmt); } if (connected) SQLDisconnect (hdbc); if (hdbc) SQLFreeHandle (SQL_HANDLE_DBC, hdbc); if (henv) SQLFreeHandle (SQL_HANDLE_ENV, henv); #endif return 0; }
// Free the statement handle, disconnect, free the connection handle, and // free the environment handle. void direxec::sqldisconn(void) { SQLFreeStmt(hstmt,SQL_DROP); SQLDisconnect(hdbc); SQLFreeConnect(hdbc); SQLFreeEnv(henv); }
// 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; }
void DataBase::disconnect() { SQLFreeStmt(_hStmt, SQL_DROP); SQLDisconnect(_hConn); SQLFreeConnect(_hConn); SQLFreeEnv(_hEnv); }
void odbc_destroyconn(SQLCONN* conn) { SQLDisconnect(((ODBC_CONN*)conn)->conn); SQLFreeConnect(((ODBC_CONN*)conn)->conn); SQLFreeEnv(((ODBC_CONN*)conn)->henv); }
static SQLRETURN fini(SQLHENV henv, SQLHDBC hdbc) { /* clean up - free the connection and environment handles */ SQLDisconnect(hdbc); SQLFreeConnect(hdbc); SQLFreeEnv(henv); return SQL_SUCCESS; }
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; }
/************************************************************************* * * Function: sql_close * * Purpose: database specific close. Closes an open database * connection and cleans up any open handles. * *************************************************************************/ static int sql_close(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config) { rlm_sql_unixodbc_sock *unixodbc_sock = handle->conn; SQLFreeStmt(unixodbc_sock->stmt_handle, SQL_DROP); SQLDisconnect(unixodbc_sock->dbc_handle); SQLFreeConnect(unixodbc_sock->dbc_handle); SQLFreeEnv(unixodbc_sock->env_handle); return 0; }
TODBCConn::~TODBCConn () { if (m_hStmt != SQL_NULL_HSTMT) SQLFreeStmt (m_hStmt, SQL_DROP); if (m_hDbc != SQL_NULL_HDBC) { SQLDisconnect (m_hDbc); SQLFreeConnect (m_hDbc); } if (m_hEnv) SQLFreeEnv (m_hEnv); }
TF EXPFUNC p_db_free(ENGid eid) { if (!g_bEnvOpen) return TRUE; g_RC = SQLFreeEnv(g_hEnv); g_hDBC = SQL_NULL_HDBC; g_hSTMT = SQL_NULL_HSTMT; ERROR_CHK("SQLFreeEnv"); g_bEnvOpen = FALSE; return TRUE; ODBC_ERROR: return FALSE; }
bool CMssqlConnection::Close() { if(m_hEnv) { SQLDisconnect(m_hDbc); SQLFreeConnect(m_hDbc); SQLFreeEnv(m_hEnv); } m_hEnv = NULL; m_hDbc = NULL; m_lastrsError=L""; return true; }
/* Deallocate the environment structure. */ int cllCloseEnv(icatSessionStruct *icss) { RETCODE stat; HENV myHenv; myHenv = icss->environPtr; stat =SQLFreeEnv(myHenv); if (stat != SQL_SUCCESS) { rodsLog(LOG_ERROR, "cllCloseEnv: SQLFreeEnv failed"); } return(stat); }
/*-----------------------------------------------------------------------------*/ void ODBCDisconnect() { struct Cursor *cur = FCursor; struct Cursor *tcur; struct NumberofCursors *numi = FCurNum, *numj = FCurNum; HDBC hdbc = (HDBC)ptoc_int(2); if (!serverConnected) return; if (hdbc == NULL) { /* close entire connection*/ if (FCursor != NULL) xsb_abort("Must close all connections before shutting down"); SQLFreeEnv(henv); serverConnected = 0; return; } /* only free cursors associated with this connection (hdbc)*/ while((numj != NULL) && (numj->hdbc != hdbc)){ if(numj != FCurNum) numi=numi->NCurNum; numj=numj->NCurNum; } if(numj != NULL){ if(numj == FCurNum) FCurNum=numj->NCurNum; else numi->NCurNum=numj->NCurNum; free(numj); } while (cur != NULL) { if (cur->hdbc == hdbc) { tcur = cur->NCursor; if (cur->Status != 0) SetCursorClose(cur); SQLFreeStmt(cur->hstmt,SQL_DROP); if (cur->PCursor) (cur->PCursor)->NCursor = cur->NCursor; else FCursor = cur->NCursor; if (cur->NCursor) (cur->NCursor)->PCursor = cur->PCursor; else LCursor = cur->PCursor; free(cur); /* (num->CursorCount)-- */ cur = tcur; } else cur = cur->NCursor; } SQLDisconnect(hdbc); SQLFreeConnect(hdbc); /* SQLFreeEnv(henv);*/ serverConnected = 0; }
static HB_ERRCODE odbcDisconnect( SQLDDCONNECTION * pConnection ) { SDDCONN * pSDDConn = ( SDDCONN * ) pConnection->pSDDConn; SQLDisconnect( pSDDConn->hConn ); #if ODBCVER >= 0x0300 SQLFreeHandle( SQL_HANDLE_DBC, pSDDConn->hConn ); SQLFreeHandle( SQL_HANDLE_ENV, pSDDConn->hEnv ); #else SQLFreeConnect( pSDDConn->hConn ); SQLFreeEnv( pSDDConn->hEnv ); #endif hb_xfree( pSDDConn ); return HB_SUCCESS; }
static int _sql_socket_destructor(rlm_sql_unixodbc_conn_t *conn) { DEBUG2("rlm_sql_unixodbc: Socket destructor called, closing socket"); if (conn->stmt) SQLFreeStmt(conn->stmt, SQL_DROP); if (conn->dbc) { SQLDisconnect(conn->dbc); SQLFreeConnect(conn->dbc); } if (conn->env) SQLFreeEnv(conn->env); 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; }
void close_handles() { if (SQL_NULL_HDBC != H_DBC) { SQLDisconnect(H_DBC); SQLFreeConnect(H_DBC); } if (SQL_NULL_HDBC != H_DBC2) { SQLDisconnect(H_DBC2); SQLFreeConnect(H_DBC2); } if (SQL_NULL_HENV != H_ENV) { SQLFreeEnv(H_ENV); } if (NULL != DB3_UD) { sqlite3_close(DB3_UD); } }
/**************************** * CloseDatabase - cleanup in prep for exiting the program ***************************/ static int CloseDatabase( SQLHENV hEnv, SQLHDBC hDbc ) { SQLDisconnect( hDbc ); if ( version3 ) { SQLFreeHandle( SQL_HANDLE_DBC, hDbc ); SQLFreeHandle( SQL_HANDLE_ENV, hEnv ); } else { SQLFreeConnect( hDbc ); SQLFreeEnv( hEnv ); } return 1; }
int backsql_free_db_env( backsql_info *bi ) { Debug( LDAP_DEBUG_TRACE, "==>backsql_free_db_env()\n", 0, 0, 0 ); (void)SQLFreeEnv( bi->sql_db_env ); bi->sql_db_env = SQL_NULL_HENV; /* * stop, if frontend waits for all threads to shutdown * before calling this -- then what are we going to delete?? * everything is already deleted... */ Debug( LDAP_DEBUG_TRACE, "<==backsql_free_db_env()\n", 0, 0, 0 ); return SQL_SUCCESS; }
static HB_GARBAGE_FUNC( hb_SQLHENV_Destructor ) { PHB_SQLHENV pHEnv = ( PHB_SQLHENV ) Cargo; /* Check if pointer is not NULL to avoid multiple freeing */ if( pHEnv->hEnv ) { #if ODBCVER >= 0x0300 SQLFreeHandle( SQL_HANDLE_ENV, ( SQLHANDLE ) pHEnv->hEnv ); #else SQLFreeEnv( pHEnv->hEnv ); #endif /* set pointer to NULL to avoid multiple freeing */ pHEnv->hEnv = NULL; } }
static void gsql_close (Database *db) { if (db->connected == 1) { if (db->hdbc) SQLDisconnect (db->hdbc); if (db->hdbc) SQLFreeConnect (db->hdbc); if (db->henv) SQLFreeEnv (db->henv); xfree (db->dsn); } }
void free_handle(SQLHENV &env, SQLHDBC &dbc, int &conn_flag) { if ( conn_flag == 1 ) { /* close connection */ SQLDisconnect( dbc ); } /* free connection handle */ if ( dbc != NULL ) { SQLFreeConnect( dbc ); } if ( env != NULL ) { SQLFreeEnv( env ); } }
cezdb::~cezdb( void ) { Disconnect(); if ( henv != NULL ) { SQLFreeEnv( henv ); henv = NULL; } if ( ResultOut != NULL ) { free( ResultOut ); ResultOut = NULL; } if ( StringOut != NULL ) { free( StringOut ); StringOut = NULL; } flag = CEZDB_MODE_NONE; }
CSQLDirect::~CSQLDirect() { SAFE_DELETE(m_psvErrorMsg);///modified by xizheng SAFE_DELETE(m_psvSQL);///modified by xizheng if( m_hStmt!=NULL ) SQLFreeStmt( m_hStmt, SQL_DROP ); if( m_hDBC!=NULL ) { SQLDisconnect( m_hDBC ); SQLFreeConnect( m_hDBC ); } if( m_hEnv!=NULL ) SQLFreeEnv( m_hEnv ); KillCols(); }
static int _sql_socket_destructor(rlm_sql_iodbc_conn_t *conn) { DEBUG2("rlm_sql_iodbc: Socket destructor called, closing socket"); if (conn->stmt_handle) { SQLFreeStmt(conn->stmt_handle, SQL_DROP); } if (conn->dbc_handle) { SQLDisconnect(conn->dbc_handle); SQLFreeConnect(conn->dbc_handle); } if (conn->env_handle) { SQLFreeEnv(conn->env_handle); } return 0; }
int odbc_disconnect(void) { if (odbc_stmt) { SQLFreeStmt(odbc_stmt, SQL_DROP); odbc_stmt = SQL_NULL_HSTMT; } if (odbc_conn) { SQLDisconnect(odbc_conn); SQLFreeConnect(odbc_conn); odbc_conn = SQL_NULL_HDBC; } if (odbc_env) { SQLFreeEnv(odbc_env); odbc_env = SQL_NULL_HENV; } return 0; }
static int sql_socket_destructor(void *c) { rlm_sql_unixodbc_conn_t *conn = c; DEBUG2("rlm_sql_sybase: Socket destructor called, closing socket"); if (conn->statement) { SQLFreeStmt(conn->statement, SQL_DROP); } if (conn->dbc) { SQLDisconnect(conn->dbc); SQLFreeConnect(conn->dbc); } if (conn->env) { SQLFreeEnv(conn->env); } return 0; }
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; }
/* ------------------------------------------------------------- */ void jx_sqlDisconnect (PJXSQLCONNECT pConnection) { XlateXdClose(pConnection->pCd) ; // disconnect from database if (pConnection->hdbc != -1) { SQLDisconnect (pConnection->hdbc); SQLFreeConnect (pConnection->hdbc); pConnection->hdbc = -1; } // free environment handle if (pConnection->henv != -1) { SQLFreeEnv (pConnection->henv); pConnection->henv = -1; } jx_Close(&pConnection->pOptions); memFree (&pConnection); }