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