int cezdb::Connect( char *dsn, int mode )
{
RETCODE res;
if ( flag != CEZDB_MODE_ENVREADY ) return -1;
res = SQLAllocConnect( henv, &hdbc );
if ( res != SQL_SUCCESS ) {
flag = CEZDB_MODE_ERROR;
return -2;
}
switch( mode ) {
case 1:
res = SQLDriverConnect( hdbc, 0, (unsigned char *)dsn, SQL_NTS, StringOut, CEZDB_OUTBUFSIZE, NULL, SQL_DRIVER_COMPLETE_REQUIRED );
break;
// case 2:
// res = SQLBrowseConnect( hdbc,(unsigned char *)dsn, SQL_NTS,StringOut, CEZDB_OUTBUFSIZE, &len );
default:
res = SQLDriverConnect( hdbc, 0, (unsigned char *)dsn, SQL_NTS, StringOut, CEZDB_OUTBUFSIZE, NULL, SQL_DRIVER_NOPROMPT );
break;
}
if ( res != SQL_SUCCESS ) {
SQLFreeConnect( hdbc );
flag = CEZDB_MODE_ERROR;
return -3;
}
//MessageBox( NULL, (char *)StringOut, "WOW", 0 );
// DBC Ready
//
flag = CEZDB_MODE_DBCREADY;
return 0;
}
// 연결 핸들을 할당하고 연결한 후 명령핸들까지 같이 할당한다.
// Type=1:ConStr은 MDB 파일의 경로를 가진다. 경로 생략시 현재 디렉토리에서 MDB를 찾는다.
// Type=2:ConStr은 SQL 서버의 연결 정보를 가지는 DSN 파일의 경로를 가진다.
// 경로는 반드시 완전 경로로 지정해야 한다.
// Type=3:SQLConnect 함수로 DSN에 직접 연결한다.
// 연결 또는 명령 핸들 할당에 실패하면 FALSE를 리턴한다.
BOOL CQuery::Connect(int Type, char *ConStr, char *UID, char *PWD)
{
SQLCHAR InCon[255];
SQLCHAR OutCon[255];
SQLSMALLINT cbOutCon;
int ii=1;
SQLRETURN Ret;
SQLINTEGER NativeError;
SQLCHAR SqlState[6], Msg[255];
SQLSMALLINT MsgLen;
char str[256];
m_Type = Type;
strcpy(m_szConnect, ConStr);
strcpy(m_Id, UID);
strcpy(m_Pass, PWD);
// 연결 타입에 따라 MDB 또는 SQL 서버, 또는 DSN에 연결한다.
SQLAllocHandle(SQL_HANDLE_DBC,hEnv,&hDbc);
switch (Type) {
case 1:
wsprintf((char *)InCon,"DRIVER={Microsoft Access Driver (*.mdb)};DBQ=%s;",ConStr);
ret=SQLDriverConnect(hDbc,NULL,(SQLCHAR *)InCon,sizeof(InCon),OutCon,
sizeof(OutCon),&cbOutCon, SQL_DRIVER_NOPROMPT);
break;
case 2:
wsprintf((char *)InCon, "FileDsn=%s",ConStr);
ret=SQLDriverConnect(hDbc,NULL,(SQLCHAR *)InCon,sizeof(InCon),OutCon,
sizeof(OutCon),&cbOutCon, SQL_DRIVER_NOPROMPT);
break;
case 3:
ret=SQLConnect(hDbc,(SQLCHAR *)ConStr,SQL_NTS,(SQLCHAR *)UID,SQL_NTS,
(SQLCHAR *)PWD,SQL_NTS);
break;
}
// 접속 에러시 진단 정보를 보여준다.
if ((ret != SQL_SUCCESS) && (ret != SQL_SUCCESS_WITH_INFO)) {
while (Ret=SQLGetDiagRec(SQL_HANDLE_DBC, hDbc, ii, SqlState, &NativeError,
Msg, sizeof(Msg), &MsgLen)!=SQL_NO_DATA) {
wsprintf(str, "(1) SQLSTATE:%s, Diagnosis:%s",(LPCTSTR)SqlState,(LPCTSTR)Msg);
//::MessageBox(NULL,str,"진단 정보",0);
gWindow.PrintLog(str);
ii++;
}
return FALSE;
}
// 명령 핸들을 할당한다.
ret=SQLAllocHandle(SQL_HANDLE_STMT,hDbc,&hStmt);
if ((ret != SQL_SUCCESS) && (ret != SQL_SUCCESS_WITH_INFO)) {
hStmt=0;
return FALSE;
}
return TRUE;
}
void ring_vm_odbc_connect ( void *pPointer )
{
ring_odbc *pODBC ;
SQLCHAR outstr[1024] ;
SQLSMALLINT outstrlen ;
SQLRETURN ret ;
if ( RING_API_PARACOUNT != 2 ) {
RING_API_ERROR(RING_API_MISS2PARA);
return ;
}
if ( RING_API_ISPOINTER(1) && RING_API_ISSTRING(2) ) {
pODBC = (ring_odbc *) RING_API_GETCPOINTER(1,RING_VM_POINTER_ODBC) ;
if ( pODBC == NULL ) {
return ;
}
if ( pODBC->nFlag & RING_ODBC_FLAG_DBC ) {
SQLFreeHandle(SQL_HANDLE_DBC,pODBC->dbc);
}
SQLAllocHandle(SQL_HANDLE_DBC, pODBC->env , &pODBC->dbc);
pODBC->nFlag = pODBC->nFlag | RING_ODBC_FLAG_DBC ;
ret = SQLDriverConnect(pODBC->dbc,NULL,(SQLCHAR *) RING_API_GETSTRING(2),SQL_NTS,outstr, sizeof(outstr), &outstrlen,SQL_DRIVER_COMPLETE);
if ( SQL_SUCCEEDED(ret) ) {
RING_API_RETNUMBER(1);
} else {
RING_API_RETNUMBER(0);
}
} else {
RING_API_ERROR(RING_API_BADPARATYPE);
}
}
static int
do_connect(Con& con)
{
int ret;
// allocate an environment handle
ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &con.henv);
if (ret != SQL_SUCCESS)
return -1;
// set odbc version (required)
ret = SQLSetEnvAttr(con.henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, 0);
if (ret != SQL_SUCCESS)
return -1;
// allocate a connection handle
ret = SQLAllocHandle(SQL_HANDLE_DBC, con.henv, &con.hdbc);
if (ret != SQL_SUCCESS)
return -1;
// connect to database
SQLCHAR szConnStrOut[256];
SQLSMALLINT cbConnStrOut;
ret = SQLDriverConnect(con.hdbc, 0, (SQLCHAR*)con.dsn, SQL_NTS,
szConnStrOut, sizeof(szConnStrOut), &cbConnStrOut, SQL_DRIVER_COMPLETE);
if (ret != SQL_SUCCESS) {
ndbout << "Connection failure: Could not connect to database" << endl;
print_err(SQL_HANDLE_DBC, con.hdbc);
return -1;
}
return 0;
}
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 void
connect_to_db(char *dsn)
{
SQLRETURN ret;
char errmsg[500];
SQLSMALLINT textlen;
char sqlstate[20];
SQLAllocHandle(SQL_HANDLE_DBC, env, &conn);
ret = SQLDriverConnect(conn, NULL, (SQLCHAR *) dsn, SQL_NTS, NULL, 0, NULL,
SQL_DRIVER_NOPROMPT);
if (!SQL_SUCCEEDED(ret))
{
printf("connection to %s failed\n", dsn);
ret = SQLGetDiagRec(SQL_HANDLE_DBC, conn, 1, sqlstate, NULL,
errmsg, sizeof(errmsg), &textlen);
if (ret == SQL_INVALID_HANDLE)
printf("Invalid handle\n");
else if (SQL_SUCCEEDED(ret))
printf("%s=%s\n", sqlstate, errmsg);
exit(1);
}
printf("connected to %s\n", dsn);
ret = SQLAllocHandle(SQL_HANDLE_STMT, conn, &hstmt);
if (!SQL_SUCCEEDED(ret))
{
printf("SQLAllocHandle failed\n");
exit(1);
}
}
void
test_connect_ext(char *extraparams)
{
SQLRETURN ret;
SQLCHAR str[1024];
SQLSMALLINT strl;
SQLCHAR dsn[1024];
snprintf(dsn, sizeof(dsn), "DSN=psqlodbc_test_dsn;%s",
extraparams ? extraparams : "");
SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env);
SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
SQLAllocHandle(SQL_HANDLE_DBC, env, &conn);
ret = SQLDriverConnect(conn, NULL, dsn, SQL_NTS,
str, sizeof(str), &strl,
SQL_DRIVER_COMPLETE);
if (SQL_SUCCEEDED(ret)) {
printf("connected\n");
} else {
print_diag("SQLDriverConnect failed.", SQL_HANDLE_DBC, conn);
exit(1);
}
}
SQLRETURN db_connect(SQLHDBC &dbc, int &conn_flag)
{
char *USERNAME = "******"; // user name
char *PASSWD = "MANAGER"; // user password
char *NLS = "US7ASCII"; // NLS_USE ( KO16KSC5601, US7ASCII )
char connStr[1024];
sprintf(connStr,
"DSN=127.0.0.1;UID=%s;PWD=%s;CONNTYPE=%d;NLS_USE=%s;PORT_NO=20300", /* ;PORT_NO=20300", */
USERNAME, PASSWD, 4, NLS);
printf( "%s\n", connStr );
/* establish connection */
if (SQLDriverConnect( dbc, NULL, (SQLCHAR*)connStr, SQL_NTS,
NULL, 0, NULL,
SQL_DRIVER_NOPROMPT ) != SQL_SUCCESS)
{
execute_err(dbc, SQL_NULL_HSTMT, "SQLDriverConnect");
return SQL_ERROR;
}
conn_flag = 1;
return SQL_SUCCESS;
}
NS_IMETHODIMP
mozSqlConnectionODBC::Init(const nsAString &aHost, PRInt32 aPort,
const nsAString &aDatabase, const nsAString &aUsername,
const nsAString &aPassword)
{
if (mConnection)
return NS_OK;
SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &mEnv);
SQLSetEnvAttr(mEnv, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
SQLAllocHandle(SQL_HANDLE_DBC, mEnv, &mConnection);
NS_LossyConvertUTF16toASCII inString(NS_LITERAL_STRING("DSN=") + aDatabase +
NS_LITERAL_STRING(";UID=") + aUsername +
NS_LITERAL_STRING(";PWD=") + aPassword);
char outString[1024];
SQLSMALLINT outStringLength;
if (!SQL_SUCCEEDED(SQLDriverConnect(mConnection, NULL,
(SQLCHAR*)inString.get(),
inString.Length(),
(SQLCHAR*)outString, sizeof(outString),
&outStringLength,
SQL_DRIVER_COMPLETE))) {
SetError(mConnection, SQL_HANDLE_DBC);
return NS_ERROR_FAILURE;
}
return NS_OK;
}
connection *create_connection(char *dsn)
{
connection *conn;
if ((conn = (connection *)malloc(sizeof *conn)) == NULL)
{
return NULL;
}
if (!SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &conn->henv)))
{
goto _free;
}
if (!SQL_SUCCEEDED(SQLSetEnvAttr(conn->henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, 0)))
{
SQLFreeHandle(SQL_HANDLE_ENV, conn->henv);
goto _free;
}
if (!SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, conn->henv, &conn->hdbc)))
{
SQLFreeHandle(SQL_HANDLE_ENV, conn->henv);
goto _free;
}
if (!SQL_SUCCEEDED(SQLDriverConnect(conn->hdbc, GetDesktopWindow(), (SQLWCHAR *)dsn, SQL_NTS, NULL, 0, NULL, SQL_DRIVER_COMPLETE)))
{
SQLFreeHandle(SQL_HANDLE_DBC, conn->hdbc);
SQLFreeHandle(SQL_HANDLE_ENV, conn->henv);
goto _free;
}
return conn;
_free:
free(conn);
return NULL;
}
BOOL CODBCDatabase::DriverConnect(CHAR* szConnStr, CHAR* szConnStrOut, HWND hWnd, enum drvCompletion drvConn)
{
SQLRETURN ret;
SQLSMALLINT pcbConnStrOut;
if(drvConn == sqlPrompt && hWnd == NULL)
return FALSE;
if(m_lConnectionTimeout > 0)
SQLSetConnectAttr(m_hDbc, SQL_ATTR_CONNECTION_TIMEOUT, (SQLPOINTER)m_lConnectionTimeout, 0);
SQLSetConnectAttr(m_hDbc, SQL_ATTR_LOGIN_TIMEOUT, (SQLPOINTER)m_lLoginTimeout, 0);
ret = SQLDriverConnect(m_hDbc,
hWnd,
(SQLCHAR*)szConnStr,
SQL_NTS,
(SQLCHAR*)szConnStrOut,
sizeof(szConnStrOut),
&pcbConnStrOut,
(SQLUSMALLINT)drvConn);
m_bIsConnected = ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO;
return m_bIsConnected;
}
SQLRETURN unixodbc_backend_debug::do_establish_connection(SQLHDBC connection_handle, SQLHWND window_handle, SQLCHAR * input_connection_string, SQLSMALLINT input_connection_string_length, SQLCHAR * out_connection_string, SQLSMALLINT output_connection_string_buffer_length, SQLSMALLINT * output_connection_string_length, SQLUSMALLINT driver_completion) const
{
std::cout << " *DEBUG* establish_connection";
auto const return_code = SQLDriverConnect(connection_handle, window_handle, input_connection_string, input_connection_string_length, out_connection_string, output_connection_string_buffer_length, output_connection_string_length, driver_completion);
std::cout << " (return code " << return_code << ")" << std::endl;
return return_code;
}
void mysql_connect()
{
SQLRETURN ret; /* ODBC API return status */
SQLCHAR outstr[1024];
SQLSMALLINT outstrlen;
/* Allocate an environment handle */
SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env);
/* We want ODBC 3 support */
SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
/* Allocate a connection handle */
SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc);
/* Connect to the DSN mydsn */
ret = SQLDriverConnect(dbc, NULL, "DSN=MYSQL_TEST", SQL_NTS,
outstr, sizeof(outstr), &outstrlen,
SQL_DRIVER_COMPLETE);
if (SQL_SUCCEEDED(ret)) {
printf("Connected\n");
printf(" Returned connection string was:\n\t%s\n", outstr);
if (ret == SQL_SUCCESS_WITH_INFO) {
printf(" Driver reported the following diagnostics\n");
extract_error("SQLDriverConnect", dbc, SQL_HANDLE_DBC);
}
} else {
fprintf(stderr, "Failed to connect\n");
extract_error("SQLDriverConnect", dbc, SQL_HANDLE_DBC);
}
printf("\n");
}
bool
CatalogBaseImpl::DriverConnect(const char* szConnStr, char* szConnStrOut, HWND hWnd, const int nDrvConn)
{
SQLRETURN ret;
SQLSMALLINT pcbConnStrOut;
if(nDrvConn == SQL_DRIVER_PROMPT && hWnd == NULL)
return FALSE;
SQLSetConnectAttr(hDbc_, SQL_ATTR_LOGIN_TIMEOUT, (SQLPOINTER)lLoginTimeout_, 0);
SQLSetConnectAttr(hDbc_, SQL_ATTR_CONNECTION_TIMEOUT, (SQLPOINTER)lQueryTimeout_, 0);
if(eAM_==READ_ONLY)
SQLSetConnectAttr(hDbc_, SQL_ATTR_ACCESS_MODE, (SQLPOINTER)SQL_MODE_READ_ONLY, 0);
else
SQLSetConnectAttr(hDbc_, SQL_ATTR_ACCESS_MODE, (SQLPOINTER)SQL_MODE_READ_WRITE, 0);
ret = SQLDriverConnect(hDbc_,
hWnd,
(SQLCHAR*)szConnStr,
SQL_NTS,
(SQLCHAR*)szConnStrOut,
sizeof(szConnStrOut),
&pcbConnStrOut,
(SQLUSMALLINT)nDrvConn);
bIsConnected_ = ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO;
return bIsConnected_;
}
SQLRETURN SQL_API
SQLDriverConnectW (
SQLHDBC hdbc,
HWND hwnd,
SQLWCHAR * wszConnStrIn,
SQLSMALLINT cbConnStrIn,
SQLWCHAR * wszConnStrOut,
SQLSMALLINT cbConnStrOut,
SQLSMALLINT * pcbConnStrOut,
SQLUSMALLINT fDriverCompletion)
{
SQLRETURN rc;
long len;
wcharset_t *charset = NULL;
DEFINE_INPUT_NARROW (ConnStrIn);
DEFINE_OUTPUT_CHAR_NARROW_N (ConnStrOut);
MAKE_INPUT_NARROW_N (ConnStrIn);
MAKE_OUTPUT_CHAR_NARROW_N (ConnStrOut);
rc = SQLDriverConnect (hdbc, hwnd, szConnStrIn, cbConnStrIn, szConnStrOut, cbConnStrOut, pcbConnStrOut, fDriverCompletion);
FREE_INPUT_NARROW (ConnStrIn);
SET_AND_FREE_OUTPUT_CHAR_NARROW_N (ConnStrOut);
return rc;
}
bool CMssqlConnection::Open()
{
CMssqlConnectionInformation *pCI = static_cast<CMssqlConnectionInformation*>(GetConnectionInformation());
m_lasterror = SQLAllocHandle(SQL_HANDLE_ENV,SQL_NULL_HANDLE,&m_hEnv);
if(!SQL_SUCCEEDED(m_lasterror))
return false;
m_lasterror = SQLSetEnvAttr(m_hEnv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, 0);
if(!SQL_SUCCEEDED(m_lasterror))
return false;
m_lasterror = SQLAllocHandle(SQL_HANDLE_DBC,m_hEnv,&m_hDbc);
if(!SQL_SUCCEEDED(m_lasterror))
return false;
cvs::wstring strConn;
cvs::swprintf(strConn,80,L"DATABASE={%s};DRIVER={SQL Server};Pwd={%s};Server={%s};Uid={%s};",
(const wchar_t*)cvs::wide(pCI->database.c_str()),(const wchar_t*)cvs::wide(pCI->password.c_str()),(const wchar_t*)cvs::wide(pCI->hostname.c_str()),(const wchar_t*)cvs::wide(pCI->username.c_str()));
m_lasterror = SQLDriverConnect(m_hDbc,NULL,(SQLWCHAR*)strConn.c_str(),(SQLSMALLINT)strConn.size(),NULL,0,NULL,SQL_DRIVER_NOPROMPT);
if(!SQL_SUCCEEDED(m_lasterror))
return false;
m_lasterror = SQLSetConnectAttr(m_hDbc,SQL_ATTR_AUTOCOMMIT,(SQLPOINTER)SQL_AUTOCOMMIT_ON,0);
if(!SQL_SUCCEEDED(m_lasterror))
return false;
return true;
}
bool OdbcConnection::Connect()
{
if (m_szDSN.length() == 0)
return false;
tstring szConn = _T("DSN=") + m_szDSN + _T(";");
// Reconnect if we need to.
if (isConnected())
Disconnect();
// Allocate enviroment handle
if (!SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &m_envHandle)))
{
ReportSQLError(SQL_HANDLE_ENV, m_envHandle, _T("SQLAllocHandle"), _T("Unable to allocate environment handle."));
goto error_handler;
}
// Request ODBC3 support
if (!SQL_SUCCEEDED(SQLSetEnvAttr(m_envHandle, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)))
{
ReportSQLError(SQL_HANDLE_ENV, m_envHandle, _T("SQLSetEnvAttr"), _T("Unable to set environment attribute (SQL_ATTR_ODBC_VERSION)."));
goto error_handler;
}
// Allocate the connection handle
if (!SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, m_envHandle, &m_connHandle)))
{
ReportSQLError(SQL_HANDLE_ENV, m_envHandle, _T("SQLAllocHandle"), _T("Unable to allocate connection handle."));
goto error_handler;
}
if (m_szUser.length())
{
szConn += _T("UID=") + m_szUser + _T(";");
if (m_szPass.length())
szConn += _T("PWD=") + m_szPass + _T(";");
}
// Enable multiple active result sets
if (m_bMarsEnabled)
szConn += _T("MARS_Connection=yes;");
if (!SQL_SUCCEEDED(SQLDriverConnect(m_connHandle, NULL, (SQLTCHAR *)szConn.c_str(), SQL_NTS, NULL, NULL, NULL, NULL)))
{
ReportSQLError(SQL_HANDLE_DBC, m_connHandle, _T("SQLDriverConnect"), _T("Unable to establish connection."));
goto error_handler;
}
for (auto itr = m_commandSet.begin(); itr != m_commandSet.end(); itr++)
(*itr)->SetConnectionHandle(m_connHandle);
return true;
error_handler:
ResetHandles();
return false;
}
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;
}
/*
* Perform a disconnect/reconnect using the DSN stored from the original
* SQLDriverConnect
*/
int
ODBC_Reconnect (void)
{
SQLRETURN status;
SQLTCHAR buf[4096];
SQLSMALLINT len;
/*
* Free old statement handle
*/
#if (ODBCVER < 0x0300)
SQLFreeStmt (hstmt, SQL_DROP);
#else
SQLFreeHandle (SQL_HANDLE_STMT, hstmt);
#endif
/*
* Disconnect
*/
SQLDisconnect (hdbc);
/*
* Reconnect
*/
status = SQLDriverConnect (hdbc, 0, outdsn, SQL_NTS,
buf, sizeof (buf), &len, SQL_DRIVER_NOPROMPT);
/*
* Allocate new statement handle
*/
if (SQL_SUCCEEDED (status))
{
#if (ODBCVER < 0x0300)
status = SQLAllocStmt (hdbc, &hstmt);
#else
status = SQLAllocHandle (SQL_HANDLE_STMT, hdbc, &hstmt);
#endif
}
/*
* Show why we where unsuccessful and return an error
*/
if (!SQL_SUCCEEDED (status))
{
ODBC_Errors ("DriverConnect (reconnect)");
return -1;
}
/*
* Success
*/
return 0;
}
void bgl_odbc_driver_connect(SQLHANDLE dbc, char* constr)
{
SQLRETURN v;
v = SQLDriverConnect(dbc,NULL,constr,SQL_NTS,NULL,
0,NULL,SQL_DRIVER_NOPROMPT);
if(!SQL_SUCCEEDED(v))
{
report_odbc_error("bgl_odbc_driver_connect",
SQL_HANDLE_DBC,
dbc);
}
}
SQLRETURN DataBase::connectExcel(const char *filename, int nTimeout)
{
SQLRETURN status;
//SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &_hEnv);
//SQLSetEnvAttr(_hEnv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0);
SQLAllocHandle(SQL_HANDLE_DBC, _hEnv, &_hConn);
setLoginTimeout(nTimeout);
char tmpStr[1024];
sprintf(tmpStr, "Driver={Microsoft Excel Driver (*.xls)}; DBQ=%s; DriverID=790", filename);
char maxStr[MAX_CONNECT_LEN];
SQLSMALLINT returnSize;
status = SQLDriverConnect(_hConn, NULL, (SQLCHAR *)tmpStr, strlen(tmpStr), (SQLCHAR *)maxStr, sizeof(maxStr), &returnSize, SQL_DRIVER_NOPROMPT );
return status;
}
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 ODBCHandler::showTables(const char *dsn)
{
SQLHENV env;
SQLHDBC dbc;
SQLHSTMT stmt;
SQLRETURN ret; /* ODBC API return status */
SQLSMALLINT columns; /* number of columns in result-set */
int row = 0;
/* Allocate an environment handle */
SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env);
/* We want ODBC 3 support */
SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3_80, 0);
/* Allocate a connection handle */
SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc);
/* Connect to the DSN mydsn */
/* You will need to change mydsn to one you have created and tested */
SQLDriverConnect(dbc, NULL, (SQLCHAR*) dsn, SQL_NTS,
NULL, 0, NULL, SQL_DRIVER_COMPLETE);
/* Allocate a statement handle */
SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt);
/* Retrieve a list of tables */
SQLTables(stmt, NULL, 0, NULL, 0, NULL, 0, (SQLCHAR*)"VIEW", SQL_NTS);
/* How many columns are there */
SQLNumResultCols(stmt, &columns);
/* Loop through the rows in the result-set */
while (SQL_SUCCEEDED(ret = SQLFetch(stmt))) {
SQLUSMALLINT i;
printf("Row %d\n", row++);
/* Loop through the columns */
for (i = 1; i <= columns; i++) {
SQLLEN indicator;
SQLCHAR buf[512];
/* retrieve column data as a string */
ret = SQLGetData(stmt, i, SQL_C_CHAR,
buf, sizeof(buf), &indicator);
if (SQL_SUCCEEDED(ret)) {
/* Handle null columns */
if (indicator == SQL_NULL_DATA) strcpy((char*)buf, "NULL");
printf(" Column %u : %s\n", i, buf);
}
}
}
}
SQLRETURN SQLDriverConnectA(
SQLHDBC hdbc,
SQLHWND hwnd,
SQLCHAR *conn_str_in,
SQLSMALLINT len_conn_str_in,
SQLCHAR *conn_str_out,
SQLSMALLINT conn_str_out_max,
SQLSMALLINT *ptr_conn_str_out,
SQLUSMALLINT driver_completion )
{
return SQLDriverConnect( hdbc,
hwnd,
conn_str_in,
len_conn_str_in,
conn_str_out,
conn_str_out_max,
ptr_conn_str_out,
driver_completion );
}
/************************************************************************
* name: SQLDriverConnectW
* arguments:
* returns/side-effects:
* description:
* NOTE:
************************************************************************/
ODBC_INTERFACE RETCODE SQL_API
SQLDriverConnectW (SQLHDBC hdbc, SQLHWND hwnd,
SQLWCHAR *in, SQLSMALLINT in_len,
SQLWCHAR *out, SQLSMALLINT out_max, SQLSMALLINT *out_len,
SQLUSMALLINT completion)
{
RETCODE rc = ODBC_SUCCESS;
SQLCHAR *pt_in, *pt_out;
int encode_len = 0, temp_out_len = 0;
ODBC_CONNECTION* conn = (ODBC_CONNECTION*)hdbc;
OutputDebugString ("SQLDriverConnectW called\n");
rc = wide_char_to_bytes (in, in_len, &pt_in, &encode_len, NULL);
if (rc != ODBC_SUCCESS)
{
odbc_set_diag (conn->diag, "HY001", 0, "encode failed");
return ODBC_ERROR;
}
pt_out = UT_ALLOC (out_max);
if (pt_out == NULL && out_max > 0)
{
odbc_set_diag (conn->diag, "HY001", 0, "malloc failed");
return ODBC_ERROR;
}
memset (pt_out, 0, out_max);
rc = SQLDriverConnect (
hdbc, hwnd,
pt_in, in_len,
pt_out, out_max, out_len,
completion);
if (out)
{
bytes_to_wide_char (pt_out, strlen (pt_out), &out, out_max, &temp_out_len, NULL);
}
if (out_len)
{
*out_len = temp_out_len;
}
UT_FREE (pt_in);
UT_FREE (pt_out);
return rc;
}
bool ODBCSession::Connect(const char *cs)
{
if(henv && IsOk(SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc))) {
if(IsOk(SQLDriverConnect(hdbc, NULL, (SQLCHAR *)cs, SQL_NTS, NULL, 0, NULL, SQL_DRIVER_NOPROMPT))) {
SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt);
if(tmode == NORMAL)
SQLSetConnectAttr(hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_ON, SQL_NTS);
SQLSetConnectAttr(hdbc, SQL_ATTR_TXN_ISOLATION, (SQLPOINTER)SQL_TRANSACTION_SERIALIZABLE, SQL_NTS);
Sql sql("select cast(current_user as text)", *this);
if(sql.Execute() && sql.Fetch())
user = sql[0];
return true;
}
SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
hdbc = SQL_NULL_HANDLE;
}
return false;
}
main() {
SQLHENV env;
SQLHDBC dbc;
SQLHSTMT stmt;
SQLRETURN ret; /* ODBC API return status */
SQLSMALLINT columns; /* number of columns in result-set */
SQLCHAR table[ 64 ];
SQLCHAR column[ 64 ];
SQLINTEGER type;
SQLLEN indicator[ 3 ];
int i;
/* Allocate an environment handle */
SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env);
/* We want ODBC 3 support */
SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
/* Allocate a connection handle */
SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc);
/* Connect to the DSN mydsn */
/* You will need to change mydsn to one you have created and tested */
SQLDriverConnect(dbc, NULL, "DSN=PostgreSQL-rupen-aws;uid=poc;pwd=****;", SQL_NTS,
NULL, 0, NULL, SQL_DRIVER_COMPLETE);
/* Allocate a statement handle */
SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt);
/* Retrieve a list of columns */
SQLColumns(stmt, NULL, 0, NULL, 0, "t1", SQL_NTS, NULL, 0);
ret = SQLBindCol( stmt, 3, SQL_C_CHAR,
table, sizeof( table ), &indicator[ 0 ] );
ret = SQLBindCol( stmt, 4, SQL_C_CHAR,
column, sizeof( column ), &indicator[ 1 ] );
ret = SQLBindCol( stmt, 5, SQL_C_LONG, &type, 0, &indicator[ 2 ] );
/* Fetch the data */
while (SQL_SUCCEEDED(ret = SQLFetch(stmt))) {
printf( "%s.%s type %d\n", table, column, type );
}
}
bool CDataBase::Connect(const char * szHost, const char * szDataBase, const char * szUser, const char * szPassword)
{
bool bReturn = false;
int iRecored = 1;
SQLSMALLINT cbOutCon = 0;
// ----
SQLCHAR InCon[255] = {0};
SQLCHAR OutCon[255] = {0};
SQLWCHAR szSQLState[MAX_DB_TEXT_LEN] = {0};
SQLWCHAR szSQLMsg[MAX_DB_TEXT_LEN] = {0};
// ----
SQLAllocHandle(SQL_HANDLE_DBC, m_hEnv, & m_hDbc);
// ----
wsprintf((char *)InCon, "DRIVER=SQL Server;Server=%s;DATABASE=%s;UID=%s;PWD=%s;", szHost,
szDataBase, szUser, szPassword);
// ----
OnMessage((char *)InCon);
// ----
m_Return = SQLDriverConnect(m_hDbc, NULL, InCon, sizeof(InCon), OutCon,
sizeof(OutCon), & cbOutCon, SQL_DRIVER_NOPROMPT);
// ----
if((m_Return == SQL_SUCCESS) || (m_Return == SQL_SUCCESS_WITH_INFO))
{
m_Return = SQLAllocHandle(SQL_HANDLE_STMT, m_hDbc, & m_hStmt);
// ----
if((m_Return == SQL_SUCCESS) || (m_Return == SQL_SUCCESS_WITH_INFO))
{
m_strHost = szHost;
m_strDataBase = szDataBase;
m_strUser = szUser;
m_strPassword = szPassword;
// ----
bReturn = true;
}
else
{
m_hStmt = 0;
}
}
// ----
return bReturn;
}
std::shared_ptr<Connection> Database::getConnection(std::string user,std::string password)
{
LOG_DEBUG(std::string(__FILE__) + " " + std::to_string(__LINE__));
std::lock_guard<std::mutex> lock(g_i_mutex);
SQLHENV henv;
SQLHDBC hdbc;
SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc);
SQLRETURN ret;
SQLCHAR outstr[1024];
SQLSMALLINT outstrlen;
std::string dsnname;
dsnname += "DSN=" + dsnentry_ + ";UID=" + user + ";PWD=" + password;
LOG_DEBUG(std::string("ODBCSYSINI :") + std::string(getenv("ODBCSYSINI")));
LOG_DEBUG(std::string("ODBCINI:") + std::string(getenv("ODBCINI")));
LOG_DEBUG(std::string("TNS_ADMIN:") + std::string(getenv("TNS_ADMIN")));
LOG_DEBUG(dsnname);
ret = SQLDriverConnect(hdbc, NULL, (SQLCHAR*)dsnname.c_str(), SQL_NTS,outstr, sizeof(outstr), &outstrlen,SQL_DRIVER_COMPLETE);
LOG_DEBUG(std::string(__FILE__) + " " + std::to_string(__LINE__));
if (SQL_SUCCEEDED(ret))
{
if (ret == SQL_SUCCESS_WITH_INFO)
{
LOG_DEBUG("SQLDriverConnect");
ODBCError err;
LOG_DEBUG(err("SQLDriverConnect", hdbc, SQL_HANDLE_DBC));
}
std::shared_ptr<Connection> cnx(new Connection(user,password,henv,hdbc));
cnx->setProvider(provider_);
cnx->setSchema(schema_);
LOG_DEBUG(std::string("Provider set for connection : ") + DBPROVIDERS[provider_]);
return move(cnx);
}
else
{
ODBCError err;
std::string message = err("SQLDriverConnect", hdbc, SQL_HANDLE_DBC) + "\nDSN : " + dsnentry_ + "\nDatabase user : " + user;
throw SQLException(message);
}
}
ODBCHandler::ODBCHandler(unsigned char *con_str)
{
string ODBC_error;
SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env);
SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc);
SQLRETURN ret = SQLDriverConnect(dbc, NULL, (SQLCHAR*)con_str, SQL_NTS,
NULL, 0, NULL, SQL_DRIVER_COMPLETE);
if (SQL_SUCCEEDED(ret)) {
if (ret == SQL_SUCCESS_WITH_INFO) {
ODBC_error = extract_error(dbc, SQL_HANDLE_DBC);
}
} else {
ODBC_error = extract_error(dbc, SQL_HANDLE_DBC);
if (&dbc)
SQLFreeHandle(SQL_HANDLE_DBC, dbc);
if (&env)
SQLFreeHandle(SQL_HANDLE_ENV, env);
cout<<ODBC_error<<endl;
}
}
