X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/9556da13bab524ea9404eb0992ba14cbb08b0588..96531a71a07563fee5fdfa69eb0a99732fed24de:/src/common/db.cpp diff --git a/src/common/db.cpp b/src/common/db.cpp index 93d1c6a74c..5d92d95366 100644 --- a/src/common/db.cpp +++ b/src/common/db.cpp @@ -18,16 +18,7 @@ // Created: 9.96 // RCS-ID: $Id$ // Copyright: (c) 1996 Remstar International, Inc. -// Licence: wxWindows licence, plus: -// Notice: This class library and its intellectual design are free of charge for use, -// modification, enhancement, debugging under the following conditions: -// 1) These classes may only be used as part of the implementation of a -// wxWindows-based application -// 2) All enhancements and bug fixes are to be submitted back to the wxWindows -// user groups free of all charges for use with the wxWindows library. -// 3) These classes may not be distributed as part of any other class library, -// DLL, text (written or electronic), other than a complete distribution of -// the wxWindows GUI development toolkit. +// Licence: wxWindows licence /////////////////////////////////////////////////////////////////////////////// /* @@ -37,50 +28,23 @@ #include "wx/wxprec.h" - -// Use this line for wxWindows v1.x -//#include "wx_ver.h" -// Use this line for wxWindows v2.x -#include "wx/version.h" - -#if wxMAJOR_VERSION == 2 - #ifdef __GNUG__ - #pragma implementation "db.h" - #endif +#ifdef __BORLANDC__ + #pragma hdrstop #endif #ifdef DBDEBUG_CONSOLE #include "wx/ioswrap.h" #endif -#ifdef __BORLANDC__ - #pragma hdrstop -#endif //__BORLANDC__ - -#if wxMAJOR_VERSION == 2 - #ifndef WX_PRECOMP - #include "wx/string.h" - #include "wx/object.h" - #include "wx/list.h" - #include "wx/utils.h" - #include "wx/msgdlg.h" - #include "wx/log.h" - #endif - #include "wx/filefn.h" - #include "wx/wxchar.h" -#endif - - -#if wxMAJOR_VERSION == 1 -# if defined(wx_msw) || defined(wx_x) -# ifdef WX_PRECOMP -# include "wx_prec.h" -# else -# include "wx.h" -# endif -# endif -# define wxUSE_ODBC 1 +#ifndef WX_PRECOMP + #include "wx/string.h" + #include "wx/object.h" + #include "wx/list.h" + #include "wx/utils.h" + #include "wx/log.h" #endif +#include "wx/filefn.h" +#include "wx/wxchar.h" #if wxUSE_ODBC @@ -90,14 +54,13 @@ #include #include -#if wxMAJOR_VERSION == 1 - #include "db.h" -#elif wxMAJOR_VERSION == 2 - #include "wx/db.h" -#endif +#include "wx/db.h" -WXDLLEXPORT_DATA(wxDbList*) PtrBegDbList = 0; +// DLL options compatibility check: +#include "wx/app.h" +WX_CHECK_BUILD_OPTIONS("wxODBC") +WXDLLIMPEXP_DATA_ODBC(wxDbList*) PtrBegDbList = 0; wxChar const *SQL_LOG_FILENAME = wxT("sqllog.txt"); wxChar const *SQL_CATALOG_FILENAME = wxT("catalog.txt"); @@ -119,7 +82,8 @@ static wxString SQLLOGfn = SQL_LOG_FILENAME; // will overwrite the errors of the previously destroyed wxDb object in // this variable. NOTE: This occurs during a CLOSE, not a FREEing of the // connection -wxChar DBerrorList[DB_MAX_ERROR_HISTORY][DB_MAX_ERROR_MSG_LEN]; +wxChar DBerrorList[DB_MAX_ERROR_HISTORY][DB_MAX_ERROR_MSG_LEN+1]; + // This type defines the return row-struct form // SQLTablePrivileges, and is used by wxDB::TablePrivileges. @@ -138,30 +102,34 @@ typedef struct /********** wxDbConnectInf Constructor - form 1 **********/ wxDbConnectInf::wxDbConnectInf() { + Henv = 0; + freeHenvOnDestroy = false; + Initialize(); } // Constructor /********** wxDbConnectInf Constructor - form 2 **********/ -wxDbConnectInf::wxDbConnectInf(HENV Henv, const wxString &Dsn, const wxString &UserID, - const wxString &Password, const wxString &DefaultDir, - const wxString &FileType, const wxString &Description) +wxDbConnectInf::wxDbConnectInf(HENV henv, const wxString &dsn, const wxString &userID, + const wxString &password, const wxString &defaultDir, + const wxString &fileType, const wxString &description) { - wxASSERT(Dsn.Length()); + Henv = 0; + freeHenvOnDestroy = false; Initialize(); - if (Henv) - SetHenv(Henv); + if (henv) + SetHenv(henv); else AllocHenv(); - SetDsn(Dsn); - SetUserID(UserID); - SetPassword(Password); - SetDescription(Description); - SetFileType(FileType); - SetDefaultDir(DefaultDir); + SetDsn(dsn); + SetUserID(userID); + SetPassword(password); + SetDescription(description); + SetFileType(fileType); + SetDefaultDir(defaultDir); } // wxDbConnectInf Constructor @@ -178,17 +146,23 @@ wxDbConnectInf::~wxDbConnectInf() /********** wxDbConnectInf::Initialize() **********/ bool wxDbConnectInf::Initialize() { - freeHenvOnDestroy = FALSE; + freeHenvOnDestroy = false; + + if (freeHenvOnDestroy && Henv) + FreeHenv(); Henv = 0; Dsn[0] = 0; Uid[0] = 0; AuthStr[0] = 0; + ConnectionStr[0] = 0; Description.Empty(); FileType.Empty(); DefaultDir.Empty(); - return TRUE; + useConnectionStr = false; + + return true; } // wxDbConnectInf::Initialize() @@ -202,13 +176,13 @@ bool wxDbConnectInf::AllocHenv() // Initialize the ODBC Environment for Database Operations if (SQLAllocEnv(&Henv) != SQL_SUCCESS) { - wxLogDebug(wxT("A problem occured while trying to get a connection to the data source")); - return FALSE; + wxLogDebug(wxT("A problem occurred while trying to get a connection to the data source")); + return false; } - freeHenvOnDestroy = TRUE; + freeHenvOnDestroy = true; - return TRUE; + return true; } // wxDbConnectInf::AllocHenv() @@ -220,7 +194,7 @@ void wxDbConnectInf::FreeHenv() SQLFreeEnv(Henv); Henv = 0; - freeHenvOnDestroy = FALSE; + freeHenvOnDestroy = false; } // wxDbConnectInf::FreeHenv() @@ -229,24 +203,36 @@ void wxDbConnectInf::SetDsn(const wxString &dsn) { wxASSERT(dsn.Length() < sizeof(Dsn)); - wxStrcpy(Dsn,dsn); + wxStrncpy(Dsn, dsn, sizeof(Dsn)-1); + Dsn[sizeof(Dsn)-1] = 0; // Prevent buffer overrun } // wxDbConnectInf::SetDsn() void wxDbConnectInf::SetUserID(const wxString &uid) { wxASSERT(uid.Length() < sizeof(Uid)); - wxStrcpy(Uid,uid); + wxStrncpy(Uid, uid, sizeof(Uid)-1); + Uid[sizeof(Uid)-1] = 0; // Prevent buffer overrun } // wxDbConnectInf::SetUserID() void wxDbConnectInf::SetPassword(const wxString &password) { wxASSERT(password.Length() < sizeof(AuthStr)); - - wxStrcpy(AuthStr,password); + + wxStrncpy(AuthStr, password, sizeof(AuthStr)-1); + AuthStr[sizeof(AuthStr)-1] = 0; // Prevent buffer overrun } // wxDbConnectInf::SetPassword() +void wxDbConnectInf::SetConnectionStr(const wxString &connectStr) +{ + wxASSERT(connectStr.Length() < sizeof(ConnectionStr)); + + useConnectionStr = wxStrlen(connectStr) > 0; + + wxStrncpy(ConnectionStr, connectStr, sizeof(ConnectionStr)-1); + ConnectionStr[sizeof(ConnectionStr)-1] = 0; // Prevent buffer overrun +} // wxDbConnectInf::SetConnectionStr() /********** wxDbColFor Constructor **********/ @@ -256,11 +242,6 @@ wxDbColFor::wxDbColFor() } // wxDbColFor::wxDbColFor() -wxDbColFor::~wxDbColFor() -{ -} // wxDbColFor::~wxDbColFor() - - /********** wxDbColFor::Initialize() **********/ void wxDbColFor::Initialize() { @@ -281,7 +262,7 @@ void wxDbColFor::Initialize() /********** wxDbColFor::Format() **********/ int wxDbColFor::Format(int Nation, int dbDataType, SWORD sqlDataType, - short columnSize, short decimalDigits) + short columnLength, short decimalDigits) { // ---------------------------------------------------------------------------------------- // -- 19991224 : mj10777 : Create @@ -303,16 +284,27 @@ int wxDbColFor::Format(int Nation, int dbDataType, SWORD sqlDataType, if (i_dbDataType == 0) // Filter unsupported dbDataTypes { - if ((i_sqlDataType == SQL_VARCHAR) || (i_sqlDataType == SQL_LONGVARCHAR)) + if ((i_sqlDataType == SQL_VARCHAR) +#if wxUSE_UNICODE + #if defined(SQL_WCHAR) + || (i_sqlDataType == SQL_WCHAR) + #endif + #if defined(SQL_WVARCHAR) + || (i_sqlDataType == SQL_WVARCHAR) + #endif +#endif + || (i_sqlDataType == SQL_LONGVARCHAR)) i_dbDataType = DB_DATA_TYPE_VARCHAR; if ((i_sqlDataType == SQL_C_DATE) || (i_sqlDataType == SQL_C_TIMESTAMP)) i_dbDataType = DB_DATA_TYPE_DATE; if (i_sqlDataType == SQL_C_BIT) i_dbDataType = DB_DATA_TYPE_INTEGER; if (i_sqlDataType == SQL_NUMERIC) - i_dbDataType = DB_DATA_TYPE_VARCHAR; + i_dbDataType = DB_DATA_TYPE_VARCHAR; // glt - ??? is this right? if (i_sqlDataType == SQL_REAL) i_dbDataType = DB_DATA_TYPE_FLOAT; + if (i_sqlDataType == SQL_C_BINARY) + i_dbDataType = DB_DATA_TYPE_BLOB; } if ((i_dbDataType == DB_DATA_TYPE_INTEGER) && (i_sqlDataType == SQL_C_DOUBLE)) @@ -331,9 +323,8 @@ int wxDbColFor::Format(int Nation, int dbDataType, SWORD sqlDataType, case DB_DATA_TYPE_FLOAT: if (decimalDigits == 0) decimalDigits = 2; - tempStr = wxT("%"); - tempStr.Printf(wxT("%s%d.%d"),tempStr.c_str(),columnSize,decimalDigits); - s_Field.Printf(wxT("%sf"),tempStr.c_str()); + tempStr.Printf(wxT("%%%d.%d"), columnLength, decimalDigits); + s_Field.Printf(wxT("%sf"), tempStr.c_str()); break; case DB_DATA_TYPE_DATE: if (i_Nation == 0) // timestamp YYYY-MM-DD HH:MM:SS.SSS (tested for SYBASE) @@ -357,17 +348,34 @@ int wxDbColFor::Format(int Nation, int dbDataType, SWORD sqlDataType, s_Field = wxT("%02d/%02d/%04d %02d:%02d:%02d.%03d"); } break; + case DB_DATA_TYPE_BLOB: + s_Field.Printf(wxT("Unable to format(%d)-SQL(%d)"), dbDataType,sqlDataType); // + break; default: - s_Field.Printf(wxT("Unknown Format(%d)-SQL(%d)"),dbDataType,sqlDataType); // + s_Field.Printf(wxT("Unknown Format(%d)-SQL(%d)"), dbDataType,sqlDataType); // break; }; return TRUE; } // wxDbColFor::Format() - /********** wxDbColInf Constructor **********/ wxDbColInf::wxDbColInf() +{ + Initialize(); +} // wxDbColInf::wxDbColInf() + + +/********** wxDbColInf Destructor ********/ +wxDbColInf::~wxDbColInf() +{ + if (pColFor) + delete pColFor; + pColFor = NULL; +} // wxDbColInf::~wxDbColInf() + + +bool wxDbColInf::Initialize() { catalog[0] = 0; schema[0] = 0; @@ -375,8 +383,8 @@ wxDbColInf::wxDbColInf() colName[0] = 0; sqlDataType = 0; typeName[0] = 0; - columnSize = 0; - bufferLength = 0; + columnLength = 0; + bufferSize = 0; decimalDigits = 0; numPrecRadix = 0; nullable = 0; @@ -387,26 +395,15 @@ wxDbColInf::wxDbColInf() FkCol = 0; FkTableName[0] = 0; pColFor = NULL; -} // wxDbColInf::wxDbColInf() - -/********** wxDbColInf Destructor ********/ -wxDbColInf::~wxDbColInf() -{ - if (pColFor) - delete pColFor; - pColFor = NULL; -} // wxDbColInf::~wxDbColInf() + return true; +} // wxDbColInf::Initialize() /********** wxDbTableInf Constructor ********/ wxDbTableInf::wxDbTableInf() { - tableName[0] = 0; - tableType[0] = 0; - tableRemarks[0] = 0; - numCols = 0; - pColInf = NULL; + Initialize(); } // wxDbTableInf::wxDbTableInf() @@ -419,6 +416,18 @@ wxDbTableInf::~wxDbTableInf() } // wxDbTableInf::~wxDbTableInf() +bool wxDbTableInf::Initialize() +{ + tableName[0] = 0; + tableType[0] = 0; + tableRemarks[0] = 0; + numCols = 0; + pColInf = NULL; + + return true; +} // wxDbTableInf::Initialize() + + /********** wxDbInf Constructor *************/ wxDbInf::wxDbInf() { @@ -436,27 +445,44 @@ wxDbInf::~wxDbInf() /********** wxDbInf::Initialize() *************/ -void wxDbInf::Initialize() +bool wxDbInf::Initialize() { catalog[0] = 0; schema[0] = 0; numTables = 0; pTableInf = NULL; + + return true; } // wxDbInf::Initialize() -/********** wxDb Constructors **********/ +/********** wxDb Constructor **********/ wxDb::wxDb(const HENV &aHenv, bool FwdOnlyCursors) { // Copy the HENV into the db class henv = aHenv; fwdOnlyCursors = FwdOnlyCursors; - Initialize(); + + initialize(); } // wxDb::wxDb() -/********** wxDb::Initialize() **********/ -void wxDb::Initialize() +/********** wxDb Destructor **********/ +wxDb::~wxDb() +{ + wxASSERT_MSG(!IsCached(),wxT("Cached connections must not be manually deleted, use\nwxDbFreeConnection() or wxDbCloseConnections().")); + + if (IsOpen()) + { + Close(); + } +} // wxDb destructor + + + +/********** PRIVATE! wxDb::initialize PRIVATE! **********/ +/********** wxDb::initialize() **********/ +void wxDb::initialize() /* * Private member function that sets all wxDb member variables to * known values at creation of the wxDb @@ -469,11 +495,11 @@ void wxDb::Initialize() nTables = 0; dbmsType = dbmsUNIDENTIFIED; - wxStrcpy(sqlState,wxT("")); - wxStrcpy(errorMsg,wxT("")); + wxStrcpy(sqlState,wxEmptyString); + wxStrcpy(errorMsg,wxEmptyString); nativeError = cbErrorMsg = 0; for (i = 0; i < DB_MAX_ERROR_HISTORY; i++) - wxStrcpy(errorList[i], wxT("")); + wxStrcpy(errorList[i], wxEmptyString); // Init typeInf structures typeInfVarchar.TypeName.Empty(); @@ -500,8 +526,14 @@ void wxDb::Initialize() typeInfDate.CaseSensitive = 0; typeInfDate.MaximumScale = 0; + typeInfBlob.TypeName.Empty(); + typeInfBlob.FsqlType = 0; + typeInfBlob.Precision = 0; + typeInfBlob.CaseSensitive = 0; + typeInfBlob.MaximumScale = 0; + // Error reporting is turned OFF by default - silent = TRUE; + silent = true; // Allocate a data source connection handle if (SQLAllocConnect(henv, &hdbc) != SQL_SUCCESS) @@ -511,8 +543,10 @@ void wxDb::Initialize() DB_STATUS = 0; // Mark database as not open as of yet - dbIsOpen = FALSE; -} // wxDb::Initialize() + dbIsOpen = false; + dbIsCached = false; + dbOpenedWithConnectionString = false; +} // wxDb::initialize() /********** PRIVATE! wxDb::convertUserID PRIVATE! **********/ @@ -534,91 +568,97 @@ const wxChar *wxDb::convertUserID(const wxChar *userID, wxString &UserID) UserID.Empty(); // dBase does not use user names, and some drivers fail if you try to pass one - if (Dbms() == dbmsDBASE) + if ( Dbms() == dbmsDBASE + || Dbms() == dbmsXBASE_SEQUITER ) UserID.Empty(); - // Oracle user names may only be in uppercase, so force - // the name to uppercase - if (Dbms() == dbmsORACLE) + // Some databases require user names to be specified in uppercase, + // so force the name to uppercase + if ((Dbms() == dbmsORACLE) || + (Dbms() == dbmsMAXDB)) UserID = UserID.Upper(); return UserID.c_str(); } // wxDb::convertUserID() -/********** wxDb::Open() **********/ -bool wxDb::Open(const wxString &Dsn, const wxString &Uid, const wxString &AuthStr) +bool wxDb::determineDataTypes(bool failOnDataTypeUnsupported) { - wxASSERT(Dsn.Length()); - dsn = Dsn; - uid = Uid; - authStr = AuthStr; - - RETCODE retcode; + size_t iIndex; - if (!FwdOnlyCursors()) - { - // Specify that the ODBC cursor library be used, if needed. This must be - // specified before the connection is made. - retcode = SQLSetConnectOption(hdbc, SQL_ODBC_CURSORS, SQL_CUR_USE_IF_NEEDED); - -#ifdef DBDEBUG_CONSOLE - if (retcode == SQL_SUCCESS) - cout << wxT("SQLSetConnectOption(CURSOR_LIB) successful") << endl; - else - cout << wxT("SQLSetConnectOption(CURSOR_LIB) failed") << endl; + // These are the possible SQL types we check for use against the datasource we are connected + // to for the purpose of determining which data type to use for the basic character strings + // column types + // + // NOTE: The first type in this enumeration that is determined to be supported by the + // datasource/driver is the one that will be used. + SWORD PossibleSqlCharTypes[] = { +#if wxUSE_UNICODE && defined(SQL_WVARCHAR) + SQL_WVARCHAR, #endif - } - - // Connect to the data source - retcode = SQLConnect(hdbc, (UCHAR FAR *) dsn.c_str(), SQL_NTS, - (UCHAR FAR *) uid.c_str(), SQL_NTS, - (UCHAR FAR *) authStr.c_str(), SQL_NTS); - -/* - if (retcode == SQL_SUCCESS_WITH_INFO) - DispAllErrors(henv, hdbc); - else if (retcode != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); - - if (retcode == SQL_ERROR) - return(DispAllErrors(henv, hdbc)); -*/ - if ((retcode != SQL_SUCCESS) && - (retcode != SQL_SUCCESS_WITH_INFO)) - return(DispAllErrors(henv, hdbc)); - -/* - If using Intersolv branded ODBC drivers, this is the place where you would substitute - your branded driver license information + SQL_VARCHAR, +#if wxUSE_UNICODE && defined(SQL_WVARCHAR) + SQL_WCHAR, +#endif + SQL_CHAR + }; - SQLSetConnectOption(hdbc, 1041, (UDWORD) wxT("")); - SQLSetConnectOption(hdbc, 1042, (UDWORD) wxT("")); -*/ + // These are the possible SQL types we check for use against the datasource we are connected + // to for the purpose of determining which data type to use for the basic non-floating point + // column types + // + // NOTE: The first type in this enumeration that is determined to be supported by the + // datasource/driver is the one that will be used. + SWORD PossibleSqlIntegerTypes[] = { + SQL_INTEGER + }; - // Mark database as open - dbIsOpen = TRUE; + // These are the possible SQL types we check for use against the datasource we are connected + // to for the purpose of determining which data type to use for the basic floating point number + // column types + // + // NOTE: The first type in this enumeration that is determined to be supported by the + // datasource/driver is the one that will be used. + SWORD PossibleSqlFloatTypes[] = { + SQL_DOUBLE, + SQL_REAL, + SQL_FLOAT, + SQL_DECIMAL, + SQL_NUMERIC + }; - // Allocate a statement handle for the database connection - if (SQLAllocStmt(hdbc, &hstmt) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + // These are the possible SQL types we check for use agains the datasource we are connected + // to for the purpose of determining which data type to use for the date/time column types + // + // NOTE: The first type in this enumeration that is determined to be supported by the + // datasource/driver is the one that will be used. + SWORD PossibleSqlDateTypes[] = { + SQL_TIMESTAMP, + SQL_DATE, +#ifdef SQL_DATETIME + SQL_DATETIME +#endif + }; - // Set Connection Options - if (!setConnectionOptions()) - return(FALSE); + // These are the possible SQL types we check for use agains the datasource we are connected + // to for the purpose of determining which data type to use for the BLOB column types. + // + // NOTE: The first type in this enumeration that is determined to be supported by the + // datasource/driver is the one that will be used. + SWORD PossibleSqlBlobTypes[] = { + SQL_LONGVARBINARY, + SQL_VARBINARY + }; - // Query the data source for inf. about itself - if (!getDbInfo()) - return(FALSE); // Query the data source regarding data type information // - // The way I determined which SQL data types to use was by calling SQLGetInfo + // The way it was determined which SQL data types to use was by calling SQLGetInfo // for all of the possible SQL data types to see which ones were supported. If // a type is not supported, the SQLFetch() that's called from getDataTypeInfo() // fails with SQL_NO_DATA_FOUND. This is ugly because I'm sure the three SQL data - // types I've selected below will not alway's be what we want. These are just + // types I've selected below will not always be what we want. These are just // what happened to work against an Oracle 7/Intersolv combination. The following is // a complete list of the results I got back against the Oracle 7 database: // @@ -652,89 +692,225 @@ bool wxDb::Open(const wxString &Dsn, const wxString &Uid, const wxString &AuthSt // SQL_DOUBLE type name = 'DOUBLE', Precision = 15 // SQL_INTEGER type name = 'LONG', Precision = 10 - // VARCHAR = Variable length character string - if (!getDataTypeInfo(SQL_VARCHAR, typeInfVarchar)) - if (!getDataTypeInfo(SQL_CHAR, typeInfVarchar)) - return(FALSE); - else - typeInfVarchar.FsqlType = SQL_CHAR; - else - typeInfVarchar.FsqlType = SQL_VARCHAR; - - // Float - if (!getDataTypeInfo(SQL_DOUBLE,typeInfFloat)) - - if (!getDataTypeInfo(SQL_REAL,typeInfFloat)) - if (!getDataTypeInfo(SQL_FLOAT,typeInfFloat)) - if (!getDataTypeInfo(SQL_DECIMAL,typeInfFloat)) - if (!getDataTypeInfo(SQL_NUMERIC,typeInfFloat)) - return(FALSE); - else - typeInfFloat.FsqlType = SQL_NUMERIC; - else - typeInfFloat.FsqlType = SQL_DECIMAL; - else - typeInfFloat.FsqlType = SQL_FLOAT; - else - typeInfFloat.FsqlType = SQL_REAL; - else - typeInfFloat.FsqlType = SQL_DOUBLE; - - // Integer - if (!getDataTypeInfo(SQL_INTEGER, typeInfInteger)) + // Query the data source for info about itself + if (!getDbInfo(failOnDataTypeUnsupported)) + return false; + + // --------------- Varchar - (Variable length character string) --------------- + for (iIndex = 0; iIndex < WXSIZEOF(PossibleSqlCharTypes) && + !getDataTypeInfo(PossibleSqlCharTypes[iIndex], typeInfVarchar); ++iIndex) + {} + + if (iIndex < WXSIZEOF(PossibleSqlCharTypes)) + typeInfVarchar.FsqlType = PossibleSqlCharTypes[iIndex]; + else if (failOnDataTypeUnsupported) + return false; + + // --------------- Float --------------- + for (iIndex = 0; iIndex < WXSIZEOF(PossibleSqlFloatTypes) && + !getDataTypeInfo(PossibleSqlFloatTypes[iIndex], typeInfFloat); ++iIndex) + {} + + if (iIndex < WXSIZEOF(PossibleSqlFloatTypes)) + typeInfFloat.FsqlType = PossibleSqlFloatTypes[iIndex]; + else if (failOnDataTypeUnsupported) + return false; + + // --------------- Integer ------------- + for (iIndex = 0; iIndex < WXSIZEOF(PossibleSqlIntegerTypes) && + !getDataTypeInfo(PossibleSqlIntegerTypes[iIndex], typeInfInteger); ++iIndex) + {} + + if (iIndex < WXSIZEOF(PossibleSqlIntegerTypes)) + typeInfInteger.FsqlType = PossibleSqlIntegerTypes[iIndex]; + else if (failOnDataTypeUnsupported) { - // If SQL_INTEGER is not supported, use the floating point - // data type to store integers as well as floats + // If no non-floating point data types are supported, we'll + // use the type assigned for floats to store integers as well if (!getDataTypeInfo(typeInfFloat.FsqlType, typeInfInteger)) - return(FALSE); + { + if (failOnDataTypeUnsupported) + return false; + } else typeInfInteger.FsqlType = typeInfFloat.FsqlType; } - else - typeInfInteger.FsqlType = SQL_INTEGER; - // Date/Time - if (Dbms() != dbmsDBASE) - { - if (! getDataTypeInfo(SQL_TIMESTAMP,typeInfDate)) - return(FALSE); - else - typeInfDate.FsqlType = SQL_TIMESTAMP; - } - else - { - if (!getDataTypeInfo(SQL_DATE,typeInfDate)) - return(FALSE); - else - typeInfDate.FsqlType = SQL_DATE; - } + // --------------- Date/Time --------------- + for (iIndex = 0; iIndex < WXSIZEOF(PossibleSqlDateTypes) && + !getDataTypeInfo(PossibleSqlDateTypes[iIndex], typeInfDate); ++iIndex) + {} + + if (iIndex < WXSIZEOF(PossibleSqlDateTypes)) + typeInfDate.FsqlType = PossibleSqlDateTypes[iIndex]; + else if (failOnDataTypeUnsupported) + return false; + + // --------------- BLOB --------------- + for (iIndex = 0; iIndex < WXSIZEOF(PossibleSqlBlobTypes) && + !getDataTypeInfo(PossibleSqlBlobTypes[iIndex], typeInfBlob); ++iIndex) + {} + + if (iIndex < WXSIZEOF(PossibleSqlBlobTypes)) + typeInfBlob.FsqlType = PossibleSqlBlobTypes[iIndex]; + else if (failOnDataTypeUnsupported) + return false; + + return true; +} // wxDb::determineDataTypes + + +bool wxDb::open(bool failOnDataTypeUnsupported) +{ +/* + If using Intersolv branded ODBC drivers, this is the place where you would substitute + your branded driver license information + + SQLSetConnectOption(hdbc, 1041, (UDWORD) wxEmptyString); + SQLSetConnectOption(hdbc, 1042, (UDWORD) wxEmptyString); +*/ + + // Mark database as open + dbIsOpen = true; + + // Allocate a statement handle for the database connection + if (SQLAllocStmt(hdbc, &hstmt) != SQL_SUCCESS) + return(DispAllErrors(henv, hdbc)); + + // Set Connection Options + if (!setConnectionOptions()) + return false; + + if (!determineDataTypes(failOnDataTypeUnsupported)) + return false; #ifdef DBDEBUG_CONSOLE cout << wxT("VARCHAR DATA TYPE: ") << typeInfVarchar.TypeName << endl; cout << wxT("INTEGER DATA TYPE: ") << typeInfInteger.TypeName << endl; cout << wxT("FLOAT DATA TYPE: ") << typeInfFloat.TypeName << endl; cout << wxT("DATE DATA TYPE: ") << typeInfDate.TypeName << endl; + cout << wxT("BLOB DATA TYPE: ") << typeInfBlob.TypeName << endl; cout << endl; #endif // Completed Successfully - return(TRUE); + return true; +} + +bool wxDb::Open(const wxString& inConnectStr, bool failOnDataTypeUnsupported) +{ + wxASSERT(inConnectStr.Length()); + return Open(inConnectStr, NULL, failOnDataTypeUnsupported); +} + +bool wxDb::Open(const wxString& inConnectStr, SQLHWND parentWnd, bool failOnDataTypeUnsupported) +{ + dsn = wxT(""); + uid = wxT(""); + authStr = wxT(""); + + RETCODE retcode; + + if (!FwdOnlyCursors()) + { + // Specify that the ODBC cursor library be used, if needed. This must be + // specified before the connection is made. + retcode = SQLSetConnectOption(hdbc, SQL_ODBC_CURSORS, SQL_CUR_USE_IF_NEEDED); + +#ifdef DBDEBUG_CONSOLE + if (retcode == SQL_SUCCESS) + cout << wxT("SQLSetConnectOption(CURSOR_LIB) successful") << endl; + else + cout << wxT("SQLSetConnectOption(CURSOR_LIB) failed") << endl; +#else + wxUnusedVar(retcode); +#endif + } + + // Connect to the data source + SQLTCHAR outConnectBuffer[SQL_MAX_CONNECTSTR_LEN+1]; // MS recommends at least 1k buffer + short outConnectBufferLen; + + inConnectionStr = inConnectStr; + + retcode = SQLDriverConnect(hdbc, parentWnd, (SQLTCHAR FAR *)inConnectionStr.c_str(), + (SWORD)inConnectionStr.Length(), (SQLTCHAR FAR *)outConnectBuffer, + sizeof(outConnectBuffer), &outConnectBufferLen, SQL_DRIVER_COMPLETE ); + + if ((retcode != SQL_SUCCESS) && + (retcode != SQL_SUCCESS_WITH_INFO)) + return(DispAllErrors(henv, hdbc)); + + outConnectBuffer[outConnectBufferLen] = 0; + outConnectionStr = outConnectBuffer; + dbOpenedWithConnectionString = true; + + return open(failOnDataTypeUnsupported); +} + +/********** wxDb::Open() **********/ +bool wxDb::Open(const wxString &Dsn, const wxString &Uid, const wxString &AuthStr, bool failOnDataTypeUnsupported) +{ + wxASSERT(Dsn.Length()); + dsn = Dsn; + uid = Uid; + authStr = AuthStr; + + inConnectionStr = wxT(""); + outConnectionStr = wxT(""); + + RETCODE retcode; + + if (!FwdOnlyCursors()) + { + // Specify that the ODBC cursor library be used, if needed. This must be + // specified before the connection is made. + retcode = SQLSetConnectOption(hdbc, SQL_ODBC_CURSORS, SQL_CUR_USE_IF_NEEDED); + +#ifdef DBDEBUG_CONSOLE + if (retcode == SQL_SUCCESS) + cout << wxT("SQLSetConnectOption(CURSOR_LIB) successful") << endl; + else + cout << wxT("SQLSetConnectOption(CURSOR_LIB) failed") << endl; +#else + wxUnusedVar( retcode ); +#endif + } + + // Connect to the data source + retcode = SQLConnect(hdbc, (SQLTCHAR FAR *) dsn.c_str(), SQL_NTS, + (SQLTCHAR FAR *) uid.c_str(), SQL_NTS, + (SQLTCHAR FAR *) authStr.c_str(), SQL_NTS); + + if ((retcode != SQL_SUCCESS) && + (retcode != SQL_SUCCESS_WITH_INFO)) + return(DispAllErrors(henv, hdbc)); + + return open(failOnDataTypeUnsupported); } // wxDb::Open() -bool wxDb::Open(wxDbConnectInf *dbConnectInf) +bool wxDb::Open(wxDbConnectInf *dbConnectInf, bool failOnDataTypeUnsupported) { - return Open(dbConnectInf->GetDsn(), dbConnectInf->GetUserID(), - dbConnectInf->GetPassword()); + wxASSERT(dbConnectInf); + + // Use the connection string if one is present + if (dbConnectInf->UseConnectionStr()) + return Open(GetConnectionInStr(), failOnDataTypeUnsupported); + else + return Open(dbConnectInf->GetDsn(), dbConnectInf->GetUserID(), + dbConnectInf->GetPassword(), failOnDataTypeUnsupported); } // wxDb::Open() bool wxDb::Open(wxDb *copyDb) { - dsn = copyDb->GetDatasourceName(); - uid = copyDb->GetUsername(); - authStr = copyDb->GetPassword(); + dsn = copyDb->GetDatasourceName(); + uid = copyDb->GetUsername(); + authStr = copyDb->GetPassword(); + inConnectionStr = copyDb->GetConnectionInStr(); + outConnectionStr = copyDb->GetConnectionOutStr(); RETCODE retcode; @@ -749,27 +925,53 @@ bool wxDb::Open(wxDb *copyDb) cout << wxT("SQLSetConnectOption(CURSOR_LIB) successful") << endl; else cout << wxT("SQLSetConnectOption(CURSOR_LIB) failed") << endl; +#else + wxUnusedVar( retcode ); #endif } - // Connect to the data source - retcode = SQLConnect(hdbc, (UCHAR FAR *) dsn.c_str(), SQL_NTS, - (UCHAR FAR *) uid.c_str(), SQL_NTS, - (UCHAR FAR *) authStr.c_str(), SQL_NTS); + if (copyDb->OpenedWithConnectionString()) + { + // Connect to the data source + SQLTCHAR outConnectBuffer[SQL_MAX_CONNECTSTR_LEN+1]; + short outConnectBufferLen; + + inConnectionStr = copyDb->GetConnectionInStr(); + + retcode = SQLDriverConnect(hdbc, NULL, (SQLTCHAR FAR *)inConnectionStr.c_str(), + (SWORD)inConnectionStr.Length(), (SQLTCHAR FAR *)outConnectBuffer, + sizeof(outConnectBuffer), &outConnectBufferLen, SQL_DRIVER_COMPLETE); + + if ((retcode != SQL_SUCCESS) && + (retcode != SQL_SUCCESS_WITH_INFO)) + return(DispAllErrors(henv, hdbc)); - if (retcode == SQL_ERROR) - return(DispAllErrors(henv, hdbc)); + outConnectBuffer[outConnectBufferLen] = 0; + outConnectionStr = outConnectBuffer; + dbOpenedWithConnectionString = true; + } + else + { + // Connect to the data source + retcode = SQLConnect(hdbc, (SQLTCHAR FAR *) dsn.c_str(), SQL_NTS, + (SQLTCHAR FAR *) uid.c_str(), SQL_NTS, + (SQLTCHAR FAR *) authStr.c_str(), SQL_NTS); + } + + if ((retcode != SQL_SUCCESS) && + (retcode != SQL_SUCCESS_WITH_INFO)) + return(DispAllErrors(henv, hdbc)); /* If using Intersolv branded ODBC drivers, this is the place where you would substitute your branded driver license information - SQLSetConnectOption(hdbc, 1041, (UDWORD) wxT("")); - SQLSetConnectOption(hdbc, 1042, (UDWORD) wxT("")); + SQLSetConnectOption(hdbc, 1041, (UDWORD) wxEmptyString); + SQLSetConnectOption(hdbc, 1042, (UDWORD) wxEmptyString); */ // Mark database as open - dbIsOpen = TRUE; + dbIsOpen = true; // Allocate a statement handle for the database connection if (SQLAllocStmt(hdbc, &hstmt) != SQL_SUCCESS) @@ -777,7 +979,7 @@ bool wxDb::Open(wxDb *copyDb) // Set Connection Options if (!setConnectionOptions()) - return(FALSE); + return false; // Instead of Querying the data source for info about itself, it can just be copied // from the wxDb instance that was passed in (copyDb). @@ -841,16 +1043,24 @@ bool wxDb::Open(wxDb *copyDb) typeInfDate.CaseSensitive = copyDb->typeInfDate.CaseSensitive; typeInfDate.MaximumScale = copyDb->typeInfDate.MaximumScale; + // Blob + typeInfBlob.FsqlType = copyDb->typeInfBlob.FsqlType; + typeInfBlob.TypeName = copyDb->typeInfBlob.TypeName; + typeInfBlob.Precision = copyDb->typeInfBlob.Precision; + typeInfBlob.CaseSensitive = copyDb->typeInfBlob.CaseSensitive; + typeInfBlob.MaximumScale = copyDb->typeInfBlob.MaximumScale; + #ifdef DBDEBUG_CONSOLE cout << wxT("VARCHAR DATA TYPE: ") << typeInfVarchar.TypeName << endl; cout << wxT("INTEGER DATA TYPE: ") << typeInfInteger.TypeName << endl; cout << wxT("FLOAT DATA TYPE: ") << typeInfFloat.TypeName << endl; cout << wxT("DATE DATA TYPE: ") << typeInfDate.TypeName << endl; + cout << wxT("BLOB DATA TYPE: ") << typeInfBlob.TypeName << endl; cout << endl; #endif // Completed Successfully - return(TRUE); + return true; } // wxDb::Open() 2 @@ -864,12 +1074,15 @@ bool wxDb::setConnectionOptions(void) // I need to get the DBMS name here, because some of the connection options // are database specific and need to call the Dbms() function. - if (SQLGetInfo(hdbc, SQL_DBMS_NAME, (UCHAR*) dbInf.dbmsName, 40, &cb) != SQL_SUCCESS) + RETCODE retcode; + + retcode = SQLGetInfo(hdbc, SQL_DBMS_NAME, (UCHAR *) dbInf.dbmsName, sizeof(dbInf.dbmsName), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) return(DispAllErrors(henv, hdbc)); - SQLSetConnectOption(hdbc, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF); - SQLSetConnectOption(hdbc, SQL_OPT_TRACE, SQL_OPT_TRACE_OFF); -// SQLSetConnectOption(hdbc, SQL_TXN_ISOLATION, SQL_TXN_READ_COMMITTED); // No dirty reads + /* retcode = */ SQLSetConnectOption(hdbc, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF); + /* retcode = */ SQLSetConnectOption(hdbc, SQL_OPT_TRACE, SQL_OPT_TRACE_OFF); +// SQLSetConnectOption(hdbc, SQL_TXN_ISOLATION, SQL_TXN_READ_COMMITTED); // No dirty reads // By default, MS Sql Server closes cursors on commit and rollback. The following // call to SQLSetConnectOption() is needed to force SQL Server to preserve cursors @@ -880,7 +1093,7 @@ bool wxDb::setConnectionOptions(void) { const long SQL_PRESERVE_CURSORS = 1204L; const long SQL_PC_ON = 1L; - SQLSetConnectOption(hdbc, SQL_PRESERVE_CURSORS, SQL_PC_ON); + /* retcode = */ SQLSetConnectOption(hdbc, SQL_PRESERVE_CURSORS, SQL_PC_ON); } // Display the connection options to verify them @@ -888,15 +1101,17 @@ bool wxDb::setConnectionOptions(void) long l; cout << wxT("****** CONNECTION OPTIONS ******") << endl; - if (SQLGetConnectOption(hdbc, SQL_AUTOCOMMIT, &l) != SQL_SUCCESS) + retcode = SQLGetConnectOption(hdbc, SQL_AUTOCOMMIT, &l); + if (retcode != SQL_SUCCESS) return(DispAllErrors(henv, hdbc)); cout << wxT("AUTOCOMMIT: ") << (l == SQL_AUTOCOMMIT_OFF ? "OFF" : "ON") << endl; - if (SQLGetConnectOption(hdbc, SQL_ODBC_CURSORS, &l) != SQL_SUCCESS) + retcode = SQLGetConnectOption(hdbc, SQL_ODBC_CURSORS, &l); + if (retcode != SQL_SUCCESS) return(DispAllErrors(henv, hdbc)); cout << wxT("ODBC CURSORS: "); switch(l) - { + { case(SQL_CUR_USE_IF_NEEDED): cout << wxT("SQL_CUR_USE_IF_NEEDED"); break; @@ -906,10 +1121,11 @@ bool wxDb::setConnectionOptions(void) case(SQL_CUR_USE_DRIVER): cout << wxT("SQL_CUR_USE_DRIVER"); break; - } - cout << endl; + } + cout << endl; - if (SQLGetConnectOption(hdbc, SQL_OPT_TRACE, &l) != SQL_SUCCESS) + retcode = SQLGetConnectOption(hdbc, SQL_OPT_TRACE, &l) + if (retcode != SQL_SUCCESS) return(DispAllErrors(henv, hdbc)); cout << wxT("TRACING: ") << (l == SQL_OPT_TRACE_OFF ? wxT("OFF") : wxT("ON")) << endl; @@ -917,119 +1133,269 @@ bool wxDb::setConnectionOptions(void) #endif // Completed Successfully - return(TRUE); + return true; } // wxDb::setConnectionOptions() /********** wxDb::getDbInfo() **********/ -bool wxDb::getDbInfo(void) +bool wxDb::getDbInfo(bool failOnDataTypeUnsupported) { SWORD cb; RETCODE retcode; - if (SQLGetInfo(hdbc, SQL_SERVER_NAME, (UCHAR*) dbInf.serverName, 80, &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_SERVER_NAME, (UCHAR*) dbInf.serverName, sizeof(dbInf.serverName), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_DATABASE_NAME, (UCHAR*) dbInf.databaseName, 128, &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_DATABASE_NAME, (UCHAR*) dbInf.databaseName, sizeof(dbInf.databaseName), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_DBMS_NAME, (UCHAR*) dbInf.dbmsName, 40, &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_DBMS_NAME, (UCHAR*) dbInf.dbmsName, sizeof(dbInf.dbmsName), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } // 16-Mar-1999 // After upgrading to MSVC6, the original 20 char buffer below was insufficient, // causing database connectivity to fail in some cases. - retcode = SQLGetInfo(hdbc, SQL_DBMS_VER, (UCHAR*) dbInf.dbmsVer, 64, &cb); - + retcode = SQLGetInfo(hdbc, SQL_DBMS_VER, (UCHAR*) dbInf.dbmsVer, sizeof(dbInf.dbmsVer), &cb); if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) - return(DispAllErrors(henv, hdbc)); + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_ACTIVE_CONNECTIONS, (UCHAR*) &dbInf.maxConnections, sizeof(dbInf.maxConnections), &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_ACTIVE_CONNECTIONS, (UCHAR*) &dbInf.maxConnections, sizeof(dbInf.maxConnections), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_ACTIVE_STATEMENTS, (UCHAR*) &dbInf.maxStmts, sizeof(dbInf.maxStmts), &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_ACTIVE_STATEMENTS, (UCHAR*) &dbInf.maxStmts, sizeof(dbInf.maxStmts), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_DRIVER_NAME, (UCHAR*) dbInf.driverName, 40, &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_DRIVER_NAME, (UCHAR*) dbInf.driverName, sizeof(dbInf.driverName), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_DRIVER_ODBC_VER, (UCHAR*) dbInf.odbcVer, 60, &cb) == SQL_ERROR) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_DRIVER_ODBC_VER, (UCHAR*) dbInf.odbcVer, sizeof(dbInf.odbcVer), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - retcode = SQLGetInfo(hdbc, SQL_ODBC_VER, (UCHAR*) dbInf.drvMgrOdbcVer, 60, &cb); + retcode = SQLGetInfo(hdbc, SQL_ODBC_VER, (UCHAR*) dbInf.drvMgrOdbcVer, sizeof(dbInf.drvMgrOdbcVer), &cb); if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) - return(DispAllErrors(henv, hdbc)); + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_DRIVER_VER, (UCHAR*) dbInf.driverVer, 60, &cb) == SQL_ERROR) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_DRIVER_VER, (UCHAR*) dbInf.driverVer, sizeof(dbInf.driverVer), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_ODBC_API_CONFORMANCE, (UCHAR*) &dbInf.apiConfLvl, sizeof(dbInf.apiConfLvl), &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_ODBC_API_CONFORMANCE, (UCHAR*) &dbInf.apiConfLvl, sizeof(dbInf.apiConfLvl), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_ODBC_SAG_CLI_CONFORMANCE, (UCHAR*) &dbInf.cliConfLvl, sizeof(dbInf.cliConfLvl), &cb) != SQL_SUCCESS) -// return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_ODBC_SAG_CLI_CONFORMANCE, (UCHAR*) &dbInf.cliConfLvl, sizeof(dbInf.cliConfLvl), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) { // Not all drivers support this call - Nick Gorham(unixODBC) dbInf.cliConfLvl = 0; + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; } - if (SQLGetInfo(hdbc, SQL_ODBC_SQL_CONFORMANCE, (UCHAR*) &dbInf.sqlConfLvl, sizeof(dbInf.sqlConfLvl), &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_ODBC_SQL_CONFORMANCE, (UCHAR*) &dbInf.sqlConfLvl, sizeof(dbInf.sqlConfLvl), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_OUTER_JOINS, (UCHAR*) dbInf.outerJoins, 2, &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_OUTER_JOINS, (UCHAR*) dbInf.outerJoins, sizeof(dbInf.outerJoins), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_PROCEDURES, (UCHAR*) dbInf.procedureSupport, 2, &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_PROCEDURES, (UCHAR*) dbInf.procedureSupport, sizeof(dbInf.procedureSupport), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_ACCESSIBLE_TABLES, (UCHAR*) dbInf.accessibleTables, 2, &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_ACCESSIBLE_TABLES, (UCHAR*) dbInf.accessibleTables, sizeof(dbInf.accessibleTables), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_CURSOR_COMMIT_BEHAVIOR, (UCHAR*) &dbInf.cursorCommitBehavior, sizeof(dbInf.cursorCommitBehavior), &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_CURSOR_COMMIT_BEHAVIOR, (UCHAR*) &dbInf.cursorCommitBehavior, sizeof(dbInf.cursorCommitBehavior), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_CURSOR_ROLLBACK_BEHAVIOR, (UCHAR*) &dbInf.cursorRollbackBehavior, sizeof(dbInf.cursorRollbackBehavior), &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_CURSOR_ROLLBACK_BEHAVIOR, (UCHAR*) &dbInf.cursorRollbackBehavior, sizeof(dbInf.cursorRollbackBehavior), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_NON_NULLABLE_COLUMNS, (UCHAR*) &dbInf.supportNotNullClause, sizeof(dbInf.supportNotNullClause), &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_NON_NULLABLE_COLUMNS, (UCHAR*) &dbInf.supportNotNullClause, sizeof(dbInf.supportNotNullClause), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_ODBC_SQL_OPT_IEF, (UCHAR*) dbInf.supportIEF, 2, &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_ODBC_SQL_OPT_IEF, (UCHAR*) dbInf.supportIEF, sizeof(dbInf.supportIEF), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_DEFAULT_TXN_ISOLATION, (UCHAR*) &dbInf.txnIsolation, sizeof(dbInf.txnIsolation), &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_DEFAULT_TXN_ISOLATION, (UCHAR*) &dbInf.txnIsolation, sizeof(dbInf.txnIsolation), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_TXN_ISOLATION_OPTION, (UCHAR*) &dbInf.txnIsolationOptions, sizeof(dbInf.txnIsolationOptions), &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_TXN_ISOLATION_OPTION, (UCHAR*) &dbInf.txnIsolationOptions, sizeof(dbInf.txnIsolationOptions), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_FETCH_DIRECTION, (UCHAR*) &dbInf.fetchDirections, sizeof(dbInf.fetchDirections), &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_FETCH_DIRECTION, (UCHAR*) &dbInf.fetchDirections, sizeof(dbInf.fetchDirections), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_LOCK_TYPES, (UCHAR*) &dbInf.lockTypes, sizeof(dbInf.lockTypes), &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_LOCK_TYPES, (UCHAR*) &dbInf.lockTypes, sizeof(dbInf.lockTypes), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_POS_OPERATIONS, (UCHAR*) &dbInf.posOperations, sizeof(dbInf.posOperations), &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_POS_OPERATIONS, (UCHAR*) &dbInf.posOperations, sizeof(dbInf.posOperations), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_POSITIONED_STATEMENTS, (UCHAR*) &dbInf.posStmts, sizeof(dbInf.posStmts), &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_POSITIONED_STATEMENTS, (UCHAR*) &dbInf.posStmts, sizeof(dbInf.posStmts), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_SCROLL_CONCURRENCY, (UCHAR*) &dbInf.scrollConcurrency, sizeof(dbInf.scrollConcurrency), &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_SCROLL_CONCURRENCY, (UCHAR*) &dbInf.scrollConcurrency, sizeof(dbInf.scrollConcurrency), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_SCROLL_OPTIONS, (UCHAR*) &dbInf.scrollOptions, sizeof(dbInf.scrollOptions), &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_SCROLL_OPTIONS, (UCHAR*) &dbInf.scrollOptions, sizeof(dbInf.scrollOptions), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_STATIC_SENSITIVITY, (UCHAR*) &dbInf.staticSensitivity, sizeof(dbInf.staticSensitivity), &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_STATIC_SENSITIVITY, (UCHAR*) &dbInf.staticSensitivity, sizeof(dbInf.staticSensitivity), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_TXN_CAPABLE, (UCHAR*) &dbInf.txnCapable, sizeof(dbInf.txnCapable), &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_TXN_CAPABLE, (UCHAR*) &dbInf.txnCapable, sizeof(dbInf.txnCapable), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } - if (SQLGetInfo(hdbc, SQL_LOGIN_TIMEOUT, (UCHAR*) &dbInf.loginTimeout, sizeof(dbInf.loginTimeout), &cb) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc)); + retcode = SQLGetInfo(hdbc, SQL_LOGIN_TIMEOUT, (UCHAR*) &dbInf.loginTimeout, sizeof(dbInf.loginTimeout), &cb); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) + { + DispAllErrors(henv, hdbc); + if (failOnDataTypeUnsupported) + return false; + } #ifdef DBDEBUG_CONSOLE cout << wxT("***** DATA SOURCE INFORMATION *****") << endl; @@ -1227,7 +1593,7 @@ bool wxDb::getDbInfo(void) #endif // Completed Successfully - return(TRUE); + return true; } // wxDb::getDbInfo() @@ -1242,26 +1608,29 @@ bool wxDb::getDataTypeInfo(SWORD fSqlType, wxDbSqlTypeInfo &structSQLTypeInfo) * wxDbSqlTypeInfo is a structure that is filled in with data type information, */ RETCODE retcode; - SDWORD cbRet; + SQLLEN cbRet; // Get information about the data type specified if (SQLGetTypeInfo(hstmt, fSqlType) != SQL_SUCCESS) return(DispAllErrors(henv, hdbc, hstmt)); + // Fetch the record - if ((retcode = SQLFetch(hstmt)) != SQL_SUCCESS) + retcode = SQLFetch(hstmt); + if (retcode != SQL_SUCCESS) { #ifdef DBDEBUG_CONSOLE if (retcode == SQL_NO_DATA_FOUND) - cout << wxT("SQL_NO_DATA_FOUND fetching inf. about data type.") << endl; + cout << wxT("SQL_NO_DATA_FOUND fetching information about data type.") << endl; #endif DispAllErrors(henv, hdbc, hstmt); SQLFreeStmt(hstmt, SQL_CLOSE); - return(FALSE); + return false; } wxChar typeName[DB_TYPE_NAME_LEN+1]; + // Obtain columns from the record - if (SQLGetData(hstmt, 1, SQL_C_CHAR, (UCHAR*) typeName, DB_TYPE_NAME_LEN, &cbRet) != SQL_SUCCESS) + if (SQLGetData(hstmt, 1, SQL_C_WXCHAR, typeName, sizeof(typeName), &cbRet) != SQL_SUCCESS) return(DispAllErrors(henv, hdbc, hstmt)); structSQLTypeInfo.TypeName = typeName; @@ -1312,7 +1681,7 @@ bool wxDb::getDataTypeInfo(SWORD fSqlType, wxDbSqlTypeInfo &structSQLTypeInfo) return(DispAllErrors(henv, hdbc, hstmt)); // Completed Successfully - return(TRUE); + return true; } // wxDb::getDataTypeInfo() @@ -1347,19 +1716,19 @@ void wxDb::Close(void) #ifdef __WXDEBUG__ wxTablesInUse *tiu; - wxNode *pNode; - pNode = TablesInUse.First(); + wxList::compatibility_iterator pNode; + pNode = TablesInUse.GetFirst(); wxString s,s2; while (pNode) { - tiu = (wxTablesInUse *)pNode->Data(); + tiu = (wxTablesInUse *)pNode->GetData(); if (tiu->pDb == this) { s.Printf(wxT("(%-20s) tableID:[%6lu] pDb:[%p]"), tiu->tableName,tiu->tableID,tiu->pDb); - s2.Printf(wxT("Orphaned found using pDb:[%p]"),this); - wxLogDebug (s,s2); + s2.Printf(wxT("Orphaned table found using pDb:[%p]"),this); + wxLogDebug(s.c_str(),s2.c_str()); } - pNode = pNode->Next(); + pNode = pNode->GetNext(); } #endif @@ -1368,8 +1737,8 @@ void wxDb::Close(void) for (i = 0; i < DB_MAX_ERROR_HISTORY; i++) wxStrcpy(DBerrorList[i], errorList[i]); - dbmsType = dbmsUNIDENTIFIED; - dbIsOpen = FALSE; + dbmsType = dbmsUNIDENTIFIED; + dbIsOpen = false; } // wxDb::Close() @@ -1385,7 +1754,7 @@ bool wxDb::CommitTrans(void) } // Completed successfully - return(TRUE); + return true; } // wxDb::CommitTrans() @@ -1398,7 +1767,7 @@ bool wxDb::RollbackTrans(void) return(DispAllErrors(henv, hdbc)); // Completed successfully - return(TRUE); + return true; } // wxDb::RollbackTrans() @@ -1408,22 +1777,22 @@ bool wxDb::DispAllErrors(HENV aHenv, HDBC aHdbc, HSTMT aHstmt) /* * This function is called internally whenever an error condition prevents the user's * request from being executed. This function will query the datasource as to the - * actual error(s) that just occured on the previous request of the datasource. + * actual error(s) that just occurred on the previous request of the datasource. * * The function will retrieve each error condition from the datasource and * Printf the codes/text values into a string which it then logs via logError(). * If in DBDEBUG_CONSOLE mode, the constructed string will be displayed in the console * window and program execution will be paused until the user presses a key. * - * This function always returns a FALSE, so that functions which call this function + * This function always returns false, so that functions which call this function * can have a line like "return (DispAllErrors(henv, hdbc));" to indicate the failure - * of the users request, so that the calling code can then process the error msg log + * of the user's request, so that the calling code can then process the error message log. */ { wxString odbcErrMsg; - while (SQLError(aHenv, aHdbc, aHstmt, (UCHAR FAR *) sqlState, &nativeError, (UCHAR FAR *) errorMsg, SQL_MAX_MESSAGE_LENGTH - 1, &cbErrorMsg) == SQL_SUCCESS) - { + while (SQLError(aHenv, aHdbc, aHstmt, (SQLTCHAR FAR *) sqlState, &nativeError, (SQLTCHAR FAR *) errorMsg, SQL_MAX_MESSAGE_LENGTH - 1, &cbErrorMsg) == SQL_SUCCESS) + { odbcErrMsg.Printf(wxT("SQL State = %s\nNative Error Code = %li\nError Message = %s\n"), sqlState, nativeError, errorMsg); logError(odbcErrMsg, sqlState); if (!silent) @@ -1441,7 +1810,7 @@ bool wxDb::DispAllErrors(HENV aHenv, HDBC aHdbc, HSTMT aHstmt) } } - return(FALSE); // This function always returns false. + return false; // This function always returns false. } // wxDb::DispAllErrors() @@ -1449,10 +1818,10 @@ bool wxDb::DispAllErrors(HENV aHenv, HDBC aHdbc, HSTMT aHstmt) /********** wxDb::GetNextError() **********/ bool wxDb::GetNextError(HENV aHenv, HDBC aHdbc, HSTMT aHstmt) { - if (SQLError(aHenv, aHdbc, aHstmt, (UCHAR FAR *) sqlState, &nativeError, (UCHAR FAR *) errorMsg, SQL_MAX_MESSAGE_LENGTH - 1, &cbErrorMsg) == SQL_SUCCESS) - return(TRUE); + if (SQLError(aHenv, aHdbc, aHstmt, (SQLTCHAR FAR *) sqlState, &nativeError, (SQLTCHAR FAR *) errorMsg, SQL_MAX_MESSAGE_LENGTH - 1, &cbErrorMsg) == SQL_SUCCESS) + return true; else - return(FALSE); + return false; } // wxDb::GetNextError() @@ -1493,12 +1862,13 @@ void wxDb::logError(const wxString &errMsg, const wxString &SQLState) if (++pLast == DB_MAX_ERROR_HISTORY) { int i; - for (i = 0; i < DB_MAX_ERROR_HISTORY; i++) + for (i = 0; i < DB_MAX_ERROR_HISTORY-1; i++) wxStrcpy(errorList[i], errorList[i+1]); pLast--; } - wxStrcpy(errorList[pLast], errMsg); + wxStrncpy(errorList[pLast], errMsg, DB_MAX_ERROR_MSG_LEN); + errorList[pLast][DB_MAX_ERROR_MSG_LEN] = 0; if (SQLState.Length()) if ((dbStatus = TranslateSqlState(SQLState)) != DB_ERR_FUNCTION_SEQUENCE_ERROR) @@ -1736,7 +2106,7 @@ bool wxDb::Grant(int privileges, const wxString &tableName, const wxString &user } sqlStmt += wxT(" ON "); - sqlStmt += tableName; + sqlStmt += SQLTableName(tableName); sqlStmt += wxT(" TO "); sqlStmt += userList; @@ -1759,7 +2129,7 @@ bool wxDb::CreateView(const wxString &viewName, const wxString &colList, // Drop the view first if (attemptDrop && !DropView(viewName)) - return FALSE; + return false; // Build the create view statement sqlStmt = wxT("CREATE VIEW "); @@ -1790,7 +2160,7 @@ bool wxDb::CreateView(const wxString &viewName, const wxString &colList, bool wxDb::DropView(const wxString &viewName) { /* - * NOTE: This function returns TRUE if the View does not exist, but + * NOTE: This function returns true if the View does not exist, but * only for identified databases. Code will need to be added * below for any other databases when those databases are defined * to handle this situation consistently @@ -1805,7 +2175,7 @@ bool wxDb::DropView(const wxString &viewName) cout << endl << sqlStmt.c_str() << endl; #endif - if (SQLExecDirect(hstmt, (UCHAR FAR *) sqlStmt.c_str(), SQL_NTS) != SQL_SUCCESS) + if (SQLExecDirect(hstmt, (SQLTCHAR FAR *) sqlStmt.c_str(), SQL_NTS) != SQL_SUCCESS) { // Check for "Base table not found" error and ignore GetNextError(henv, hdbc, hstmt); @@ -1817,16 +2187,16 @@ bool wxDb::DropView(const wxString &viewName) DispNextError(); DispAllErrors(henv, hdbc, hstmt); RollbackTrans(); - return(FALSE); + return false; } } } // Commit the transaction - if (! CommitTrans()) - return(FALSE); + if (!CommitTrans()) + return false; - return TRUE; + return true; } // wxDb::DropView() @@ -1834,61 +2204,168 @@ bool wxDb::DropView(const wxString &viewName) /********** wxDb::ExecSql() **********/ bool wxDb::ExecSql(const wxString &pSqlStmt) { + RETCODE retcode; + SQLFreeStmt(hstmt, SQL_CLOSE); - if (SQLExecDirect(hstmt, (UCHAR FAR *) pSqlStmt.c_str(), SQL_NTS) == SQL_SUCCESS) - return(TRUE); + + retcode = SQLExecDirect(hstmt, (SQLTCHAR FAR *) pSqlStmt.c_str(), SQL_NTS); + if (retcode == SQL_SUCCESS || + (Dbms() == dbmsDB2 && (retcode == SQL_SUCCESS_WITH_INFO || retcode == SQL_NO_DATA_FOUND))) + { + return true; + } else { DispAllErrors(henv, hdbc, hstmt); - return(FALSE); + return false; } } // wxDb::ExecSql() +/********** wxDb::ExecSql() with column info **********/ +bool wxDb::ExecSql(const wxString &pSqlStmt, wxDbColInf** columns, short& numcols) +{ + //execute the statement first + if (!ExecSql(pSqlStmt)) + return false; + + SWORD noCols; + if (SQLNumResultCols(hstmt, &noCols) != SQL_SUCCESS) + { + DispAllErrors(henv, hdbc, hstmt); + return false; + } + + if (noCols == 0) + return false; + else + numcols = noCols; + + // Get column information + short colNum; + wxChar name[DB_MAX_COLUMN_NAME_LEN+1]; + SWORD Sword; + SQLLEN Sqllen; + wxDbColInf* pColInf = new wxDbColInf[noCols]; + + // Fill in column information (name, datatype) + for (colNum = 0; colNum < noCols; colNum++) + { + if (SQLColAttributes(hstmt, (UWORD)(colNum+1), SQL_COLUMN_NAME, + name, sizeof(name), + &Sword, &Sqllen) != SQL_SUCCESS) + { + DispAllErrors(henv, hdbc, hstmt); + delete[] pColInf; + return false; + } + + wxStrncpy(pColInf[colNum].colName, name, DB_MAX_COLUMN_NAME_LEN); + pColInf[colNum].colName[DB_MAX_COLUMN_NAME_LEN] = 0; // Prevent buffer overrun + + if (SQLColAttributes(hstmt, (UWORD)(colNum+1), SQL_COLUMN_TYPE, + NULL, 0, &Sword, &Sqllen) != SQL_SUCCESS) + { + DispAllErrors(henv, hdbc, hstmt); + delete[] pColInf; + return false; + } + + switch (Sqllen) + { +#if wxUSE_UNICODE + #if defined(SQL_WCHAR) + case SQL_WCHAR: + #endif + #if defined(SQL_WVARCHAR) + case SQL_WVARCHAR: + #endif +#endif + case SQL_VARCHAR: + case SQL_CHAR: + pColInf[colNum].dbDataType = DB_DATA_TYPE_VARCHAR; + break; + case SQL_TINYINT: + case SQL_SMALLINT: + case SQL_INTEGER: + case SQL_BIT: + pColInf[colNum].dbDataType = DB_DATA_TYPE_INTEGER; + break; + case SQL_DOUBLE: + case SQL_DECIMAL: + case SQL_NUMERIC: + case SQL_FLOAT: + case SQL_REAL: + pColInf[colNum].dbDataType = DB_DATA_TYPE_FLOAT; + break; + case SQL_DATE: + case SQL_TIMESTAMP: + pColInf[colNum].dbDataType = DB_DATA_TYPE_DATE; + break; + case SQL_BINARY: + pColInf[colNum].dbDataType = DB_DATA_TYPE_BLOB; + break; +#ifdef __WXDEBUG__ + default: + wxString errMsg; + errMsg.Printf(wxT("SQL Data type %ld currently not supported by wxWidgets"), (long)Sqllen); + wxLogDebug(errMsg,wxT("ODBC DEBUG MESSAGE")); +#endif + } + } + + *columns = pColInf; + return true; +} // wxDb::ExecSql() + /********** wxDb::GetNext() **********/ bool wxDb::GetNext(void) { if (SQLFetch(hstmt) == SQL_SUCCESS) - return(TRUE); + return true; else { DispAllErrors(henv, hdbc, hstmt); - return(FALSE); + return false; } } // wxDb::GetNext() /********** wxDb::GetData() **********/ -bool wxDb::GetData(UWORD colNo, SWORD cType, PTR pData, SDWORD maxLen, SDWORD FAR *cbReturned) +bool wxDb::GetData(UWORD colNo, SWORD cType, PTR pData, SDWORD maxLen, SQLLEN FAR *cbReturned) { wxASSERT(pData); wxASSERT(cbReturned); - if (SQLGetData(hstmt, colNo, cType, pData, maxLen, cbReturned) == SQL_SUCCESS) - return(TRUE); + long bufferSize = maxLen; + + if (cType == SQL_C_WXCHAR) + bufferSize = maxLen * sizeof(wxChar); + + if (SQLGetData(hstmt, colNo, cType, pData, bufferSize, cbReturned) == SQL_SUCCESS) + return true; else { DispAllErrors(henv, hdbc, hstmt); - return(FALSE); + return false; } } // wxDb::GetData() /********** wxDb::GetKeyFields() **********/ -int wxDb::GetKeyFields(const wxString &tableName, wxDbColInf* colInf, int noCols) +int wxDb::GetKeyFields(const wxString &tableName, wxDbColInf* colInf, UWORD noCols) { wxChar szPkTable[DB_MAX_TABLE_NAME_LEN+1]; /* Primary key table name */ wxChar szFkTable[DB_MAX_TABLE_NAME_LEN+1]; /* Foreign key table name */ - short iKeySeq; -// SQLSMALLINT iKeySeq; + SWORD iKeySeq; wxChar szPkCol[DB_MAX_COLUMN_NAME_LEN+1]; /* Primary key column */ wxChar szFkCol[DB_MAX_COLUMN_NAME_LEN+1]; /* Foreign key column */ SQLRETURN retcode; - SDWORD cb; - int i; + SQLLEN cb; + SWORD i; wxString tempStr; /* * ----------------------------------------------------------------------- @@ -1909,7 +2386,7 @@ int wxDb::GetKeyFields(const wxString &tableName, wxDbColInf* colInf, int noCols retcode = SQLPrimaryKeys(hstmt, NULL, 0, /* Catalog name */ NULL, 0, /* Schema name */ - (UCHAR FAR *) tableName.c_str(), SQL_NTS); /* Table name */ + (SQLTCHAR FAR *) tableName.c_str(), SQL_NTS); /* Table name */ /*---------------------------------------------------------------------*/ /* Fetch and display the result set. This will be a list of the */ @@ -1920,7 +2397,7 @@ int wxDb::GetKeyFields(const wxString &tableName, wxDbColInf* colInf, int noCols retcode = SQLFetch(hstmt); if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) { - GetData( 4, SQL_C_CHAR, szPkCol, DB_MAX_COLUMN_NAME_LEN+1, &cb); + GetData( 4, SQL_C_WXCHAR, szPkCol, DB_MAX_COLUMN_NAME_LEN+1, &cb); GetData( 5, SQL_C_SSHORT, &iKeySeq, 0, &cb); //------- for (i=0;inumTables == 0) { - GetData( 1, SQL_C_CHAR, (UCHAR*) pDbInf->catalog, 128+1, &cb); - GetData( 2, SQL_C_CHAR, (UCHAR*) pDbInf->schema, 128+1, &cb); + GetData( 1, SQL_C_WXCHAR, (UCHAR*) pDbInf->catalog, 128+1, &cb); + GetData( 2, SQL_C_WXCHAR, (UCHAR*) pDbInf->schema, 128+1, &cb); } pDbInf->numTables++; // Counter for Tables } // if (pass == 1) @@ -2872,9 +3373,9 @@ wxDbInf *wxDb::GetCatalog(const wxChar *userID) noTab = 0; } // if (pDbInf->pTableInf == NULL) // Has the Table Array been created - GetData( 3, SQL_C_CHAR, (UCHAR*) (pDbInf->pTableInf+noTab)->tableName, DB_MAX_TABLE_NAME_LEN+1, &cb); - GetData( 4, SQL_C_CHAR, (UCHAR*) (pDbInf->pTableInf+noTab)->tableType, 30+1, &cb); - GetData( 5, SQL_C_CHAR, (UCHAR*) (pDbInf->pTableInf+noTab)->tableRemarks, 254+1, &cb); + GetData( 3, SQL_C_WXCHAR, (UCHAR*) (pDbInf->pTableInf+noTab)->tableName, DB_MAX_TABLE_NAME_LEN+1, &cb); + GetData( 4, SQL_C_WXCHAR, (UCHAR*) (pDbInf->pTableInf+noTab)->tableType, 30+1, &cb); + GetData( 5, SQL_C_WXCHAR, (UCHAR*) (pDbInf->pTableInf+noTab)->tableRemarks, 254+1, &cb); noTab++; } // if @@ -2885,7 +3386,7 @@ wxDbInf *wxDb::GetCatalog(const wxChar *userID) // Query how many columns are in each table for (noTab=0;noTabnumTables;noTab++) { - (pDbInf->pTableInf+noTab)->numCols = GetColumnCount((pDbInf->pTableInf+noTab)->tableName,UserID); + (pDbInf->pTableInf+noTab)->numCols = (UWORD)GetColumnCount((pDbInf->pTableInf+noTab)->tableName,UserID); } return pDbInf; @@ -2913,31 +3414,33 @@ bool wxDb::Catalog(const wxChar *userID, const wxString &fileName) wxASSERT(fileName.Length()); RETCODE retcode; - SDWORD cb; + SQLLEN cb; wxChar tblName[DB_MAX_TABLE_NAME_LEN+1]; wxString tblNameSave; wxChar colName[DB_MAX_COLUMN_NAME_LEN+1]; SWORD sqlDataType; wxChar typeName[30+1]; - SWORD precision, length; + SDWORD precision, length; - FILE *fp = fopen(fileName.c_str(),wxT("wt")); + FILE *fp = wxFopen(fileName.c_str(),wxT("wt")); if (fp == NULL) - return(FALSE); + return false; SQLFreeStmt(hstmt, SQL_CLOSE); wxString UserID; convertUserID(userID,UserID); - if (!UserID.IsEmpty() && + if (!UserID.empty() && Dbms() != dbmsMY_SQL && Dbms() != dbmsACCESS && + Dbms() != dbmsFIREBIRD && + Dbms() != dbmsINTERBASE && Dbms() != dbmsMS_SQL_SERVER) { retcode = SQLColumns(hstmt, NULL, 0, // All qualifiers - (UCHAR *) UserID.c_str(), SQL_NTS, // User specified + (SQLTCHAR *) UserID.c_str(), SQL_NTS, // User specified NULL, 0, // All tables NULL, 0); // All columns } @@ -2953,49 +3456,53 @@ bool wxDb::Catalog(const wxChar *userID, const wxString &fileName) { DispAllErrors(henv, hdbc, hstmt); fclose(fp); - return(FALSE); + return false; } wxString outStr; tblNameSave.Empty(); int cnt = 0; - while ((retcode = SQLFetch(hstmt)) == SQL_SUCCESS) + while (true) { + retcode = SQLFetch(hstmt); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) + break; + + GetData(3,SQL_C_WXCHAR, (UCHAR *) tblName, DB_MAX_TABLE_NAME_LEN+1, &cb); + GetData(4,SQL_C_WXCHAR, (UCHAR *) colName, DB_MAX_COLUMN_NAME_LEN+1,&cb); + GetData(5,SQL_C_SSHORT, (UCHAR *)&sqlDataType, 0, &cb); + GetData(6,SQL_C_WXCHAR, (UCHAR *) typeName, sizeof(typeName), &cb); + GetData(7,SQL_C_SLONG, (UCHAR *)&precision, 0, &cb); + GetData(8,SQL_C_SLONG, (UCHAR *)&length, 0, &cb); + if (wxStrcmp(tblName, tblNameSave.c_str())) { if (cnt) - fputs(wxT("\n"), fp); - fputs(wxT("================================ "), fp); - fputs(wxT("================================ "), fp); - fputs(wxT("===================== "), fp); - fputs(wxT("========= "), fp); - fputs(wxT("=========\n"), fp); + wxFputs(wxT("\n"), fp); + wxFputs(wxT("================================ "), fp); + wxFputs(wxT("================================ "), fp); + wxFputs(wxT("===================== "), fp); + wxFputs(wxT("========= "), fp); + wxFputs(wxT("=========\n"), fp); outStr.Printf(wxT("%-32s %-32s %-21s %9s %9s\n"), wxT("TABLE NAME"), wxT("COLUMN NAME"), wxT("DATA TYPE"), wxT("PRECISION"), wxT("LENGTH")); - fputs(outStr.c_str(), fp); - fputs(wxT("================================ "), fp); - fputs(wxT("================================ "), fp); - fputs(wxT("===================== "), fp); - fputs(wxT("========= "), fp); - fputs(wxT("=========\n"), fp); + wxFputs(outStr.c_str(), fp); + wxFputs(wxT("================================ "), fp); + wxFputs(wxT("================================ "), fp); + wxFputs(wxT("===================== "), fp); + wxFputs(wxT("========= "), fp); + wxFputs(wxT("=========\n"), fp); tblNameSave = tblName; } - GetData(3,SQL_C_CHAR, (UCHAR *)tblName, DB_MAX_TABLE_NAME_LEN+1, &cb); - GetData(4,SQL_C_CHAR, (UCHAR *)colName, DB_MAX_COLUMN_NAME_LEN+1,&cb); - GetData(5,SQL_C_SSHORT,(UCHAR *)&sqlDataType,0, &cb); - GetData(6,SQL_C_CHAR, (UCHAR *)typeName, sizeof(typeName), &cb); - GetData(7,SQL_C_SSHORT,(UCHAR *)&precision, 0, &cb); - GetData(8,SQL_C_SSHORT,(UCHAR *)&length, 0, &cb); - - outStr.Printf(wxT("%-32s %-32s (%04d)%-15s %9d %9d\n"), + outStr.Printf(wxT("%-32s %-32s (%04d)%-15s %9ld %9ld\n"), tblName, colName, sqlDataType, typeName, precision, length); - if (fputs(outStr.c_str(), fp) == EOF) + if (wxFputs(outStr.c_str(), fp) == EOF) { SQLFreeStmt(hstmt, SQL_CLOSE); fclose(fp); - return(FALSE); + return false; } cnt++; } @@ -3048,6 +3555,7 @@ bool wxDb::TableExists(const wxString &tableName, const wxChar *userID, const wx // Oracle and Interbase table names are uppercase only, so force // the name to uppercase just in case programmer forgot to do this if ((Dbms() == dbmsORACLE) || + (Dbms() == dbmsFIREBIRD) || (Dbms() == dbmsINTERBASE)) TableName = TableName.Upper(); @@ -3056,15 +3564,19 @@ bool wxDb::TableExists(const wxString &tableName, const wxChar *userID, const wx // Some databases cannot accept a user name when looking up table names, // so we use the call below that leaves out the user name - if (!UserID.IsEmpty() && + if (!UserID.empty() && Dbms() != dbmsMY_SQL && Dbms() != dbmsACCESS && - Dbms() != dbmsMS_SQL_SERVER) + Dbms() != dbmsMS_SQL_SERVER && + Dbms() != dbmsDB2 && + Dbms() != dbmsFIREBIRD && + Dbms() != dbmsINTERBASE && + Dbms() != dbmsPERVASIVE_SQL) { retcode = SQLTables(hstmt, NULL, 0, // All qualifiers - (UCHAR *) UserID.c_str(), SQL_NTS, // Only tables owned by this user - (UCHAR FAR *)TableName.c_str(), SQL_NTS, + (SQLTCHAR *) UserID.c_str(), SQL_NTS, // Only tables owned by this user + (SQLTCHAR FAR *)TableName.c_str(), SQL_NTS, NULL, 0); // All table types } else @@ -3072,7 +3584,7 @@ bool wxDb::TableExists(const wxString &tableName, const wxChar *userID, const wx retcode = SQLTables(hstmt, NULL, 0, // All qualifiers NULL, 0, // All owners - (UCHAR FAR *)TableName.c_str(), SQL_NTS, + (SQLTCHAR FAR *)TableName.c_str(), SQL_NTS, NULL, 0); // All table types } if (retcode != SQL_SUCCESS) @@ -3087,19 +3599,19 @@ bool wxDb::TableExists(const wxString &tableName, const wxChar *userID, const wx SQLFreeStmt(hstmt, SQL_CLOSE); - return(TRUE); + return true; } // wxDb::TableExists() /********** wxDb::TablePrivileges() **********/ bool wxDb::TablePrivileges(const wxString &tableName, const wxString &priv, const wxChar *userID, - const wxChar *schema, const wxString &tablePath) + const wxChar *schema, const wxString &WXUNUSED(tablePath)) { wxASSERT(tableName.Length()); wxDbTablePrivilegeInfo result; - SDWORD cbRetVal; + SQLLEN cbRetVal; RETCODE retcode; // We probably need to be able to dynamically set this based on @@ -3108,99 +3620,139 @@ bool wxDb::TablePrivileges(const wxString &tableName, const wxString &priv, cons wxString TableName; - wxString UserID; + wxString UserID,Schema; convertUserID(userID,UserID); + convertUserID(schema,Schema); TableName = tableName; // Oracle and Interbase table names are uppercase only, so force // the name to uppercase just in case programmer forgot to do this if ((Dbms() == dbmsORACLE) || + (Dbms() == dbmsFIREBIRD) || (Dbms() == dbmsINTERBASE)) TableName = TableName.Upper(); SQLFreeStmt(hstmt, SQL_CLOSE); - if (!schema) + // Some databases cannot accept a user name when looking up table names, + // so we use the call below that leaves out the user name + if (!Schema.empty() && + Dbms() != dbmsMY_SQL && + Dbms() != dbmsACCESS && + Dbms() != dbmsMS_SQL_SERVER) { retcode = SQLTablePrivileges(hstmt, NULL, 0, // Catalog - NULL, 0, // Schema - (UCHAR FAR *)TableName.c_str(), SQL_NTS); + (SQLTCHAR FAR *)Schema.c_str(), SQL_NTS, // Schema + (SQLTCHAR FAR *)TableName.c_str(), SQL_NTS); } else { retcode = SQLTablePrivileges(hstmt, NULL, 0, // Catalog - (UCHAR FAR *)schema, SQL_NTS, // Schema - (UCHAR FAR *)TableName.c_str(), SQL_NTS); + NULL, 0, // Schema + (SQLTCHAR FAR *)TableName.c_str(), SQL_NTS); } #ifdef DBDEBUG_CONSOLE - fprintf(stderr ,wxT("SQLTablePrivileges() returned %i \n"),retcode); + wxFprintf(stderr ,wxT("SQLTablePrivileges() returned %i \n"),retcode); #endif if ((retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO)) - return(DispAllErrors(henv, hdbc, hstmt)); + return (DispAllErrors(henv, hdbc, hstmt)); + bool failed = false; retcode = SQLFetch(hstmt); while (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) { - if (SQLGetData(hstmt, 1, SQL_C_CHAR, (UCHAR*) result.tableQual, sizeof(result.tableQual), &cbRetVal) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc, hstmt)); + if (SQLGetData(hstmt, 1, SQL_C_WXCHAR, (UCHAR*) result.tableQual, sizeof(result.tableQual), &cbRetVal) != SQL_SUCCESS) + failed = true; - if (SQLGetData(hstmt, 2, SQL_C_CHAR, (UCHAR*) result.tableOwner, sizeof(result.tableOwner), &cbRetVal) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc, hstmt)); + if (!failed && SQLGetData(hstmt, 2, SQL_C_WXCHAR, (UCHAR*) result.tableOwner, sizeof(result.tableOwner), &cbRetVal) != SQL_SUCCESS) + failed = true; - if (SQLGetData(hstmt, 3, SQL_C_CHAR, (UCHAR*) result.tableName, sizeof(result.tableName), &cbRetVal) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc, hstmt)); + if (!failed && SQLGetData(hstmt, 3, SQL_C_WXCHAR, (UCHAR*) result.tableName, sizeof(result.tableName), &cbRetVal) != SQL_SUCCESS) + failed = true; - if (SQLGetData(hstmt, 4, SQL_C_CHAR, (UCHAR*) result.grantor, sizeof(result.grantor), &cbRetVal) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc, hstmt)); + if (!failed && SQLGetData(hstmt, 4, SQL_C_WXCHAR, (UCHAR*) result.grantor, sizeof(result.grantor), &cbRetVal) != SQL_SUCCESS) + failed = true; - if (SQLGetData(hstmt, 5, SQL_C_CHAR, (UCHAR*) result.grantee, sizeof(result.grantee), &cbRetVal) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc, hstmt)); + if (!failed && SQLGetData(hstmt, 5, SQL_C_WXCHAR, (UCHAR*) result.grantee, sizeof(result.grantee), &cbRetVal) != SQL_SUCCESS) + failed = true; - if (SQLGetData(hstmt, 6, SQL_C_CHAR, (UCHAR*) result.privilege, sizeof(result.privilege), &cbRetVal) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc, hstmt)); + if (!failed && SQLGetData(hstmt, 6, SQL_C_WXCHAR, (UCHAR*) result.privilege, sizeof(result.privilege), &cbRetVal) != SQL_SUCCESS) + failed = true; - if (SQLGetData(hstmt, 7, SQL_C_CHAR, (UCHAR*) result.grantable, sizeof(result.grantable), &cbRetVal) != SQL_SUCCESS) - return(DispAllErrors(henv, hdbc, hstmt)); + if (!failed && SQLGetData(hstmt, 7, SQL_C_WXCHAR, (UCHAR*) result.grantable, sizeof(result.grantable), &cbRetVal) != SQL_SUCCESS) + failed = true; + if (failed) + { + return(DispAllErrors(henv, hdbc, hstmt)); + } #ifdef DBDEBUG_CONSOLE - fprintf(stderr,wxT("Scanning %s privilege on table %s.%s granted by %s to %s\n"), + wxFprintf(stderr,wxT("Scanning %s privilege on table %s.%s granted by %s to %s\n"), result.privilege,result.tableOwner,result.tableName, result.grantor, result.grantee); #endif - if (UserID.IsSameAs(result.tableOwner,FALSE)) + if (UserID.IsSameAs(result.tableOwner,false)) { SQLFreeStmt(hstmt, SQL_CLOSE); - return TRUE; + return true; } - if (UserID.IsSameAs(result.grantee,FALSE) && + if (UserID.IsSameAs(result.grantee,false) && !wxStrcmp(result.privilege,priv)) { SQLFreeStmt(hstmt, SQL_CLOSE); - return TRUE; + return true; } if (!wxStrcmp(result.grantee,curRole) && !wxStrcmp(result.privilege,priv)) { SQLFreeStmt(hstmt, SQL_CLOSE); - return TRUE; + return true; } retcode = SQLFetch(hstmt); } SQLFreeStmt(hstmt, SQL_CLOSE); - return FALSE; + return false; } // wxDb::TablePrivileges +const wxString wxDb::SQLTableName(const wxChar *tableName) +{ + wxString TableName; + + if (Dbms() == dbmsACCESS) + TableName = _T("\""); + TableName += tableName; + if (Dbms() == dbmsACCESS) + TableName += _T("\""); + + return TableName; +} // wxDb::SQLTableName() + + +const wxString wxDb::SQLColumnName(const wxChar *colName) +{ + wxString ColName; + + if (Dbms() == dbmsACCESS) + ColName = _T("\""); + ColName += colName; + if (Dbms() == dbmsACCESS) + ColName += _T("\""); + + return ColName; +} // wxDb::SQLColumnName() + + /********** wxDb::SetSqlLogging() **********/ bool wxDb::SetSqlLogging(wxDbSqlLogState state, const wxString &filename, bool append) { @@ -3211,9 +3763,9 @@ bool wxDb::SetSqlLogging(wxDbSqlLogState state, const wxString &filename, bool a { if (fpSqlLog == 0) { - fpSqlLog = fopen(filename, (append ? wxT("at") : wxT("wt"))); + fpSqlLog = wxFopen(filename.c_str(), (append ? wxT("at") : wxT("wt"))); if (fpSqlLog == NULL) - return(FALSE); + return false; } } else // sqlLogOFF @@ -3221,13 +3773,13 @@ bool wxDb::SetSqlLogging(wxDbSqlLogState state, const wxString &filename, bool a if (fpSqlLog) { if (fclose(fpSqlLog)) - return(FALSE); + return false; fpSqlLog = 0; } } sqlLogState = state; - return(TRUE); + return true; } // wxDb::SetSqlLogging() @@ -3238,16 +3790,16 @@ bool wxDb::WriteSqlLog(const wxString &logMsg) wxASSERT(logMsg.Length()); if (fpSqlLog == 0 || sqlLogState == sqlLogOFF) - return(FALSE); + return false; - if (fputs(wxT("\n"), fpSqlLog) == EOF) - return(FALSE); - if (fputs(logMsg, fpSqlLog) == EOF) - return(FALSE); - if (fputs(wxT("\n"), fpSqlLog) == EOF) - return(FALSE); + if (wxFputs(wxT("\n"), fpSqlLog) == EOF) + return false; + if (wxFputs(logMsg, fpSqlLog) == EOF) + return false; + if (wxFputs(wxT("\n"), fpSqlLog) == EOF) + return false; - return(TRUE); + return true; } // wxDb::WriteSqlLog() @@ -3275,7 +3827,7 @@ wxDBMS wxDb::Dbms(void) * - Does not support the SQL_TIMESTAMP structure * - Supports only one cursor and one connect (apparently? with Microsoft driver only?) * - Does not automatically create the primary index if the 'keyField' param of SetColDef - * is TRUE. The user must create ALL indexes from their program. + * is true. The user must create ALL indexes from their program. * - Table names can only be 8 characters long * - Column names can only be 10 characters long * @@ -3303,7 +3855,16 @@ wxDBMS wxDb::Dbms(void) * * DB2 * - Primary keys must be declared as NOT NULL + * - Table and index names must not be longer than 13 characters in length (technically + * table names can be up to 18 characters, but the primary index is created using the + * base table name plus "_PIDX", so the limit if the table has a primary index is 13. + * + * PERVASIVE SQL * + * INTERBASE + * - Columns that are part of primary keys must be defined as being NOT NULL + * when they are created. Some code is added in ::CreateIndex to try to adjust the + * column definition if it is not defined correctly, but it is experimental */ { // Should only need to do this once for each new database connection @@ -3312,8 +3873,16 @@ wxDBMS wxDb::Dbms(void) if (dbmsType != dbmsUNIDENTIFIED) return(dbmsType); +#ifdef DBDEBUG_CONSOLE + // When run in console mode, use standard out to display errors. + cout << "Database connecting to: " << dbInf.dbmsName << endl; +#endif // DBDEBUG_CONSOLE + + wxLogDebug(wxT("Database connecting to: ")); + wxLogDebug(dbInf.dbmsName); + wxChar baseName[25+1]; - wxStrncpy(baseName,dbInf.dbmsName,25); + wxStrncpy(baseName, dbInf.dbmsName, 25); baseName[25] = 0; // RGG 20001025 : add support for Interbase @@ -3336,35 +3905,46 @@ wxDBMS wxDb::Dbms(void) { if (!wxStrncmp(dbInf.driverName, wxT("oplodbc"), 7) || !wxStrncmp(dbInf.driverName, wxT("OLOD"), 4)) - return ((wxDBMS)(dbmsMS_SQL_SERVER)); - else - return ((wxDBMS)(dbmsType = dbmsSYBASE_ASE)); + return ((wxDBMS)(dbmsMS_SQL_SERVER)); + else + return ((wxDBMS)(dbmsType = dbmsSYBASE_ASE)); } if (!wxStricmp(dbInf.dbmsName,wxT("Microsoft SQL Server"))) return((wxDBMS)(dbmsType = dbmsMS_SQL_SERVER)); - if (!wxStricmp(dbInf.dbmsName,wxT("MySQL"))) - return((wxDBMS)(dbmsType = dbmsMY_SQL)); - if (!wxStricmp(dbInf.dbmsName,wxT("PostgreSQL"))) // v6.5.0 + + baseName[10] = 0; + if (!wxStricmp(baseName,wxT("PostgreSQL"))) // v6.5.0 return((wxDBMS)(dbmsType = dbmsPOSTGRES)); + baseName[9] = 0; + if (!wxStricmp(baseName,wxT("Pervasive"))) + return((wxDBMS)(dbmsType = dbmsPERVASIVE_SQL)); + baseName[8] = 0; if (!wxStricmp(baseName,wxT("Informix"))) return((wxDBMS)(dbmsType = dbmsINFORMIX)); + if (!wxStricmp(baseName,wxT("Firebird"))) + return((wxDBMS)(dbmsType = dbmsFIREBIRD)); + baseName[6] = 0; if (!wxStricmp(baseName,wxT("Oracle"))) return((wxDBMS)(dbmsType = dbmsORACLE)); - if (!wxStricmp(dbInf.dbmsName,wxT("ACCESS"))) + if (!wxStricmp(baseName,wxT("ACCESS"))) return((wxDBMS)(dbmsType = dbmsACCESS)); - if (!wxStricmp(dbInf.dbmsName,wxT("MySQL"))) - return((wxDBMS)(dbmsType = dbmsMY_SQL)); if (!wxStricmp(baseName,wxT("Sybase"))) return((wxDBMS)(dbmsType = dbmsSYBASE_ASE)); baseName[5] = 0; if (!wxStricmp(baseName,wxT("DBASE"))) return((wxDBMS)(dbmsType = dbmsDBASE)); + if (!wxStricmp(baseName,wxT("xBase"))) + return((wxDBMS)(dbmsType = dbmsXBASE_SEQUITER)); + if (!wxStricmp(baseName,wxT("MySQL"))) + return((wxDBMS)(dbmsType = dbmsMY_SQL)); + if (!wxStricmp(baseName,wxT("MaxDB"))) + return((wxDBMS)(dbmsType = dbmsMAXDB)); baseName[3] = 0; if (!wxStricmp(baseName,wxT("DB2"))) @@ -3386,61 +3966,74 @@ bool wxDb::ModifyColumn(const wxString &tableName, const wxString &columnName, // Must specify a columnLength if modifying a VARCHAR type column if (dataType == DB_DATA_TYPE_VARCHAR && !columnLength) - return FALSE; - + return false; + wxString dataTypeName; - wxString sqlStmt; + wxString sqlStmt; wxString alterSlashModify; - switch(dataType) - { - case DB_DATA_TYPE_VARCHAR : - dataTypeName = typeInfVarchar.TypeName; - break; - case DB_DATA_TYPE_INTEGER : - dataTypeName = typeInfInteger.TypeName; - break; - case DB_DATA_TYPE_FLOAT : - dataTypeName = typeInfFloat.TypeName; - break; - case DB_DATA_TYPE_DATE : - dataTypeName = typeInfDate.TypeName; - break; - default: - return FALSE; - } - - // Set the modify or alter syntax depending on the type of database connected to - switch (Dbms()) - { - case dbmsORACLE : - alterSlashModify = "MODIFY"; - break; - case dbmsMS_SQL_SERVER : - alterSlashModify = "ALTER COLUMN"; - break; - case dbmsUNIDENTIFIED : - return FALSE; - case dbmsSYBASE_ASA : - case dbmsSYBASE_ASE : - case dbmsMY_SQL : - case dbmsPOSTGRES : - case dbmsACCESS : - case dbmsDBASE : - default : - alterSlashModify = "MODIFY"; - break; - } - - // create the SQL statement - sqlStmt.Printf(wxT("ALTER TABLE %s %s %s %s"), tableName.c_str(), alterSlashModify.c_str(), - columnName.c_str(), dataTypeName.c_str()); + switch(dataType) + { + case DB_DATA_TYPE_VARCHAR : + dataTypeName = typeInfVarchar.TypeName; + break; + case DB_DATA_TYPE_INTEGER : + dataTypeName = typeInfInteger.TypeName; + break; + case DB_DATA_TYPE_FLOAT : + dataTypeName = typeInfFloat.TypeName; + break; + case DB_DATA_TYPE_DATE : + dataTypeName = typeInfDate.TypeName; + break; + case DB_DATA_TYPE_BLOB : + dataTypeName = typeInfBlob.TypeName; + break; + default: + return false; + } + + // Set the modify or alter syntax depending on the type of database connected to + switch (Dbms()) + { + case dbmsORACLE : + alterSlashModify = _T("MODIFY"); + break; + case dbmsMS_SQL_SERVER : + alterSlashModify = _T("ALTER COLUMN"); + break; + case dbmsUNIDENTIFIED : + return false; + case dbmsSYBASE_ASA : + case dbmsSYBASE_ASE : + case dbmsMY_SQL : + case dbmsPOSTGRES : + case dbmsACCESS : + case dbmsDBASE : + case dbmsXBASE_SEQUITER : + default : + alterSlashModify = _T("MODIFY"); + break; + } + + // create the SQL statement + if ( Dbms() == dbmsMY_SQL ) + { + sqlStmt.Printf(wxT("ALTER TABLE %s %s %s %s"), tableName.c_str(), alterSlashModify.c_str(), + columnName.c_str(), dataTypeName.c_str()); + } + else + { + sqlStmt.Printf(wxT("ALTER TABLE \"%s\" \"%s\" \"%s\" %s"), tableName.c_str(), alterSlashModify.c_str(), + columnName.c_str(), dataTypeName.c_str()); + } // For varchars only, append the size of the column - if (dataType == DB_DATA_TYPE_VARCHAR) + if (dataType == DB_DATA_TYPE_VARCHAR && + (Dbms() != dbmsMY_SQL || dataTypeName != _T("text"))) { wxString s; - s.Printf(wxT("(%d)"), columnLength); + s.Printf(wxT("(%lu)"), columnLength); sqlStmt += s; } @@ -3451,13 +4044,13 @@ bool wxDb::ModifyColumn(const wxString &tableName, const wxString &columnName, sqlStmt += optionalParam; } - return ExecSql(sqlStmt); + return ExecSql(sqlStmt); } // wxDb::ModifyColumn() /********** wxDbGetConnection() **********/ -wxDb WXDLLEXPORT *wxDbGetConnection(wxDbConnectInf *pDbConfig, bool FwdOnlyCursors) +wxDb WXDLLIMPEXP_ODBC *wxDbGetConnection(wxDbConnectInf *pDbConfig, bool FwdOnlyCursors) { wxDbList *pList; @@ -3475,17 +4068,42 @@ wxDb WXDLLEXPORT *wxDbGetConnection(wxDbConnectInf *pDbConfig, bool FwdOnlyCurso // The database connection must be for the same datasource // name and must currently not be in use. if (pList->Free && - (pList->PtrDb->FwdOnlyCursors() == FwdOnlyCursors) && - (!wxStrcmp(pDbConfig->GetDsn(), pList->Dsn))) // Found a free connection + (pList->PtrDb->FwdOnlyCursors() == FwdOnlyCursors)) { - pList->Free = FALSE; - return(pList->PtrDb); + if (pDbConfig->UseConnectionStr()) + { + if (pList->PtrDb->OpenedWithConnectionString() && + (!wxStrcmp(pDbConfig->GetConnectionStr(), pList->ConnectionStr))) + { + // Found a free connection + pList->Free = false; + return(pList->PtrDb); + } + } + else + { + if (!pList->PtrDb->OpenedWithConnectionString() && + (!wxStrcmp(pDbConfig->GetDsn(), pList->Dsn))) + { + // Found a free connection + pList->Free = false; + return(pList->PtrDb); + } + } } - if (!wxStrcmp(pDbConfig->GetDsn(), pList->Dsn) && - !wxStrcmp(pDbConfig->GetUserID(), pList->Uid) && - !wxStrcmp(pDbConfig->GetPassword(), pList->AuthStr)) - matchingDbConnection = pList->PtrDb; + if (pDbConfig->UseConnectionStr()) + { + if (!wxStrcmp(pDbConfig->GetConnectionStr(), pList->ConnectionStr)) + matchingDbConnection = pList->PtrDb; + } + else + { + if (!wxStrcmp(pDbConfig->GetDsn(), pList->Dsn) && + !wxStrcmp(pDbConfig->GetUserID(), pList->Uid) && + !wxStrcmp(pDbConfig->GetPassword(), pList->AuthStr)) + matchingDbConnection = pList->PtrDb; + } } // No available connections. A new connection must be made and @@ -3507,25 +4125,36 @@ wxDb WXDLLEXPORT *wxDbGetConnection(wxDbConnectInf *pDbConfig, bool FwdOnlyCurso } // Initialize new node in the linked list - pList->PtrNext = 0; - pList->Free = FALSE; - pList->Dsn = pDbConfig->GetDsn(); //glt - will this assignment work? - pList->Uid = pDbConfig->GetUserID(); - pList->AuthStr = pDbConfig->GetPassword(); + pList->PtrNext = 0; + pList->Free = false; + pList->Dsn = pDbConfig->GetDsn(); + pList->Uid = pDbConfig->GetUserID(); + pList->AuthStr = pDbConfig->GetPassword(); + pList->ConnectionStr = pDbConfig->GetConnectionStr(); pList->PtrDb = new wxDb(pDbConfig->GetHenv(), FwdOnlyCursors); - bool opened = FALSE; + bool opened; if (!matchingDbConnection) - opened = pList->PtrDb->Open(pDbConfig->GetDsn(), pDbConfig->GetUserID(), pDbConfig->GetPassword()); + { + if (pDbConfig->UseConnectionStr()) + { + opened = pList->PtrDb->Open(pDbConfig->GetConnectionStr()); + } + else + { + opened = pList->PtrDb->Open(pDbConfig->GetDsn(), pDbConfig->GetUserID(), pDbConfig->GetPassword()); + } + } else opened = pList->PtrDb->Open(matchingDbConnection); // Connect to the datasource if (opened) { - pList->PtrDb->SetSqlLogging(SQLLOGstate,SQLLOGfn,TRUE); + pList->PtrDb->setCached(true); // Prevent a user from deleting a cached connection + pList->PtrDb->SetSqlLogging(SQLLOGstate, SQLLOGfn, true); return(pList->PtrDb); } else // Unable to connect, destroy list item @@ -3533,11 +4162,12 @@ wxDb WXDLLEXPORT *wxDbGetConnection(wxDbConnectInf *pDbConfig, bool FwdOnlyCurso if (pList->PtrPrev) pList->PtrPrev->PtrNext = 0; else - PtrBegDbList = 0; // Empty list again - pList->PtrDb->CommitTrans(); // Commit any open transactions on wxDb object - pList->PtrDb->Close(); // Close the wxDb object - delete pList->PtrDb; // Deletes the wxDb object - delete pList; // Deletes the linked list object + PtrBegDbList = 0; // Empty list again + + pList->PtrDb->CommitTrans(); // Commit any open transactions on wxDb object + pList->PtrDb->Close(); // Close the wxDb object + delete pList->PtrDb; // Deletes the wxDb object + delete pList; // Deletes the linked list object return(0); } @@ -3545,7 +4175,7 @@ wxDb WXDLLEXPORT *wxDbGetConnection(wxDbConnectInf *pDbConfig, bool FwdOnlyCurso /********** wxDbFreeConnection() **********/ -bool WXDLLEXPORT wxDbFreeConnection(wxDb *pDb) +bool WXDLLIMPEXP_ODBC wxDbFreeConnection(wxDb *pDb) { wxDbList *pList; @@ -3553,17 +4183,17 @@ bool WXDLLEXPORT wxDbFreeConnection(wxDb *pDb) for (pList = PtrBegDbList; pList; pList = pList->PtrNext) { if (pList->PtrDb == pDb) // Found it, now free it!!! - return (pList->Free = TRUE); + return (pList->Free = true); } // Never found the database object, return failure - return(FALSE); + return false; } // wxDbFreeConnection() /********** wxDbCloseConnections() **********/ -void WXDLLEXPORT wxDbCloseConnections(void) +void WXDLLIMPEXP_ODBC wxDbCloseConnections(void) { wxDbList *pList, *pNext; @@ -3573,6 +4203,7 @@ void WXDLLEXPORT wxDbCloseConnections(void) pNext = pList->PtrNext; // Save the pointer to next pList->PtrDb->CommitTrans(); // Commit any open transactions on wxDb object pList->PtrDb->Close(); // Close the wxDb object + pList->PtrDb->setCached(false); // Allows deletion of the wxDb instance delete pList->PtrDb; // Deletes the wxDb object delete pList; // Deletes the linked list object } @@ -3584,7 +4215,7 @@ void WXDLLEXPORT wxDbCloseConnections(void) /********** wxDbConnectionsInUse() **********/ -int WXDLLEXPORT wxDbConnectionsInUse(void) +int WXDLLIMPEXP_ODBC wxDbConnectionsInUse(void) { wxDbList *pList; int cnt = 0; @@ -3592,7 +4223,7 @@ int WXDLLEXPORT wxDbConnectionsInUse(void) // Scan the linked list counting db connections that are currently in use for (pList = PtrBegDbList; pList; pList = pList->PtrNext) { - if (pList->Free == FALSE) + if (pList->Free == false) cnt++; } @@ -3601,23 +4232,71 @@ int WXDLLEXPORT wxDbConnectionsInUse(void) } // wxDbConnectionsInUse() + +/********** wxDbLogExtendedErrorMsg() **********/ +// DEBUG ONLY function +const wxChar WXDLLIMPEXP_ODBC *wxDbLogExtendedErrorMsg(const wxChar *userText, + wxDb *pDb, + const wxChar *ErrFile, + int ErrLine) +{ + static wxString msg; + msg = userText; + + wxString tStr; + + if (ErrFile || ErrLine) + { + msg += wxT("File: "); + msg += ErrFile; + msg += wxT(" Line: "); + tStr.Printf(wxT("%d"),ErrLine); + msg += tStr.c_str(); + msg += wxT("\n"); + } + + msg.Append (wxT("\nODBC errors:\n")); + msg += wxT("\n"); + + // Display errors for this connection + int i; + for (i = 0; i < DB_MAX_ERROR_HISTORY; i++) + { + if (pDb->errorList[i]) + { + msg.Append(pDb->errorList[i]); + if (wxStrcmp(pDb->errorList[i], wxEmptyString) != 0) + msg.Append(wxT("\n")); + // Clear the errmsg buffer so the next error will not + // end up showing the previous error that have occurred + wxStrcpy(pDb->errorList[i], wxEmptyString); + } + } + msg += wxT("\n"); + + wxLogDebug(msg.c_str()); + + return msg.c_str(); +} // wxDbLogExtendedErrorMsg() + + /********** wxDbSqlLog() **********/ bool wxDbSqlLog(wxDbSqlLogState state, const wxChar *filename) { - bool append = FALSE; + bool append = false; wxDbList *pList; for (pList = PtrBegDbList; pList; pList = pList->PtrNext) { if (!pList->PtrDb->SetSqlLogging(state,filename,append)) - return(FALSE); - append = TRUE; + return false; + append = true; } SQLLOGstate = state; SQLLOGfn = filename; - return(TRUE); + return true; } // wxDbSqlLog() @@ -3650,12 +4329,12 @@ int wxDbCreateDataSource(const wxString &driverName, const wxString &dsn, const // embedded nulls in strings setupStr.Printf(wxT("DSN=%s%cDescription=%s%cDefaultDir=%s%c"),dsn,2,description,2,defDir,2); - // Replace the separator from above with the '\0' seperator needed + // Replace the separator from above with the '\0' separator needed // by the SQLConfigDataSource() function int k; do { - k = setupStr.Find((wxChar)2,TRUE); + k = setupStr.Find((wxChar)2,true); if (k != wxNOT_FOUND) setupStr[(UINT)k] = wxT('\0'); } @@ -3706,20 +4385,22 @@ int wxDbCreateDataSource(const wxString &driverName, const wxString &dsn, const /********** wxDbGetDataSource() **********/ -bool wxDbGetDataSource(HENV henv, wxChar *Dsn, SWORD DsnMax, wxChar *DsDesc, - SWORD DsDescMax, UWORD direction) +bool wxDbGetDataSource(HENV henv, wxChar *Dsn, SWORD DsnMaxLength, wxChar *DsDesc, + SWORD DsDescMaxLength, UWORD direction) /* * Dsn and DsDesc will contain the data source name and data source * description upon return */ { SWORD cb1,cb2; + SWORD lengthDsn = (SWORD)(DsnMaxLength*sizeof(wxChar)); + SWORD lengthDsDesc = (SWORD)(DsDescMaxLength*sizeof(wxChar)); - if (SQLDataSources(henv, direction, (UCHAR FAR *) Dsn, DsnMax, &cb1, - (UCHAR FAR *) DsDesc, DsDescMax, &cb2) == SQL_SUCCESS) - return(TRUE); + if (SQLDataSources(henv, direction, (SQLTCHAR FAR *) Dsn, lengthDsn, &cb1, + (SQLTCHAR FAR *) DsDesc, lengthDsDesc, &cb2) == SQL_SUCCESS) + return true; else - return(FALSE); + return false; } // wxDbGetDataSource() @@ -3730,7 +4411,7 @@ bool wxDbGetDataSource(HENV henv, wxChar *Dsn, SWORD DsnMax, wxChar *DsDesc, ******************************************************************** * * The following functions are all DEPRECATED and are included for - * backward compatability reasons only + * backward compatibility reasons only * ******************************************************************** ********************************************************************/ @@ -3745,22 +4426,22 @@ bool GetDataSource(HENV henv, char *Dsn, SWORD DsnMax, char *DsDesc, SWORD DsDes return wxDbGetDataSource(henv, Dsn, DsnMax, DsDesc, DsDescMax, direction); } /***** DEPRECATED: use wxDbGetConnection() *****/ -wxDb WXDLLEXPORT *GetDbConnection(DbStuff *pDbStuff, bool FwdOnlyCursors) +wxDb WXDLLIMPEXP_ODBC *GetDbConnection(DbStuff *pDbStuff, bool FwdOnlyCursors) { return wxDbGetConnection((wxDbConnectInf *)pDbStuff, FwdOnlyCursors); } /***** DEPRECATED: use wxDbFreeConnection() *****/ -bool WXDLLEXPORT FreeDbConnection(wxDb *pDb) +bool WXDLLIMPEXP_ODBC FreeDbConnection(wxDb *pDb) { return wxDbFreeConnection(pDb); } /***** DEPRECATED: use wxDbCloseConnections() *****/ -void WXDLLEXPORT CloseDbConnections(void) +void WXDLLIMPEXP_ODBC CloseDbConnections(void) { wxDbCloseConnections(); } /***** DEPRECATED: use wxDbConnectionsInUse() *****/ -int WXDLLEXPORT NumberDbConnectionsInUse(void) +int WXDLLIMPEXP_ODBC NumberDbConnectionsInUse(void) { return wxDbConnectionsInUse(); }