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_;
}
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;
}
// open a connection with a data_source
bool connection::connect(const _tstring & _dsn, const _tstring & _user, const _tstring & _pass,
int _timeout, bool _autocommit)
{
cleanup();
// Allocate handles
b_own_handle = true;
__allocate_handle(env_h, conn_h);
if (_timeout != -1) {
// Set connection timeout
SQLSetConnectAttr(conn_h, SQL_ATTR_LOGIN_TIMEOUT, (SQLPOINTER)(size_t)_timeout, 0);
}
b_autocommit = _autocommit;
if (!b_autocommit) {
// Set manual commit mode
SQLSetConnectAttr(conn_h, SQL_ATTR_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF, 0);
}
// Connect!
SQLTCHAR_buf s_dsn = ybstring2sqltchar(_dsn, ""),
s_user = ybstring2sqltchar(_user, ""),
s_pass = ybstring2sqltchar(_pass, "");
RETCODE rc = SQLConnect(conn_h,
s_dsn.data, SQL_NTS,
s_user.data, SQL_NTS,
s_pass.data, SQL_NTS);
if (TIODBC_SUCCESS_CODE(rc)) {
b_connected = true;
}
return b_connected;
}
void ring_vm_odbc_autocommit ( void *pPointer )
{
ring_odbc *pODBC ;
SQLRETURN ret ;
if ( RING_API_PARACOUNT != 2 ) {
RING_API_ERROR(RING_API_MISS2PARA);
return ;
}
if ( RING_API_ISPOINTER(1) && RING_API_ISNUMBER(2) ) {
pODBC = (ring_odbc *) RING_API_GETCPOINTER(1,RING_VM_POINTER_ODBC) ;
if ( pODBC == NULL ) {
return ;
}
if ( RING_API_GETNUMBER(2) == 1 ) {
ret = SQLSetConnectAttr(pODBC->dbc,SQL_ATTR_AUTOCOMMIT, ( SQLPOINTER ) SQL_AUTOCOMMIT_ON,0);
} else {
ret = SQLSetConnectAttr(pODBC->dbc,SQL_ATTR_AUTOCOMMIT, ( SQLPOINTER ) SQL_AUTOCOMMIT_OFF,0);
}
if ( SQL_SUCCEEDED(ret) ) {
RING_API_RETNUMBER(1);
} else {
RING_API_RETNUMBER(0);
}
} else {
RING_API_ERROR(RING_API_BADPARATYPE);
}
}
SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_SQLSetAutoCommitAttr(switch_odbc_handle_t *handle, switch_bool_t on)
{
#ifdef SWITCH_HAVE_ODBC
if (on) {
return SQLSetConnectAttr(handle->con, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER *) SQL_AUTOCOMMIT_ON, 0 );
} else {
return SQLSetConnectAttr(handle->con, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER *) SQL_AUTOCOMMIT_OFF, 0 );
}
#else
return (switch_odbc_status_t) SWITCH_FALSE;
#endif
}
BOOL CODBCDatabase::Open(CHAR* szDSN,CHAR* szUser, CHAR* szPass)
{
SQLRETURN ret;
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 = SQLConnectA(m_hDbc, (SQLCHAR *)szDSN, SQL_NTS, (SQLCHAR *)szUser, SQL_NTS, (SQLCHAR *)szPass, SQL_NTS);
m_bIsConnected = ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO;
return m_bIsConnected;
}
/*
** Sets the auto commit mode
*/
static int conn_setautocommit (lua_State *L) {
conn_data *conn = (conn_data *) getconnection (L);
SQLRETURN ret;
if (lua_toboolean (L, 2)) {
ret = SQLSetConnectAttr(conn->hdbc, SQL_ATTR_AUTOCOMMIT,
(SQLPOINTER) SQL_AUTOCOMMIT_ON, 0);
} else {
ret = SQLSetConnectAttr(conn->hdbc, SQL_ATTR_AUTOCOMMIT,
(SQLPOINTER) SQL_AUTOCOMMIT_OFF, 0);
}
if (error(ret))
return fail(L, hSTMT, conn->hdbc);
else
return pass(L);
}
/** \brief Set a integer connection attribute.
*
* This function sets one attribute in the connection.
*
* \param[in] attr The attribute to be modified
* \param[in] integer The integer attribute data
*
* \exception odbcpp_error
* And odbcpp_error will be thrown if the SQL function returns an error.
*/
void connection::set_attr(SQLINTEGER attr, SQLINTEGER integer)
{
// TODO: see whether SQL_IS_INTEGER works even if SQL_IS_UINTEGER is required?
#ifdef _MSC_VER
SQLPOINTER ptr;
if(sizeof(ptr) < sizeof(integer)) {
diagnostic d(odbcpp_error::ODBCPP_INTERNAL, std::string("the size of an SQLINTEGER is larger than SQLPOINTER?!"));
throw odbcpp_error(d);
}
memcpy(&ptr, &integer, sizeof(integer));
check(SQLSetConnectAttr(f_handle, attr, ptr, 0));
#else
check(SQLSetConnectAttr(f_handle, attr, reinterpret_cast<SQLPOINTER>(integer), 0));
#endif
}
void ODBCSession::SetTransactionMode(int mode)
{
tmode = mode;
SQLSetConnectAttr(hdbc, SQL_ATTR_AUTOCOMMIT,
mode == IMPLICIT ? (SQLPOINTER)SQL_AUTOCOMMIT_OFF
: (SQLPOINTER)SQL_AUTOCOMMIT_ON, SQL_NTS);
}
static void
insert_test_man(void)
{
SQLLEN sql_nts = SQL_NTS;
SQLINTEGER commit_off = SQL_AUTOCOMMIT_OFF;
SQLINTEGER commit_on = SQL_AUTOCOMMIT_ON;
SQLINTEGER id = 0;
char string[64];
CHKSetConnectAttr(SQL_ATTR_AUTOCOMMIT, int2ptr(commit_off), SQL_IS_INTEGER, "SI");
odbc_reset_statement();
CHKBindParameter(1, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, sizeof(id), 0, &id, 0, &sql_nts, "SI");
CHKBindParameter(2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, sizeof(string), 0, string, 0, &sql_nts, "SI");
CHKPrepare(T("insert into test values (?, ?)"), SQL_NTS, "SI");
for (id = 0; id < 20; id++) {
sprintf(string, "This is a test (%d)", (int) id);
CHKExecute("SI");
}
SQLEndTran(SQL_HANDLE_DBC, odbc_conn, SQL_COMMIT);
SQLSetConnectAttr(odbc_conn, SQL_ATTR_AUTOCOMMIT, int2ptr(commit_on), SQL_IS_INTEGER);
odbc_reset_statement();
}
bool OdbcConnection::TryEndTran(SQLSMALLINT completionType)
{
SQLRETURN ret = SQLEndTran(SQL_HANDLE_DBC, connection, completionType);
if (ret == SQL_STILL_EXECUTING)
{
return false;
}
if (!SQL_SUCCEEDED(ret))
{
statement.Throw();
}
// put the connection back into auto commit mode
ret = SQLSetConnectAttr( connection, SQL_ATTR_AUTOCOMMIT, reinterpret_cast<SQLPOINTER>( SQL_AUTOCOMMIT_ON ),
SQL_IS_UINTEGER );
// TODO: This will not work because calling into TryEndTran again from the callback will fail
// when the completion has already finished.
if (ret == SQL_STILL_EXECUTING)
{
return false;
}
if (!SQL_SUCCEEDED(ret))
{
statement.Throw();
}
return true;
}
/* Write a merged node record to the database */
Int2 DB_WriteTaxMergedNodeRec(Int4 oldTaxId, Int4 newTaxId)
{
if(oldTaxId < 0) {
ErrPostEx(SEV_INFO, 3, 0, "DB_WriteTaxMergedNodeRec: Passed oldTaxId < 0.");
return(-1);
}
if(newTaxId < 0) {
ErrPostEx(SEV_INFO, 3, 0, "DB_WriteTaxMergedNodeRec: Passed newTaxId < 0.");
return(-1);
}
/*set up the input parameters */
SQLBindParameter(hstmt_merge, 1, SQL_PARAM_INPUT, SQL_C_LONG,SQL_INTEGER, 0, 0, &oldTaxId, 0, NULL);
SQLBindParameter(hstmt_merge, 2, SQL_PARAM_INPUT, SQL_C_LONG,SQL_INTEGER, 0, 0, &newTaxId, 0, NULL);
/* set auto commit on */
SQLSetConnectAttr( hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_ON, SQL_NTS);
/* execute statment */
if (SQLExecute (hstmt_merge) != SQL_SUCCESS){
ErrPostEx(SEV_ERROR,0,0, "DB_WriteTaxMergedRec: unable to execute insert statement. ");
print_err(hstmt_merge);
return FALSE;
}
return TRUE;
}
int open_connection()
{
SQLRETURN ret;
/* Allocate Environment handle and register version */
ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &ODenvi);
if ((ret != SQL_SUCCESS) && (ret != SQL_SUCCESS_WITH_INFO)) {
db_d_append_error("SQLAllocHandle()");
db_d_report_error();
return DB_FAILED;
}
ret =
SQLSetEnvAttr(ODenvi, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0);
if ((ret != SQL_SUCCESS) && (ret != SQL_SUCCESS_WITH_INFO)) {
db_d_append_error("SQLSetEnvAttr()");
db_d_report_error();
SQLFreeHandle(SQL_HANDLE_ENV, ODenvi);
return DB_FAILED;
}
/* Allocate connection handle */
ret = SQLAllocHandle(SQL_HANDLE_DBC, ODenvi, &ODconn);
if ((ret != SQL_SUCCESS) && (ret != SQL_SUCCESS_WITH_INFO)) {
db_d_append_error("SQLAllocHandle()");
db_d_report_error();
SQLFreeHandle(SQL_HANDLE_ENV, ODenvi);
return DB_FAILED;
}
/* Set timeout */
SQLSetConnectAttr(ODconn, SQL_LOGIN_TIMEOUT, (SQLPOINTER *) 5, 0);
return DB_OK;
}
void sqlConnect(SQLHENV *henv, SQLHDBC *hdbc, SQLHSTMT *hstmt)
{
// sql vars
SQLRETURN rc;
// allocate environment handle
rc = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, henv);
if (!checkReturnCode("SQLAllocHandle [henv]", rc, *henv, SQL_HANDLE_ENV)){
freeSQLHandles(henv, hdbc, SQL_NULL_HSTMT);
exit(0);
}
rc = SQLSetEnvAttr(*henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER*)SQL_OV_ODBC3, 0);
if (!checkReturnCode("SQLSetEnvAttr [henv]", rc, henv, SQL_HANDLE_ENV)){
freeSQLHandles(henv, hdbc, SQL_NULL_HSTMT);
exit(0);
}
// allocate connection handle
rc = SQLAllocHandle(SQL_HANDLE_DBC, *henv, hdbc);
if (!checkReturnCode("SQLAllocHandle [hdbc]", rc, *hdbc, SQL_HANDLE_DBC)){
freeSQLHandles(henv, hdbc, SQL_NULL_HSTMT);
exit(0);
}
// set login timeout to 5 seconds
rc = SQLSetConnectAttr(*hdbc, SQL_LOGIN_TIMEOUT, (SQLPOINTER)5, 0);
if (!checkReturnCode("SQLSetConnectAttr [hdbc]", rc, *hdbc, SQL_HANDLE_DBC)){
freeSQLHandles(henv, hdbc, SQL_NULL_HSTMT);
exit(0);
}
// linux
// connect to data source
char* server = "MSSQLSERVER";
char* login = "******";
char* password = "******";
rc = SQLConnect(*hdbc, (SQLCHAR*) server, SQL_NTS, (SQLCHAR*) login, SQL_NTS, (SQLCHAR*) password, SQL_NTS);
if (!checkReturnCode("SQLConnect [hdbc]", rc, *hdbc, SQL_HANDLE_DBC)) {
freeSQLHandles(henv, hdbc, hstmt);
exit(0);
}
// windows
// sql driver connect
/*SQLCHAR retconstring[1024];
char* connStr = "DRIVER={SQL Server};SERVER=141.56.2.45, 1433;DATABASE=Verkauf;UID=stud01;PWD=stud01;";
rc = SQLDriverConnect(*hdbc, NULL, (SQLCHAR*)connStr, SQL_NTS, retconstring, 1024, NULL, SQL_DRIVER_NOPROMPT);
if (!checkReturnCode("SQLDriverConnect [hdbc]", rc, *hdbc, SQL_HANDLE_DBC)){
freeSQLHandles(henv, hdbc, SQL_NULL_HSTMT);
exit(0);
}*/
// allocate statement handle
rc = SQLAllocHandle(SQL_HANDLE_STMT, *hdbc, hstmt);
if (!checkReturnCode("SQLAllocHandle [hstmt]", rc, *hstmt, SQL_HANDLE_STMT)) {
freeSQLHandles(henv, hdbc, hstmt);
exit(0);
}
}
bool COdbcConnection::Open()
{
COdbcConnectionInformation *pCI = static_cast<COdbcConnectionInformation*>(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;
m_lasterror = SQLConnect(m_hDbc,(SQLCHAR*)pCI->database.c_str(),SQL_NTS,(SQLCHAR*)pCI->username.c_str(),SQL_NTS,(SQLCHAR*)pCI->password.c_str(),SQL_NTS);
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;
}
static int odbc_handle_rollback(pdo_dbh_t *dbh)
{
pdo_odbc_db_handle *H = (pdo_odbc_db_handle *)dbh->driver_data;
RETCODE rc;
rc = SQLEndTran(SQL_HANDLE_DBC, H->dbc, SQL_ROLLBACK);
if (rc != SQL_SUCCESS) {
pdo_odbc_drv_error("SQLEndTran: Rollback");
if (rc != SQL_SUCCESS_WITH_INFO) {
return 0;
}
}
if (dbh->auto_commit && H->dbc) {
/* turn auto-commit back on again */
rc = SQLSetConnectAttr(H->dbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_ON, SQL_IS_INTEGER);
if (rc != SQL_SUCCESS) {
pdo_odbc_drv_error("SQLSetConnectAttr AUTOCOMMIT = ON");
return 0;
}
}
return 1;
}
// 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 bool Connect(PyObject* pConnectString, HDBC hdbc, bool fAnsi, long timeout,
Object& encoding)
{
// This should have been checked by the global connect function.
I(PyString_Check(pConnectString) || PyUnicode_Check(pConnectString));
const int cchMax = 600;
if (PySequence_Length(pConnectString) >= cchMax)
{
PyErr_SetString(PyExc_TypeError, "connection string too long");
return false;
}
// The driver manager determines if the app is a Unicode app based on whether we call SQLDriverConnectA or
// SQLDriverConnectW. Some drivers, notably Microsoft Access/Jet, change their behavior based on this, so we try
// the Unicode version first. (The Access driver only supports Unicode text, but SQLDescribeCol returns SQL_CHAR
// instead of SQL_WCHAR if we connect with the ANSI version. Obviously this causes lots of errors since we believe
// what it tells us (SQL_CHAR).)
// Python supports only UCS-2 and UCS-4, so we shouldn't need to worry about receiving surrogate pairs. However,
// Windows does use UCS-16, so it is possible something would be misinterpreted as one. We may need to examine
// this more.
SQLRETURN ret;
if (timeout > 0)
{
Py_BEGIN_ALLOW_THREADS
ret = SQLSetConnectAttr(hdbc, SQL_ATTR_LOGIN_TIMEOUT, (SQLPOINTER)(uintptr_t)timeout, SQL_IS_UINTEGER);
Py_END_ALLOW_THREADS
if (!SQL_SUCCEEDED(ret))
RaiseErrorFromHandle("SQLSetConnectAttr(SQL_ATTR_LOGIN_TIMEOUT)", hdbc, SQL_NULL_HANDLE);
}
/************************************************************************
* name: SQLSetConnectAttrW
* arguments:
* returns/side-effects:
* description:
* NOTE:
************************************************************************/
ODBC_INTERFACE RETCODE SQL_API
SQLSetConnectAttrW (SQLHDBC hdbc, SQLINTEGER attribute,
SQLPOINTER value, SQLINTEGER value_len)
{
OutputDebugString ("SQLSetConnectAttrW called.\n");
return SQLSetConnectAttr (hdbc, attribute, value, value_len);
}
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;
}
void CODBCDatabase::SetConnectionTimeout(LONG nSeconds)
{
if(m_hDbc)
SQLSetConnectAttr(m_hDbc, SQL_ATTR_CONNECTION_TIMEOUT, (SQLPOINTER)nSeconds, 0);
m_lConnectionTimeout = nSeconds;
}
/* -------------------------------------------------------------------
* Provide options to a pSQL environment - If NULL the use the default
* ------------------------------------------------------------------- */
void jx_sqlSetOptions (PJXNODE pOptionsP)
{
PJXSQLCONNECT pc = jx_getCurrentConnection();
PSQLOPTIONS po = &pConnection->options;
PJXNODE pNode;
// Delete previous settings, if we did that parsing
if (pConnection->pOptionsCleanup) {
jx_Close(&pConnection->pOptions);
}
// .. and set the new setting
pConnection->pOptionsCleanup = false;
if (ON == jx_isNode(pOptionsP)) {
pConnection->pOptions = pOptionsP;
} else if (pOptionsP != NULL) {
pConnection->pOptions = jx_ParseString ((PUCHAR) pOptionsP , NULL);
pConnection->pOptionsCleanup = true;
}
pNode = jx_GetNode(pConnection->pOptions, "/");
while (pNode) {
int rc = SQL_SUCCESS;
PUCHAR name, value;
LONG attrParm;
name = jx_GetNodeNamePtr (pNode);
value = jx_GetNodeValuePtr (pNode , NULL);
// Is header overriden by userprogram ?
if (BeginsWith(name , "upperCaseColName")) {
po->upperCaseColName = *value == 't'? ON:OFF; // for true
}
else if (BeginsWith(name , "autoParseContent")) {
po->autoParseContent = *value == 't' ? ON:OFF; // for true
}
else if (BeginsWith(name , "DecimalPoint")) {
po->DecimalPoint = *value;
}
else if (BeginsWith(name , "sqlNaming")) {
po->sqlNaming = *value == 't' ? ON:OFF; // for true
attrParm = po->sqlNaming == OFF; // sysname is invers of SQL naming :(
rc = SQLSetConnectAttr (pConnection->hdbc , SQL_ATTR_DBC_SYS_NAMING, &attrParm , 0);
}
if (rc != SQL_SUCCESS ) {
check_error (NULL);
return ; // we have an error
}
/* more to come....
po->hexSort;
po->DateSep;
po->DateFmt;
po->TimeSep;
po->TimeFmt;
po->DecimalPoint;
*/
pNode = jx_GetNodeNext(pNode);
}
}
SQLRETURN unixodbc_backend_debug::do_set_connection_attribute(SQLHDBC connection_handle, SQLINTEGER attribute, SQLPOINTER value_ptr, SQLINTEGER string_length) const
{
std::cout << " *DEBUG* set_connection_attribute";
auto const return_code = SQLSetConnectAttr(connection_handle, attribute, value_ptr, string_length);
std::cout << " (return code " << return_code << ")" << std::endl;
return return_code;
}
static int odbc_dispatch3(void)
{
unsigned long retval;
PWord rval; int rtype;
PWord arg1; int type1;
PWord arg2; int type2;
PWord arg3; int type3;
PWord arg4; int type4;
PWord arg5; int type5;
PWord arg6; int type6;
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);
if (type3 != PI_INT)
if (!CI_get_integer((unsigned long *)&arg3,type3))
PI_FAIL;
PI_getan(&arg4,&type4,4);
if (type4 != PI_INT)
if (!CI_get_integer((unsigned long *)&arg4,type4))
PI_FAIL;
PI_getan(&arg5,&type5,5);
if (type5 != PI_INT)
if (!CI_get_integer((unsigned long *)&arg5,type5))
PI_FAIL;
PI_getan(&arg6,&type6,6);
switch(arg1)
{
case 0:
retval = (unsigned long) SQLSetScrollOptions(((SQLHSTMT ) arg2),((SQLUSMALLINT ) arg3),((SQLINTEGER ) arg4),((SQLUSMALLINT ) arg5));
break;
case 1:
retval = (unsigned long) SQLSetPos(((SQLHSTMT ) arg2),((SQLUSMALLINT ) arg3),((SQLUSMALLINT ) arg4),((SQLUSMALLINT ) arg5));
break;
case 2:
retval = (unsigned long) SQLSetStmtAttr(((SQLHSTMT ) arg2),((SQLINTEGER ) arg3),((SQLPOINTER ) arg4),((SQLINTEGER ) arg5));
break;
case 3:
retval = (unsigned long) SQLSetEnvAttr(((SQLHENV ) arg2),((SQLINTEGER ) arg3),((SQLPOINTER ) arg4),((SQLINTEGER ) arg5));
break;
case 4:
retval = (unsigned long) SQLSetConnectAttr(((SQLHDBC ) arg2),((SQLINTEGER ) arg3),((SQLPOINTER ) arg4),((SQLINTEGER ) arg5));
break;
default:
PI_FAIL;
}
PI_makedouble(&rval,&rtype,(double) retval);
if (PI_unify(arg6,type6,rval,rtype))
PI_SUCCEED;
PI_FAIL;
}
/* Open an ODBC connection to the database. */
int _connect_to_db(struct db_context_t *odbcc)
{
SQLRETURN rc;
/* Allocate connection handles. */
pthread_mutex_lock(&db_source_mutex);
rc = SQLAllocHandle(SQL_HANDLE_DBC, henv, &odbcc->hdbc);
if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
LOG_ODBC_ERROR(SQL_HANDLE_DBC, odbcc->hdbc);
SQLFreeHandle(SQL_HANDLE_DBC, odbcc->hdbc);
return ERROR;
}
/* Open connection to the database. */
rc = SQLConnect(odbcc->hdbc, servername, SQL_NTS,
username, SQL_NTS, authentication, SQL_NTS);
if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
LOG_ODBC_ERROR(SQL_HANDLE_DBC, odbcc->hdbc);
SQLFreeHandle(SQL_HANDLE_DBC, odbcc->hdbc);
return ERROR;
}
rc = SQLSetConnectAttr(odbcc->hdbc, SQL_ATTR_AUTOCOMMIT,
SQL_AUTOCOMMIT_OFF, 0);
if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt);
return ERROR;
}
rc = SQLSetConnectAttr(odbcc->hdbc, SQL_ATTR_TXN_ISOLATION,
(SQLPOINTER *) SQL_TXN_REPEATABLE_READ, 0);
if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt);
return ERROR;
}
/* allocate statement handle */
rc = SQLAllocHandle(SQL_HANDLE_STMT, odbcc->hdbc, &odbcc->hstmt);
if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt);
return ERROR;
}
pthread_mutex_unlock(&db_source_mutex);
return OK;
}
bool CMssqlConnection::BeginTrans()
{
m_lasterror = SQLSetConnectAttr(m_hDbc,SQL_ATTR_AUTOCOMMIT,(SQLPOINTER)SQL_AUTOCOMMIT_OFF,0);
if(!SQL_SUCCEEDED(m_lasterror))
return false;
return true;
}
// --------------------------------------------------------------------
// to set attributes specific to a connection
// --------------------------------------------------------------------
RETCODE SQL_API SQLSetConnectAttrW ( SQLHDBC hdbc,
SQLINTEGER fAttribute,
SQLPOINTER rgbValue,
SQLINTEGER cbValue ) {
__ODBCLOG ( _ODBCLogMsg ( LogLevel_DEBUG, "SQLSetConnectAttrW, Attr: %d, DataPtr: %d, DataSize: %d", fAttribute,
rgbValue, cbValue ) );
RETCODE code = SQLSetConnectAttr ( hdbc, fAttribute, rgbValue, cbValue );
return code;
}
static void
AutoCommit(int onoff)
{
SQLRETURN ret;
ret = SQLSetConnectAttr(Connection, SQL_ATTR_AUTOCOMMIT, int2ptr(onoff), 0);
if (ret != SQL_SUCCESS)
ODBC_REPORT_ERROR("Enabling AutoCommit");
}
DatabaseODBC::DatabaseODBC()
{
m_connected = false;
char* dns = new char[SQL_MAX_DSN_LENGTH];
char* user = new char[32];
char* pass = new char[32];
strcpy((char*)dns, g_config.getString(ConfigManager::SQL_DB).c_str());
strcpy((char*)user, g_config.getString(ConfigManager::SQL_USER).c_str());
strcpy((char*)pass, g_config.getString(ConfigManager::SQL_PASS).c_str());
SQLRETURN ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &m_env);
if(!RETURN_SUCCESS(ret)){
std::cout << "Failed to allocate ODBC SQLHENV enviroment handle." << std::endl;
m_env = NULL;
return;
}
ret = SQLSetEnvAttr(m_env, SQL_ATTR_ODBC_VERSION, (SQLPOINTER*)SQL_OV_ODBC3, 0);
if(!RETURN_SUCCESS(ret)){
std::cout << "SQLSetEnvAttr(SQL_ATTR_ODBC_VERSION): Failed to switch to ODBC 3 version." << std::endl;
SQLFreeHandle(SQL_HANDLE_ENV, m_env);
m_env = NULL;
}
if(m_env == NULL){
std::cout << "ODBC SQLHENV enviroment not initialized." << std::endl;
return;
}
ret = SQLAllocHandle(SQL_HANDLE_DBC, m_env, &m_handle);
if(!RETURN_SUCCESS(ret)){
std::cout << "Failed to allocate ODBC SQLHDBC connection handle." << std::endl;
m_handle = NULL;
return;
}
ret = SQLSetConnectAttr(m_handle, SQL_ATTR_CONNECTION_TIMEOUT, (SQLPOINTER*)5, 0);
if(!RETURN_SUCCESS(ret)){
std::cout << "SQLSetConnectAttr(SQL_ATTR_CONNECTION_TIMEOUT): Failed to set connection timeout." << std::endl;
SQLFreeHandle(SQL_HANDLE_DBC, m_handle);
m_handle = NULL;
return;
}
ret = SQLConnect(m_handle, (SQLCHAR*)dns, SQL_NTS, (SQLCHAR*)user, SQL_NTS, (SQLCHAR*)pass, SQL_NTS);
if(!RETURN_SUCCESS(ret)){
std::cout << "Failed to connect to ODBC via DSN: " << dns << " (user " << user << ")" << std::endl;
SQLFreeHandle(SQL_HANDLE_DBC, m_handle);
m_handle = NULL;
return;
}
m_connected = true;
}
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;
}
