WXDLLEXPORT_DATA(wxDbList*) PtrBegDbList = 0;
-char const *SQL_LOG_FILENAME = "sqllog.txt";
-char const *SQL_CATALOG_FILENAME = "catalog.txt";
+wxChar const *SQL_LOG_FILENAME = wxT("sqllog.txt");
+wxChar const *SQL_CATALOG_FILENAME = wxT("catalog.txt");
#ifdef __WXDEBUG__
extern wxList TablesInUse;
// SQL Log defaults to be used by GetDbConnection
wxDbSqlLogState SQLLOGstate = sqlLogOFF;
-//char SQLLOGfn[wxDB_PATH_MAX+1] = SQL_LOG_FILENAME;
-//wxChar *SQLLOGfn = (wxChar*) SQL_LOG_FILENAME;
static wxString SQLLOGfn = SQL_LOG_FILENAME;
// The wxDb::errorList is copied to this variable when the wxDb object
// 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
-char DBerrorList[DB_MAX_ERROR_HISTORY][DB_MAX_ERROR_MSG_LEN];
+wxChar DBerrorList[DB_MAX_ERROR_HISTORY][DB_MAX_ERROR_MSG_LEN];
// This type defines the return row-struct form
// SQLTablePrivileges, and is used by wxDB::TablePrivileges.
/********** wxDbColFor Constructor **********/
wxDbColFor::wxDbColFor()
{
- s_Field = "";
+ s_Field.Empty();
int i;
- for (i=0;i<7;i++)
+ for (i=0; i<7; i++)
{
- s_Format[i] = "";
- s_Amount[i] = "";
+ s_Format[i].Empty();
+ s_Amount[i].Empty();
i_Amount[i] = 0;
}
i_Nation = 0; // 0=EU, 1=UK, 2=International, 3=US
} // wxDbInf::~wxDbInf()
-/*************************************************/
-
-
-int wxDbColFor::Format(int Nation,int dbDataType,SWORD sqlDataType,short columnSize,short decimalDigits)
+int wxDbColFor::Format(int Nation, int dbDataType, SWORD sqlDataType,
+ short columnSize, short decimalDigits)
{
// ----------------------------------------------------------------------------------------
// -- 19991224 : mj10777 : Create
// ----------------------------------------------------------------------------------------
// There should also be a function to scan in a string to fill the variable
// ----------------------------------------------------------------------------------------
- wxString Temp0;
+ wxString tempStr;
i_Nation = Nation; // 0 = timestamp , 1=EU, 2=UK, 3=International, 4=US
i_dbDataType = dbDataType;
i_sqlDataType = sqlDataType;
s_Field.Printf(wxT("%s%d"),s_Amount[1].c_str(),i_Amount[1]); // OK for VARCHAR, INTEGER and FLOAT
+
if (i_dbDataType == 0) // Filter unsupported dbDataTypes
{
if ((i_sqlDataType == SQL_VARCHAR) || (i_sqlDataType == SQL_LONGVARCHAR))
if (i_sqlDataType == SQL_REAL)
i_dbDataType = DB_DATA_TYPE_FLOAT;
}
+
if ((i_dbDataType == DB_DATA_TYPE_INTEGER) && (i_sqlDataType == SQL_C_DOUBLE))
{ // DBASE Numeric
i_dbDataType = DB_DATA_TYPE_FLOAT;
}
- switch(i_dbDataType) // -A-> Still a lot of proper formatting to do
+
+ switch(i_dbDataType) // TBD: Still a lot of proper formatting to do
{
case DB_DATA_TYPE_VARCHAR:
- s_Field = "%s";
+ s_Field = wxT("%s");
break;
case DB_DATA_TYPE_INTEGER:
- s_Field = "%d";
+ s_Field = wxT("%d");
break;
case DB_DATA_TYPE_FLOAT:
if (decimalDigits == 0)
decimalDigits = 2;
- Temp0 = "%";
- Temp0.Printf(wxT("%s%d.%d"),Temp0.c_str(),columnSize,decimalDigits);
- s_Field.Printf(wxT("%sf"),Temp0.c_str());
+ tempStr = wxT("%");
+ tempStr.Printf(wxT("%s%d.%d"),tempStr.c_str(),columnSize,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)
{
- s_Field = "%04d-%02d-%02d %02d:%02d:%02d.%03d";
+ s_Field = wxT("%04d-%02d-%02d %02d:%02d:%02d.%03d");
}
if (i_Nation == 1) // European DD.MM.YYYY HH:MM:SS.SSS
{
- s_Field = "%02d.%02d.%04d %02d:%02d:%02d.%03d";
+ s_Field = wxT("%02d.%02d.%04d %02d:%02d:%02d.%03d");
}
if (i_Nation == 2) // UK DD/MM/YYYY HH:MM:SS.SSS
{
- s_Field = "%02d/%02d/%04d %02d:%02d:%02d.%03d";
+ s_Field = wxT("%02d/%02d/%04d %02d:%02d:%02d.%03d");
}
if (i_Nation == 3) // International YYYY-MM-DD HH:MM:SS.SSS
{
- s_Field = "%04d-%02d-%02d %02d:%02d:%02d.%03d";
+ s_Field = wxT("%04d-%02d-%02d %02d:%02d:%02d.%03d");
}
if (i_Nation == 4) // US MM/DD/YYYY HH:MM:SS.SSS
{
- s_Field = "%02d/%02d/%04d %02d:%02d:%02d.%03d";
+ s_Field = wxT("%02d/%02d/%04d %02d:%02d:%02d.%03d");
}
break;
default:
} // wxDb::wxDb()
+/********** PRIVATE! wxDb::initialize PRIVATE! **********/
void wxDb::initialize()
/*
* Private member function that sets all wxDb member variables to
wxStrcpy(errorList[i], wxT(""));
// Init typeInf structures
- wxStrcpy(typeInfVarchar.TypeName,wxT(""));
+ typeInfVarchar.TypeName.Empty();
typeInfVarchar.FsqlType = 0;
typeInfVarchar.Precision = 0;
typeInfVarchar.CaseSensitive = 0;
typeInfVarchar.MaximumScale = 0;
- wxStrcpy(typeInfInteger.TypeName,wxT(""));
+ typeInfInteger.TypeName.Empty();
typeInfInteger.FsqlType = 0;
typeInfInteger.Precision = 0;
typeInfInteger.CaseSensitive = 0;
typeInfInteger.MaximumScale = 0;
- wxStrcpy(typeInfFloat.TypeName,wxT(""));
+ typeInfFloat.TypeName.Empty();
typeInfFloat.FsqlType = 0;
typeInfFloat.Precision = 0;
typeInfFloat.CaseSensitive = 0;
typeInfFloat.MaximumScale = 0;
- wxStrcpy(typeInfDate.TypeName,wxT(""));
+ typeInfDate.TypeName.Empty();
typeInfDate.FsqlType = 0;
typeInfDate.Precision = 0;
typeInfDate.CaseSensitive = 0;
} // wxDb::initialize()
+/********** PRIVATE! wxDb::initialize PRIVATE! **********/
+//
+// NOTE: Return value from this function MUST be copied
+// immediately, as the value is not good after
+// this function has left scope.
+//
+const wxChar *wxDb::convertUserID(const wxChar *userID, wxString &UserID)
+{
+ if (userID)
+ {
+ if (!wxStrlen(userID))
+ UserID = uid;
+ else
+ UserID = userID;
+ }
+ else
+ UserID.Empty();
+
+ // dBase does not use user names, and some drivers fail if you try to pass one
+ if (Dbms() == dbmsDBASE)
+ UserID.Empty();
+
+ // Oracle user names may only be in uppercase, so force
+ // the name to uppercase
+ if (Dbms() == dbmsORACLE)
+ UserID = UserID.Upper();
+
+ return UserID.c_str();
+} // wxDb::convertUserID()
+
+
/********** wxDb::Open() **********/
-bool wxDb::Open(char *Dsn, char *Uid, char *AuthStr)
+bool wxDb::Open(const wxString &Dsn, const wxString &Uid, const wxString &AuthStr)
{
- assert(Dsn && wxStrlen(Dsn));
+ wxASSERT(Dsn.Length());
dsn = Dsn;
uid = Uid;
authStr = AuthStr;
#ifdef DBDEBUG_CONSOLE
if (retcode == SQL_SUCCESS)
- cout << "SQLSetConnectOption(CURSOR_LIB) successful" << endl;
+ cout << wxT("SQLSetConnectOption(CURSOR_LIB) successful") << endl;
else
- cout << "SQLSetConnectOption(CURSOR_LIB) failed" << endl;
+ cout << wxT("SQLSetConnectOption(CURSOR_LIB) failed") << endl;
#endif
}
// Connect to the data source
- retcode = SQLConnect(hdbc, (UCHAR FAR *) dsn, SQL_NTS,
- (UCHAR FAR *) uid, SQL_NTS,
- (UCHAR FAR *) authStr,SQL_NTS);
+ 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)
If using Intersolv branded ODBC drivers, this is the place where you would substitute
your branded driver license information
- SQLSetConnectOption(hdbc, 1041, (UDWORD) "");
- SQLSetConnectOption(hdbc, 1042, (UDWORD) "");
+ SQLSetConnectOption(hdbc, 1041, (UDWORD) wxT(""));
+ SQLSetConnectOption(hdbc, 1042, (UDWORD) wxT(""));
*/
// Mark database as open
}
#ifdef DBDEBUG_CONSOLE
- cout << "VARCHAR DATA TYPE: " << typeInfVarchar.TypeName << endl;
- cout << "INTEGER DATA TYPE: " << typeInfInteger.TypeName << endl;
- cout << "FLOAT DATA TYPE: " << typeInfFloat.TypeName << endl;
- cout << "DATE DATA TYPE: " << typeInfDate.TypeName << endl;
+ 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 << endl;
#endif
bool wxDb::Open(wxDb *copyDb)
{
- dsn = (char *)copyDb->GetDatasourceName();
- uid = (char *)copyDb->GetUsername();
- authStr = (char *)copyDb->GetPassword();
+ dsn = copyDb->GetDatasourceName();
+ uid = copyDb->GetUsername();
+ authStr = copyDb->GetPassword();
RETCODE retcode;
#ifdef DBDEBUG_CONSOLE
if (retcode == SQL_SUCCESS)
- cout << "SQLSetConnectOption(CURSOR_LIB) successful" << endl;
+ cout << wxT("SQLSetConnectOption(CURSOR_LIB) successful") << endl;
else
- cout << "SQLSetConnectOption(CURSOR_LIB) failed" << endl;
+ cout << wxT("SQLSetConnectOption(CURSOR_LIB) failed") << endl;
#endif
}
// Connect to the data source
- retcode = SQLConnect(hdbc, (UCHAR FAR *) dsn, SQL_NTS,
- (UCHAR FAR *) uid, SQL_NTS,
- (UCHAR FAR *) authStr, SQL_NTS);
+ 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_ERROR)
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) "");
- SQLSetConnectOption(hdbc, 1042, (UDWORD) "");
+ SQLSetConnectOption(hdbc, 1041, (UDWORD) wxT(""));
+ SQLSetConnectOption(hdbc, 1042, (UDWORD) wxT(""));
*/
// Mark database as open
dbInf.loginTimeout = copyDb->dbInf.loginTimeout;
// VARCHAR = Variable length character string
- typeInfVarchar.FsqlType = copyDb->typeInfVarchar.FsqlType;
- wxStrcpy(typeInfVarchar.TypeName, copyDb->typeInfVarchar.TypeName);
+ typeInfVarchar.FsqlType = copyDb->typeInfVarchar.FsqlType;
+ typeInfVarchar.TypeName = copyDb->typeInfVarchar.TypeName;
typeInfVarchar.Precision = copyDb->typeInfVarchar.Precision;
typeInfVarchar.CaseSensitive = copyDb->typeInfVarchar.CaseSensitive;
typeInfVarchar.MaximumScale = copyDb->typeInfVarchar.MaximumScale;
// Float
- typeInfFloat.FsqlType = copyDb->typeInfFloat.FsqlType;
- wxStrcpy(typeInfFloat.TypeName, copyDb->typeInfFloat.TypeName);
+ typeInfFloat.FsqlType = copyDb->typeInfFloat.FsqlType;
+ typeInfFloat.TypeName = copyDb->typeInfFloat.TypeName;
typeInfFloat.Precision = copyDb->typeInfFloat.Precision;
typeInfFloat.CaseSensitive = copyDb->typeInfFloat.CaseSensitive;
typeInfFloat.MaximumScale = copyDb->typeInfFloat.MaximumScale;
// Integer
- typeInfInteger.FsqlType = copyDb->typeInfInteger.FsqlType;
- wxStrcpy(typeInfInteger.TypeName, copyDb->typeInfInteger.TypeName);
+ typeInfInteger.FsqlType = copyDb->typeInfInteger.FsqlType;
+ typeInfInteger.TypeName = copyDb->typeInfInteger.TypeName;
typeInfInteger.Precision = copyDb->typeInfInteger.Precision;
typeInfInteger.CaseSensitive = copyDb->typeInfInteger.CaseSensitive;
typeInfInteger.MaximumScale = copyDb->typeInfInteger.MaximumScale;
// Date/Time
- typeInfDate.FsqlType = copyDb->typeInfDate.FsqlType;
- wxStrcpy(typeInfDate.TypeName, copyDb->typeInfDate.TypeName);
+ typeInfDate.FsqlType = copyDb->typeInfDate.FsqlType;
+ typeInfDate.TypeName = copyDb->typeInfDate.TypeName;
typeInfDate.Precision = copyDb->typeInfDate.Precision;
typeInfDate.CaseSensitive = copyDb->typeInfDate.CaseSensitive;
typeInfDate.MaximumScale = copyDb->typeInfDate.MaximumScale;
#ifdef DBDEBUG_CONSOLE
- cout << "VARCHAR DATA TYPE: " << typeInfVarchar.TypeName << endl;
- cout << "INTEGER DATA TYPE: " << typeInfInteger.TypeName << endl;
- cout << "FLOAT DATA TYPE: " << typeInfFloat.TypeName << endl;
- cout << "DATE DATA TYPE: " << typeInfDate.TypeName << endl;
+ 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 << endl;
#endif
// Display the connection options to verify them
#ifdef DBDEBUG_CONSOLE
long l;
- cout << "****** CONNECTION OPTIONS ******" << endl;
+ cout << wxT("****** CONNECTION OPTIONS ******") << endl;
if (SQLGetConnectOption(hdbc, SQL_AUTOCOMMIT, &l) != SQL_SUCCESS)
return(DispAllErrors(henv, hdbc));
- cout << "AUTOCOMMIT: " << (l == SQL_AUTOCOMMIT_OFF ? "OFF" : "ON") << endl;
+ cout << wxT("AUTOCOMMIT: ") << (l == SQL_AUTOCOMMIT_OFF ? "OFF" : "ON") << endl;
if (SQLGetConnectOption(hdbc, SQL_ODBC_CURSORS, &l) != SQL_SUCCESS)
return(DispAllErrors(henv, hdbc));
- cout << "ODBC CURSORS: ";
+ cout << wxT("ODBC CURSORS: ");
switch(l)
{
case(SQL_CUR_USE_IF_NEEDED):
- cout << "SQL_CUR_USE_IF_NEEDED";
+ cout << wxT("SQL_CUR_USE_IF_NEEDED");
break;
case(SQL_CUR_USE_ODBC):
- cout << "SQL_CUR_USE_ODBC";
+ cout << wxT("SQL_CUR_USE_ODBC");
break;
case(SQL_CUR_USE_DRIVER):
- cout << "SQL_CUR_USE_DRIVER";
+ cout << wxT("SQL_CUR_USE_DRIVER");
break;
}
cout << endl;
if (SQLGetConnectOption(hdbc, SQL_OPT_TRACE, &l) != SQL_SUCCESS)
return(DispAllErrors(henv, hdbc));
- cout << "TRACING: " << (l == SQL_OPT_TRACE_OFF ? "OFF" : "ON") << endl;
+ cout << wxT("TRACING: ") << (l == SQL_OPT_TRACE_OFF ? wxT("OFF") : wxT("ON")) << endl;
cout << endl;
#endif
return(DispAllErrors(henv, hdbc));
#ifdef DBDEBUG_CONSOLE
- cout << "***** DATA SOURCE INFORMATION *****" << endl;
- cout << "SERVER Name: " << dbInf.serverName << endl;
- cout << "DBMS Name: " << dbInf.dbmsName << "; DBMS Version: " << dbInf.dbmsVer << endl;
- cout << "ODBC Version: " << dbInf.odbcVer << "; Driver Version: " << dbInf.driverVer << endl;
+ cout << wxT("***** DATA SOURCE INFORMATION *****") << endl;
+ cout << wxT(wxT("SERVER Name: ") << dbInf.serverName << endl;
+ cout << wxT("DBMS Name: ") << dbInf.dbmsName << wxT("; DBMS Version: ") << dbInf.dbmsVer << endl;
+ cout << wxT("ODBC Version: ") << dbInf.odbcVer << wxT("; Driver Version: ") << dbInf.driverVer << endl;
- cout << "API Conf. Level: ";
+ cout << wxT("API Conf. Level: ");
switch(dbInf.apiConfLvl)
{
- case SQL_OAC_NONE: cout << "None"; break;
- case SQL_OAC_LEVEL1: cout << "Level 1"; break;
- case SQL_OAC_LEVEL2: cout << "Level 2"; break;
+ case SQL_OAC_NONE: cout << wxT("None"); break;
+ case SQL_OAC_LEVEL1: cout << wxT("Level 1"); break;
+ case SQL_OAC_LEVEL2: cout << wxT("Level 2"); break;
}
cout << endl;
- cout << "SAG CLI Conf. Level: ";
+ cout << wxT("SAG CLI Conf. Level: ");
switch(dbInf.cliConfLvl)
{
- case SQL_OSCC_NOT_COMPLIANT: cout << "Not Compliant"; break;
- case SQL_OSCC_COMPLIANT: cout << "Compliant"; break;
+ case SQL_OSCC_NOT_COMPLIANT: cout << wxT("Not Compliant"); break;
+ case SQL_OSCC_COMPLIANT: cout << wxT("Compliant"); break;
}
cout << endl;
- cout << "SQL Conf. Level: ";
+ cout << wxT("SQL Conf. Level: ");
switch(dbInf.sqlConfLvl)
{
- case SQL_OSC_MINIMUM: cout << "Minimum Grammar"; break;
- case SQL_OSC_CORE: cout << "Core Grammar"; break;
- case SQL_OSC_EXTENDED: cout << "Extended Grammar"; break;
+ case SQL_OSC_MINIMUM: cout << wxT("Minimum Grammar"); break;
+ case SQL_OSC_CORE: cout << wxT("Core Grammar"); break;
+ case SQL_OSC_EXTENDED: cout << wxT("Extended Grammar"); break;
}
cout << endl;
- cout << "Max. Connections: " << dbInf.maxConnections << endl;
- cout << "Outer Joins: " << dbInf.outerJoins << endl;
- cout << "Support for Procedures: " << dbInf.procedureSupport << endl;
- cout << "All tables accessible : " << dbInf.accessibleTables << endl;
- cout << "Cursor COMMIT Behavior: ";
+ cout << wxT("Max. Connections: ") << dbInf.maxConnections << endl;
+ cout << wxT("Outer Joins: ") << dbInf.outerJoins << endl;
+ cout << wxT("Support for Procedures: ") << dbInf.procedureSupport << endl;
+ cout << wxT("All tables accessible : ") << dbInf.accessibleTables << endl;
+ cout << wxT("Cursor COMMIT Behavior: ");
switch(dbInf.cursorCommitBehavior)
{
- case SQL_CB_DELETE: cout << "Delete cursors"; break;
- case SQL_CB_CLOSE: cout << "Close cursors"; break;
- case SQL_CB_PRESERVE: cout << "Preserve cursors"; break;
+ case SQL_CB_DELETE: cout << wxT("Delete cursors"); break;
+ case SQL_CB_CLOSE: cout << wxT("Close cursors"); break;
+ case SQL_CB_PRESERVE: cout << wxT("Preserve cursors"); break;
}
cout << endl;
- cout << "Cursor ROLLBACK Behavior: ";
+ cout << wxT("Cursor ROLLBACK Behavior: ");
switch(dbInf.cursorRollbackBehavior)
{
- case SQL_CB_DELETE: cout << "Delete cursors"; break;
- case SQL_CB_CLOSE: cout << "Close cursors"; break;
- case SQL_CB_PRESERVE: cout << "Preserve cursors"; break;
+ case SQL_CB_DELETE: cout << wxT("Delete cursors"); break;
+ case SQL_CB_CLOSE: cout << wxT("Close cursors"); break;
+ case SQL_CB_PRESERVE: cout << wxT("Preserve cursors"); break;
}
cout << endl;
- cout << "Support NOT NULL clause: ";
+ cout << wxT("Support NOT NULL clause: ");
switch(dbInf.supportNotNullClause)
{
- case SQL_NNC_NULL: cout << "No"; break;
- case SQL_NNC_NON_NULL: cout << "Yes"; break;
+ case SQL_NNC_NULL: cout << wxT("No"); break;
+ case SQL_NNC_NON_NULL: cout << wxT("Yes"); break;
}
cout << endl;
- cout << "Support IEF (Ref. Integrity): " << dbInf.supportIEF << endl;
- cout << "Login Timeout: " << dbInf.loginTimeout << endl;
+ cout << wxT("Support IEF (Ref. Integrity): ") << dbInf.supportIEF << endl;
+ cout << wxT("Login Timeout: ") << dbInf.loginTimeout << endl;
- cout << endl << endl << "more ..." << endl;
+ cout << endl << endl << wxT("more ...") << endl;
getchar();
- cout << "Default Transaction Isolation: ";
+ cout << wxT("Default Transaction Isolation: ";
switch(dbInf.txnIsolation)
{
- case SQL_TXN_READ_UNCOMMITTED: cout << "Read Uncommitted"; break;
- case SQL_TXN_READ_COMMITTED: cout << "Read Committed"; break;
- case SQL_TXN_REPEATABLE_READ: cout << "Repeatable Read"; break;
- case SQL_TXN_SERIALIZABLE: cout << "Serializable"; break;
+ case SQL_TXN_READ_UNCOMMITTED: cout << wxT("Read Uncommitted"); break;
+ case SQL_TXN_READ_COMMITTED: cout << wxT("Read Committed"); break;
+ case SQL_TXN_REPEATABLE_READ: cout << wxT("Repeatable Read"); break;
+ case SQL_TXN_SERIALIZABLE: cout << wxT("Serializable"); break;
#ifdef ODBC_V20
- case SQL_TXN_VERSIONING: cout << "Versioning"; break;
+ case SQL_TXN_VERSIONING: cout << wxT("Versioning"); break;
#endif
}
cout << endl;
- cout << "Transaction Isolation Options: ";
+ cout << wxT("Transaction Isolation Options: ");
if (dbInf.txnIsolationOptions & SQL_TXN_READ_UNCOMMITTED)
- cout << "Read Uncommitted, ";
+ cout << wxT("Read Uncommitted, ");
if (dbInf.txnIsolationOptions & SQL_TXN_READ_COMMITTED)
- cout << "Read Committed, ";
+ cout << wxT("Read Committed, ");
if (dbInf.txnIsolationOptions & SQL_TXN_REPEATABLE_READ)
- cout << "Repeatable Read, ";
+ cout << wxT("Repeatable Read, ");
if (dbInf.txnIsolationOptions & SQL_TXN_SERIALIZABLE)
- cout << "Serializable, ";
+ cout << wxT("Serializable, ");
#ifdef ODBC_V20
if (dbInf.txnIsolationOptions & SQL_TXN_VERSIONING)
- cout << "Versioning";
+ cout << wxT("Versioning");
#endif
cout << endl;
- cout << "Fetch Directions Supported:" << endl << " ";
+ cout << wxT("Fetch Directions Supported:") << endl << wxT(" ");
if (dbInf.fetchDirections & SQL_FD_FETCH_NEXT)
- cout << "Next, ";
+ cout << wxT("Next, ");
if (dbInf.fetchDirections & SQL_FD_FETCH_PRIOR)
- cout << "Prev, ";
+ cout << wxT("Prev, ");
if (dbInf.fetchDirections & SQL_FD_FETCH_FIRST)
- cout << "First, ";
+ cout << wxT("First, ");
if (dbInf.fetchDirections & SQL_FD_FETCH_LAST)
- cout << "Last, ";
+ cout << wxT("Last, ");
if (dbInf.fetchDirections & SQL_FD_FETCH_ABSOLUTE)
- cout << "Absolute, ";
+ cout << wxT("Absolute, ");
if (dbInf.fetchDirections & SQL_FD_FETCH_RELATIVE)
- cout << "Relative, ";
+ cout << wxT("Relative, ");
#ifdef ODBC_V20
if (dbInf.fetchDirections & SQL_FD_FETCH_RESUME)
- cout << "Resume, ";
+ cout << wxT("Resume, ");
#endif
if (dbInf.fetchDirections & SQL_FD_FETCH_BOOKMARK)
- cout << "Bookmark";
+ cout << wxT("Bookmark");
cout << endl;
- cout << "Lock Types Supported (SQLSetPos): ";
+ cout << wxT("Lock Types Supported (SQLSetPos): ");
if (dbInf.lockTypes & SQL_LCK_NO_CHANGE)
- cout << "No Change, ";
+ cout << wxT("No Change, ");
if (dbInf.lockTypes & SQL_LCK_EXCLUSIVE)
- cout << "Exclusive, ";
+ cout << wxT("Exclusive, ");
if (dbInf.lockTypes & SQL_LCK_UNLOCK)
- cout << "UnLock";
+ cout << wxT("UnLock");
cout << endl;
- cout << "Position Operations Supported (SQLSetPos): ";
+ cout << wxT("Position Operations Supported (SQLSetPos): ");
if (dbInf.posOperations & SQL_POS_POSITION)
- cout << "Position, ";
+ cout << wxT("Position, ");
if (dbInf.posOperations & SQL_POS_REFRESH)
- cout << "Refresh, ";
+ cout << wxT("Refresh, ");
if (dbInf.posOperations & SQL_POS_UPDATE)
- cout << "Upd, ";
+ cout << wxT("Upd, "));
if (dbInf.posOperations & SQL_POS_DELETE)
- cout << "Del, ";
+ cout << wxT("Del, ");
if (dbInf.posOperations & SQL_POS_ADD)
- cout << "Add";
+ cout << wxT("Add");
cout << endl;
- cout << "Positioned Statements Supported: ";
+ cout << wxT("Positioned Statements Supported: ");
if (dbInf.posStmts & SQL_PS_POSITIONED_DELETE)
- cout << "Pos delete, ";
+ cout << wxT("Pos delete, ");
if (dbInf.posStmts & SQL_PS_POSITIONED_UPDATE)
- cout << "Pos update, ";
+ cout << wxT("Pos update, ");
if (dbInf.posStmts & SQL_PS_SELECT_FOR_UPDATE)
- cout << "Select for update";
+ cout << wxT("Select for update");
cout << endl;
- cout << "Scroll Concurrency: ";
+ cout << wxT("Scroll Concurrency: ");
if (dbInf.scrollConcurrency & SQL_SCCO_READ_ONLY)
- cout << "Read Only, ";
+ cout << wxT("Read Only, ");
if (dbInf.scrollConcurrency & SQL_SCCO_LOCK)
- cout << "Lock, ";
+ cout << wxT("Lock, ");
if (dbInf.scrollConcurrency & SQL_SCCO_OPT_ROWVER)
- cout << "Opt. Rowver, ";
+ cout << wxT("Opt. Rowver, ");
if (dbInf.scrollConcurrency & SQL_SCCO_OPT_VALUES)
- cout << "Opt. Values";
+ cout << wxT("Opt. Values");
cout << endl;
- cout << "Scroll Options: ";
+ cout << wxT("Scroll Options: ");
if (dbInf.scrollOptions & SQL_SO_FORWARD_ONLY)
- cout << "Fwd Only, ";
+ cout << wxT("Fwd Only, ");
if (dbInf.scrollOptions & SQL_SO_STATIC)
- cout << "Static, ";
+ cout << wxT("Static, ");
if (dbInf.scrollOptions & SQL_SO_KEYSET_DRIVEN)
- cout << "Keyset Driven, ";
+ cout << wxT("Keyset Driven, ");
if (dbInf.scrollOptions & SQL_SO_DYNAMIC)
- cout << "Dynamic, ";
+ cout << wxT("Dynamic, ");
if (dbInf.scrollOptions & SQL_SO_MIXED)
- cout << "Mixed";
+ cout << wxT("Mixed");
cout << endl;
- cout << "Static Sensitivity: ";
+ cout << wxT("Static Sensitivity: ");
if (dbInf.staticSensitivity & SQL_SS_ADDITIONS)
- cout << "Additions, ";
+ cout << wxT("Additions, ");
if (dbInf.staticSensitivity & SQL_SS_DELETIONS)
- cout << "Deletions, ";
+ cout << wxT("Deletions, ");
if (dbInf.staticSensitivity & SQL_SS_UPDATES)
- cout << "Updates";
+ cout << wxT("Updates");
cout << endl;
- cout << "Transaction Capable?: ";
+ cout << wxT("Transaction Capable?: ");
switch(dbInf.txnCapable)
{
- case SQL_TC_NONE: cout << "No"; break;
- case SQL_TC_DML: cout << "DML Only"; break;
- case SQL_TC_DDL_COMMIT: cout << "DDL Commit"; break;
- case SQL_TC_DDL_IGNORE: cout << "DDL Ignore"; break;
- case SQL_TC_ALL: cout << "DDL & DML"; break;
+ case SQL_TC_NONE: cout << wxT("No"); break;
+ case SQL_TC_DML: cout << wxT("DML Only"); break;
+ case SQL_TC_DDL_COMMIT: cout << wxT("DDL Commit"); break;
+ case SQL_TC_DDL_IGNORE: cout << wxT("DDL Ignore"); break;
+ case SQL_TC_ALL: cout << wxT("DDL & DML"); break;
}
cout << endl;
{
#ifdef DBDEBUG_CONSOLE
if (retcode == SQL_NO_DATA_FOUND)
- cout << "SQL_NO_DATA_FOUND fetching inf. about data type." << endl;
+ cout << wxT("SQL_NO_DATA_FOUND fetching inf. about data type.") << endl;
#endif
DispAllErrors(henv, hdbc, hstmt);
SQLFreeStmt(hstmt, SQL_CLOSE);
return(FALSE);
}
+
+ wxChar typeName[DB_TYPE_NAME_LEN+1];
// Obtain columns from the record
- if (SQLGetData(hstmt, 1, SQL_C_CHAR, (UCHAR*) structSQLTypeInfo.TypeName, DB_TYPE_NAME_LEN, &cbRet) != SQL_SUCCESS)
+ if (SQLGetData(hstmt, 1, SQL_C_CHAR, (UCHAR*) typeName, DB_TYPE_NAME_LEN, &cbRet) != SQL_SUCCESS)
return(DispAllErrors(henv, hdbc, hstmt));
+ structSQLTypeInfo.TypeName = typeName;
+
// BJO 20000503: no more needed with new GetColumns...
#if OLD_GETCOLUMNS
// BJO 991209
if (Dbms() == dbmsMY_SQL)
{
- if (!wxStrcmp(structSQLTypeInfo.TypeName, "middleint")) wxStrcpy(structSQLTypeInfo.TypeName, "mediumint");
- if (!wxStrcmp(structSQLTypeInfo.TypeName, "middleint unsigned")) wxStrcpy(structSQLTypeInfo.TypeName, "mediumint unsigned");
- if (!wxStrcmp(structSQLTypeInfo.TypeName, "integer")) wxStrcpy(structSQLTypeInfo.TypeName, "int");
- if (!wxStrcmp(structSQLTypeInfo.TypeName, "integer unsigned")) wxStrcpy(structSQLTypeInfo.TypeName, "int unsigned");
- if (!wxStrcmp(structSQLTypeInfo.TypeName, "middleint")) wxStrcpy(structSQLTypeInfo.TypeName, "mediumint");
- if (!wxStrcmp(structSQLTypeInfo.TypeName, "varchar")) wxStrcpy(structSQLTypeInfo.TypeName, "char");
+ if (structSQLTypeInfo.TypeName == wxT("middleint"))
+ structSQLTypeInfo.TypeName = wxT("mediumint");
+ else if (structSQLTypeInfo.TypeName == wxT("middleint unsigned"))
+ structSQLTypeInfo.TypeName = wxT("mediumint unsigned");
+ else if (structSQLTypeInfo.TypeName == wxT("integer"))
+ structSQLTypeInfo.TypeName = wxT("int");
+ else if (structSQLTypeInfo.TypeName == wxT("integer unsigned"))
+ structSQLTypeInfo.TypeName = wxT("int unsigned");
+ else if (structSQLTypeInfo.TypeName == wxT("middleint"))
+ structSQLTypeInfo.TypeName = wxT("mediumint");
+ else if (structSQLTypeInfo.TypeName == wxT("varchar"))
+ structSQLTypeInfo.TypeName = wxT("char");
}
// BJO 20000427 : OpenLink driver
- if (!wxStrncmp(dbInf.driverName, "oplodbc", 7) ||
- !wxStrncmp(dbInf.driverName, "OLOD", 4))
+ if (!wxStrncmp(dbInf.driverName, wxT("oplodbc"), 7) ||
+ !wxStrncmp(dbInf.driverName, wxT("OLOD"), 4))
{
- if (!wxStrcmp(structSQLTypeInfo.TypeName, "double precision"))
- wxStrcpy(structSQLTypeInfo.TypeName, "real");
+ if (structSQLTypeInfo.TypeName == wxT("double precision"))
+ structSQLTypeInfo.TypeName = wxT("real");
}
#endif
DispAllErrors(henv, hdbc);
// There should be zero Ctable objects still connected to this db object
- assert(nTables == 0);
+ wxASSERT(nTables == 0);
#ifdef __WXDEBUG__
wxTablesInUse *tiu;
tiu = (wxTablesInUse *)pNode->Data();
if (tiu->pDb == this)
{
- s.sprintf(wxT("(%-20s) tableID:[%6lu] pDb:[%p]"), tiu->tableName,tiu->tableID,tiu->pDb);
- s2.sprintf(wxT("Orphaned found using pDb:[%p]"),this);
- wxLogDebug (s.c_str(),s2.c_str());
+ 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);
}
pNode = pNode->Next();
}
* actual error(s) that just occured on the previous request of the datasource.
*
* The function will retrieve each error condition from the datasource and
- * sprintf the codes/text values into a string which it then logs via logError().
+ * 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.
*
while (SQLError(aHenv, aHdbc, aHstmt, (UCHAR FAR *) sqlState, &nativeError, (UCHAR FAR *) errorMsg, SQL_MAX_MESSAGE_LENGTH - 1, &cbErrorMsg) == SQL_SUCCESS)
{
- odbcErrMsg.sprintf("SQL State = %s\nNative Error Code = %li\nError Message = %s\n", sqlState, nativeError, errorMsg);
- logError(odbcErrMsg.c_str(), sqlState);
+ odbcErrMsg.Printf(wxT("SQL State = %s\nNative Error Code = %li\nError Message = %s\n"), sqlState, nativeError, errorMsg);
+ logError(odbcErrMsg, sqlState);
if (!silent)
{
#ifdef DBDEBUG_CONSOLE
// When run in console mode, use standard out to display errors.
cout << odbcErrMsg.c_str() << endl;
- cout << "Press any key to continue..." << endl;
+ cout << wxT("Press any key to continue...") << endl;
getchar();
#endif
#ifdef __WXDEBUG__
- wxLogDebug(odbcErrMsg.c_str(),wxT("ODBC DEBUG MESSAGE from DispAllErrors()"));
+ wxLogDebug(odbcErrMsg,wxT("ODBC DEBUG MESSAGE from DispAllErrors()"));
#endif
}
}
{
wxString odbcErrMsg;
- odbcErrMsg.sprintf("SQL State = %s\nNative Error Code = %li\nError Message = %s\n", sqlState, nativeError, errorMsg);
- logError(odbcErrMsg.c_str(), sqlState);
+ odbcErrMsg.Printf(wxT("SQL State = %s\nNative Error Code = %li\nError Message = %s\n"), sqlState, nativeError, errorMsg);
+ logError(odbcErrMsg, sqlState);
if (silent)
return;
#ifdef DBDEBUG_CONSOLE
// When run in console mode, use standard out to display errors.
cout << odbcErrMsg.c_str() << endl;
- cout << "Press any key to continue..." << endl;
+ cout << wxT("Press any key to continue...") << endl;
getchar();
#endif
/********** wxDb::logError() **********/
-void wxDb::logError(const char *errMsg, const char *SQLState)
+void wxDb::logError(const wxString &errMsg, const wxString &SQLState)
{
- assert(errMsg && wxStrlen(errMsg));
+ wxASSERT(errMsg.Length());
static int pLast = -1;
int dbStatus;
wxStrcpy(errorList[pLast], errMsg);
- if (SQLState && wxStrlen(SQLState))
+ if (SQLState.Length())
if ((dbStatus = TranslateSqlState(SQLState)) != DB_ERR_FUNCTION_SEQUENCE_ERROR)
DB_STATUS = dbStatus;
/**********wxDb::TranslateSqlState() **********/
-int wxDb::TranslateSqlState(const wxChar *SQLState)
+int wxDb::TranslateSqlState(const wxString &SQLState)
{
if (!wxStrcmp(SQLState, wxT("01000")))
return(DB_ERR_GENERAL_WARNING);
/********** wxDb::Grant() **********/
-bool wxDb::Grant(int privileges, const char *tableName, const char *userList)
+bool wxDb::Grant(int privileges, const wxString &tableName, const wxString &userList)
{
wxString sqlStmt;
// Build the grant statement
- sqlStmt = "GRANT ";
+ sqlStmt = wxT("GRANT ");
if (privileges == DB_GRANT_ALL)
- sqlStmt += "ALL";
+ sqlStmt += wxT("ALL");
else
{
int c = 0;
if (privileges & DB_GRANT_SELECT)
{
- sqlStmt += "SELECT";
+ sqlStmt += wxT("SELECT");
c++;
}
if (privileges & DB_GRANT_INSERT)
{
if (c++)
- sqlStmt += ", ";
- sqlStmt += "INSERT";
+ sqlStmt += wxT(", ");
+ sqlStmt += wxT("INSERT");
}
if (privileges & DB_GRANT_UPDATE)
{
if (c++)
- sqlStmt += ", ";
- sqlStmt += "UPDATE";
+ sqlStmt += wxT(", ");
+ sqlStmt += wxT("UPDATE");
}
if (privileges & DB_GRANT_DELETE)
{
if (c++)
- sqlStmt += ", ";
- sqlStmt += "DELETE";
+ sqlStmt += wxT(", ");
+ sqlStmt += wxT("DELETE");
}
}
- sqlStmt += " ON ";
+ sqlStmt += wxT(" ON ");
sqlStmt += tableName;
- sqlStmt += " TO ";
+ sqlStmt += wxT(" TO ");
sqlStmt += userList;
#ifdef DBDEBUG_CONSOLE
cout << endl << sqlStmt.c_str() << endl;
#endif
- WriteSqlLog(sqlStmt.c_str());
+ WriteSqlLog(sqlStmt);
- return(ExecSql(sqlStmt.c_str()));
+ return(ExecSql(sqlStmt));
} // wxDb::Grant()
/********** wxDb::CreateView() **********/
-bool wxDb::CreateView(const char *viewName, const char *colList, const char *pSqlStmt, bool attemptDrop)
+bool wxDb::CreateView(const wxString &viewName, const wxString &colList,
+ const wxString &pSqlStmt, bool attemptDrop)
{
wxString sqlStmt;
return FALSE;
// Build the create view statement
- sqlStmt = "CREATE VIEW ";
+ sqlStmt = wxT("CREATE VIEW ");
sqlStmt += viewName;
- if (wxStrlen(colList))
+ if (colList.Length())
{
- sqlStmt += " (";
+ sqlStmt += wxT(" (");
sqlStmt += colList;
- sqlStmt += ")";
+ sqlStmt += wxT(")");
}
- sqlStmt += " AS ";
+ sqlStmt += wxT(" AS ");
sqlStmt += pSqlStmt;
- WriteSqlLog(sqlStmt.c_str());
+ WriteSqlLog(sqlStmt);
#ifdef DBDEBUG_CONSOLE
cout << sqlStmt.c_str() << endl;
#endif
- return(ExecSql(sqlStmt.c_str()));
+ return(ExecSql(sqlStmt));
} // wxDb::CreateView()
/********** wxDb::DropView() **********/
-bool wxDb::DropView(const char *viewName)
+bool wxDb::DropView(const wxString &viewName)
{
/*
* NOTE: This function returns TRUE if the View does not exist, but
* below for any other databases when those databases are defined
* to handle this situation consistently
*/
-// char sqlStmt[DB_MAX_STATEMENT_LEN];
wxString sqlStmt;
- sqlStmt.sprintf("DROP VIEW %s", viewName);
+ sqlStmt.Printf(wxT("DROP VIEW %s"), viewName);
- WriteSqlLog(sqlStmt.c_str());
+ WriteSqlLog(sqlStmt);
#ifdef DBDEBUG_CONSOLE
cout << endl << sqlStmt.c_str() << endl;
/********** wxDb::ExecSql() **********/
-bool wxDb::ExecSql(const char *pSqlStmt)
+bool wxDb::ExecSql(const wxString &pSqlStmt)
{
SQLFreeStmt(hstmt, SQL_CLOSE);
- if (SQLExecDirect(hstmt, (UCHAR FAR *) pSqlStmt, SQL_NTS) == SQL_SUCCESS)
+ if (SQLExecDirect(hstmt, (UCHAR FAR *) pSqlStmt.c_str(), SQL_NTS) == SQL_SUCCESS)
return(TRUE);
else
{
/********** wxDb::GetData() **********/
bool wxDb::GetData(UWORD colNo, SWORD cType, PTR pData, SDWORD maxLen, SDWORD FAR *cbReturned)
{
- assert(pData);
- assert(cbReturned);
+ wxASSERT(pData);
+ wxASSERT(cbReturned);
if (SQLGetData(hstmt, colNo, cType, pData, maxLen, cbReturned) == SQL_SUCCESS)
return(TRUE);
/********** wxDb::GetKeyFields() **********/
-int wxDb::GetKeyFields(char *tableName, wxDbColInf* colInf, int noCols)
+int wxDb::GetKeyFields(const wxString &tableName, wxDbColInf* colInf, int noCols)
{
- char szPkTable[DB_MAX_TABLE_NAME_LEN+1]; /* Primary key table name */
- char szFkTable[DB_MAX_TABLE_NAME_LEN+1]; /* Foreign key table name */
+ 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;
- char szPkCol[DB_MAX_COLUMN_NAME_LEN+1]; /* Primary key column */
- char szFkCol[DB_MAX_COLUMN_NAME_LEN+1]; /* Foreign key column */
+ 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;
- wxString Temp0;
+ wxString tempStr;
/*
- * ---------------------------------------------------------------------
- * -- 19991224 : mj10777 : Create ------
- * -- : Three things are done and stored here : ------
- * -- : 1) which Column(s) is/are Primary Key(s) ------
- * -- : 2) which tables use this Key as a Foreign Key ------
- * -- : 3) which columns are Foreign Key and the name ------
- * -- : of the Table where the Key is the Primary Key -----
- * -- : Called from GetColumns(char *tableName, ------
- * -- int *numCols,const char *userID ) ------
- * ---------------------------------------------------------------------
+ * -----------------------------------------------------------------------
+ * -- 19991224 : mj10777 : Create ------
+ * -- : Three things are done and stored here : ------
+ * -- : 1) which Column(s) is/are Primary Key(s) ------
+ * -- : 2) which tables use this Key as a Foreign Key ------
+ * -- : 3) which columns are Foreign Key and the name ------
+ * -- : of the Table where the Key is the Primary Key -----
+ * -- : Called from GetColumns(const wxString &tableName, ------
+ * -- int *numCols,const wxChar *userID ) ------
+ * -----------------------------------------------------------------------
*/
/*---------------------------------------------------------------------*/
/* Get the names of the columns in the primary key. */
/*---------------------------------------------------------------------*/
retcode = SQLPrimaryKeys(hstmt,
- NULL, 0, /* Catalog name */
- NULL, 0, /* Schema name */
- (UCHAR *) tableName, SQL_NTS); /* Table name */
+ NULL, 0, /* Catalog name */
+ NULL, 0, /* Schema name */
+ (UCHAR FAR *) tableName.c_str(), SQL_NTS); /* Table name */
/*---------------------------------------------------------------------*/
/* Fetch and display the result set. This will be a list of the */
/* Get all the foreign keys that refer to tableName primary key. */
/*---------------------------------------------------------------------*/
retcode = SQLForeignKeys(hstmt,
- NULL, 0, /* Primary catalog */
- NULL, 0, /* Primary schema */
- (UCHAR *)tableName, SQL_NTS, /* Primary table */
- NULL, 0, /* Foreign catalog */
- NULL, 0, /* Foreign schema */
- NULL, 0); /* Foreign table */
+ NULL, 0, /* Primary catalog */
+ NULL, 0, /* Primary schema */
+ (UCHAR FAR *)tableName.c_str(), SQL_NTS,/* Primary table */
+ NULL, 0, /* Foreign catalog */
+ NULL, 0, /* Foreign schema */
+ NULL, 0); /* Foreign table */
/*---------------------------------------------------------------------*/
/* Fetch and display the result set. This will be all of the foreign */
/* keys in other tables that refer to the tableName primary key. */
/*---------------------------------------------------------------------*/
- Temp0.Empty();
+ tempStr.Empty();
szPkCol[0] = 0;
while ((retcode == SQL_SUCCESS) || (retcode == SQL_SUCCESS_WITH_INFO))
{
GetData( 5, SQL_C_SSHORT, &iKeySeq, 0, &cb);
GetData( 7, SQL_C_CHAR, szFkTable, DB_MAX_TABLE_NAME_LEN+1, &cb);
GetData( 8, SQL_C_CHAR, szFkCol, DB_MAX_COLUMN_NAME_LEN+1, &cb);
- Temp0.Printf(wxT("%s[%s] "),Temp0.c_str(),szFkTable); // [ ] in case there is a blank in the Table name
+ tempStr.Printf(wxT("%s[%s] "),tempStr.c_str(),szFkTable); // [ ] in case there is a blank in the Table name
} // if
} // while
- Temp0.Trim(); // Get rid of any unneeded blanks
- if (Temp0 != wxT(""))
+
+ tempStr.Trim(); // Get rid of any unneeded blanks
+ if (!tempStr.IsEmpty())
{
- for (i=0;i<noCols;i++)
+ for (i=0; i<noCols; i++)
{ // Find the Column name
- if (!wxStrcmp(colInf[i].colName,szPkCol)) // We have found the Column, store the Information
- wxStrcpy(colInf[i].PkTableName,Temp0.c_str()); // Name of the Tables where this Primary Key is used as a Foreign Key
+ if (!wxStrcmp(colInf[i].colName, szPkCol)) // We have found the Column, store the Information
+ wxStrcpy(colInf[i].PkTableName, tempStr.c_str()); // Name of the Tables where this Primary Key is used as a Foreign Key
}
} // if
+
SQLFreeStmt(hstmt, SQL_CLOSE); /* Close the cursor (the hstmt is still allocated). */
/*---------------------------------------------------------------------*/
/* Get all the foreign keys in the tablename table. */
/*---------------------------------------------------------------------*/
retcode = SQLForeignKeys(hstmt,
- NULL, 0, /* Primary catalog */
- NULL, 0, /* Primary schema */
- NULL, 0, /* Primary table */
- NULL, 0, /* Foreign catalog */
- NULL, 0, /* Foreign schema */
- (UCHAR *)tableName, SQL_NTS); /* Foreign table */
+ NULL, 0, /* Primary catalog */
+ NULL, 0, /* Primary schema */
+ NULL, 0, /* Primary table */
+ NULL, 0, /* Foreign catalog */
+ NULL, 0, /* Foreign schema */
+ (UCHAR *)tableName.c_str(), SQL_NTS);/* Foreign table */
/*---------------------------------------------------------------------*/
/* Fetch and display the result set. This will be all of the */
GetData( 5, SQL_C_SSHORT, &iKeySeq, 0, &cb);
GetData( 8, SQL_C_CHAR, szFkCol, DB_MAX_COLUMN_NAME_LEN+1, &cb);
//-------
- for (i=0;i<noCols;i++) // Find the Column name
+ for (i=0; i<noCols; i++) // Find the Column name
{
if (!wxStrcmp(colInf[i].colName,szFkCol)) // We have found the (Foreign Key) Column
{
#if OLD_GETCOLUMNS
/********** wxDb::GetColumns() **********/
-wxDbColInf *wxDb::GetColumns(char *tableName[], const char *userID)
+wxDbColInf *wxDb::GetColumns(wxChar *tableName[], const wxChar *userID)
/*
* 1) The last array element of the tableName[] argument must be zero (null).
* This is how the end of the array is detected.
RETCODE retcode;
SDWORD cb;
- wxString UserID;
wxString TableName;
- if (userID)
- {
- if (!wxStrlen(userID))
- UserID = uid;
- else
- UserID = userID;
- }
- else
- UserID = "";
-
- // dBase does not use user names, and some drivers fail if you try to pass one
- if (Dbms() == dbmsDBASE)
- UserID = "";
-
- // Oracle and Interbase user names may only be in uppercase, so force
- // the name to uppercase
- if (Dbms() == dbmsORACLE)
- UserID = UserID.Upper();
+ wxString UserID;
+ convertUserID(userID,UserID);
// Pass 1 - Determine how many columns there are.
// Pass 2 - Allocate the wxDbColInf array and fill in
if (!colInf)
break;
// Mark the end of the array
- wxStrcpy(colInf[noCols].tableName, wxT(""));
- wxStrcpy(colInf[noCols].colName, wxT(""));
+ wxStrcpy(colInf[noCols].tableName,wxT(""));
+ wxStrcpy(colInf[noCols].colName,wxT(""));
colInf[noCols].sqlDataType = 0;
}
// Loop through each table name
// MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
// use the call below that leaves out the user name
- if (wxStrcmp(UserID.c_str(),wxT("")) &&
- Dbms() != dbmsMY_SQL &&
- Dbms() != dbmsACCESS &&
- Dbms() != dbmsMS_SQL_SERVER)
+ if (!UserID.IsEmpty() &&
+ Dbms() != dbmsMY_SQL &&
+ Dbms() != dbmsACCESS &&
+ Dbms() != dbmsMS_SQL_SERVER)
{
retcode = SQLColumns(hstmt,
NULL, 0, // All qualifiers
- (UCHAR *) UserID.c_str(), SQL_NTS, // Owner
+ (UCHAR *) UserID.c_str(), SQL_NTS, // Owner
(UCHAR *) TableName.c_str(), SQL_NTS,
NULL, 0); // All columns
}
/********** wxDb::GetColumns() **********/
-wxDbColInf *wxDb::GetColumns(char *tableName, int *numCols, const char *userID)
+wxDbColInf *wxDb::GetColumns(const wxString &tableName, int *numCols, const wxChar *userID)
//
// Same as the above GetColumns() function except this one gets columns
// only for a single table, and if 'numCols' is not NULL, the number of
RETCODE retcode;
SDWORD cb;
- wxString UserID;
wxString TableName;
- if (userID)
- {
- if (!wxStrlen(userID))
- UserID = uid;
- else
- UserID = userID;
- }
- else
- UserID = "";
-
- // dBase does not use user names, and some drivers fail if you try to pass one
- if (Dbms() == dbmsDBASE)
- UserID = "";
-
- // Oracle user names may only be in uppercase, so force
- // the name to uppercase
- if (Dbms() == dbmsORACLE)
- UserID = UserID.Upper();
+ wxString UserID;
+ convertUserID(userID,UserID);
// Pass 1 - Determine how many columns there are.
// Pass 2 - Allocate the wxDbColInf array and fill in
// Mark the end of the array
wxStrcpy(colInf[noCols].tableName, wxT(""));
wxStrcpy(colInf[noCols].colName, wxT(""));
- colInf[noCols].sqlDataType = 0;
+ colInf[noCols].sqlDataType = 0;
}
TableName = tableName;
// MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
// use the call below that leaves out the user name
- if (wxStrcmp(UserID.c_str(),wxT("")) &&
- Dbms() != dbmsMY_SQL &&
- Dbms() != dbmsACCESS &&
- Dbms() != dbmsMS_SQL_SERVER)
+ if (!UserID.IsEmpty() &&
+ Dbms() != dbmsMY_SQL &&
+ Dbms() != dbmsACCESS &&
+ Dbms() != dbmsMS_SQL_SERVER)
{
retcode = SQLColumns(hstmt,
NULL, 0, // All qualifiers
// BJO 20000428 : Virtuoso returns type names with upper cases!
if (Dbms() == dbmsVIRTUOSO)
{
- wxString s = colInf[colNo].typeName;
+ wxString s = colInf[colNo].typeName;
s = s.MakeLower();
wxStrcmp(colInf[colNo].typeName, s.c_str());
}
independant and which always returns the columns in the order they were
created.
- - The first one (wxDbColInf *wxDb::GetColumns(char *tableName[], const
- char* userID)) calls the second implementation for each separate table
+ - The first one (wxDbColInf *wxDb::GetColumns(wxChar *tableName[], const
+ wxChar* userID)) calls the second implementation for each separate table
before merging the results. This makes the code easier to maintain as
only one member (the second) makes the real work
- - wxDbColInf *wxDb::GetColumns(char *tableName, int *numCols, const
- char *userID) is a little bit improved
+ - wxDbColInf *wxDb::GetColumns(const wxString &tableName, int *numCols, const
+ wxChar *userID) is a little bit improved
- It doesn't anymore rely on the type-name to find out which database-type
each column has
- It ends by sorting the columns, so that they are returned in the same
} _TableColumns;
-wxDbColInf *wxDb::GetColumns(char *tableName[], const char* userID)
+wxDbColInf *wxDb::GetColumns(wxChar *tableName[], const wxChar *userID)
{
int i, j;
// The last array element of the tableName[] argument must be zero (null).
// Mark the end of the array
wxStrcpy(colInf[noCols].tableName, wxT(""));
wxStrcpy(colInf[noCols].colName, wxT(""));
- colInf[noCols].sqlDataType = 0;
+ colInf[noCols].sqlDataType = 0;
// Merge ...
int offset = 0;
} // wxDb::GetColumns() -- NEW
-wxDbColInf *wxDb::GetColumns(char *tableName, int *numCols, const char *userID)
+wxDbColInf *wxDb::GetColumns(const wxString &tableName, int *numCols, const wxChar *userID)
//
// Same as the above GetColumns() function except this one gets columns
// only for a single table, and if 'numCols' is not NULL, the number of
RETCODE retcode;
SDWORD cb;
- wxString UserID;
wxString TableName;
- if (userID)
- {
- if (!wxStrlen(userID))
- UserID = uid;
- else
- UserID = userID;
- }
- else
- UserID = "";
-
- // dBase does not use user names, and some drivers fail if you try to pass one
- if (Dbms() == dbmsDBASE)
- UserID = "";
-
- // Oracle user names may only be in uppercase, so force
- // the name to uppercase
- if (Dbms() == dbmsORACLE)
- UserID = UserID.Upper();
+ wxString UserID;
+ convertUserID(userID,UserID);
// Pass 1 - Determine how many columns there are.
// Pass 2 - Allocate the wxDbColInf array and fill in
// MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
// use the call below that leaves out the user name
- if (wxStrcmp(UserID.c_str(),wxT("")) &&
+ if (!UserID.IsEmpty() &&
Dbms() != dbmsMY_SQL &&
Dbms() != dbmsACCESS &&
Dbms() != dbmsMS_SQL_SERVER)
#ifdef __WXDEBUG__
default:
wxString errMsg;
- errMsg.sprintf("SQL Data type %d currently not supported by wxWindows", colInf[colNo].sqlDataType);
+ errMsg.Printf(wxT("SQL Data type %d currently not supported by wxWindows"), colInf[colNo].sqlDataType);
wxLogDebug(errMsg,wxT("ODBC DEBUG MESSAGE"));
#endif
}
// Build a generic SELECT statement which returns 0 rows
wxString Stmt;
- Stmt.sprintf("select * from %s where 0=1", tableName);
+ Stmt.Printf(wxT("select * from %s where 0=1"), tableName);
// Execute query
if (SQLExecDirect(hstmt, (UCHAR FAR *) Stmt.c_str(), SQL_NTS) != SQL_SUCCESS)
/********** wxDb::GetColumnCount() **********/
-int wxDb::GetColumnCount(char *tableName, const char *userID)
+int wxDb::GetColumnCount(const wxString &tableName, const wxChar *userID)
/*
* Returns a count of how many columns are in a table.
* If an error occurs in computing the number of columns
RETCODE retcode;
- wxString UserID;
wxString TableName;
- if (userID)
- {
- if (!wxStrlen(userID))
- UserID = uid;
- else
- UserID = userID;
- }
- else
- UserID = wxT("");
+ wxString UserID;
+ convertUserID(userID,UserID);
- // dBase does not use user names, and some drivers fail if you try to pass one
- if (Dbms() == dbmsDBASE)
- UserID = wxT("");
+ 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() == dbmsINTERBASE))
+ TableName = TableName.Upper();
- // Oracle user names may only be in uppercase, so force
- // the name to uppercase
- if (Dbms() == dbmsORACLE)
- UserID = UserID.Upper();
+ SQLFreeStmt(hstmt, SQL_CLOSE);
+ // MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
+ // use the call below that leaves out the user name
+ if (!UserID.IsEmpty() &&
+ Dbms() != dbmsMY_SQL &&
+ Dbms() != dbmsACCESS &&
+ Dbms() != dbmsMS_SQL_SERVER)
{
- // Loop through each table name
- {
- 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() == dbmsINTERBASE))
- TableName = TableName.Upper();
-
- SQLFreeStmt(hstmt, SQL_CLOSE);
-
- // MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
- // use the call below that leaves out the user name
- if (wxStrcmp(UserID.c_str(),wxT("")) &&
- Dbms() != dbmsMY_SQL &&
- Dbms() != dbmsACCESS &&
- Dbms() != dbmsMS_SQL_SERVER)
- {
- retcode = SQLColumns(hstmt,
- NULL, 0, // All qualifiers
- (UCHAR *) UserID.c_str(), SQL_NTS, // Owner
- (UCHAR *) TableName.c_str(), SQL_NTS,
- NULL, 0); // All columns
- }
- else
- {
- retcode = SQLColumns(hstmt,
- NULL, 0, // All qualifiers
- NULL, 0, // Owner
- (UCHAR *) TableName.c_str(), SQL_NTS,
- NULL, 0); // All columns
- }
- if (retcode != SQL_SUCCESS)
- { // Error occured, abort
- DispAllErrors(henv, hdbc, hstmt);
- SQLFreeStmt(hstmt, SQL_CLOSE);
- return(-1);
- }
+ retcode = SQLColumns(hstmt,
+ NULL, 0, // All qualifiers
+ (UCHAR *) UserID.c_str(), SQL_NTS, // Owner
+ (UCHAR *) TableName.c_str(), SQL_NTS,
+ NULL, 0); // All columns
+ }
+ else
+ {
+ retcode = SQLColumns(hstmt,
+ NULL, 0, // All qualifiers
+ NULL, 0, // Owner
+ (UCHAR *) TableName.c_str(), SQL_NTS,
+ NULL, 0); // All columns
+ }
+ if (retcode != SQL_SUCCESS)
+ { // Error occured, abort
+ DispAllErrors(henv, hdbc, hstmt);
+ SQLFreeStmt(hstmt, SQL_CLOSE);
+ return(-1);
+ }
- // Count the columns
- while ((retcode = SQLFetch(hstmt)) == SQL_SUCCESS)
- noCols++;
+ // Count the columns
+ while ((retcode = SQLFetch(hstmt)) == SQL_SUCCESS)
+ noCols++;
- if (retcode != SQL_NO_DATA_FOUND)
- { // Error occured, abort
- DispAllErrors(henv, hdbc, hstmt);
- SQLFreeStmt(hstmt, SQL_CLOSE);
- return(-1);
- }
- }
+ if (retcode != SQL_NO_DATA_FOUND)
+ { // Error occured, abort
+ DispAllErrors(henv, hdbc, hstmt);
+ SQLFreeStmt(hstmt, SQL_CLOSE);
+ return(-1);
}
SQLFreeStmt(hstmt, SQL_CLOSE);
/********** wxDb::GetCatalog() *******/
-wxDbInf *wxDb::GetCatalog(char *userID)
+wxDbInf *wxDb::GetCatalog(const wxChar *userID)
/*
* ---------------------------------------------------------------------
* -- 19991203 : mj10777 : Create ------
wxString tblNameSave;
wxString UserID;
-
- if (userID)
- {
- if (!wxStrlen(userID))
- UserID = uid;
- else
- UserID = userID;
- }
- else
- UserID = wxT("");
-
- // dBase does not use user names, and some drivers fail if you try to pass one
- if (Dbms() == dbmsDBASE)
- UserID = wxT("");
-
- // Oracle user names may only be in uppercase, so force
- // the name to uppercase
- if (Dbms() == dbmsORACLE)
- UserID = UserID.Upper();
+ convertUserID(userID,UserID);
//-------------------------------------------------------------
- pDbInf = new wxDbInf; // Create the Database Arrray
+ pDbInf = new wxDbInf; // Create the Database Array
//-------------------------------------------------------------
// Table Information
// Pass 1 - Determine how many Tables there are.
for (pass = 1; pass <= 2; pass++)
{
SQLFreeStmt(hstmt, SQL_CLOSE); // Close if Open
- tblNameSave = wxT("");
+ tblNameSave.Empty();
- if (wxStrcmp(UserID.c_str(),wxT("")) &&
+ if (!UserID.IsEmpty() &&
Dbms() != dbmsMY_SQL &&
- Dbms() != dbmsACCESS)
+ Dbms() != dbmsACCESS &&
+ Dbms() != dbmsMS_SQL_SERVER)
{
retcode = SQLTables(hstmt,
NULL, 0, // All qualifiers
/********** wxDb::Catalog() **********/
-bool wxDb::Catalog(const char *userID, const char *fileName)
+bool wxDb::Catalog(const wxChar *userID, const wxString &fileName)
/*
* Creates the text file specified in 'filename' which will contain
* a minimal data dictionary of all tables accessible by the user specified
* to avoid undesired unbinding of columns.
*/
{
- assert(fileName && wxStrlen(fileName));
+ wxASSERT(fileName.Length());
RETCODE retcode;
SDWORD cb;
- char tblName[DB_MAX_TABLE_NAME_LEN+1];
+ wxChar tblName[DB_MAX_TABLE_NAME_LEN+1];
wxString tblNameSave;
- char colName[DB_MAX_COLUMN_NAME_LEN+1];
+ wxChar colName[DB_MAX_COLUMN_NAME_LEN+1];
SWORD sqlDataType;
- char typeName[30+1];
+ wxChar typeName[30+1];
SWORD precision, length;
- wxString UserID;
-
- FILE *fp = fopen(fileName,"wt");
+ FILE *fp = fopen(fileName.c_str(),wxT("wt"));
if (fp == NULL)
return(FALSE);
SQLFreeStmt(hstmt, SQL_CLOSE);
- if (userID)
- {
- if (!wxStrlen(userID))
- UserID = uid;
- else
- UserID = userID;
- }
- else
- UserID = wxT("");
-
- // dBase does not use user names, and some drivers fail if you try to pass one
- if (Dbms() == dbmsDBASE)
- UserID = wxT("");
-
- // Oracle user names may only be in uppercase, so force
- // the name to uppercase
- if (Dbms() == dbmsORACLE)
- UserID = UserID.Upper();
+ wxString UserID;
+ convertUserID(userID,UserID);
- if (wxStrcmp(UserID.c_str(),wxT("")) &&
- Dbms() != dbmsMY_SQL &&
- Dbms() != dbmsACCESS)
+ if (!UserID.IsEmpty() &&
+ Dbms() != dbmsMY_SQL &&
+ Dbms() != dbmsACCESS &&
+ Dbms() != dbmsMS_SQL_SERVER)
{
retcode = SQLColumns(hstmt,
NULL, 0, // All qualifiers
}
wxString outStr;
- tblNameSave = wxT("");
+ tblNameSave.Empty();
int cnt = 0;
while ((retcode = SQLFetch(hstmt)) == SQL_SUCCESS)
{
- if (wxStrcmp(tblName,tblNameSave.c_str()))
+ if (wxStrcmp(tblName, tblNameSave.c_str()))
{
if (cnt)
- fputs("\n", fp);
- fputs("================================ ", fp);
- fputs("================================ ", fp);
- fputs("===================== ", fp);
- fputs("========= ", fp);
- fputs("=========\n", fp);
- outStr.sprintf(wxT("%-32s %-32s %-21s %9s %9s\n"),
+ fputs(wxT("\n"), fp);
+ fputs(wxT("================================ "), fp);
+ fputs(wxT("================================ "), fp);
+ fputs(wxT("===================== "), fp);
+ fputs(wxT("========= "), fp);
+ fputs(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("================================ ", fp);
- fputs("================================ ", fp);
- fputs("===================== ", fp);
- fputs("========= ", fp);
- fputs("=========\n", fp);
+ fputs(wxT("================================ "), fp);
+ fputs(wxT("================================ "), fp);
+ fputs(wxT("===================== "), fp);
+ fputs(wxT("========= "), fp);
+ fputs(wxT("=========\n"), fp);
tblNameSave = tblName;
}
GetData(7,SQL_C_SSHORT,(UCHAR *)&precision, 0, &cb);
GetData(8,SQL_C_SSHORT,(UCHAR *)&length, 0, &cb);
- outStr.sprintf("%-32s %-32s (%04d)%-15s %9d %9d\n",
+ outStr.Printf(wxT("%-32s %-32s (%04d)%-15s %9d %9d\n"),
tblName, colName, sqlDataType, typeName, precision, length);
if (fputs(outStr.c_str(), fp) == EOF)
{
} // wxDb::Catalog()
-bool wxDb::TableExists(const char *tableName, const char *userID, const char *tablePath)
+bool wxDb::TableExists(const wxString &tableName, const wxChar *userID, const wxString &tablePath)
/*
* Table name can refer to a table, view, alias or synonym. Returns true
* if the object exists in the database. This function does not indicate
* userID != "" ... UserID set equal to 'userID'
*/
{
- wxString UserID;
- wxString TableName;
+ wxASSERT(tableName.Length());
- assert(tableName && wxStrlen(tableName));
+ wxString TableName;
if (Dbms() == dbmsDBASE)
{
wxString dbName;
- if (tablePath && wxStrlen(tablePath))
- dbName.sprintf("%s\\%s.dbf",tablePath,tableName);
+ if (tablePath.Length())
+ dbName.Printf(wxT("%s/%s.dbf"),tablePath,tableName);
else
- dbName.sprintf("%s.dbf",tableName);
+ dbName.Printf(wxT("%s.dbf"),tableName);
bool exists;
- exists = wxFileExists(dbName.c_str());
+ exists = wxFileExists(dbName);
return exists;
}
- if (userID)
- {
- if (!wxStrlen(userID))
- UserID = uid;
- else
- UserID = userID;
- }
- else
- UserID = "";
-
- // Oracle user names may only be in uppercase, so force
- // the name to uppercase
- if (Dbms() == dbmsORACLE)
- UserID = UserID.Upper();
+ wxString UserID;
+ convertUserID(userID,UserID);
TableName = tableName;
// Oracle and Interbase table names are uppercase only, so force
// 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 (wxStrcmp(UserID,"") &&
+ if (!UserID.IsEmpty() &&
Dbms() != dbmsMY_SQL &&
Dbms() != dbmsACCESS &&
Dbms() != dbmsMS_SQL_SERVER)
/********** wxDb::TablePrivileges() **********/
-bool wxDb::TablePrivileges(const char *tableName, const char* priv, const char *userID,
- const char *schema, const char *tablePath)
+bool wxDb::TablePrivileges(const wxString &tableName, const wxString &priv, const wxChar *userID,
+ const wxChar *schema, const wxString &tablePath)
{
+ wxASSERT(tableName.Length());
+
wxDbTablePrivilegeInfo result;
SDWORD cbRetVal;
RETCODE retcode;
- //We probably need to be able to dynamically set this based on
- //the driver type, and state.
- char curRole[]="public";
+ // We probably need to be able to dynamically set this based on
+ // the driver type, and state.
+ wxChar curRole[]=wxT("public");
- //Prologue here similar to db::TableExists()
- wxString UserID;
wxString TableName;
- assert(userID);
- assert(tableName && wxStrlen(tableName));
-
- if (userID)
- {
- if (!wxStrlen(userID))
- UserID = uid;
- else
- UserID = userID;
- }
- else
- UserID = "";
-
- // Oracle user names may only be in uppercase, so force
- // the name to uppercase
- if (Dbms() == dbmsORACLE)
- UserID = UserID.Upper();
+ wxString UserID;
+ convertUserID(userID,UserID);
TableName = tableName;
// Oracle and Interbase table names are uppercase only, so force
}
#ifdef DBDEBUG_CONSOLE
- fprintf(stderr ,"SQLTablePrivileges() returned %i \n",retcode);
+ fprintf(stderr ,wxT("SQLTablePrivileges() returned %i \n"),retcode);
#endif
if ((retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO))
return(DispAllErrors(henv, hdbc, hstmt));
#ifdef DBDEBUG_CONSOLE
- fprintf(stderr,"Scanning %s privilege on table %s.%s granted by %s to %s\n",
+ fprintf(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
/********** wxDb::SetSqlLogging() **********/
-bool wxDb::SetSqlLogging(wxDbSqlLogState state, const char *filename, bool append)
+bool wxDb::SetSqlLogging(wxDbSqlLogState state, const wxString &filename, bool append)
{
- assert(state == sqlLogON || state == sqlLogOFF);
- assert(state == sqlLogOFF || filename);
+ wxASSERT(state == sqlLogON || state == sqlLogOFF);
+ wxASSERT(state == sqlLogOFF || filename.Length());
if (state == sqlLogON)
{
if (fpSqlLog == 0)
{
- fpSqlLog = fopen(filename, (append ? "at" : "wt"));
+ fpSqlLog = fopen(filename, (append ? wxT("at") : wxT("wt")));
if (fpSqlLog == NULL)
return(FALSE);
}
/********** wxDb::WriteSqlLog() **********/
-bool wxDb::WriteSqlLog(const wxChar *logMsg)
+bool wxDb::WriteSqlLog(const wxString &logMsg)
{
- assert(logMsg);
+ wxASSERT(logMsg.Length());
if (fpSqlLog == 0 || sqlLogState == sqlLogOFF)
return(FALSE);
- if (fputs("\n", fpSqlLog) == EOF) return(FALSE);
- if (fputs(logMsg, fpSqlLog) == EOF) return(FALSE);
- if (fputs("\n", fpSqlLog) == EOF) 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);
return(TRUE);
// RGG 20001025 : add support for Interbase
// GT : Integrated to base classes on 20001121
- if (!wxStricmp(dbInf.dbmsName,"Interbase"))
+ if (!wxStricmp(dbInf.dbmsName,wxT("Interbase")))
return((wxDBMS)(dbmsType = dbmsINTERBASE));
// BJO 20000428 : add support for Virtuoso
- if (!wxStricmp(dbInf.dbmsName,"OpenLink Virtuoso VDBMS"))
+ if (!wxStricmp(dbInf.dbmsName,wxT("OpenLink Virtuoso VDBMS")))
return((wxDBMS)(dbmsType = dbmsVIRTUOSO));
- if (!wxStricmp(dbInf.dbmsName,"Adaptive Server Anywhere"))
+ if (!wxStricmp(dbInf.dbmsName,wxT("Adaptive Server Anywhere")))
return((wxDBMS)(dbmsType = dbmsSYBASE_ASA));
// BJO 20000427 : The "SQL Server" string is also returned by SQLServer when
// connected through an OpenLink driver.
// Is it also returned by Sybase Adapatitve server?
// OpenLink driver name is OLOD3032.DLL for msw and oplodbc.so for unix
- if (!wxStricmp(dbInf.dbmsName,"SQL Server"))
+ if (!wxStricmp(dbInf.dbmsName,wxT("SQL Server")))
{
- if (!wxStrncmp(dbInf.driverName, "oplodbc", 7) ||
- !wxStrncmp(dbInf.driverName, "OLOD", 4))
+ if (!wxStrncmp(dbInf.driverName, wxT("oplodbc"), 7) ||
+ !wxStrncmp(dbInf.driverName, wxT("OLOD"), 4))
return ((wxDBMS)(dbmsMS_SQL_SERVER));
else
return ((wxDBMS)(dbmsType = dbmsSYBASE_ASE));
}
- if (!wxStricmp(dbInf.dbmsName,"Microsoft SQL Server"))
+ if (!wxStricmp(dbInf.dbmsName,wxT("Microsoft SQL Server")))
return((wxDBMS)(dbmsType = dbmsMS_SQL_SERVER));
- if (!wxStricmp(dbInf.dbmsName,"MySQL"))
+ if (!wxStricmp(dbInf.dbmsName,wxT("MySQL")))
return((wxDBMS)(dbmsType = dbmsMY_SQL));
- if (!wxStricmp(dbInf.dbmsName,"PostgreSQL")) // v6.5.0
+ if (!wxStricmp(dbInf.dbmsName,wxT("PostgreSQL"))) // v6.5.0
return((wxDBMS)(dbmsType = dbmsPOSTGRES));
baseName[8] = 0;
- if (!wxStricmp(baseName,"Informix"))
+ if (!wxStricmp(baseName,wxT("Informix")))
return((wxDBMS)(dbmsType = dbmsINFORMIX));
baseName[6] = 0;
- if (!wxStricmp(baseName,"Oracle"))
+ if (!wxStricmp(baseName,wxT("Oracle")))
return((wxDBMS)(dbmsType = dbmsORACLE));
- if (!wxStricmp(dbInf.dbmsName,"ACCESS"))
+ if (!wxStricmp(dbInf.dbmsName,wxT("ACCESS")))
return((wxDBMS)(dbmsType = dbmsACCESS));
- if (!wxStricmp(dbInf.dbmsName,"MySQL"))
+ if (!wxStricmp(dbInf.dbmsName,wxT("MySQL")))
return((wxDBMS)(dbmsType = dbmsMY_SQL));
- if (!wxStricmp(baseName,"Sybase"))
+ if (!wxStricmp(baseName,wxT("Sybase")))
return((wxDBMS)(dbmsType = dbmsSYBASE_ASE));
baseName[5] = 0;
- if (!wxStricmp(baseName,"DBASE"))
+ if (!wxStricmp(baseName,wxT("DBASE")))
return((wxDBMS)(dbmsType = dbmsDBASE));
baseName[3] = 0;
- if (!wxStricmp(baseName,"DB2"))
+ if (!wxStricmp(baseName,wxT("DB2")))
return((wxDBMS)(dbmsType = dbmsDBASE));
return((wxDBMS)(dbmsType = dbmsUNIDENTIFIED));
} // wxDb::Dbms()
+bool wxDb::ModifyColumn(const wxString &tableName, const wxString &columnName,
+ int dataType, ULONG columnLength,
+ const wxString &optionalParam)
+{
+ wxASSERT(tableName.Length());
+ wxASSERT(columnName.Length());
+ wxASSERT((dataType == DB_DATA_TYPE_VARCHAR && columnLength > 0) ||
+ dataType != DB_DATA_TYPE_VARCHAR);
+
+ // Must specify a columnLength if modifying a VARCHAR type column
+ if (dataType == DB_DATA_TYPE_VARCHAR && !columnLength)
+ return FALSE;
+
+ wxString dataTypeName;
+ 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, alterSlashModify,
+ columnName, dataTypeName);
+
+ // For varchars only, append the size of the column
+ if (dataType == DB_DATA_TYPE_VARCHAR)
+ {
+ wxString s;
+ s.Printf(wxT("(%d)"), columnLength);
+ sqlStmt += s;
+ }
+
+ // for passing things like "NOT NULL"
+ if (optionalParam.Length())
+ {
+ sqlStmt += wxT(" ");
+ sqlStmt += optionalParam;
+ }
+
+ return ExecSql(sqlStmt);
+
+} // wxDb::ModifyColumn()
+
+
/********** wxDbGetConnection() **********/
wxDb WXDLLEXPORT *wxDbGetConnection(wxDbConnectInf *pDbConfig, bool FwdOnlyCursors)
{
}
// Initialize new node in the linked list
- pList->PtrNext = 0;
- pList->Free = FALSE;
- wxStrcpy(pList->Dsn, pDbConfig->Dsn);
- wxStrcpy(pList->Uid, pDbConfig->Uid);
- wxStrcpy(pList->AuthStr, pDbConfig->AuthStr);
+ pList->PtrNext = 0;
+ pList->Free = FALSE;
+ pList->Dsn = pDbConfig->Dsn;
+ pList->Uid = pDbConfig->Uid;
+ pList->AuthStr = pDbConfig->AuthStr;
pList->PtrDb = new wxDb(pDbConfig->Henv,FwdOnlyCursors);
#if 0
/********** wxDbCreateDataSource() **********/
-int wxDbCreateDataSource(const char *driverName, const char *dsn, const char *description,
- bool sysDSN, const char *defDir, wxWindow *parent)
+int wxDbCreateDataSource(const wxString &driverName, const wxString &dsn, const wxString &description,
+ bool sysDSN, const wxString &defDir, wxWindow *parent)
/*
* !!!! ONLY FUNCTIONAL UNDER MSW with VC6 !!!!
* Very rudimentary creation of an ODBC data source.
// NOTE: The decimal 2 is an invalid character in all keyword pairs
// so that is why I used it, as wxString does not deal well with
// embedded nulls in strings
- setupStr.sprintf("DSN=%s%cDescription=%s%cDefaultDir=%s%c",dsn,2,description,2,defDir,2);
+ 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
// by the SQLConfigDataSource() function
{
k = setupStr.Find((wxChar)2,TRUE);
if (k != wxNOT_FOUND)
- setupStr[(UINT)k] = '\0';
+ setupStr[(UINT)k] = wxT('\0');
}
while (k != wxNOT_FOUND);
DWORD retcode = 0;
WORD cb;
wxChar errMsg[SQL_MAX_MESSAGE_LENGTH];
- errMsg[0] = '\0';
+ errMsg[0] = wxT('\0');
// This function is only supported in ODBC drivers v3.0 compliant and above
SQLInstallerError(1,&retcode,errMsg,SQL_MAX_MESSAGE_LENGTH-1,&cb);
// Using iODBC/unixODBC or some other compiler which does not support the APIs
// necessary to use this function, so this function is not supported
#ifdef __WXDEBUG__
- wxLogDebug("wxDbCreateDataSource() not available except under VC++/MSW",wxT("ODBC DEBUG MESSAGE"));
+ wxLogDebug(wxT("wxDbCreateDataSource() not available except under VC++/MSW"),wxT("ODBC DEBUG MESSAGE"));
#endif
result = FALSE;
#endif // __VISUALC__
/********** wxDbGetDataSource() **********/
-bool wxDbGetDataSource(HENV henv, char *Dsn, SWORD DsnMax, char *DsDesc, SWORD DsDescMax,
- UWORD direction)
+bool wxDbGetDataSource(HENV henv, wxChar *Dsn, SWORD DsnMax, wxChar *DsDesc,
+ SWORD DsDescMax, UWORD direction)
/*
* Dsn and DsDesc will contain the data source name and data source
* description upon return
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#include <assert.h>
#if wxMAJOR_VERSION == 1
#include "table.h"
/********** wxDbTable::wxDbTable() **********/
-wxDbTable::wxDbTable(wxDb *pwxDb, const char *tblName, const int nCols,
- const char *qryTblName, bool qryOnly, const char *tblPath)
+wxDbTable::wxDbTable(wxDb *pwxDb, const wxString &tblName, const int nCols,
+ const wxString &qryTblName, bool qryOnly, const wxString &tblPath)
{
+ if (!initialize(pwxDb, tblName, nCols, qryTblName, qryOnly, tblPath))
+ cleanup();
+} // wxDbTable::wxDbTable()
+
+
+/***** DEPRECATED: use wxDbTable::wxDbTable() format above *****/
+wxDbTable::wxDbTable(wxDb *pwxDb, const wxString &tblName, const int nCols,
+ const wxChar *qryTblName, bool qryOnly, const wxString &tblPath)
+{
+ wxString tempQryTblName;
+ tempQryTblName = qryTblName;
+ if (!initialize(pwxDb, tblName, nCols, tempQryTblName, qryOnly, tblPath))
+ cleanup();
+} // wxDbTable::wxDbTable()
+
+
+/********** wxDbTable::~wxDbTable() **********/
+wxDbTable::~wxDbTable()
+{
+ this->cleanup();
+} // wxDbTable::~wxDbTable()
+
+
+bool wxDbTable::initialize(wxDb *pwxDb, const wxString &tblName, const int nCols,
+ const wxString &qryTblName, bool qryOnly, const wxString &tblPath)
+{
+ // Initializing member variables
pDb = pwxDb; // Pointer to the wxDb object
henv = 0;
hdbc = 0;
colDefs = 0;
tableID = 0;
noCols = nCols; // No. of cols in the table
- where = ""; // Where clause
- orderBy = ""; // Order By clause
- from = ""; // From clause
+ where.Empty(); // Where clause
+ orderBy.Empty(); // Order By clause
+ from.Empty(); // From clause
selectForUpdate = FALSE; // SELECT ... FOR UPDATE; Indicates whether to include the FOR UPDATE phrase
queryOnly = qryOnly;
insertable = TRUE;
- wxStrcpy(tablePath,"");
- wxStrcpy(tableName,"");
- wxStrcpy(queryTableName,"");
+ tablePath.Empty();
+ tableName.Empty();
+ queryTableName.Empty();
- assert (tblName);
+ wxASSERT(tblName.Length());
+ wxASSERT(pDb);
- wxStrcpy(tableName, tblName); // Table Name
- if (tblPath)
- wxStrcpy(tablePath, tblPath); // Table Path - used for dBase files
+ if (!pDb)
+ return FALSE;
+
+ tableName = tblName; // Table Name
+ if (tblPath.Length())
+ tablePath = tblPath; // Table Path - used for dBase files
else
- tablePath[0] = 0;
+ tablePath.Empty();
- if (qryTblName) // Name of the table/view to query
- wxStrcpy(queryTableName, qryTblName);
+ if (qryTblName.Length()) // Name of the table/view to query
+ queryTableName = qryTblName;
else
- wxStrcpy(queryTableName, tblName);
-
- if (!pDb)
- return;
+ queryTableName = tblName;
pDb->incrementTableCount();
wxString s;
tableID = ++lastTableID;
- s.sprintf("wxDbTable constructor (%-20s) tableID:[%6lu] pDb:[%p]", tblName,tableID,pDb);
+ s.Printf(wxT("wxDbTable constructor (%-20s) tableID:[%6lu] pDb:[%p]"), tblName,tableID,pDb);
#ifdef __WXDEBUG__
wxTablesInUse *tableInUse;
TablesInUse.Append(tableInUse);
#endif
- pDb->WriteSqlLog(s.c_str());
+ pDb->WriteSqlLog(s);
// Grab the HENV and HDBC from the wxDb object
henv = pDb->GetHENV();
// Allocate space for column definitions
if (noCols)
- colDefs = new wxDbColDef[noCols]; // Points to the first column defintion
+ colDefs = new wxDbColDef[noCols]; // Points to the first column definition
// Allocate statement handles for the table
if (!queryOnly)
{
// Check to see if cursor type is supported
pDb->GetNextError(henv, hdbc, hstmtInternal);
- if (! wxStrcmp(pDb->sqlState, "01S02")) // Option Value Changed
+ if (! wxStrcmp(pDb->sqlState, wxT("01S02"))) // Option Value Changed
{
// Datasource does not support static cursors. Driver
// will substitute a cursor type. Call SQLGetStmtOption()
if (SQLGetStmtOption(hstmtInternal, SQL_CURSOR_TYPE, &cursorType) != SQL_SUCCESS)
pDb->DispAllErrors(henv, hdbc, hstmtInternal);
#ifdef DBDEBUG_CONSOLE
- cout << "Static cursor changed to: ";
+ cout << wxT("Static cursor changed to: ");
switch(cursorType)
{
case SQL_CURSOR_FORWARD_ONLY:
- cout << "Forward Only";
+ cout << wxT("Forward Only");
break;
case SQL_CURSOR_STATIC:
- cout << "Static";
+ cout << wxT("Static");
break;
case SQL_CURSOR_KEYSET_DRIVEN:
- cout << "Keyset Driven";
+ cout << wxT("Keyset Driven");
break;
case SQL_CURSOR_DYNAMIC:
- cout << "Dynamic";
+ cout << wxT("Dynamic");
break;
}
cout << endl << endl;
{
// Should never happen
pDb->GetNextError(henv, hdbc, hstmtInternal);
- return;
+ return FALSE;
}
}
}
}
#ifdef DBDEBUG_CONSOLE
else
- cout << "Cursor Type set to STATIC" << endl << endl;
+ cout << wxT("Cursor Type set to STATIC") << endl << endl;
#endif
if (!queryOnly)
// Make the default cursor the active cursor
hstmtDefault = GetNewCursor(FALSE,FALSE);
- assert(hstmtDefault);
+ wxASSERT(hstmtDefault);
hstmt = *hstmtDefault;
-
-} // wxDbTable::wxDbTable()
+ return TRUE;
-/********** wxDbTable::~wxDbTable() **********/
-wxDbTable::~wxDbTable()
+} // wxDbTable::initialize()
+
+
+void wxDbTable::cleanup()
{
wxString s;
if (pDb)
{
- s.sprintf("wxDbTable destructor (%-20s) tableID:[%6lu] pDb:[%p]", tableName,tableID,pDb);
- pDb->WriteSqlLog(s.c_str());
+ s.Printf(wxT("wxDbTable destructor (%-20s) tableID:[%6lu] pDb:[%p]"), tableName,tableID,pDb);
+ pDb->WriteSqlLog(s);
}
#ifdef __WXDEBUG__
{
found = TRUE;
if (!TablesInUse.DeleteNode(pNode))
- wxLogDebug (s.c_str(),wxT("Unable to delete node!"));
+ wxLogDebug (s,wxT("Unable to delete node!"));
}
else
pNode = pNode->Next();
if (!found)
{
wxString msg;
- msg.sprintf(wxT("Unable to find the tableID in the linked\nlist of tables in use.\n\n%s"),s.c_str());
- wxLogDebug (msg.c_str(),wxT("NOTICE..."));
+ msg.Printf(wxT("Unable to find the tableID in the linked\nlist of tables in use.\n\n%s"),s);
+ wxLogDebug (msg,wxT("NOTICE..."));
}
}
#endif
if (hstmtCount)
DeleteCursor(hstmtCount);
-
-} // wxDbTable::~wxDbTable()
-
+} // wxDbTable::cleanup()
/***************************** PRIVATE FUNCTIONS *****************************/
-
-/********** wxDbTable::bindInsertParams() **********/
-bool wxDbTable::bindInsertParams(void)
+/********** wxDbTable::bindUpdateParams() **********/
+bool wxDbTable::bindParams(bool forUpdate)
{
- assert(!queryOnly);
+ wxASSERT(!queryOnly);
if (queryOnly)
return(FALSE);
-
+
SWORD fSqlType = 0;
UDWORD precision = 0;
SWORD scale = 0;
-
- // Bind each column (that can be inserted) of the table to a parameter marker
+
+ // Bind each column of the table that should be bound
+ // to a parameter marker
int i,colNo;
for (i = 0, colNo = 1; i < noCols; i++)
{
- if (! colDefs[i].InsertAllowed)
- continue;
- switch(colDefs[i].DbDataType)
+ if (forUpdate)
{
- case DB_DATA_TYPE_VARCHAR:
- fSqlType = pDb->GetTypeInfVarchar().FsqlType;
- precision = colDefs[i].SzDataObj;
- scale = 0;
- if (colDefs[i].Null)
- colDefs[i].CbValue = SQL_NULL_DATA;
- else
- colDefs[i].CbValue = SQL_NTS;
- break;
- case DB_DATA_TYPE_INTEGER:
- fSqlType = pDb->GetTypeInfInteger().FsqlType;
- precision = pDb->GetTypeInfInteger().Precision;
- scale = 0;
- if (colDefs[i].Null)
- colDefs[i].CbValue = SQL_NULL_DATA;
- else
- colDefs[i].CbValue = 0;
- break;
- case DB_DATA_TYPE_FLOAT:
- fSqlType = pDb->GetTypeInfFloat().FsqlType;
- precision = pDb->GetTypeInfFloat().Precision;
- scale = pDb->GetTypeInfFloat().MaximumScale;
- // SQL Sybase Anywhere v5.5 returned a negative number for the
- // MaxScale. This caused ODBC to kick out an error on ibscale.
- // I check for this here and set the scale = precision.
- //if (scale < 0)
- // scale = (short) precision;
- if (colDefs[i].Null)
- colDefs[i].CbValue = SQL_NULL_DATA;
- else
- colDefs[i].CbValue = 0;
- break;
- case DB_DATA_TYPE_DATE:
- fSqlType = pDb->GetTypeInfDate().FsqlType;
- precision = pDb->GetTypeInfDate().Precision;
- scale = 0;
- if (colDefs[i].Null)
- colDefs[i].CbValue = SQL_NULL_DATA;
- else
- colDefs[i].CbValue = 0;
- break;
+ if (! colDefs[i].Updateable)
+ continue;
}
- // Null values
-//RG-NULL
-//RG-NULL if (colDefs[i].Null)
-//RG-NULL {
-//RG-NULL colDefs[i].CbValue = SQL_NULL_DATA;
-//RG-NULL colDefs[i].Null = FALSE;
-//RG-NULL }
-
- if (SQLBindParameter(hstmtInsert, colNo++, SQL_PARAM_INPUT, colDefs[i].SqlCtype,
- fSqlType, precision, scale, (UCHAR*) colDefs[i].PtrDataObj,
- precision+1,&colDefs[i].CbValue) != SQL_SUCCESS)
+ else
{
- return(pDb->DispAllErrors(henv, hdbc, hstmtInsert));
+ if (! colDefs[i].InsertAllowed)
+ continue;
}
- }
-
- // Completed successfully
- return(TRUE);
-} // wxDbTable::bindInsertParams()
-
-
-/********** wxDbTable::bindUpdateParams() **********/
-bool wxDbTable::bindUpdateParams(void)
-{
- assert(!queryOnly);
- if (queryOnly)
- return(FALSE);
-
- SWORD fSqlType = 0;
- UDWORD precision = 0;
- SWORD scale = 0;
-
- // Bind each UPDATEABLE column of the table to a parameter marker
- int i,colNo;
- for (i = 0, colNo = 1; i < noCols; i++)
- {
- if (! colDefs[i].Updateable)
- continue;
switch(colDefs[i].DbDataType)
{
case DB_DATA_TYPE_VARCHAR:
colDefs[i].CbValue = 0;
break;
}
-
- if (SQLBindParameter(hstmtUpdate, colNo++, SQL_PARAM_INPUT, colDefs[i].SqlCtype,
- fSqlType, precision, scale, (UCHAR*) colDefs[i].PtrDataObj,
- precision+1, &colDefs[i].CbValue) != SQL_SUCCESS)
+ if (forUpdate)
+ {
+ if (SQLBindParameter(hstmtUpdate, colNo++, SQL_PARAM_INPUT, colDefs[i].SqlCtype,
+ fSqlType, precision, scale, (UCHAR*) colDefs[i].PtrDataObj,
+ precision+1, &colDefs[i].CbValue) != SQL_SUCCESS)
+ {
+ return(pDb->DispAllErrors(henv, hdbc, hstmtUpdate));
+ }
+ }
+ else
{
- return(pDb->DispAllErrors(henv, hdbc, hstmtUpdate));
+ if (SQLBindParameter(hstmtInsert, colNo++, SQL_PARAM_INPUT, colDefs[i].SqlCtype,
+ fSqlType, precision, scale, (UCHAR*) colDefs[i].PtrDataObj,
+ precision+1,&colDefs[i].CbValue) != SQL_SUCCESS)
+ {
+ return(pDb->DispAllErrors(henv, hdbc, hstmtInsert));
+ }
}
}
// Completed successfully
return(TRUE);
+} // wxDbTable::bindParams()
+
+
+/********** wxDbTable::bindInsertParams() **********/
+bool wxDbTable::bindInsertParams(void)
+{
+ return bindParams(FALSE);
+} // wxDbTable::bindInsertParams()
+
+
+/********** wxDbTable::bindUpdateParams() **********/
+bool wxDbTable::bindUpdateParams(void)
+{
+ return bindParams(TRUE);
} // wxDbTable::bindUpdateParams()
/********** wxDbTable::execDelete() **********/
-bool wxDbTable::execDelete(const char *pSqlStmt)
+bool wxDbTable::execDelete(const wxString &pSqlStmt)
{
// Execute the DELETE statement
- if (SQLExecDirect(hstmtDelete, (UCHAR FAR *) pSqlStmt, SQL_NTS) != SQL_SUCCESS)
+ if (SQLExecDirect(hstmtDelete, (UCHAR FAR *) pSqlStmt.c_str(), SQL_NTS) != SQL_SUCCESS)
return(pDb->DispAllErrors(henv, hdbc, hstmtDelete));
// Record deleted successfully
/********** wxDbTable::execUpdate() **********/
-bool wxDbTable::execUpdate(const char *pSqlStmt)
+bool wxDbTable::execUpdate(const wxString &pSqlStmt)
{
// Execute the UPDATE statement
- if (SQLExecDirect(hstmtUpdate, (UCHAR FAR *) pSqlStmt, SQL_NTS) != SQL_SUCCESS)
+ if (SQLExecDirect(hstmtUpdate, (UCHAR FAR *) pSqlStmt.c_str(), SQL_NTS) != SQL_SUCCESS)
return(pDb->DispAllErrors(henv, hdbc, hstmtUpdate));
// Record deleted successfully
/********** wxDbTable::query() **********/
-bool wxDbTable::query(int queryType, bool forUpdate, bool distinct, const char *pSqlStmt)
+bool wxDbTable::query(int queryType, bool forUpdate, bool distinct, const wxString &pSqlStmt)
{
- char sqlStmt[DB_MAX_STATEMENT_LEN];
+ wxString sqlStmt;
if (forUpdate)
// The user may wish to select for update, but the DBMS may not be capable
// Execute the SQL SELECT statement
int retcode;
- retcode = SQLExecDirect(hstmt, (UCHAR FAR *) (queryType == DB_SELECT_STATEMENT ? pSqlStmt : sqlStmt), SQL_NTS);
+ retcode = SQLExecDirect(hstmt, (UCHAR FAR *) (queryType == DB_SELECT_STATEMENT ? pSqlStmt.c_str() : sqlStmt.c_str()), SQL_NTS);
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
return(pDb->DispAllErrors(henv, hdbc, hstmt));
wxString sqlStmt;
wxString s;
- s = "";
+ s.Empty();
// Verify that the table exists in the database
if (!pDb->TableExists(tableName,/*pDb->GetUsername()*/NULL,tablePath))
{
- s = "Table/view does not exist in the database";
- if ( *(pDb->dbInf.accessibleTables) == 'Y')
- s += ", or you have no permissions.\n";
+ s = wxT("Table/view does not exist in the database");
+ if ( *(pDb->dbInf.accessibleTables) == wxT('Y'))
+ s += wxT(", or you have no permissions.\n");
else
- s += ".\n";
+ s += wxT(".\n");
}
else if (checkPrivileges)
{
// Unfortunately this optimization doesn't seem to be
// reliable!
if (// *(pDb->dbInf.accessibleTables) == 'N' &&
- !pDb->TablePrivileges(tableName,"SELECT",NULL,pDb->GetUsername(),tablePath))
- s = "Current logged in user does not have sufficient privileges to access this table.\n";
+ !pDb->TablePrivileges(tableName,wxT("SELECT"),NULL,pDb->GetUsername(),tablePath))
+ s = wxT("Current logged in user does not have sufficient privileges to access this table.\n");
}
if (!s.IsEmpty())
{
wxString p;
- if (wxStrcmp(tablePath,""))
- p.sprintf("Error opening '%s/%s'.\n",tablePath,tableName);
+ if (!tablePath.IsEmpty())
+ p.Printf(wxT("Error opening '%s/%s'.\n"),tablePath,tableName);
else
- p.sprintf("Error opening '%s'.\n", tableName);
+ p.Printf(wxT("Error opening '%s'.\n"), tableName);
p += s;
pDb->LogError(p.GetData());
if (!queryOnly && noCols > 0)
{
bool needComma = FALSE;
- sqlStmt.sprintf("INSERT INTO %s (", tableName);
+ sqlStmt.Printf(wxT("INSERT INTO %s ("), tableName);
for (i = 0; i < noCols; i++)
{
if (! colDefs[i].InsertAllowed)
continue;
if (needComma)
- sqlStmt += ",";
+ sqlStmt += wxT(",");
sqlStmt += colDefs[i].ColName;
needComma = TRUE;
}
needComma = FALSE;
- sqlStmt += ") VALUES (";
+ sqlStmt += wxT(") VALUES (");
int insertableCount = 0;
if (! colDefs[i].InsertAllowed)
continue;
if (needComma)
- sqlStmt += ",";
- sqlStmt += "?";
+ sqlStmt += wxT(",");
+ sqlStmt += wxT("?");
needComma = TRUE;
insertableCount++;
}
- sqlStmt += ")";
+ sqlStmt += wxT(")");
// Prepare the insert statement for execution
if (insertableCount)
/********** wxDbTable::QueryBySqlStmt() **********/
-bool wxDbTable::QueryBySqlStmt(const char *pSqlStmt)
+bool wxDbTable::QueryBySqlStmt(const wxString &pSqlStmt)
{
pDb->WriteSqlLog(pSqlStmt);
} // wxDbTable::GetLast()
-/********** wxDbTable::BuildSelectStmt() **********/
-void wxDbTable::BuildSelectStmt(char *pSqlStmt, int typeOfSelect, bool distinct)
+/********** wxDbTable::BuildDeleteStmt() **********/
+void wxDbTable::BuildDeleteStmt(wxString &pSqlStmt, int typeOfDel, const wxString &pWhereClause)
{
- char whereClause[DB_MAX_WHERE_CLAUSE_LEN];
+ wxASSERT(!queryOnly);
+ if (queryOnly)
+ return;
+
+ wxString whereClause;
- whereClause[0] = 0;
+ whereClause.Empty();
+
+ // Handle the case of DeleteWhere() and the where clause is blank. It should
+ // delete all records from the database in this case.
+ if (typeOfDel == DB_DEL_WHERE && (pWhereClause.Length() == 0))
+ {
+ pSqlStmt.Printf(wxT("DELETE FROM %s"), tableName);
+ return;
+ }
+
+ pSqlStmt.Printf(wxT("DELETE FROM %s WHERE "), tableName);
+
+ // Append the WHERE clause to the SQL DELETE statement
+ switch(typeOfDel)
+ {
+ case DB_DEL_KEYFIELDS:
+ // If the datasource supports the ROWID column, build
+ // the where on ROWID for efficiency purposes.
+ // e.g. DELETE FROM PARTS WHERE ROWID = '111.222.333'
+ if (CanUpdByROWID())
+ {
+ SDWORD cb;
+ wxChar rowid[wxDB_ROWID_LEN+1];
+
+ // Get the ROWID value. If not successful retreiving the ROWID,
+ // simply fall down through the code and build the WHERE clause
+ // based on the key fields.
+ if (SQLGetData(hstmt, noCols+1, SQL_C_CHAR, (UCHAR*) rowid, wxDB_ROWID_LEN, &cb) == SQL_SUCCESS)
+ {
+ pSqlStmt += wxT("ROWID = '");
+ pSqlStmt += rowid;
+ pSqlStmt += wxT("'");
+ break;
+ }
+ }
+ // Unable to delete by ROWID, so build a WHERE
+ // clause based on the keyfields.
+ BuildWhereClause(whereClause, DB_WHERE_KEYFIELDS);
+ pSqlStmt += whereClause;
+ break;
+ case DB_DEL_WHERE:
+ pSqlStmt += pWhereClause;
+ break;
+ case DB_DEL_MATCHING:
+ BuildWhereClause(whereClause, DB_WHERE_MATCHING);
+ pSqlStmt += whereClause;
+ break;
+ }
+
+} // BuildDeleteStmt()
+
+
+/***** DEPRECATED: use wxDbTable::BuildDeleteStmt(wxString &....) form *****/
+void wxDbTable::BuildDeleteStmt(wxChar *pSqlStmt, int typeOfDel, const wxString &pWhereClause)
+{
+ wxString tempSqlStmt;
+ BuildDeleteStmt(tempSqlStmt, typeOfDel, pWhereClause);
+ wxStrcpy(pSqlStmt, tempSqlStmt);
+} // wxDbTable::BuildDeleteStmt()
+
+
+/********** wxDbTable::BuildSelectStmt() **********/
+void wxDbTable::BuildSelectStmt(wxString &pSqlStmt, int typeOfSelect, bool distinct)
+{
+ wxString whereClause;
+ whereClause.Empty();
// Build a select statement to query the database
- wxStrcpy(pSqlStmt, "SELECT ");
+ pSqlStmt = wxT("SELECT ");
// SELECT DISTINCT values only?
if (distinct)
- wxStrcat(pSqlStmt, "DISTINCT ");
+ pSqlStmt += wxT("DISTINCT ");
// Was a FROM clause specified to join tables to the base table?
// Available for ::Query() only!!!
// If joining tables, the base table column names must be qualified to avoid ambiguity
if (appendFromClause)
{
- wxStrcat(pSqlStmt, queryTableName);
- wxStrcat(pSqlStmt, ".");
+ pSqlStmt += queryTableName;
+ pSqlStmt += wxT(".");
}
- wxStrcat(pSqlStmt, colDefs[i].ColName);
+ pSqlStmt += colDefs[i].ColName;
if (i + 1 < noCols)
- wxStrcat(pSqlStmt, ",");
+ pSqlStmt += wxT(",");
}
// If the datasource supports ROWID, get this column as well. Exception: Don't retrieve
// If joining tables, the base table column names must be qualified to avoid ambiguity
if (appendFromClause)
{
- wxStrcat(pSqlStmt, ",");
- wxStrcat(pSqlStmt, queryTableName);
- wxStrcat(pSqlStmt, ".ROWID");
+ pSqlStmt += wxT(",");
+ pSqlStmt += queryTableName;
+ pSqlStmt += wxT(".ROWID");
}
else
- wxStrcat(pSqlStmt, ",ROWID");
+ pSqlStmt += wxT(",ROWID");
}
// Append the FROM tablename portion
- wxStrcat(pSqlStmt, " FROM ");
- wxStrcat(pSqlStmt, queryTableName);
+ pSqlStmt += wxT(" FROM ");
+ pSqlStmt += queryTableName;
// Sybase uses the HOLDLOCK keyword to lock a record during query.
// The HOLDLOCK keyword follows the table name in the from clause.
// NOHOLDLOCK (the default). Note: The "FOR UPDATE" clause
// is parsed but ignored in SYBASE Transact-SQL.
if (selectForUpdate && (pDb->Dbms() == dbmsSYBASE_ASA || pDb->Dbms() == dbmsSYBASE_ASE))
- wxStrcat(pSqlStmt, " HOLDLOCK");
+ pSqlStmt += wxT(" HOLDLOCK");
if (appendFromClause)
- wxStrcat(pSqlStmt, from);
+ pSqlStmt += from;
// Append the WHERE clause. Either append the where clause for the class
// or build a where clause. The typeOfSelect determines this.
if (where.Length()) // May not want a where clause!!!
#endif
{
- wxStrcat(pSqlStmt, " WHERE ");
- wxStrcat(pSqlStmt, where);
+ pSqlStmt += wxT(" WHERE ");
+ pSqlStmt += where;
}
break;
case DB_SELECT_KEYFIELDS:
BuildWhereClause(whereClause, DB_WHERE_KEYFIELDS);
- if (wxStrlen(whereClause))
+ if (whereClause.Length())
{
- wxStrcat(pSqlStmt, " WHERE ");
- wxStrcat(pSqlStmt, whereClause);
+ pSqlStmt += wxT(" WHERE ");
+ pSqlStmt += whereClause;
}
break;
case DB_SELECT_MATCHING:
BuildWhereClause(whereClause, DB_WHERE_MATCHING);
- if (wxStrlen(whereClause))
+ if (whereClause.Length())
{
- wxStrcat(pSqlStmt, " WHERE ");
- wxStrcat(pSqlStmt, whereClause);
+ pSqlStmt += wxT(" WHERE ");
+ pSqlStmt += whereClause;
}
break;
}
if (orderBy.Length())
#endif
{
- wxStrcat(pSqlStmt, " ORDER BY ");
- wxStrcat(pSqlStmt, orderBy);
+ pSqlStmt += wxT(" ORDER BY ");
+ pSqlStmt += orderBy;
}
// SELECT FOR UPDATE if told to do so and the datasource is capable. Sybase
// parses the FOR UPDATE clause but ignores it. See the comment above on the
// HOLDLOCK for Sybase.
if (selectForUpdate && CanSelectForUpdate())
- wxStrcat(pSqlStmt, " FOR UPDATE");
+ pSqlStmt += wxT(" FOR UPDATE");
+
+} // wxDbTable::BuildSelectStmt()
+
+/***** DEPRECATED: use wxDbTable::BuildSelectStmt(wxString &....) form *****/
+void wxDbTable::BuildSelectStmt(wxChar *pSqlStmt, int typeOfSelect, bool distinct)
+{
+ wxString tempSqlStmt;
+ BuildSelectStmt(tempSqlStmt, typeOfSelect, distinct);
+ wxStrcpy(pSqlStmt, tempSqlStmt);
} // wxDbTable::BuildSelectStmt()
+/********** wxDbTable::BuildUpdateStmt() **********/
+void wxDbTable::BuildUpdateStmt(wxString &pSqlStmt, int typeOfUpd, const wxString &pWhereClause)
+{
+ wxASSERT(!queryOnly);
+ if (queryOnly)
+ return;
+
+ wxString whereClause;
+ whereClause.Empty();
+
+ bool firstColumn = TRUE;
+
+ pSqlStmt.Printf(wxT("UPDATE %s SET "), tableName);
+
+ // Append a list of columns to be updated
+ int i;
+ for (i = 0; i < noCols; i++)
+ {
+ // Only append Updateable columns
+ if (colDefs[i].Updateable)
+ {
+ if (! firstColumn)
+ pSqlStmt += wxT(",");
+ else
+ firstColumn = FALSE;
+ pSqlStmt += colDefs[i].ColName;
+ pSqlStmt += wxT(" = ?");
+ }
+ }
+
+ // Append the WHERE clause to the SQL UPDATE statement
+ pSqlStmt += wxT(" WHERE ");
+ switch(typeOfUpd)
+ {
+ case DB_UPD_KEYFIELDS:
+ // If the datasource supports the ROWID column, build
+ // the where on ROWID for efficiency purposes.
+ // e.g. UPDATE PARTS SET Col1 = ?, Col2 = ? WHERE ROWID = '111.222.333'
+ if (CanUpdByROWID())
+ {
+ SDWORD cb;
+ wxChar rowid[wxDB_ROWID_LEN+1];
+
+ // Get the ROWID value. If not successful retreiving the ROWID,
+ // simply fall down through the code and build the WHERE clause
+ // based on the key fields.
+ if (SQLGetData(hstmt, noCols+1, SQL_C_CHAR, (UCHAR*) rowid, wxDB_ROWID_LEN, &cb) == SQL_SUCCESS)
+ {
+ pSqlStmt += wxT("ROWID = '");
+ pSqlStmt += rowid;
+ pSqlStmt += wxT("'");
+ break;
+ }
+ }
+ // Unable to delete by ROWID, so build a WHERE
+ // clause based on the keyfields.
+ BuildWhereClause(whereClause, DB_WHERE_KEYFIELDS);
+ pSqlStmt += whereClause;
+ break;
+ case DB_UPD_WHERE:
+ pSqlStmt += pWhereClause;
+ break;
+ }
+} // BuildUpdateStmt()
+
+
+/***** DEPRECATED: use wxDbTable::BuildUpdateStmt(wxString &....) form *****/
+void wxDbTable::BuildUpdateStmt(wxChar *pSqlStmt, int typeOfUpd, const wxString &pWhereClause)
+{
+ wxString tempSqlStmt;
+ BuildUpdateStmt(tempSqlStmt, typeOfUpd, pWhereClause);
+ wxStrcpy(pSqlStmt, tempSqlStmt);
+} // BuildUpdateStmt()
+
+
+/********** wxDbTable::BuildWhereClause() **********/
+void wxDbTable::BuildWhereClause(wxString &pWhereClause, int typeOfWhere,
+ const wxString &qualTableName, bool useLikeComparison)
+/*
+ * Note: BuildWhereClause() currently ignores timestamp columns.
+ * They are not included as part of the where clause.
+ */
+{
+ bool moreThanOneColumn = FALSE;
+ wxString colValue;
+
+ // Loop through the columns building a where clause as you go
+ int i;
+ for (i = 0; i < noCols; i++)
+ {
+ // Determine if this column should be included in the WHERE clause
+ if ((typeOfWhere == DB_WHERE_KEYFIELDS && colDefs[i].KeyField) ||
+ (typeOfWhere == DB_WHERE_MATCHING && (!IsColNull(i))))
+ {
+ // Skip over timestamp columns
+ if (colDefs[i].SqlCtype == SQL_C_TIMESTAMP)
+ continue;
+ // If there is more than 1 column, join them with the keyword "AND"
+ if (moreThanOneColumn)
+ pWhereClause += wxT(" AND ");
+ else
+ moreThanOneColumn = TRUE;
+ // Concatenate where phrase for the column
+ if (qualTableName.Length())
+ {
+ pWhereClause += qualTableName;
+ pWhereClause += wxT(".");
+ }
+ pWhereClause += colDefs[i].ColName;
+ if (useLikeComparison && (colDefs[i].SqlCtype == SQL_C_CHAR))
+ pWhereClause += wxT(" LIKE ");
+ else
+ pWhereClause += wxT(" = ");
+ switch(colDefs[i].SqlCtype)
+ {
+ case SQL_C_CHAR:
+ colValue.Printf(wxT("'%s'"), (UCHAR FAR *) colDefs[i].PtrDataObj);
+ break;
+ case SQL_C_SSHORT:
+ colValue.Printf(wxT("%hi"), *((SWORD *) colDefs[i].PtrDataObj));
+ break;
+ case SQL_C_USHORT:
+ colValue.Printf(wxT("%hu"), *((UWORD *) colDefs[i].PtrDataObj));
+ break;
+ case SQL_C_SLONG:
+ colValue.Printf(wxT("%li"), *((SDWORD *) colDefs[i].PtrDataObj));
+ break;
+ case SQL_C_ULONG:
+ colValue.Printf(wxT("%lu"), *((UDWORD *) colDefs[i].PtrDataObj));
+ break;
+ case SQL_C_FLOAT:
+ colValue.Printf(wxT("%.6f"), *((SFLOAT *) colDefs[i].PtrDataObj));
+ break;
+ case SQL_C_DOUBLE:
+ colValue.Printf(wxT("%.6f"), *((SDOUBLE *) colDefs[i].PtrDataObj));
+ break;
+ }
+ pWhereClause += colValue;
+ }
+ }
+} // wxDbTable::BuildWhereClause()
+
+
+/***** DEPRECATED: use wxDbTable::BuildWhereClause(wxString &....) form *****/
+void wxDbTable::BuildWhereClause(wxChar *pWhereClause, int typeOfWhere,
+ const wxString &qualTableName, bool useLikeComparison)
+{
+ wxString tempSqlStmt;
+ BuildWhereClause(tempSqlStmt, typeOfWhere, qualTableName, useLikeComparison);
+ wxStrcpy(pWhereClause, tempSqlStmt);
+} // wxDbTable::BuildWhereClause()
+
+
/********** wxDbTable::GetRowNum() **********/
UWORD wxDbTable::GetRowNum(void)
{
wxString sqlStmt;
#ifdef DBDEBUG_CONSOLE
- cout << "Creating Table " << tableName << "..." << endl;
+ cout << wxT("Creating Table ") << tableName << wxT("...") << endl;
#endif
// Drop table first
// Exclude derived columns since they are NOT part of the base table
if (colDefs[i].DerivedCol)
continue;
- cout << i + 1 << ": " << colDefs[i].ColName << "; ";
+ cout << i + 1 << wxT(": ") << colDefs[i].ColName << wxT("; ");
switch(colDefs[i].DbDataType)
{
case DB_DATA_TYPE_VARCHAR:
- cout << pDb->typeInfVarchar.TypeName << "(" << colDefs[i].SzDataObj << ")";
+ cout << pDb->typeInfVarchar.TypeName << wxT("(") << colDefs[i].SzDataObj << wxT(")");
break;
case DB_DATA_TYPE_INTEGER:
cout << pDb->typeInfInteger.TypeName;
// Build a CREATE TABLE string from the colDefs structure.
bool needComma = FALSE;
- sqlStmt.sprintf("CREATE TABLE %s (", tableName);
+ sqlStmt.Printf(wxT("CREATE TABLE %s ("), tableName);
for (i = 0; i < noCols; i++)
{
continue;
// Comma Delimiter
if (needComma)
- sqlStmt += ",";
+ sqlStmt += wxT(",");
// Column Name
sqlStmt += colDefs[i].ColName;
- sqlStmt += " ";
+ sqlStmt += wxT(" ");
// Column Type
switch(colDefs[i].DbDataType)
{
if (colDefs[i].DbDataType == DB_DATA_TYPE_VARCHAR)
{
wxString s;
- // wxStrcat(sqlStmt, "(");
- // wxStrcat(sqlStmt, itoa(colDefs[i].SzDataObj, s, 10));
- // wxStrcat(sqlStmt, ")");
- s.sprintf("(%d)", colDefs[i].SzDataObj);
- sqlStmt += s.c_str();
+ s.Printf(wxT("(%d)"), colDefs[i].SzDataObj);
+ sqlStmt += s;
}
if (pDb->Dbms() == dbmsDB2 ||
{
if (colDefs[i].KeyField)
{
- sqlStmt += " NOT NULL";
+ sqlStmt += wxT(" NOT NULL");
}
}
{
if (pDb->Dbms() != dbmsMY_SQL)
{
- sqlStmt += ",CONSTRAINT ";
+ sqlStmt += wxT(",CONSTRAINT ");
sqlStmt += tableName;
- sqlStmt += "_PIDX PRIMARY KEY (";
+ sqlStmt += wxT("_PIDX PRIMARY KEY (");
}
else
{
/* MySQL goes out on this one. We also declare the relevant key NON NULL above */
- sqlStmt += ", PRIMARY KEY (";
+ sqlStmt += wxT(", PRIMARY KEY (");
}
// List column name(s) of column(s) comprising the primary key
if (colDefs[i].KeyField)
{
if (j++) // Multi part key, comma separate names
- sqlStmt += ",";
+ sqlStmt += wxT(",");
sqlStmt += colDefs[i].ColName;
}
}
- sqlStmt += ")";
+ sqlStmt += wxT(")");
}
// Append the closing parentheses for the create table statement
- sqlStmt += ")";
+ sqlStmt += wxT(")");
- pDb->WriteSqlLog(sqlStmt.c_str());
+ pDb->WriteSqlLog(sqlStmt);
#ifdef DBDEBUG_CONSOLE
cout << endl << sqlStmt.c_str() << endl;
wxString sqlStmt;
- sqlStmt.sprintf("DROP TABLE %s", tableName);
+ sqlStmt.Printf(wxT("DROP TABLE %s"), tableName);
- pDb->WriteSqlLog(sqlStmt.c_str());
+ pDb->WriteSqlLog(sqlStmt);
#ifdef DBDEBUG_CONSOLE
cout << endl << sqlStmt.c_str() << endl;
{
// Check for "Base table not found" error and ignore
pDb->GetNextError(henv, hdbc, hstmt);
- if (wxStrcmp(pDb->sqlState,"S0002") && wxStrcmp(pDb->sqlState, "S1000")) // "Base table not found"
+ if (wxStrcmp(pDb->sqlState, wxT("S0002")) &&
+ wxStrcmp(pDb->sqlState, wxT("S1000"))) // "Base table not found"
{
// Check for product specific error codes
- if (!((pDb->Dbms() == dbmsSYBASE_ASA && !wxStrcmp(pDb->sqlState,"42000")) || // 5.x (and lower?)
- (pDb->Dbms() == dbmsSYBASE_ASE && !wxStrcmp(pDb->sqlState,"37000")) ||
- (pDb->Dbms() == dbmsPOSTGRES && !wxStrcmp(pDb->sqlState,"08S01"))))
+ if (!((pDb->Dbms() == dbmsSYBASE_ASA && !wxStrcmp(pDb->sqlState,wxT("42000"))) || // 5.x (and lower?)
+ (pDb->Dbms() == dbmsSYBASE_ASE && !wxStrcmp(pDb->sqlState,wxT("37000"))) ||
+ (pDb->Dbms() == dbmsPOSTGRES && !wxStrcmp(pDb->sqlState,wxT("08S01")))))
{
pDb->DispNextError();
pDb->DispAllErrors(henv, hdbc, hstmt);
/********** wxDbTable::CreateIndex() **********/
-bool wxDbTable::CreateIndex(const char * idxName, bool unique, int noIdxCols, wxDbIdxDef *pIdxDefs, bool attemptDrop)
+bool wxDbTable::CreateIndex(const wxString &idxName, bool unique, int noIdxCols, wxDbIdxDef *pIdxDefs, bool attemptDrop)
{
wxString sqlStmt;
if (found)
{
- wxString typeNameAndSize;
-
- switch(colDefs[j].DbDataType)
- {
- case DB_DATA_TYPE_VARCHAR:
- typeNameAndSize = pDb->GetTypeInfVarchar().TypeName;
- break;
- case DB_DATA_TYPE_INTEGER:
- typeNameAndSize = pDb->GetTypeInfInteger().TypeName;
- break;
- case DB_DATA_TYPE_FLOAT:
- typeNameAndSize = pDb->GetTypeInfFloat().TypeName;
- break;
- case DB_DATA_TYPE_DATE:
- typeNameAndSize = pDb->GetTypeInfDate().TypeName;
- break;
- }
-
- // For varchars, append the size of the string
- if (colDefs[j].DbDataType == DB_DATA_TYPE_VARCHAR)
- {
- wxString s;
- s.sprintf("(%d)", colDefs[i].SzDataObj);
- typeNameAndSize += s.c_str();
- }
-
- sqlStmt.sprintf("ALTER TABLE %s MODIFY %s %s NOT NULL",tableName,pIdxDefs[i].ColName,typeNameAndSize.c_str());
- ok = pDb->ExecSql(sqlStmt.c_str());
-
+ ok = pDb->ModifyColumn(tableName, pIdxDefs[i].ColName,
+ colDefs[j].DbDataType, colDefs[j].SzDataObj,
+ wxT("NOT NULL"));
+
if (!ok)
{
wxODBC_ERRORS retcode;
}
// Build a CREATE INDEX statement
- sqlStmt = "CREATE ";
+ sqlStmt = wxT("CREATE ");
if (unique)
- sqlStmt += "UNIQUE ";
+ sqlStmt += wxT("UNIQUE ");
- sqlStmt += "INDEX ";
+ sqlStmt += wxT("INDEX ");
sqlStmt += idxName;
- sqlStmt += " ON ";
+ sqlStmt += wxT(" ON ");
sqlStmt += tableName;
- sqlStmt += " (";
+ sqlStmt += wxT(" (");
// Append list of columns making up index
int i;
if (pDb->Dbms() != dbmsPOSTGRES)
{
if (pIdxDefs[i].Ascending)
- sqlStmt += " ASC";
+ sqlStmt += wxT(" ASC");
else
- sqlStmt += " DESC";
+ sqlStmt += wxT(" DESC");
}
if ((i + 1) < noIdxCols)
- sqlStmt += ",";
+ sqlStmt += wxT(",");
}
// Append closing parentheses
- sqlStmt += ")";
+ sqlStmt += wxT(")");
- pDb->WriteSqlLog(sqlStmt.c_str());
+ pDb->WriteSqlLog(sqlStmt);
#ifdef DBDEBUG_CONSOLE
cout << endl << sqlStmt.c_str() << endl << endl;
/********** wxDbTable::DropIndex() **********/
-bool wxDbTable::DropIndex(const char * idxName)
+bool wxDbTable::DropIndex(const wxString &idxName)
{
// NOTE: This function returns TRUE if the Index does not exist, but
// only for identified databases. Code will need to be added
wxString sqlStmt;
if (pDb->Dbms() == dbmsACCESS || pDb->Dbms() == dbmsMY_SQL)
- sqlStmt.sprintf("DROP INDEX %s ON %s",idxName,tableName);
+ sqlStmt.Printf(wxT("DROP INDEX %s ON %s"),idxName,tableName);
else if ((pDb->Dbms() == dbmsMS_SQL_SERVER) ||
(pDb->Dbms() == dbmsSYBASE_ASE))
- sqlStmt.sprintf("DROP INDEX %s.%s",tableName,idxName);
+ sqlStmt.Printf(wxT("DROP INDEX %s.%s"),tableName,idxName);
else
- sqlStmt.sprintf("DROP INDEX %s",idxName);
+ sqlStmt.Printf(wxT("DROP INDEX %s"),idxName);
- pDb->WriteSqlLog(sqlStmt.c_str());
+ pDb->WriteSqlLog(sqlStmt);
#ifdef DBDEBUG_CONSOLE
cout << endl << sqlStmt.c_str() << endl;
{
// Check for "Index not found" error and ignore
pDb->GetNextError(henv, hdbc, hstmt);
- if (wxStrcmp(pDb->sqlState,"S0012")) // "Index not found"
+ if (wxStrcmp(pDb->sqlState,wxT("S0012"))) // "Index not found"
{
// Check for product specific error codes
- if (!((pDb->Dbms() == dbmsSYBASE_ASA && !wxStrcmp(pDb->sqlState,"42000")) || // v5.x (and lower?)
- (pDb->Dbms() == dbmsSYBASE_ASE && !wxStrcmp(pDb->sqlState,"37000")) ||
- (pDb->Dbms() == dbmsMS_SQL_SERVER && !wxStrcmp(pDb->sqlState,"S1000")) ||
- (pDb->Dbms() == dbmsSYBASE_ASE && !wxStrcmp(pDb->sqlState,"S0002")) || // Base table not found
- (pDb->Dbms() == dbmsMY_SQL && !wxStrcmp(pDb->sqlState,"42S12")) || // tested by Christopher Ludwik Marino-Cebulski using v3.23.21beta
- (pDb->Dbms() == dbmsPOSTGRES && !wxStrcmp(pDb->sqlState,"08S01"))
+ if (!((pDb->Dbms() == dbmsSYBASE_ASA && !wxStrcmp(pDb->sqlState,wxT("42000"))) || // v5.x (and lower?)
+ (pDb->Dbms() == dbmsSYBASE_ASE && !wxStrcmp(pDb->sqlState,wxT("37000"))) ||
+ (pDb->Dbms() == dbmsMS_SQL_SERVER && !wxStrcmp(pDb->sqlState,wxT("S1000"))) ||
+ (pDb->Dbms() == dbmsSYBASE_ASE && !wxStrcmp(pDb->sqlState,wxT("S0002"))) || // Base table not found
+ (pDb->Dbms() == dbmsMY_SQL && !wxStrcmp(pDb->sqlState,wxT("42S12"))) || // tested by Christopher Ludwik Marino-Cebulski using v3.23.21beta
+ (pDb->Dbms() == dbmsPOSTGRES && !wxStrcmp(pDb->sqlState,wxT("08S01")))
))
{
pDb->DispNextError();
}
if (colNo != first)
- tempStr += ",";
+ tempStr += wxT(",");
tempStr += colDefs[colNo].ColName;
colNo = va_arg (argptr, int);
}
va_end (argptr); /* Reset variable arguments. */
- SetOrderByClause(tempStr.c_str());
+ SetOrderByClause(tempStr);
return (!abort);
} // wxDbTable::SetOrderByColNums()
/********** wxDbTable::Insert() **********/
int wxDbTable::Insert(void)
{
- assert(!queryOnly);
+ wxASSERT(!queryOnly);
if (queryOnly || !insertable)
return(DB_FAILURE);
{
// Check to see if integrity constraint was violated
pDb->GetNextError(henv, hdbc, hstmtInsert);
- if (! wxStrcmp(pDb->sqlState, "23000")) // Integrity constraint violated
+ if (! wxStrcmp(pDb->sqlState, wxT("23000"))) // Integrity constraint violated
return(DB_ERR_INTEGRITY_CONSTRAINT_VIOL);
else
{
/********** wxDbTable::Update() **********/
bool wxDbTable::Update(void)
{
- assert(!queryOnly);
+ wxASSERT(!queryOnly);
if (queryOnly)
return(FALSE);
- char sqlStmt[DB_MAX_STATEMENT_LEN];
+ wxString sqlStmt;
// Build the SQL UPDATE statement
BuildUpdateStmt(sqlStmt, DB_UPD_KEYFIELDS);
pDb->WriteSqlLog(sqlStmt);
#ifdef DBDEBUG_CONSOLE
- cout << endl << sqlStmt << endl << endl;
+ cout << endl << sqlStmt.c_str() << endl << endl;
#endif
// Execute the SQL UPDATE statement
/********** wxDbTable::Update(pSqlStmt) **********/
-bool wxDbTable::Update(const char *pSqlStmt)
+bool wxDbTable::Update(const wxString &pSqlStmt)
{
- assert(!queryOnly);
+ wxASSERT(!queryOnly);
if (queryOnly)
return(FALSE);
/********** wxDbTable::UpdateWhere() **********/
-bool wxDbTable::UpdateWhere(const char *pWhereClause)
+bool wxDbTable::UpdateWhere(const wxString &pWhereClause)
{
- assert(!queryOnly);
+ wxASSERT(!queryOnly);
if (queryOnly)
return(FALSE);
- char sqlStmt[DB_MAX_STATEMENT_LEN];
+ wxString sqlStmt;
// Build the SQL UPDATE statement
BuildUpdateStmt(sqlStmt, DB_UPD_WHERE, pWhereClause);
pDb->WriteSqlLog(sqlStmt);
#ifdef DBDEBUG_CONSOLE
- cout << endl << sqlStmt << endl << endl;
+ cout << endl << sqlStmt.c_str() << endl << endl;
#endif
// Execute the SQL UPDATE statement
/********** wxDbTable::Delete() **********/
bool wxDbTable::Delete(void)
{
- assert(!queryOnly);
+ wxASSERT(!queryOnly);
if (queryOnly)
return(FALSE);
- char sqlStmt[DB_MAX_STATEMENT_LEN];
+ wxString sqlStmt;
+ sqlStmt.Empty();
// Build the SQL DELETE statement
BuildDeleteStmt(sqlStmt, DB_DEL_KEYFIELDS);
/********** wxDbTable::DeleteWhere() **********/
-bool wxDbTable::DeleteWhere(const char *pWhereClause)
+bool wxDbTable::DeleteWhere(const wxString &pWhereClause)
{
- assert(!queryOnly);
+ wxASSERT(!queryOnly);
if (queryOnly)
return(FALSE);
- char sqlStmt[DB_MAX_STATEMENT_LEN];
+ wxString sqlStmt;
+ sqlStmt.Empty();
// Build the SQL DELETE statement
BuildDeleteStmt(sqlStmt, DB_DEL_WHERE, pWhereClause);
/********** wxDbTable::DeleteMatching() **********/
bool wxDbTable::DeleteMatching(void)
{
- assert(!queryOnly);
+ wxASSERT(!queryOnly);
if (queryOnly)
return(FALSE);
- char sqlStmt[DB_MAX_STATEMENT_LEN];
+ wxString sqlStmt;
+ sqlStmt.Empty();
// Build the SQL DELETE statement
BuildDeleteStmt(sqlStmt, DB_DEL_MATCHING);
} // wxDbTable::DeleteMatching()
-/********** wxDbTable::BuildUpdateStmt() **********/
-void wxDbTable::BuildUpdateStmt(char *pSqlStmt, int typeOfUpd, const char *pWhereClause)
-{
- assert(!queryOnly);
- if (queryOnly)
- return;
-
- char whereClause[DB_MAX_WHERE_CLAUSE_LEN];
- bool firstColumn = TRUE;
-
- whereClause[0] = 0;
- sprintf(pSqlStmt, "UPDATE %s SET ", tableName);
-
- // Append a list of columns to be updated
- int i;
- for (i = 0; i < noCols; i++)
- {
- // Only append Updateable columns
- if (colDefs[i].Updateable)
- {
- if (! firstColumn)
- wxStrcat(pSqlStmt, ",");
- else
- firstColumn = FALSE;
- wxStrcat(pSqlStmt, colDefs[i].ColName);
- wxStrcat(pSqlStmt, " = ?");
- }
- }
-
- // Append the WHERE clause to the SQL UPDATE statement
- wxStrcat(pSqlStmt, " WHERE ");
- switch(typeOfUpd)
- {
- case DB_UPD_KEYFIELDS:
- // If the datasource supports the ROWID column, build
- // the where on ROWID for efficiency purposes.
- // e.g. UPDATE PARTS SET Col1 = ?, Col2 = ? WHERE ROWID = '111.222.333'
- if (CanUpdByROWID())
- {
- SDWORD cb;
- char rowid[wxDB_ROWID_LEN];
-
- // Get the ROWID value. If not successful retreiving the ROWID,
- // simply fall down through the code and build the WHERE clause
- // based on the key fields.
- if (SQLGetData(hstmt, noCols+1, SQL_C_CHAR, (UCHAR*) rowid, wxDB_ROWID_LEN, &cb) == SQL_SUCCESS)
- {
- wxStrcat(pSqlStmt, "ROWID = '");
- wxStrcat(pSqlStmt, rowid);
- wxStrcat(pSqlStmt, "'");
- break;
- }
- }
- // Unable to delete by ROWID, so build a WHERE
- // clause based on the keyfields.
- BuildWhereClause(whereClause, DB_WHERE_KEYFIELDS);
- wxStrcat(pSqlStmt, whereClause);
- break;
- case DB_UPD_WHERE:
- wxStrcat(pSqlStmt, pWhereClause);
- break;
- }
-} // BuildUpdateStmt()
-
-
-/********** wxDbTable::BuildDeleteStmt() **********/
-void wxDbTable::BuildDeleteStmt(char *pSqlStmt, int typeOfDel, const char *pWhereClause)
-{
- assert(!queryOnly);
- if (queryOnly)
- return;
-
- char whereClause[DB_MAX_WHERE_CLAUSE_LEN];
-
- whereClause[0] = 0;
-
- // Handle the case of DeleteWhere() and the where clause is blank. It should
- // delete all records from the database in this case.
- if (typeOfDel == DB_DEL_WHERE && (pWhereClause == 0 || wxStrlen(pWhereClause) == 0))
- {
- sprintf(pSqlStmt, "DELETE FROM %s", tableName);
- return;
- }
-
- sprintf(pSqlStmt, "DELETE FROM %s WHERE ", tableName);
-
- // Append the WHERE clause to the SQL DELETE statement
- switch(typeOfDel)
- {
- case DB_DEL_KEYFIELDS:
- // If the datasource supports the ROWID column, build
- // the where on ROWID for efficiency purposes.
- // e.g. DELETE FROM PARTS WHERE ROWID = '111.222.333'
- if (CanUpdByROWID())
- {
- SDWORD cb;
- char rowid[wxDB_ROWID_LEN];
-
- // Get the ROWID value. If not successful retreiving the ROWID,
- // simply fall down through the code and build the WHERE clause
- // based on the key fields.
- if (SQLGetData(hstmt, noCols+1, SQL_C_CHAR, (UCHAR*) rowid, wxDB_ROWID_LEN, &cb) == SQL_SUCCESS)
- {
- wxStrcat(pSqlStmt, "ROWID = '");
- wxStrcat(pSqlStmt, rowid);
- wxStrcat(pSqlStmt, "'");
- break;
- }
- }
- // Unable to delete by ROWID, so build a WHERE
- // clause based on the keyfields.
- BuildWhereClause(whereClause, DB_WHERE_KEYFIELDS);
- wxStrcat(pSqlStmt, whereClause);
- break;
- case DB_DEL_WHERE:
- wxStrcat(pSqlStmt, pWhereClause);
- break;
- case DB_DEL_MATCHING:
- BuildWhereClause(whereClause, DB_WHERE_MATCHING);
- wxStrcat(pSqlStmt, whereClause);
- break;
- }
-
-} // BuildDeleteStmt()
-
-
-/********** wxDbTable::BuildWhereClause() **********/
-void wxDbTable::BuildWhereClause(char *pWhereClause, int typeOfWhere,
- const char *qualTableName, bool useLikeComparison)
-/*
- * Note: BuildWhereClause() currently ignores timestamp columns.
- * They are not included as part of the where clause.
- */
-{
- bool moreThanOneColumn = FALSE;
- char colValue[255];
-
- // Loop through the columns building a where clause as you go
- int i;
- for (i = 0; i < noCols; i++)
- {
- // Determine if this column should be included in the WHERE clause
- if ((typeOfWhere == DB_WHERE_KEYFIELDS && colDefs[i].KeyField) ||
- (typeOfWhere == DB_WHERE_MATCHING && (!IsColNull(i))))
- {
- // Skip over timestamp columns
- if (colDefs[i].SqlCtype == SQL_C_TIMESTAMP)
- continue;
- // If there is more than 1 column, join them with the keyword "AND"
- if (moreThanOneColumn)
- wxStrcat(pWhereClause, " AND ");
- else
- moreThanOneColumn = TRUE;
- // Concatenate where phrase for the column
- if (qualTableName && wxStrlen(qualTableName))
- {
- wxStrcat(pWhereClause, qualTableName);
- wxStrcat(pWhereClause, ".");
- }
- wxStrcat(pWhereClause, colDefs[i].ColName);
- if (useLikeComparison && (colDefs[i].SqlCtype == SQL_C_CHAR))
- wxStrcat(pWhereClause, " LIKE ");
- else
- wxStrcat(pWhereClause, " = ");
- switch(colDefs[i].SqlCtype)
- {
- case SQL_C_CHAR:
- sprintf(colValue, "'%s'", (UCHAR FAR *) colDefs[i].PtrDataObj);
- break;
- case SQL_C_SSHORT:
- sprintf(colValue, "%hi", *((SWORD *) colDefs[i].PtrDataObj));
- break;
- case SQL_C_USHORT:
- sprintf(colValue, "%hu", *((UWORD *) colDefs[i].PtrDataObj));
- break;
- case SQL_C_SLONG:
- sprintf(colValue, "%li", *((SDWORD *) colDefs[i].PtrDataObj));
- break;
- case SQL_C_ULONG:
- sprintf(colValue, "%lu", *((UDWORD *) colDefs[i].PtrDataObj));
- break;
- case SQL_C_FLOAT:
- sprintf(colValue, "%.6f", *((SFLOAT *) colDefs[i].PtrDataObj));
- break;
- case SQL_C_DOUBLE:
- sprintf(colValue, "%.6f", *((SDOUBLE *) colDefs[i].PtrDataObj));
- break;
- }
- wxStrcat(pWhereClause, colValue);
- }
- }
-} // wxDbTable::BuildWhereClause()
-
-
/********** wxDbTable::IsColNull() **********/
bool wxDbTable::IsColNull(int colNo)
{
/********** wxDbTable::ClearMemberVar() **********/
void wxDbTable::ClearMemberVar(int colNo, bool setToNull)
{
- assert(colNo < noCols);
+ wxASSERT(colNo < noCols);
switch(colDefs[colNo].SqlCtype)
{
/********** wxDbTable::SetColDefs() **********/
-void wxDbTable::SetColDefs(int index, const char *fieldName, int dataType, void *pData,
+void wxDbTable::SetColDefs(int index, const wxString &fieldName, int dataType, void *pData,
int cType, int size, bool keyField, bool upd,
bool insAllow, bool derivedCol)
{
if (!colDefs) // May happen if the database connection fails
return;
- if (wxStrlen(fieldName) > (unsigned int) DB_MAX_COLUMN_NAME_LEN)
+ if (fieldName.Length() > (unsigned int) DB_MAX_COLUMN_NAME_LEN)
{
wxStrncpy (colDefs[index].ColName, fieldName, DB_MAX_COLUMN_NAME_LEN);
colDefs[index].ColName[DB_MAX_COLUMN_NAME_LEN] = 0;
/********** wxDbTable::SetColDefs() **********/
wxDbColDataPtr* wxDbTable::SetColDefs(wxDbColInf *pColInfs, ULONG numCols)
{
- assert(pColInfs);
+ wxASSERT(pColInfs);
wxDbColDataPtr *pColDataPtrs = NULL;
if (pColInfs)
switch (pColInfs[index].dbDataType)
{
case DB_DATA_TYPE_VARCHAR:
- pColDataPtrs[index].PtrDataObj = new char[pColInfs[index].bufferLength+1];
+ pColDataPtrs[index].PtrDataObj = new wxChar[pColInfs[index].bufferLength+1];
pColDataPtrs[index].SzDataObj = pColInfs[index].columnSize;
pColDataPtrs[index].SqlCtype = SQL_C_CHAR;
break;
} // wxDbTable::SetCursor()
-/********** wxDbTable::Count(const char *) **********/
-ULONG wxDbTable::Count(const char *args)
+/********** wxDbTable::Count(const wxString &) **********/
+ULONG wxDbTable::Count(const wxString &args)
{
ULONG count;
wxString sqlStmt;
SDWORD cb;
// Build a "SELECT COUNT(*) FROM queryTableName [WHERE whereClause]" SQL Statement
- sqlStmt = "SELECT COUNT(";
+ sqlStmt = wxT("SELECT COUNT(");
sqlStmt += args;
- sqlStmt += ") FROM ";
+ sqlStmt += wxT(") FROM ");
sqlStmt += queryTableName;
#if wxODBC_BACKWARD_COMPATABILITY
if (from && wxStrlen(from))
if (where.Length())
#endif
{
- sqlStmt += " WHERE ";
+ sqlStmt += wxT(" WHERE ");
sqlStmt += where;
}
- pDb->WriteSqlLog(sqlStmt.c_str());
+ pDb->WriteSqlLog(sqlStmt);
// Initialize the Count cursor if it's not already initialized
if (!hstmtCount)
{
hstmtCount = GetNewCursor(FALSE,FALSE);
- assert(hstmtCount);
+ wxASSERT(hstmtCount);
if (!hstmtCount)
return(0);
}
#endif
// Build a where clause to refetch the record with. Try and use the
// ROWID if it's available, ow use the key fields.
- char whereClause[DB_MAX_WHERE_CLAUSE_LEN+1];
- wxStrcpy(whereClause, "");
+ wxString whereClause;
+ whereClause.Empty();
+
if (CanUpdByROWID())
{
SDWORD cb;
- char rowid[wxDB_ROWID_LEN+1];
+ wxChar rowid[wxDB_ROWID_LEN+1];
// Get the ROWID value. If not successful retreiving the ROWID,
// simply fall down through the code and build the WHERE clause
// based on the key fields.
if (SQLGetData(hstmt, noCols+1, SQL_C_CHAR, (UCHAR*) rowid, wxDB_ROWID_LEN, &cb) == SQL_SUCCESS)
{
- wxStrcat(whereClause, queryTableName);
- wxStrcat(whereClause, ".ROWID = '");
- wxStrcat(whereClause, rowid);
- wxStrcat(whereClause, "'");
+ whereClause += queryTableName;
+ whereClause += wxT(".ROWID = '");
+ whereClause += rowid;
+ whereClause += wxT("'");
}
}
// Requery the record
where = whereClause;
- orderBy = "";
+ orderBy.Empty();
if (!Query())
result = FALSE;
else
return(FALSE);
-} // wxDbTable::SetColNull(int colNo)
+} // wxDbTable::SetColNull()
-/********** wxDbTable::SetColNull(char *colName, bool set) **********/
-bool wxDbTable::SetColNull(const char *colName, bool set)
+/********** wxDbTable::SetColNull(const wxString &colName, bool set) **********/
+bool wxDbTable::SetColNull(const wxString &colName, bool set)
{
int i;
for (i = 0; i < noCols; i++)
else
return(FALSE);
-} // wxDbTable::SetColNull(char *colName)
+} // wxDbTable::SetColNull()
/********** wxDbTable::GetNewCursor() **********/
HSTMT *wxDbTable::GetNewCursor(bool setCursor, bool bindColumns)
{
HSTMT *newHSTMT = new HSTMT;
- assert(newHSTMT);
+ wxASSERT(newHSTMT);
if (!newHSTMT)
return(0);
projects / wxWidgets.git / commitdiff
