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);
}
