bool SqliteDatabaseLayer::Open(const wxString& strDatabase) { ResetErrorCodes(); //if (m_pDatabase == NULL) // m_pDatabase = new sqlite3; wxCharBuffer databaseNameBuffer = ConvertToUnicodeStream(strDatabase); sqlite3* pDbPtr = (sqlite3*)m_pDatabase; int nReturn = sqlite3_open(databaseNameBuffer, &pDbPtr); m_pDatabase = pDbPtr; if (nReturn != SQLITE_OK) { SetErrorCode(SqliteDatabaseLayer::TranslateErrorCode(sqlite3_errcode((sqlite3*)m_pDatabase))); SetErrorMessage(ConvertFromUnicodeStream(sqlite3_errmsg((sqlite3*)m_pDatabase))); ThrowDatabaseException(); return false; } return true; }
void* OTLResultSet::GetResultBlob(int nField, wxMemoryBuffer& Buffer) { try { /*fixme OTL::occi::Blob blob = m_pResultSet->getBlob(nField); blob.open(OTL::occi::OCCI_LOB_READONLY); int nLength = blob.length(); unsigned char* pBuffer = (unsigned char*)(Buffer.GetWriteBuf(nLength)); int nLengthRead = blob.read(nLength, pBuffer, nLength); */ } catch (otl_exception& e) { SetErrorCode(OTLDatabaseLayer::TranslateErrorCode(e.code)); SetErrorMessage(ConvertFromUnicodeStream((char*)e.msg)); ThrowDatabaseException(); } return Buffer.GetData(); }
void wxOdbcResultSet::InterpretErrorCodes( long WXUNUSED(nCode), SQLHSTMT stmth_ptr ) { //if ((nCode != SQL_SUCCESS) ) // && (nCode != SQL_SUCCESS_WITH_INFO)) { SQLINTEGER iNativeCode; SQLTCHAR strState[ERR_STATE_LEN]; SQLTCHAR strBuffer[ERR_BUFFER_LEN]; SQLSMALLINT iMsgLen; memset(strState, 0, ERR_STATE_LEN*sizeof(SQLTCHAR)); memset(strBuffer, 0, ERR_BUFFER_LEN*sizeof(SQLTCHAR)); m_pInterface->GetSQLGetDiagRec()(SQL_HANDLE_STMT, stmth_ptr, 1, strState, &iNativeCode, strBuffer, ERR_BUFFER_LEN, &iMsgLen); SetErrorCode((int)iNativeCode); SetErrorMessage(ConvertFromUnicodeStream((char*)strBuffer)); // AML //AML SetErrorMessage(wxString((wxChar*)strBuffer)); } }
wxString wxPostgresResultSet::GetResultString(int nField) { wxString strValue = wxT(""); if (m_bBinaryResults) { wxLogError(_("Not implemented\n")); } else { if (nField != -1) { if (m_pInterface->GetPQgetisnull()(m_pResult, m_nCurrentRow, nField-1) != 1) { strValue = ConvertFromUnicodeStream(m_pInterface->GetPQgetvalue()(m_pResult, m_nCurrentRow, nField-1)); } } } return strValue; }
// query database int SqliteDatabaseLayer::RunQuery(const wxString& strQuery, bool bParseQuery) { ResetErrorCodes(); if (m_pDatabase == NULL) return false; wxArrayString QueryArray; if (bParseQuery) QueryArray = ParseQueries(strQuery); else QueryArray.push_back(strQuery); wxArrayString::iterator start = QueryArray.begin(); wxArrayString::iterator stop = QueryArray.end(); while (start != stop) { char* szErrorMessage = NULL; wxString strErrorMessage = _(""); wxCharBuffer sqlBuffer = ConvertToUnicodeStream(*start); int nReturn = sqlite3_exec((sqlite3*)m_pDatabase, sqlBuffer, 0, 0, &szErrorMessage); if (szErrorMessage != NULL) { strErrorMessage = ConvertFromUnicodeStream(szErrorMessage); sqlite3_free(szErrorMessage); } if (nReturn != SQLITE_OK) { SetErrorCode(SqliteDatabaseLayer::TranslateErrorCode(sqlite3_errcode((sqlite3*)m_pDatabase))); SetErrorMessage(strErrorMessage); ThrowDatabaseException(); return DATABASE_LAYER_QUERY_RESULT_ERROR; } start++; } return (sqlite3_changes((sqlite3*)m_pDatabase)); }
void OTLResultSet::Close() { try { CloseMetaData(); for (unsigned int i = 0 ; i < m_otldesc.size() ;++i) { delete m_otldesc[i]; } m_otldesc.clear(); if (m_pResultSet != NULL) { delete m_pResultSet; m_pResultSet =NULL; } //fixme /* otl_stream* pStatement = m_pResultSet->getStatement(); if (pStatement) { pStatement->closeResultSet(m_pResultSet); if (m_bManageStatement) { OTL::occi::Connection* pDatabase = pStatement->getConnection(); if (pDatabase) pDatabase->terminateStatement(pStatement); } } */ } catch (otl_exception& e) { SetErrorCode(OTLDatabaseLayer::TranslateErrorCode(e.code)); SetErrorMessage(ConvertFromUnicodeStream((char*)e.msg)); ThrowDatabaseException(); } }
// PreparedStatement support PreparedStatement* OTLDatabaseLayer::PrepareStatement(const wxString& strQuery) { OTLPreparedStatement* pStatement = NULL; try { wxArrayString QueryArray = ParseQueries(strQuery); wxArrayString::iterator start = QueryArray.begin(); wxArrayString::iterator stop = QueryArray.end(); while (start != stop) { wxCharBuffer sqlBuffer = ConvertToUnicodeStream((*start)); std::string strSQL(sqlBuffer); //fixme /* OTL::occi::Statement* pOTLStatement = m_pDatabase->createStatement(strSQL); if (pOTLStatement) { pOTLStatement->setAutoCommit(m_bAutoCommit); pStatement->AddStatement(pOTLStatement); } */ start++; } } catch (otl_exception& e) { SetErrorCode(OTLDatabaseLayer::TranslateErrorCode(e.code)); SetErrorMessage(ConvertFromUnicodeStream((char*)e.msg)); wxDELETE(pStatement); ThrowDatabaseException(); return NULL; } if (pStatement) LogStatementForCleanup(pStatement); return pStatement; }
// close database bool SqliteDatabaseLayer::Close() { ResetErrorCodes(); CloseResultSets(); CloseStatements(); if (m_pDatabase != NULL) { int nReturn = sqlite3_close((sqlite3*)m_pDatabase); if (nReturn != SQLITE_OK) { SetErrorCode(SqliteDatabaseLayer::TranslateErrorCode(sqlite3_errcode((sqlite3*)m_pDatabase))); SetErrorMessage(ConvertFromUnicodeStream(sqlite3_errmsg((sqlite3*)m_pDatabase))); ThrowDatabaseException(); return false; } m_pDatabase = NULL; } return true; }
wxDatabaseResultSet* wxPostgresDatabase::RunQueryWithResults(const wxString& strQuery) { ResetErrorCodes(); wxCharBuffer sqlBuffer = ConvertToUnicodeStream(strQuery); PGresult* pResultCode = m_pInterface->GetPQexec()((PGconn*)m_pDatabase, sqlBuffer); if ((pResultCode == NULL) || (m_pInterface->GetPQresultStatus()(pResultCode) != PGRES_TUPLES_OK)) { SetErrorCode(wxPostgresDatabase::TranslateErrorCode(m_pInterface->GetPQstatus()((PGconn*)m_pDatabase))); SetErrorMessage(ConvertFromUnicodeStream(m_pInterface->GetPQerrorMessage()((PGconn*)m_pDatabase))); m_pInterface->GetPQclear()(pResultCode); ThrowDatabaseException(); return NULL; } else { wxPostgresResultSet* pResultSet = new wxPostgresResultSet(m_pInterface, pResultCode); pResultSet->SetEncoding(GetEncoding()); LogResultSetForCleanup(pResultSet); return pResultSet; } }
DatabaseResultSet* PostgresPreparedStatementWrapper::RunQueryWithResults() { int nParameters = m_Parameters.GetSize(); char** paramValues = m_Parameters.GetParamValues(); int* paramLengths = m_Parameters.GetParamLengths(); int* paramFormats = m_Parameters.GetParamFormats(); int nResultFormat = 0; // 0 = text, 1 = binary (all or none on the result set, not column based) wxCharBuffer statementNameBuffer = ConvertToUnicodeStream(m_strStatementName); PGresult* pResult = m_pInterface->GetPQexecPrepared()(m_pDatabase, statementNameBuffer, nParameters, paramValues, paramLengths, paramFormats, nResultFormat); if (pResult != NULL) { ExecStatusType status = m_pInterface->GetPQresultStatus()(pResult); if ((status != PGRES_COMMAND_OK) && (status != PGRES_TUPLES_OK)) { SetErrorCode(PostgresDatabaseLayer::TranslateErrorCode(status)); SetErrorMessage(ConvertFromUnicodeStream(m_pInterface->GetPQresultErrorMessage()(pResult))); } else { delete []paramValues; delete []paramLengths; delete []paramFormats; PostgresResultSet* pResultSet = new PostgresResultSet(m_pInterface, pResult); pResultSet->SetEncoding(GetEncoding()); return pResultSet; } m_pInterface->GetPQclear()(pResult); } delete []paramValues; delete []paramLengths; delete []paramFormats; ThrowDatabaseException(); return NULL; }
wxString OdbcResultSetMetaData::GetColumnName(int i) { wxString columnName; SQLTCHAR col_name[8192]; SQLSMALLINT col_name_length; SQLSMALLINT col_data_type; SQLUINTEGER col_size; SQLSMALLINT col_decimal_digits; SQLSMALLINT col_nullable; memset(col_name, 0, 8192); SQLRETURN nRet = m_pInterface->GetSQLDescribeCol()( m_pOdbcStatement, i, col_name, 8192, &col_name_length, &col_data_type, &col_size, &col_decimal_digits, &col_nullable ); if ( nRet == SQL_SUCCESS ) { //return wxString((wxChar*)col_name); columnName = ConvertFromUnicodeStream((const char*)(wxChar*)col_name); } return columnName; }
wxString OTLResultSetMetaData::GetColumnName(int i) { wxString strField = ConvertFromUnicodeStream(m_desc[i]->name); return strField; }
int OTLResultSetMetaData::GetColumnType(int i) { int fieldType = COLUMN_UNKNOWN; int OTLFieldType = m_desc[i]->dbtype; wxString strV(ConvertFromUnicodeStream(m_desc[i]->name)); switch (OTLFieldType) { case extLong: case extUInt: case extNumber: case extInt: case extVarNum: case extRowId: //fixme: check fieldType = COLUMN_INTEGER; break; case extVarChar2: case extLongVarChar: case extCChar: case extVarChar: case extChar: case extCharZ: case extMslabel://fixme : Check fieldType = COLUMN_STRING; break; case extFloat: fieldType = COLUMN_DOUBLE; break; /* case SQL_BIT: fieldType = COLUMN_BOOL; break; */ case extBLOB: case extCLOB: case extVarRaw: //fixme : Check //case extRaw: //fixme : Check case extLongRaw://fixme : Check case extLongVarRaw://fixme : Check fieldType = COLUMN_BLOB; break; case extDate: #if (defined(OTL_ORA8I)||defined(OTL_ORA9I))&&defined(OTL_ORA_TIMESTAMP) case extTimestamp: case extTimestamp_TZ: case extTimestamp_LTZ: #endif fieldType = COLUMN_DATE; break; default: fieldType = COLUMN_UNKNOWN; break; }; return fieldType; }
PreparedStatement* SqliteDatabaseLayer::PrepareStatement(const wxString& strQuery, bool bLogForCleanup) { ResetErrorCodes(); if (m_pDatabase != NULL) { SqlitePreparedStatement* pReturnStatement = new SqlitePreparedStatement((sqlite3*)m_pDatabase); if (pReturnStatement) pReturnStatement->SetEncoding(GetEncoding()); wxArrayString QueryArray = ParseQueries(strQuery); wxArrayString::iterator start = QueryArray.begin(); wxArrayString::iterator stop = QueryArray.end(); while (start != stop) { const char* szTail=0; wxCharBuffer sqlBuffer; do { sqlite3_stmt* pStatement; wxString strSQL; if (szTail != 0) { strSQL = (wxChar*)szTail; } else { strSQL = (*start); } sqlBuffer = ConvertToUnicodeStream(strSQL); #if SQLITE_VERSION_NUMBER>=3003009 int nReturn = sqlite3_prepare_v2((sqlite3*)m_pDatabase, sqlBuffer, -1, &pStatement, &szTail); #else int nReturn = sqlite3_prepare((sqlite3*)m_pDatabase, sqlBuffer, -1, &pStatement, &szTail); #endif if (nReturn != SQLITE_OK) { SetErrorCode(SqliteDatabaseLayer::TranslateErrorCode(nReturn)); SetErrorMessage(ConvertFromUnicodeStream(sqlite3_errmsg((sqlite3*)m_pDatabase))); wxDELETE(pReturnStatement); ThrowDatabaseException(); return NULL; } pReturnStatement->AddPreparedStatement(pStatement); #if wxUSE_UNICODE } while (strlen(szTail) > 0); #else } while (wxStrlen(szTail) > 0); #endif start++; } if (bLogForCleanup) LogStatementForCleanup(pReturnStatement); return pReturnStatement; }
// open database bool OTLDatabaseLayer::Open() { try { wxString tnsString = wxT(""); if (m_strServer != wxEmptyString) { tnsString += _("Host=") + m_strServer; if (m_strPort != wxEmptyString) { // Add the parameter separater (colon) if needed if (tnsString.length() > 0) tnsString += _(";"); tnsString += _("Port=") + m_strPort; } } if (m_strDatabase != wxEmptyString) { // Add the parameter separater (colon) if needed if (tnsString.length() > 0) tnsString += _(";"); tnsString += _("Service Name=") + m_strDatabase; } wxCharBuffer tnsStringBuffer = ConvertToUnicodeStream(tnsString); std::string strTnsString(tnsStringBuffer); wxString connectString = m_strUser + wxT("/") + m_strPassword; if (m_strDatabase != wxEmptyString) connectString += wxT("@") + m_strDatabase; try { m_database.rlogon(connectString.mb_str()); } catch (otl_exception& e) { SetErrorCode(OTLDatabaseLayer::TranslateErrorCode(e.code)); SetErrorMessage(ConvertFromUnicodeStream((char*)e.msg)); ThrowDatabaseException(); return false; } catch (...) { if (GetErrorCode() == DATABASE_LAYER_OK) { SetErrorCode(DATABASE_LAYER_ERROR); SetErrorMessage(_("Error creating database connection")); } ThrowDatabaseException(); return false; } } catch (otl_exception& e) { SetErrorCode(OTLDatabaseLayer::TranslateErrorCode(e.code)); SetErrorMessage(ConvertFromUnicodeStream((char*)e.msg)); ThrowDatabaseException(); return false; } return true; }
void wxOdbcResultSet::RetrieveFieldData(int nField) { if (nField != -1) { SQLRETURN rc; SQLSMALLINT buflen; unsigned long int colType; rc = m_pInterface->GetSQLColAttribute()(m_pOdbcStatement, nField, SQL_DESC_TYPE, NULL, 0, &buflen, &colType); if (SQL_FLOAT == colType || SQL_DOUBLE == colType) { SQLFLOAT ret; SQLINTEGER sqlPtr; rc = m_pInterface->GetSQLGetData()(m_pOdbcStatement, nField, SQL_C_DOUBLE, &ret, 0, &sqlPtr); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { InterpretErrorCodes(rc, m_pOdbcStatement); ThrowDatabaseException(); return; } // Mark this field as retrieved m_RetrievedValues.insert(nField); // Record whether this field is NULL if (sqlPtr == SQL_NULL_DATA) { m_NullValues.insert(nField); ret = 0; m_fieldValues[nField-1] = ret; } else { m_fieldValues[nField-1] = ret; } } else if (SQL_DATETIME == colType) { TIMESTAMP_STRUCT ret; SQLINTEGER sqlPtr; rc = m_pInterface->GetSQLGetData()(m_pOdbcStatement, nField, SQL_C_TIMESTAMP, &ret, sizeof(ret), &sqlPtr); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { InterpretErrorCodes(rc, m_pOdbcStatement); ThrowDatabaseException(); return; } // Mark this field as retrieved m_RetrievedValues.insert(nField); // Record whether this field is NULL if (sqlPtr == SQL_NULL_DATA) { m_NullValues.insert(nField); //m_fieldValues[nField-1] = wxInvalidDateTime; } else { /* wxPrintf(_T("day = %d, month = %d, year = %d, hour = %d, minute = %d, second = %d, fraction = %d\n"), ret.day, ret.month, ret.year, ret.hour, ret.minute, ret.second, ret.fraction);*/ wxDateTime dt(ret.day, wxDateTime::Month(ret.month-1), ret.year, ret.hour, ret.minute, ret.second, ret.fraction); m_fieldValues[nField-1] = dt; } } else { wxString strValue; SQLPOINTER buff[8192]; memset(buff, 0, 8192*sizeof(SQLTCHAR)); SQLINTEGER col_size = 8192; SQLINTEGER real_size = 0; if (m_pOdbcStatement == NULL) m_pOdbcStatement = m_pStatement->GetLastStatement(); SQLRETURN nRet = m_pInterface->GetSQLGetData()( m_pOdbcStatement, nField, SQL_C_TCHAR, buff, col_size, &real_size ); // should SQL_C_CHAR be SQL_C_TCHAR? if ( nRet != SQL_SUCCESS && nRet != SQL_SUCCESS_WITH_INFO ) { InterpretErrorCodes(nRet, m_pOdbcStatement); ThrowDatabaseException(); return; } strValue += ConvertFromUnicodeStream((const wxChar*)/*(const char*)*/buff); // Mark this field as retrieved m_RetrievedValues.insert(nField); // Record whether this field is NULL if (real_size == SQL_NULL_DATA) m_NullValues.insert(nField); if ( real_size > col_size ) { while ( nRet != SQL_NO_DATA ) { nRet = m_pInterface->GetSQLGetData()( m_pOdbcStatement, nField, SQL_C_TCHAR, buff, col_size, &real_size ); // should SQL_C_CHAR be SQL_C_TCHAR? if ( nRet != SQL_SUCCESS && nRet != SQL_SUCCESS_WITH_INFO && nRet != SQL_NO_DATA ) { InterpretErrorCodes(nRet, m_pOdbcStatement); ThrowDatabaseException(); return; } strValue += ConvertFromUnicodeStream((const wxChar*)/*(const char*)*/buff); } } m_fieldValues[nField-1] = strValue;//.Trim(); } } }
wxString OracleResultSetMetaData::GetColumnName(int i) { wxString strField = ConvertFromUnicodeStream(m_MetaData[i].getString(oracle::occi::MetaData::ATTR_NAME).c_str()); return strField; }