X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/a2115c88f381b95cf6d423a5d3128ccbe20c4fa1..399b60a0ad232265cd74ce8bf6a53a1f2cc57ff2:/src/common/dbtable.cpp?ds=inline diff --git a/src/common/dbtable.cpp b/src/common/dbtable.cpp index 3fab3c4813..396ed696c0 100644 --- a/src/common/dbtable.cpp +++ b/src/common/dbtable.cpp @@ -2,16 +2,17 @@ // Name: dbtable.cpp // Purpose: Implementation of the wxTable class. // Author: Doug Card -// Mods: April 1999 -// -Dynamic cursor support - Only one predefined cursor, as many others as -// you need may be created on demand -// -Reduced number of active cursors significantly -// -Query-Only wxTable objects +// Modified by: George Tasker +// Mods: April 1999 +// -Dynamic cursor support - Only one predefined cursor, as many others as +// you need may be created on demand +// -Reduced number of active cursors significantly +// -Query-Only wxTable objects // Created: 9.96 // RCS-ID: $Id$ // Copyright: (c) 1996 Remstar International, Inc. // Licence: wxWindows licence, plus: -// Notice: This class library and its intellectual design are free of charge for use, +// Notice: This class library and its intellectual design are free of charge for use, // modification, enhancement, debugging under the following conditions: // 1) These classes may only be used as part of the implementation of a // wxWindows-based application @@ -34,34 +35,40 @@ #include "wx/wxprec.h" #if wxMAJOR_VERSION == 2 -# ifdef __GNUG__ -# pragma implementation "dbtable.h" -# endif +# ifdef __GNUG__ +# pragma implementation "dbtable.h" +# endif #endif #ifdef DBDEBUG_CONSOLE -# include + #include "wx/ioswrap.h" #endif #ifdef __BORLANDC__ - #pragma hdrstop + #pragma hdrstop #endif //__BORLANDC__ #if wxMAJOR_VERSION == 2 -# ifndef WX_PRECOMP -# include -# endif //WX_PRECOMP + #ifndef WX_PRECOMP + #include "wx/string.h" + #include "wx/object.h" + #include "wx/list.h" + #include "wx/utils.h" + #include "wx/msgdlg.h" + #include "wx/log.h" + #endif + #include "wx/filefn.h" #endif #if wxMAJOR_VERSION == 1 -# if defined(wx_msw) || defined(wx_x) -# ifdef WX_PRECOMP -# include "wx_prec.h" -# else -# include "wx.h" -# endif -# endif -# define wxUSE_ODBC 1 +# if defined(wx_msw) || defined(wx_x) +# ifdef WX_PRECOMP +# include "wx_prec.h" +# else +# include "wx.h" +# endif +# endif +# define wxUSE_ODBC 1 #endif #if wxUSE_ODBC @@ -70,10 +77,11 @@ #include #include #include + #if wxMAJOR_VERSION == 1 - #include "table.h" + #include "table.h" #elif wxMAJOR_VERSION == 2 - #include "wx/dbtable.h" + #include "wx/dbtable.h" #endif #ifdef __UNIX__ @@ -90,1746 +98,1946 @@ ULONG lastTableID = 0; -#if __WXDEBUG__ > 0 - wxList TablesInUse; +#ifdef __WXDEBUG__ + wxList TablesInUse; #endif /********** wxTable::wxTable() **********/ wxTable::wxTable(wxDB *pwxDB, const char *tblName, const int nCols, - const char *qryTblName, bool qryOnly, char *tblPath) + const char *qryTblName, bool qryOnly, const char *tblPath) { - pDb = pwxDB; // Pointer to the wxDB object - henv = 0; - hdbc = 0; - hstmt = 0; - hstmtDefault = 0; // Initialized below - hstmtCount = 0; // Initialized first time it is needed - hstmtInsert = 0; - hstmtDelete = 0; - hstmtUpdate = 0; - hstmtInternal = 0; - colDefs = 0; - tableID = 0; - noCols = nCols; // No. of cols in the table - where = 0; // Where clause - orderBy = 0; // Order By clause - from = 0; // From clause - selectForUpdate = FALSE; // SELECT ... FOR UPDATE; Indicates whether to include the FOR UPDATE phrase - queryOnly = qryOnly; - - assert (tblName); - - strcpy(tableName, tblName); // Table Name - if (tblPath) - strcpy(tablePath, tblPath); // Table Path - used for dBase files - - if (qryTblName) // Name of the table/view to query - strcpy(queryTableName, qryTblName); - else - strcpy(queryTableName, tblName); - -// assert(pDb); // Assert is placed after table name is assigned for error reporting reasons - if (!pDb) - return; - - pDb->nTables++; - - char s[200]; - tableID = ++lastTableID; - sprintf(s, "wxTable constructor (%-20s) tableID:[%6lu] pDb:[%lu]", tblName,tableID,pDb); - -#if __WXDEBUG__ > 0 - CstructTablesInUse *tableInUse; - tableInUse = new CstructTablesInUse(); - tableInUse->tableName = tblName; - tableInUse->tableID = tableID; - tableInUse->pDb = pDb; - TablesInUse.Append(tableInUse); + pDb = pwxDB; // Pointer to the wxDB object + henv = 0; + hdbc = 0; + hstmt = 0; + hstmtDefault = 0; // Initialized below + hstmtCount = 0; // Initialized first time it is needed + hstmtInsert = 0; + hstmtDelete = 0; + hstmtUpdate = 0; + hstmtInternal = 0; + colDefs = 0; + tableID = 0; + noCols = nCols; // No. of cols in the table + where = 0; // Where clause + orderBy = 0; // Order By clause + from = 0; // From clause + selectForUpdate = FALSE; // SELECT ... FOR UPDATE; Indicates whether to include the FOR UPDATE phrase + queryOnly = qryOnly; + + assert (tblName); + + wxStrcpy(tableName, tblName); // Table Name + if (tblPath) + wxStrcpy(tablePath, tblPath); // Table Path - used for dBase files + + if (qryTblName) // Name of the table/view to query + wxStrcpy(queryTableName, qryTblName); + else + wxStrcpy(queryTableName, tblName); + + if (!pDb) + return; + + pDb->nTables++; + + wxString s; + tableID = ++lastTableID; + s.sprintf("wxTable constructor (%-20s) tableID:[%6lu] pDb:[%p]", tblName,tableID,pDb); + +#ifdef __WXDEBUG__ + CstructTablesInUse *tableInUse; + tableInUse = new CstructTablesInUse(); + tableInUse->tableName = tblName; + tableInUse->tableID = tableID; + tableInUse->pDb = pDb; + TablesInUse.Append(tableInUse); #endif - pDb->WriteSqlLog(s); - - // Grab the HENV and HDBC from the wxDB object - henv = pDb->henv; - hdbc = pDb->hdbc; - - // Allocate space for column definitions - if (noCols) - colDefs = new CcolDef[noCols]; // Points to the first column defintion - - // Allocate statement handles for the table - if (!queryOnly) - { - // Allocate a separate statement handle for performing inserts - if (SQLAllocStmt(hdbc, &hstmtInsert) != SQL_SUCCESS) - pDb->DispAllErrors(henv, hdbc); - // Allocate a separate statement handle for performing deletes - if (SQLAllocStmt(hdbc, &hstmtDelete) != SQL_SUCCESS) - pDb->DispAllErrors(henv, hdbc); - // Allocate a separate statement handle for performing updates - if (SQLAllocStmt(hdbc, &hstmtUpdate) != SQL_SUCCESS) - pDb->DispAllErrors(henv, hdbc); - } - // Allocate a separate statement handle for internal use - if (SQLAllocStmt(hdbc, &hstmtInternal) != SQL_SUCCESS) - pDb->DispAllErrors(henv, hdbc); - - // Set the cursor type for the statement handles - cursorType = SQL_CURSOR_STATIC; - if (SQLSetStmtOption(hstmtInternal, SQL_CURSOR_TYPE, cursorType) != SQL_SUCCESS) - { - // Check to see if cursor type is supported - pDb->GetNextError(henv, hdbc, hstmtInternal); - if (! strcmp(pDb->sqlState, "01S02")) // Option Value Changed - { - // Datasource does not support static cursors. Driver - // will substitute a cursor type. Call SQLGetStmtOption() - // to determine which cursor type was selected. - if (SQLGetStmtOption(hstmtInternal, SQL_CURSOR_TYPE, &cursorType) != SQL_SUCCESS) - pDb->DispAllErrors(henv, hdbc, hstmtInternal); + pDb->WriteSqlLog(s.GetData()); + + // Grab the HENV and HDBC from the wxDB object + henv = pDb->henv; + hdbc = pDb->hdbc; + + // Allocate space for column definitions + if (noCols) + colDefs = new wxColDef[noCols]; // Points to the first column defintion + + // Allocate statement handles for the table + if (!queryOnly) + { + // Allocate a separate statement handle for performing inserts + if (SQLAllocStmt(hdbc, &hstmtInsert) != SQL_SUCCESS) + pDb->DispAllErrors(henv, hdbc); + // Allocate a separate statement handle for performing deletes + if (SQLAllocStmt(hdbc, &hstmtDelete) != SQL_SUCCESS) + pDb->DispAllErrors(henv, hdbc); + // Allocate a separate statement handle for performing updates + if (SQLAllocStmt(hdbc, &hstmtUpdate) != SQL_SUCCESS) + pDb->DispAllErrors(henv, hdbc); + } + // Allocate a separate statement handle for internal use + if (SQLAllocStmt(hdbc, &hstmtInternal) != SQL_SUCCESS) + pDb->DispAllErrors(henv, hdbc); + + // Set the cursor type for the statement handles + cursorType = SQL_CURSOR_STATIC; + if (SQLSetStmtOption(hstmtInternal, SQL_CURSOR_TYPE, cursorType) != SQL_SUCCESS) + { + // Check to see if cursor type is supported + pDb->GetNextError(henv, hdbc, hstmtInternal); + if (! wxStrcmp(pDb->sqlState, "01S02")) // Option Value Changed + { + // Datasource does not support static cursors. Driver + // will substitute a cursor type. Call SQLGetStmtOption() + // to determine which cursor type was selected. + if (SQLGetStmtOption(hstmtInternal, SQL_CURSOR_TYPE, &cursorType) != SQL_SUCCESS) + pDb->DispAllErrors(henv, hdbc, hstmtInternal); #ifdef DBDEBUG_CONSOLE - cout << "Static cursor changed to: "; - switch(cursorType) - { - case SQL_CURSOR_FORWARD_ONLY: - cout << "Forward Only"; break; - case SQL_CURSOR_STATIC: - cout << "Static"; break; - case SQL_CURSOR_KEYSET_DRIVEN: - cout << "Keyset Driven"; break; - case SQL_CURSOR_DYNAMIC: - cout << "Dynamic"; break; - } - cout << endl << endl; + cout << "Static cursor changed to: "; + switch(cursorType) + { + case SQL_CURSOR_FORWARD_ONLY: + cout << "Forward Only"; break; + case SQL_CURSOR_STATIC: + cout << "Static"; break; + case SQL_CURSOR_KEYSET_DRIVEN: + cout << "Keyset Driven"; break; + case SQL_CURSOR_DYNAMIC: + cout << "Dynamic"; break; + } + cout << endl << endl; #endif - } - else - { - pDb->DispNextError(); - pDb->DispAllErrors(henv, hdbc, hstmtInternal); - } - } + } + else + { + pDb->DispNextError(); + pDb->DispAllErrors(henv, hdbc, hstmtInternal); + } + } #ifdef DBDEBUG_CONSOLE - else - cout << "Cursor Type set to STATIC" << endl << endl; + else + cout << "Cursor Type set to STATIC" << endl << endl; #endif - if (!queryOnly) - { - // Set the cursor type for the INSERT statement handle - if (SQLSetStmtOption(hstmtInsert, SQL_CURSOR_TYPE, SQL_CURSOR_FORWARD_ONLY) != SQL_SUCCESS) - pDb->DispAllErrors(henv, hdbc, hstmtInsert); - // Set the cursor type for the DELETE statement handle - if (SQLSetStmtOption(hstmtDelete, SQL_CURSOR_TYPE, SQL_CURSOR_FORWARD_ONLY) != SQL_SUCCESS) - pDb->DispAllErrors(henv, hdbc, hstmtDelete); - // Set the cursor type for the UPDATE statement handle - if (SQLSetStmtOption(hstmtUpdate, SQL_CURSOR_TYPE, SQL_CURSOR_FORWARD_ONLY) != SQL_SUCCESS) - pDb->DispAllErrors(henv, hdbc, hstmtUpdate); - } - - // Make the default cursor the active cursor - hstmtDefault = NewCursor(FALSE,FALSE); - assert(hstmtDefault); - hstmt = *hstmtDefault; + if (!queryOnly) + { + // Set the cursor type for the INSERT statement handle + if (SQLSetStmtOption(hstmtInsert, SQL_CURSOR_TYPE, SQL_CURSOR_FORWARD_ONLY) != SQL_SUCCESS) + pDb->DispAllErrors(henv, hdbc, hstmtInsert); + // Set the cursor type for the DELETE statement handle + if (SQLSetStmtOption(hstmtDelete, SQL_CURSOR_TYPE, SQL_CURSOR_FORWARD_ONLY) != SQL_SUCCESS) + pDb->DispAllErrors(henv, hdbc, hstmtDelete); + // Set the cursor type for the UPDATE statement handle + if (SQLSetStmtOption(hstmtUpdate, SQL_CURSOR_TYPE, SQL_CURSOR_FORWARD_ONLY) != SQL_SUCCESS) + pDb->DispAllErrors(henv, hdbc, hstmtUpdate); + } + + // Make the default cursor the active cursor + hstmtDefault = NewCursor(FALSE,FALSE); + assert(hstmtDefault); + hstmt = *hstmtDefault; } // wxTable::wxTable() + /********** wxTable::~wxTable() **********/ wxTable::~wxTable() { - char s[80]; - if (pDb) - { - sprintf(s, "wxTable destructor (%-20s) tableID:[%6lu] pDb:[%lu]", tableName,tableID,pDb); - pDb->WriteSqlLog(s); - } - -#ifndef PROGRAM_FP4UPG -#if __WXDEBUG__ > 0 - if (tableID) - { - bool found = FALSE; - wxNode *pNode; - pNode = TablesInUse.First(); - while (pNode && !found) - { - if (((CstructTablesInUse *)pNode->Data())->tableID == tableID) - { - found = TRUE; - if (!TablesInUse.DeleteNode(pNode)) - wxMessageBox (s,"Unable to delete node!"); - } - else - pNode = pNode->Next(); - } - if (!found) - { - char msg[250]; - sprintf(msg,"Unable to find the tableID in the linked\nlist of tables in use.\n\n%s",s); - wxMessageBox (msg,"NOTICE..."); - } - } -#endif + wxString s; + if (pDb) + { + s.sprintf("wxTable destructor (%-20s) tableID:[%6lu] pDb:[%p]", tableName,tableID,pDb); + pDb->WriteSqlLog(s.GetData()); + } + +#ifdef __WXDEBUG__ + if (tableID) + { + TablesInUse.DeleteContents(TRUE); + bool found = FALSE; + + wxNode *pNode; + pNode = TablesInUse.First(); + while (pNode && !found) + { + if (((CstructTablesInUse *)pNode->Data())->tableID == tableID) + { + found = TRUE; + if (!TablesInUse.DeleteNode(pNode)) + wxLogDebug (s.c_str(),"Unable to delete node!"); + } + else + pNode = pNode->Next(); + } + if (!found) + { + wxString msg; + msg.sprintf("Unable to find the tableID in the linked\nlist of tables in use.\n\n%s",s.GetData()); + wxLogDebug (msg.GetData(),"NOTICE..."); + } + } #endif - // Decrement the wxDB table count - if (pDb) - pDb->nTables--; - - // Delete memory allocated for column definitions - if (colDefs) - delete [] colDefs; - - // Free statement handles - if (!queryOnly) - { - if (hstmtInsert) - if (SQLFreeStmt(hstmtInsert, SQL_DROP) != SQL_SUCCESS) - pDb->DispAllErrors(henv, hdbc); - if (hstmtDelete) - if (SQLFreeStmt(hstmtDelete, SQL_DROP) != SQL_SUCCESS) - pDb->DispAllErrors(henv, hdbc); - if (hstmtUpdate) - if (SQLFreeStmt(hstmtUpdate, SQL_DROP) != SQL_SUCCESS) - pDb->DispAllErrors(henv, hdbc); - } - if (hstmtInternal) - if (SQLFreeStmt(hstmtInternal, SQL_DROP) != SQL_SUCCESS) - pDb->DispAllErrors(henv, hdbc); - - // Delete dynamically allocated cursors - if (hstmtDefault) - DeleteCursor(hstmtDefault); - if (hstmtCount) - DeleteCursor(hstmtCount); + + + + // Decrement the wxDB table count + if (pDb) + pDb->nTables--; + + // Delete memory allocated for column definitions + if (colDefs) + delete [] colDefs; + + // Free statement handles + if (!queryOnly) + { + if (hstmtInsert) + if (SQLFreeStmt(hstmtInsert, SQL_DROP) != SQL_SUCCESS) + pDb->DispAllErrors(henv, hdbc); + + if (hstmtDelete) + if (SQLFreeStmt(hstmtDelete, SQL_DROP) != SQL_SUCCESS) + + if (hstmtUpdate) + if (SQLFreeStmt(hstmtUpdate, SQL_DROP) != SQL_SUCCESS) + pDb->DispAllErrors(henv, hdbc); + + } + if (hstmtInternal) + if (SQLFreeStmt(hstmtInternal, SQL_DROP) != SQL_SUCCESS) + pDb->DispAllErrors(henv, hdbc); + + // Delete dynamically allocated cursors + if (hstmtDefault) + DeleteCursor(hstmtDefault); + + if (hstmtCount) + DeleteCursor(hstmtCount); + } // wxTable::~wxTable() -/********** wxTable::Open() **********/ -bool wxTable::Open(void) + + +/***************************** PRIVATE FUNCTIONS *****************************/ + + + +/********** wxTable::bindInsertParams() **********/ +bool wxTable::bindInsertParams(void) { - if (!pDb) - return FALSE; - - int i; - char sqlStmt[DB_MAX_STATEMENT_LEN]; - - // Verify that the table exists in the database - if (!pDb->TableExists(tableName,NULL,tablePath)) - { - char s[128]; - sprintf(s, "Error opening '%s', table/view does not exist in the database.", tableName); - pDb->LogError(s); - return(FALSE); - } - - // Bind the member variables for field exchange between - // the wxTable object and the ODBC record. - if (!queryOnly) - { - if (!bindInsertParams()) // Inserts - return(FALSE); - if (!bindUpdateParams()) // Updates - return(FALSE); - } - if (!bindCols(*hstmtDefault)) // Selects - return(FALSE); - if (!bindCols(hstmtInternal)) // Internal use only - return(FALSE); - /* - * Do NOT bind the hstmtCount cursor!!! - */ - - // Build an insert statement using parameter markers - if (!queryOnly && noCols > 0) - { - bool needComma = FALSE; - sprintf(sqlStmt, "INSERT INTO %s (", tableName); - for (i = 0; i < noCols; i++) - { - if (! colDefs[i].InsertAllowed) - continue; - if (needComma) - strcat(sqlStmt, ","); - strcat(sqlStmt, colDefs[i].ColName); - needComma = TRUE; - } - needComma = FALSE; - strcat(sqlStmt, ") VALUES ("); - for (i = 0; i < noCols; i++) - { - if (! colDefs[i].InsertAllowed) - continue; - if (needComma) - strcat(sqlStmt, ","); - strcat(sqlStmt, "?"); - needComma = TRUE; - } - strcat(sqlStmt, ")"); - -// pDb->WriteSqlLog(sqlStmt); - - // Prepare the insert statement for execution - if (SQLPrepare(hstmtInsert, (UCHAR FAR *) sqlStmt, SQL_NTS) != SQL_SUCCESS) - return(pDb->DispAllErrors(henv, hdbc, hstmtInsert)); - } - - // Completed successfully - return(TRUE); + assert(!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 + int i,colNo; + for (i = 0, colNo = 1; i < noCols; i++) + { + if (! colDefs[i].InsertAllowed) + continue; + switch(colDefs[i].DbDataType) + { + case DB_DATA_TYPE_VARCHAR: + fSqlType = pDb->typeInfVarchar.FsqlType; + precision = colDefs[i].SzDataObj; + scale = 0; + colDefs[i].CbValue = SQL_NTS; + break; + case DB_DATA_TYPE_INTEGER: + fSqlType = pDb->typeInfInteger.FsqlType; + precision = pDb->typeInfInteger.Precision; + scale = 0; + colDefs[i].CbValue = 0; + break; + case DB_DATA_TYPE_FLOAT: + fSqlType = pDb->typeInfFloat.FsqlType; + precision = pDb->typeInfFloat.Precision; + scale = pDb->typeInfFloat.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; + colDefs[i].CbValue = 0; + break; + case DB_DATA_TYPE_DATE: + fSqlType = pDb->typeInfDate.FsqlType; + precision = pDb->typeInfDate.Precision; + scale = 0; + colDefs[i].CbValue = 0; + break; + } + // Null values + if (colDefs[i].Null) + { + colDefs[i].CbValue = SQL_NULL_DATA; + colDefs[i].Null = FALSE; + } + 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); -} // wxTable::Open() +} // wxTable::bindInsertParams() -/********** wxTable::Query() **********/ -bool wxTable::Query(bool forUpdate, bool distinct) + +/********** wxTable::bindUpdateParams() **********/ +bool wxTable::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: + fSqlType = pDb->typeInfVarchar.FsqlType; + precision = colDefs[i].SzDataObj; + scale = 0; + colDefs[i].CbValue = SQL_NTS; + break; + case DB_DATA_TYPE_INTEGER: + fSqlType = pDb->typeInfInteger.FsqlType; + precision = pDb->typeInfInteger.Precision; + scale = 0; + colDefs[i].CbValue = 0; + break; + case DB_DATA_TYPE_FLOAT: + fSqlType = pDb->typeInfFloat.FsqlType; + precision = pDb->typeInfFloat.Precision; + scale = pDb->typeInfFloat.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; + colDefs[i].CbValue = 0; + break; + case DB_DATA_TYPE_DATE: + fSqlType = pDb->typeInfDate.FsqlType; + precision = pDb->typeInfDate.Precision; + scale = 0; + 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) + return(pDb->DispAllErrors(henv, hdbc, hstmtUpdate)); + } + + // Completed successfully + return(TRUE); - return(query(DB_SELECT_WHERE, forUpdate, distinct)); +} // wxTable::bindUpdateParams() -} // wxTable::Query() -/********** wxTable::QueryBySqlStmt() **********/ -bool wxTable::QueryBySqlStmt(char *pSqlStmt) +/********** wxTable::bindCols() **********/ +bool wxTable::bindCols(HSTMT cursor) { - pDb->WriteSqlLog(pSqlStmt); + static SDWORD cb; + + // Bind each column of the table to a memory address for fetching data + int i; + for (i = 0; i < noCols; i++) + { + if (SQLBindCol(cursor, i+1, colDefs[i].SqlCtype, (UCHAR*) colDefs[i].PtrDataObj, + colDefs[i].SzDataObj, &cb) != SQL_SUCCESS) + return(pDb->DispAllErrors(henv, hdbc, cursor)); + } + + // Completed successfully + return(TRUE); - return(query(DB_SELECT_STATEMENT, FALSE, FALSE, pSqlStmt)); +} // wxTable::bindCols() -} // wxTable::QueryBySqlStmt() -/********** wxTable::QueryMatching() **********/ -bool wxTable::QueryMatching(bool forUpdate, bool distinct) +/********** wxTable::getRec() **********/ +bool wxTable::getRec(UWORD fetchType) { + RETCODE retcode; + + if (!pDb->FwdOnlyCursors()) + { + // Fetch the NEXT, PREV, FIRST or LAST record, depending on fetchType + UDWORD cRowsFetched; + UWORD rowStatus; + + retcode = SQLExtendedFetch(hstmt, fetchType, 0, &cRowsFetched, &rowStatus); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) + if (retcode == SQL_NO_DATA_FOUND) + return(FALSE); + else + return(pDb->DispAllErrors(henv, hdbc, hstmt)); + } + else + { + // Fetch the next record from the record set + retcode = SQLFetch(hstmt); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) + { + if (retcode == SQL_NO_DATA_FOUND) + return(FALSE); + else + return(pDb->DispAllErrors(henv, hdbc, hstmt)); + } + } + + // Completed successfully + return(TRUE); - return(query(DB_SELECT_MATCHING, forUpdate, distinct)); +} // wxTable::getRec() -} // wxTable::QueryMatching() -/********** wxTable::QueryOnKeyFields() **********/ -bool wxTable::QueryOnKeyFields(bool forUpdate, bool distinct) +/********** wxTable::execDelete() **********/ +bool wxTable::execDelete(const char *pSqlStmt) { + // Execute the DELETE statement + if (SQLExecDirect(hstmtDelete, (UCHAR FAR *) pSqlStmt, SQL_NTS) != SQL_SUCCESS) + return(pDb->DispAllErrors(henv, hdbc, hstmtDelete)); - return(query(DB_SELECT_KEYFIELDS, forUpdate, distinct)); + // Record deleted successfully + return(TRUE); + +} // wxTable::execDelete() + + +/********** wxTable::execUpdate() **********/ +bool wxTable::execUpdate(const char *pSqlStmt) +{ + // Execute the UPDATE statement + if (SQLExecDirect(hstmtUpdate, (UCHAR FAR *) pSqlStmt, SQL_NTS) != SQL_SUCCESS) + return(pDb->DispAllErrors(henv, hdbc, hstmtUpdate)); + + // Record deleted successfully + return(TRUE); + +} // wxTable::execUpdate() -} // wxTable::QueryOnKeyFields() /********** wxTable::query() **********/ bool wxTable::query(int queryType, bool forUpdate, bool distinct, char *pSqlStmt) { - char sqlStmt[DB_MAX_STATEMENT_LEN]; + char sqlStmt[DB_MAX_STATEMENT_LEN]; - // Set the selectForUpdate member variable - if (forUpdate) - // The user may wish to select for update, but the DBMS may not be capable - selectForUpdate = CanSelectForUpdate(); - else - selectForUpdate = FALSE; + // Set the selectForUpdate member variable + if (forUpdate) + // The user may wish to select for update, but the DBMS may not be capable + selectForUpdate = CanSelectForUpdate(); + else + selectForUpdate = FALSE; - // Set the SQL SELECT string - if (queryType != DB_SELECT_STATEMENT) // A select statement was not passed in, - { // so generate a select statement. - GetSelectStmt(sqlStmt, queryType, distinct); - pDb->WriteSqlLog(sqlStmt); - } + // Set the SQL SELECT string + if (queryType != DB_SELECT_STATEMENT) // A select statement was not passed in, + { // so generate a select statement. + GetSelectStmt(sqlStmt, queryType, distinct); + pDb->WriteSqlLog(sqlStmt); + } - // Make sure the cursor is closed first - if (! CloseCursor(hstmt)) - return(FALSE); + // Make sure the cursor is closed first + if (! CloseCursor(hstmt)) + return(FALSE); - // Execute the SQL SELECT statement - int retcode; + // Execute the SQL SELECT statement + int retcode; - retcode = SQLExecDirect(hstmt, (UCHAR FAR *) (queryType == DB_SELECT_STATEMENT ? pSqlStmt : sqlStmt), SQL_NTS); - if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) - return(pDb->DispAllErrors(henv, hdbc, hstmt)); + retcode = SQLExecDirect(hstmt, (UCHAR FAR *) (queryType == DB_SELECT_STATEMENT ? pSqlStmt : sqlStmt), SQL_NTS); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) + return(pDb->DispAllErrors(henv, hdbc, hstmt)); - // Completed successfully - return(TRUE); + // Completed successfully + return(TRUE); } // wxTable::query() -/********** wxTable::GetSelectStmt() **********/ -void wxTable::GetSelectStmt(char *pSqlStmt, int typeOfSelect, bool distinct) + +/***************************** PUBLIC FUNCTIONS *****************************/ + + +/********** wxTable::Open() **********/ +bool wxTable::Open(void) { - char whereClause[DB_MAX_WHERE_CLAUSE_LEN]; - - whereClause[0] = 0; - - // Build a select statement to query the database - strcpy(pSqlStmt, "SELECT "); - - // SELECT DISTINCT values only? - if (distinct) - strcat(pSqlStmt, "DISTINCT "); - - // Was a FROM clause specified to join tables to the base table? - // Available for ::Query() only!!! - bool appendFromClause = FALSE; - if (typeOfSelect == DB_SELECT_WHERE && from && strlen(from)) - appendFromClause = TRUE; - - // Add the column list - int i; - for (i = 0; i < noCols; i++) - { - // If joining tables, the base table column names must be qualified to avoid ambiguity - if (appendFromClause) - { - strcat(pSqlStmt, queryTableName); - strcat(pSqlStmt, "."); - } - strcat(pSqlStmt, colDefs[i].ColName); - if (i + 1 < noCols) - strcat(pSqlStmt, ","); - } - - // If the datasource supports ROWID, get this column as well. Exception: Don't retrieve - // the ROWID if querying distinct records. The rowid will always be unique. - if (!distinct && CanUpdByROWID()) - { - // If joining tables, the base table column names must be qualified to avoid ambiguity - if (appendFromClause) - { - strcat(pSqlStmt, ","); - strcat(pSqlStmt, queryTableName); - strcat(pSqlStmt, ".ROWID"); - } - else - strcat(pSqlStmt, ",ROWID"); - } - - // Append the FROM tablename portion - strcat(pSqlStmt, " FROM "); - strcat(pSqlStmt, queryTableName); - - // Sybase uses the HOLDLOCK keyword to lock a record during query. - // The HOLDLOCK keyword follows the table name in the from clause. - // Each table in the from clause must specify HOLDLOCK or - // 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)) - strcat(pSqlStmt, " HOLDLOCK"); - - if (appendFromClause) - strcat(pSqlStmt, from); - - // Append the WHERE clause. Either append the where clause for the class - // or build a where clause. The typeOfSelect determines this. - switch(typeOfSelect) - { - case DB_SELECT_WHERE: - if (where && strlen(where)) // May not want a where clause!!! - { - strcat(pSqlStmt, " WHERE "); - strcat(pSqlStmt, where); - } - break; - case DB_SELECT_KEYFIELDS: - GetWhereClause(whereClause, DB_WHERE_KEYFIELDS); - if (strlen(whereClause)) - { - strcat(pSqlStmt, " WHERE "); - strcat(pSqlStmt, whereClause); - } - break; - case DB_SELECT_MATCHING: - GetWhereClause(whereClause, DB_WHERE_MATCHING); - if (strlen(whereClause)) - { - strcat(pSqlStmt, " WHERE "); - strcat(pSqlStmt, whereClause); - } - break; - } - - // Append the ORDER BY clause - if (orderBy && strlen(orderBy)) - { - strcat(pSqlStmt, " ORDER BY "); - strcat(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()) - strcat(pSqlStmt, " FOR UPDATE"); + if (!pDb) + return FALSE; + + int i; + wxString sqlStmt; + + // Verify that the table exists in the database + if (!pDb->TableExists(tableName,pDb->GetUsername(),tablePath)) + { + wxString s; + if (wxStrcmp(tablePath,"")) + s.sprintf("Error opening '%s/%s'.\n",tablePath,tableName); + else + s.sprintf("Error opening '%s'.\n", tableName); + if (!pDb->TableExists(tableName,NULL,tablePath)) + s += "Table/view does not exist in the database.\n"; + else + s += "Current logged in user does not have sufficient privileges to access this table.\n"; + pDb->LogError(s.GetData()); + return(FALSE); + } + + // Bind the member variables for field exchange between + // the wxTable object and the ODBC record. + if (!queryOnly) + { + if (!bindInsertParams()) // Inserts + return(FALSE); + if (!bindUpdateParams()) // Updates + return(FALSE); + } + if (!bindCols(*hstmtDefault)) // Selects + return(FALSE); + if (!bindCols(hstmtInternal)) // Internal use only + return(FALSE); + /* + * Do NOT bind the hstmtCount cursor!!! + */ + + // Build an insert statement using parameter markers + if (!queryOnly && noCols > 0) + { + bool needComma = FALSE; + sqlStmt.sprintf("INSERT INTO %s (", tableName); + for (i = 0; i < noCols; i++) + { + if (! colDefs[i].InsertAllowed) + continue; + if (needComma) + sqlStmt += ","; + sqlStmt += colDefs[i].ColName; + needComma = TRUE; + } + needComma = FALSE; + sqlStmt += ") VALUES ("; + for (i = 0; i < noCols; i++) + { + if (! colDefs[i].InsertAllowed) + continue; + if (needComma) + sqlStmt += ","; + sqlStmt += "?"; + needComma = TRUE; + } + sqlStmt += ")"; + +// pDb->WriteSqlLog(sqlStmt); + + // Prepare the insert statement for execution + if (SQLPrepare(hstmtInsert, (UCHAR FAR *) sqlStmt.GetData(), SQL_NTS) != SQL_SUCCESS) + return(pDb->DispAllErrors(henv, hdbc, hstmtInsert)); + } + + // Completed successfully + return(TRUE); -} // wxTable::GetSelectStmt() +} // wxTable::Open() -/********** wxTable::getRec() **********/ -bool wxTable::getRec(UWORD fetchType) + +/********** wxTable::Query() **********/ +bool wxTable::Query(bool forUpdate, bool distinct) { - RETCODE retcode; - -#ifndef FWD_ONLY_CURSORS - // Fetch the NEXT, PREV, FIRST or LAST record, depending on fetchType - UDWORD cRowsFetched; - UWORD rowStatus; - if ((retcode = SQLExtendedFetch(hstmt, fetchType, 0, &cRowsFetched, &rowStatus)) != SQL_SUCCESS) - if (retcode == SQL_NO_DATA_FOUND) - return(FALSE); - else - return(pDb->DispAllErrors(henv, hdbc, hstmt)); -#else - // Fetch the next record from the record set - - retcode = SQLFetch(hstmt); - if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) - { - if (retcode == SQL_NO_DATA_FOUND) - return(FALSE); - else - return(pDb->DispAllErrors(henv, hdbc, hstmt)); - } -#endif - // Completed successfully - return(TRUE); + return(query(DB_SELECT_WHERE, forUpdate, distinct)); -} // wxTable::getRec() +} // wxTable::Query() -/********** wxTable::GetRowNum() **********/ -UWORD wxTable::GetRowNum(void) + +/********** wxTable::QueryBySqlStmt() **********/ +bool wxTable::QueryBySqlStmt(char *pSqlStmt) { - UDWORD rowNum; + pDb->WriteSqlLog(pSqlStmt); - if (SQLGetStmtOption(hstmt, SQL_ROW_NUMBER, (UCHAR*) &rowNum) != SQL_SUCCESS) - { - pDb->DispAllErrors(henv, hdbc, hstmt); - return(0); - } + return(query(DB_SELECT_STATEMENT, FALSE, FALSE, pSqlStmt)); - // Completed successfully - return((UWORD) rowNum); +} // wxTable::QueryBySqlStmt() -} // wxTable::GetRowNum() -/********** wxTable::bindInsertParams() **********/ -bool wxTable::bindInsertParams(void) +/********** wxTable::QueryMatching() **********/ +bool wxTable::QueryMatching(bool forUpdate, bool distinct) { - assert(!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 - int i; - for (i = 0; i < noCols; i++) - { - if (! colDefs[i].InsertAllowed) - continue; - switch(colDefs[i].DbDataType) - { - case DB_DATA_TYPE_VARCHAR: - fSqlType = pDb->typeInfVarchar.FsqlType; - precision = colDefs[i].SzDataObj; - scale = 0; - colDefs[i].CbValue = SQL_NTS; - break; - case DB_DATA_TYPE_INTEGER: - fSqlType = pDb->typeInfInteger.FsqlType; - precision = pDb->typeInfInteger.Precision; - scale = 0; - colDefs[i].CbValue = 0; - break; - case DB_DATA_TYPE_FLOAT: - fSqlType = pDb->typeInfFloat.FsqlType; - precision = pDb->typeInfFloat.Precision; - scale = pDb->typeInfFloat.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; - colDefs[i].CbValue = 0; - break; - case DB_DATA_TYPE_DATE: - fSqlType = pDb->typeInfDate.FsqlType; - precision = pDb->typeInfDate.Precision; - scale = 0; - colDefs[i].CbValue = 0; - break; - } - // Null values - if (colDefs[i].Null) - { - colDefs[i].CbValue = SQL_NULL_DATA; - colDefs[i].Null = FALSE; - } - if (SQLBindParameter(hstmtInsert, i+1, 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); -} // wxTable::bindInsertParams() + return(query(DB_SELECT_MATCHING, forUpdate, distinct)); -/********** wxTable::bindUpdateParams() **********/ -bool wxTable::bindUpdateParams(void) +} // wxTable::QueryMatching() + + +/********** wxTable::QueryOnKeyFields() **********/ +bool wxTable::QueryOnKeyFields(bool forUpdate, bool distinct) { - 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: - fSqlType = pDb->typeInfVarchar.FsqlType; - precision = colDefs[i].SzDataObj; - scale = 0; - colDefs[i].CbValue = SQL_NTS; - break; - case DB_DATA_TYPE_INTEGER: - fSqlType = pDb->typeInfInteger.FsqlType; - precision = pDb->typeInfInteger.Precision; - scale = 0; - colDefs[i].CbValue = 0; - break; - case DB_DATA_TYPE_FLOAT: - fSqlType = pDb->typeInfFloat.FsqlType; - precision = pDb->typeInfFloat.Precision; - scale = pDb->typeInfFloat.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; - colDefs[i].CbValue = 0; - break; - case DB_DATA_TYPE_DATE: - fSqlType = pDb->typeInfDate.FsqlType; - precision = pDb->typeInfDate.Precision; - scale = 0; - 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) - return(pDb->DispAllErrors(henv, hdbc, hstmtUpdate)); - } - - // Completed successfully - return(TRUE); + return(query(DB_SELECT_KEYFIELDS, forUpdate, distinct)); -} // wxTable::bindUpdateParams() +} // wxTable::QueryOnKeyFields() -/********** wxTable::bindCols() **********/ -bool wxTable::bindCols(HSTMT cursor) + +/********** wxTable::GetPrev() **********/ +bool wxTable::GetPrev(void) { - static SDWORD cb; - - // Bind each column of the table to a memory address for fetching data - int i; - for (i = 0; i < noCols; i++) - { - if (SQLBindCol(cursor, i+1, colDefs[i].SqlCtype, (UCHAR*) colDefs[i].PtrDataObj, - colDefs[i].SzDataObj, &cb) != SQL_SUCCESS) - return(pDb->DispAllErrors(henv, hdbc, cursor)); - } - - // Completed successfully - return(TRUE); + if (pDb->FwdOnlyCursors()) + { + wxFAIL_MSG(wxT("GetPrev()::Backward scrolling cursors are not enabled for this instance of wxTable")); + return FALSE; + } + else + return(getRec(SQL_FETCH_PRIOR)); +} // wxTable::GetPrev() + + +/********** wxTable::operator-- **********/ +bool wxTable::operator--(int) +{ + if (pDb->FwdOnlyCursors()) + { + wxFAIL_MSG(wxT("operator--:Backward scrolling cursors are not enabled for this instance of wxTable")); + return FALSE; + } + else + return(getRec(SQL_FETCH_PRIOR)); +} // wxTable::operator-- + + +/********** wxTable::GetFirst() **********/ +bool wxTable::GetFirst(void) +{ + if (pDb->FwdOnlyCursors()) + { + wxFAIL_MSG(wxT("GetFirst():Backward scrolling cursors are not enabled for this instance of wxTable")); + return FALSE; + } + else + return(getRec(SQL_FETCH_FIRST)); +} // wxTable::GetFirst() + + +/********** wxTable::GetLast() **********/ +bool wxTable::GetLast(void) +{ + if (pDb->FwdOnlyCursors()) + { + wxFAIL_MSG(wxT("GetLast()::Backward scrolling cursors are not enabled for this instance of wxTable")); + return FALSE; + } + else + return(getRec(SQL_FETCH_LAST)); +} // wxTable::GetLast() + + +/********** wxTable::GetSelectStmt() **********/ +void wxTable::GetSelectStmt(char *pSqlStmt, int typeOfSelect, bool distinct) +{ + char whereClause[DB_MAX_WHERE_CLAUSE_LEN]; + + whereClause[0] = 0; + + // Build a select statement to query the database + wxStrcpy(pSqlStmt, "SELECT "); + + // SELECT DISTINCT values only? + if (distinct) + wxStrcat(pSqlStmt, "DISTINCT "); + + // Was a FROM clause specified to join tables to the base table? + // Available for ::Query() only!!! + bool appendFromClause = FALSE; + if (typeOfSelect == DB_SELECT_WHERE && from && wxStrlen(from)) + appendFromClause = TRUE; + + // Add the column list + int i; + for (i = 0; i < noCols; i++) + { + // If joining tables, the base table column names must be qualified to avoid ambiguity + if (appendFromClause) + { + wxStrcat(pSqlStmt, queryTableName); + wxStrcat(pSqlStmt, "."); + } + wxStrcat(pSqlStmt, colDefs[i].ColName); + if (i + 1 < noCols) + wxStrcat(pSqlStmt, ","); + } + + // If the datasource supports ROWID, get this column as well. Exception: Don't retrieve + // the ROWID if querying distinct records. The rowid will always be unique. + if (!distinct && CanUpdByROWID()) + { + // If joining tables, the base table column names must be qualified to avoid ambiguity + if (appendFromClause) + { + wxStrcat(pSqlStmt, ","); + wxStrcat(pSqlStmt, queryTableName); + wxStrcat(pSqlStmt, ".ROWID"); + } + else + wxStrcat(pSqlStmt, ",ROWID"); + } + + // Append the FROM tablename portion + wxStrcat(pSqlStmt, " FROM "); + wxStrcat(pSqlStmt, queryTableName); + + // Sybase uses the HOLDLOCK keyword to lock a record during query. + // The HOLDLOCK keyword follows the table name in the from clause. + // Each table in the from clause must specify HOLDLOCK or + // 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"); + + if (appendFromClause) + wxStrcat(pSqlStmt, from); + + // Append the WHERE clause. Either append the where clause for the class + // or build a where clause. The typeOfSelect determines this. + switch(typeOfSelect) + { + case DB_SELECT_WHERE: + if (where && wxStrlen(where)) // May not want a where clause!!! + { + wxStrcat(pSqlStmt, " WHERE "); + wxStrcat(pSqlStmt, where); + } + break; + case DB_SELECT_KEYFIELDS: + GetWhereClause(whereClause, DB_WHERE_KEYFIELDS); + if (wxStrlen(whereClause)) + { + wxStrcat(pSqlStmt, " WHERE "); + wxStrcat(pSqlStmt, whereClause); + } + break; + case DB_SELECT_MATCHING: + GetWhereClause(whereClause, DB_WHERE_MATCHING); + if (wxStrlen(whereClause)) + { + wxStrcat(pSqlStmt, " WHERE "); + wxStrcat(pSqlStmt, whereClause); + } + break; + } + + // Append the ORDER BY clause + if (orderBy && wxStrlen(orderBy)) + { + wxStrcat(pSqlStmt, " ORDER BY "); + wxStrcat(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"); + +} // wxTable::GetSelectStmt() + + +/********** wxTable::GetRowNum() **********/ +UWORD wxTable::GetRowNum(void) +{ + UDWORD rowNum; + + if (SQLGetStmtOption(hstmt, SQL_ROW_NUMBER, (UCHAR*) &rowNum) != SQL_SUCCESS) + { + pDb->DispAllErrors(henv, hdbc, hstmt); + return(0); + } + + // Completed successfully + return((UWORD) rowNum); + +} // wxTable::GetRowNum() -} // wxTable::bindCols() /********** wxTable::CloseCursor() **********/ bool wxTable::CloseCursor(HSTMT cursor) { - if (SQLFreeStmt(cursor, SQL_CLOSE) != SQL_SUCCESS) - return(pDb->DispAllErrors(henv, hdbc, cursor)); + if (SQLFreeStmt(cursor, SQL_CLOSE) != SQL_SUCCESS) + return(pDb->DispAllErrors(henv, hdbc, cursor)); - // Completed successfully - return(TRUE); + // Completed successfully + return(TRUE); } // wxTable::CloseCursor() + /********** wxTable::CreateTable() **********/ bool wxTable::CreateTable(bool attemptDrop) { - if (!pDb) - return FALSE; + if (!pDb) + return FALSE; - int i, j; - char sqlStmt[DB_MAX_STATEMENT_LEN]; + int i, j; +// char sqlStmt[DB_MAX_STATEMENT_LEN]; + wxString sqlStmt; #ifdef DBDEBUG_CONSOLE - cout << "Creating Table " << tableName << "..." << endl; + cout << "Creating Table " << tableName << "..." << endl; #endif - // Drop table first - if (attemptDrop && !DropTable()) - return FALSE; + // Drop table first + if (attemptDrop && !DropTable()) + return FALSE; - // Create the table + // Create the table #ifdef DBDEBUG_CONSOLE - for (i = 0; i < noCols; i++) - { - // Exclude derived columns since they are NOT part of the base table - if (colDefs[i].DerivedCol) - continue; - cout << i + 1 << ": " << colDefs[i].ColName << "; "; - switch(colDefs[i].DbDataType) - { - case DB_DATA_TYPE_VARCHAR: - cout << pDb->typeInfVarchar.TypeName << "(" << colDefs[i].SzDataObj << ")"; - break; - case DB_DATA_TYPE_INTEGER: - cout << pDb->typeInfInteger.TypeName; - break; - case DB_DATA_TYPE_FLOAT: - cout << pDb->typeInfFloat.TypeName; - break; - case DB_DATA_TYPE_DATE: - cout << pDb->typeInfDate.TypeName; - break; - } - cout << endl; - } + for (i = 0; i < noCols; i++) + { + // Exclude derived columns since they are NOT part of the base table + if (colDefs[i].DerivedCol) + continue; + cout << i + 1 << ": " << colDefs[i].ColName << "; "; + switch(colDefs[i].DbDataType) + { + case DB_DATA_TYPE_VARCHAR: + cout << pDb->typeInfVarchar.TypeName << "(" << colDefs[i].SzDataObj << ")"; + break; + case DB_DATA_TYPE_INTEGER: + cout << pDb->typeInfInteger.TypeName; + break; + case DB_DATA_TYPE_FLOAT: + cout << pDb->typeInfFloat.TypeName; + break; + case DB_DATA_TYPE_DATE: + cout << pDb->typeInfDate.TypeName; + break; + } + cout << endl; + } #endif - // Build a CREATE TABLE string from the colDefs structure. - bool needComma = FALSE; - sprintf(sqlStmt, "CREATE TABLE %s (", tableName); - for (i = 0; i < noCols; i++) - { - // Exclude derived columns since they are NOT part of the base table - if (colDefs[i].DerivedCol) - continue; - // Comma Delimiter - if (needComma) - strcat(sqlStmt, ","); - // Column Name - strcat(sqlStmt, colDefs[i].ColName); - strcat(sqlStmt, " "); - // Column Type - switch(colDefs[i].DbDataType) - { - case DB_DATA_TYPE_VARCHAR: - strcat(sqlStmt, pDb->typeInfVarchar.TypeName); break; - case DB_DATA_TYPE_INTEGER: - strcat(sqlStmt, pDb->typeInfInteger.TypeName); break; - case DB_DATA_TYPE_FLOAT: - strcat(sqlStmt, pDb->typeInfFloat.TypeName); break; - case DB_DATA_TYPE_DATE: - strcat(sqlStmt, pDb->typeInfDate.TypeName); break; - } - // For varchars, append the size of the string - if (colDefs[i].DbDataType == DB_DATA_TYPE_VARCHAR) - { - char s[10]; - // strcat(sqlStmt, "("); - // strcat(sqlStmt, itoa(colDefs[i].SzDataObj, s, 10)); - // strcat(sqlStmt, ")"); - sprintf(s, "(%d)", colDefs[i].SzDataObj); - strcat(sqlStmt, s); - } - - if (pDb->Dbms() == dbmsSYBASE_ASE || pDb->Dbms() == dbmsMY_SQL) - { - if (colDefs[i].KeyField) - { - strcat(sqlStmt, " NOT NULL"); - } - } - - needComma = TRUE; - } - // If there is a primary key defined, include it in the create statement - for (i = j = 0; i < noCols; i++) - { - if (colDefs[i].KeyField) - { - j++; - break; - } - } - if (j && pDb->Dbms() != dbmsDBASE) // Found a keyfield - { - if (pDb->Dbms() != dbmsMY_SQL) - { - strcat(sqlStmt, ",CONSTRAINT "); - strcat(sqlStmt, tableName); - strcat(sqlStmt, "_PIDX PRIMARY KEY ("); - } - else - { - /* MySQL goes out on this one. We also declare the relevant key NON NULL above */ - strcat(sqlStmt, ", PRIMARY KEY ("); - } - - // List column name(s) of column(s) comprising the primary key - for (i = j = 0; i < noCols; i++) - { - if (colDefs[i].KeyField) - { - if (j++) // Multi part key, comma separate names - strcat(sqlStmt, ","); - strcat(sqlStmt, colDefs[i].ColName); - } - } - strcat(sqlStmt, ")"); - } - // Append the closing parentheses for the create table statement - strcat(sqlStmt, ")"); - - pDb->WriteSqlLog(sqlStmt); + // Build a CREATE TABLE string from the colDefs structure. + bool needComma = FALSE; + sqlStmt.sprintf("CREATE TABLE %s (", tableName); + + for (i = 0; i < noCols; i++) + { + // Exclude derived columns since they are NOT part of the base table + if (colDefs[i].DerivedCol) + continue; + // Comma Delimiter + if (needComma) + sqlStmt += ","; + // Column Name + sqlStmt += colDefs[i].ColName; + sqlStmt += " "; + // Column Type + switch(colDefs[i].DbDataType) + { + case DB_DATA_TYPE_VARCHAR: + sqlStmt += pDb->typeInfVarchar.TypeName; break; + case DB_DATA_TYPE_INTEGER: + sqlStmt += pDb->typeInfInteger.TypeName; break; + case DB_DATA_TYPE_FLOAT: + sqlStmt += pDb->typeInfFloat.TypeName; break; + case DB_DATA_TYPE_DATE: + sqlStmt += pDb->typeInfDate.TypeName; break; + } + // For varchars, append the size of the string + 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.GetData(); + } + + if (pDb->Dbms() == dbmsSYBASE_ASE || pDb->Dbms() == dbmsMY_SQL) + { + if (colDefs[i].KeyField) + { + sqlStmt += " NOT NULL"; + } + } + + needComma = TRUE; + } + // If there is a primary key defined, include it in the create statement + for (i = j = 0; i < noCols; i++) + { + if (colDefs[i].KeyField) + { + j++; + break; + } + } + if (j && pDb->Dbms() != dbmsDBASE) // Found a keyfield + { + if (pDb->Dbms() != dbmsMY_SQL) + { + sqlStmt += ",CONSTRAINT "; + sqlStmt += tableName; + sqlStmt += "_PIDX PRIMARY KEY ("; + } + else + { + /* MySQL goes out on this one. We also declare the relevant key NON NULL above */ + sqlStmt += ", PRIMARY KEY ("; + } + + // List column name(s) of column(s) comprising the primary key + for (i = j = 0; i < noCols; i++) + { + if (colDefs[i].KeyField) + { + if (j++) // Multi part key, comma separate names + sqlStmt += ","; + sqlStmt += colDefs[i].ColName; + } + } + sqlStmt += ")"; + } + // Append the closing parentheses for the create table statement + sqlStmt += ")"; + + pDb->WriteSqlLog(sqlStmt.GetData()); #ifdef DBDEBUG_CONSOLE - cout << endl << sqlStmt << endl; + cout << endl << sqlStmt.GetData() << endl; #endif - // Execute the CREATE TABLE statement - if (SQLExecDirect(hstmt, (UCHAR FAR *) sqlStmt, SQL_NTS) != SQL_SUCCESS) - { - pDb->DispAllErrors(henv, hdbc, hstmt); - pDb->RollbackTrans(); - CloseCursor(hstmt); - return(FALSE); - } - - // Commit the transaction and close the cursor - if (! pDb->CommitTrans()) - return(FALSE); - if (! CloseCursor(hstmt)) - return(FALSE); - - // Database table created successfully - return(TRUE); + // Execute the CREATE TABLE statement + RETCODE retcode = SQLExecDirect(hstmt, (UCHAR FAR *) sqlStmt.GetData(), SQL_NTS); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) + { + pDb->DispAllErrors(henv, hdbc, hstmt); + pDb->RollbackTrans(); + CloseCursor(hstmt); + return(FALSE); + } + + // Commit the transaction and close the cursor + if (! pDb->CommitTrans()) + return(FALSE); + if (! CloseCursor(hstmt)) + return(FALSE); + + // Database table created successfully + return(TRUE); } // wxTable::CreateTable() + /********** wxTable::DropTable() **********/ bool wxTable::DropTable() { - // NOTE: This function returns TRUE if the Table does not exist, but - // only for identified databases. Code will need to be added - // below for any other databases when those databases are defined - // to handle this situation consistently + // NOTE: This function returns TRUE if the Table does not exist, but + // only for identified databases. Code will need to be added + // below for any other databases when those databases are defined + // to handle this situation consistently - char sqlStmt[DB_MAX_STATEMENT_LEN]; + wxString sqlStmt; - sprintf(sqlStmt, "DROP TABLE %s", tableName); + sqlStmt.sprintf("DROP TABLE %s", tableName); - pDb->WriteSqlLog(sqlStmt); + pDb->WriteSqlLog(sqlStmt.GetData()); #ifdef DBDEBUG_CONSOLE - cout << endl << sqlStmt << endl; + cout << endl << sqlStmt.GetData() << endl; #endif - if (SQLExecDirect(hstmt, (UCHAR FAR *) sqlStmt, SQL_NTS) != SQL_SUCCESS) - { - // Check for "Base table not found" error and ignore - pDb->GetNextError(henv, hdbc, hstmt); - if (strcmp(pDb->sqlState,"S0002")) // "Base table not found" - { - // Check for product specific error codes - if (!((pDb->Dbms() == dbmsSYBASE_ASA && !strcmp(pDb->sqlState,"42000")) || // 5.x (and lower?) - (pDb->Dbms() == dbmsMY_SQL && !strcmp(pDb->sqlState,"S1000")) || // untested - (pDb->Dbms() == dbmsPOSTGRES && !strcmp(pDb->sqlState,"08S01")))) // untested - { - pDb->DispNextError(); - pDb->DispAllErrors(henv, hdbc, hstmt); - pDb->RollbackTrans(); - CloseCursor(hstmt); - return(FALSE); - } - } - } - - // Commit the transaction and close the cursor - if (! pDb->CommitTrans()) - return(FALSE); - if (! CloseCursor(hstmt)) - return(FALSE); - - return(TRUE); + if (SQLExecDirect(hstmt, (UCHAR FAR *) sqlStmt.GetData(), SQL_NTS) != SQL_SUCCESS) + { + // Check for "Base table not found" error and ignore + pDb->GetNextError(henv, hdbc, hstmt); + if (wxStrcmp(pDb->sqlState,"S0002")) // "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() == dbmsMY_SQL && !wxStrcmp(pDb->sqlState,"S1000")) || // untested + (pDb->Dbms() == dbmsPOSTGRES && !wxStrcmp(pDb->sqlState,"08S01")))) // untested + { + pDb->DispNextError(); + pDb->DispAllErrors(henv, hdbc, hstmt); + pDb->RollbackTrans(); + CloseCursor(hstmt); + return(FALSE); + } + } + } + + // Commit the transaction and close the cursor + if (! pDb->CommitTrans()) + return(FALSE); + if (! CloseCursor(hstmt)) + return(FALSE); + + return(TRUE); } // wxTable::DropTable() + /********** wxTable::CreateIndex() **********/ -bool wxTable::CreateIndex(char * idxName, bool unique, int noIdxCols, CidxDef *pIdxDefs, bool attemptDrop) +bool wxTable::CreateIndex(const char * idxName, bool unique, int noIdxCols, CidxDef *pIdxDefs, bool attemptDrop) { - char sqlStmt[DB_MAX_STATEMENT_LEN]; - - // Drop the index first - if (attemptDrop && !DropIndex(idxName)) - return (FALSE); - - // Build a CREATE INDEX statement - strcpy(sqlStmt, "CREATE "); - if (unique) - strcat(sqlStmt, "UNIQUE "); - - strcat(sqlStmt, "INDEX "); - strcat(sqlStmt, idxName); - strcat(sqlStmt, " ON "); - strcat(sqlStmt, tableName); - strcat(sqlStmt, " ("); - - // Append list of columns making up index - int i; - for (i = 0; i < noIdxCols; i++) - { - strcat(sqlStmt, pIdxDefs[i].ColName); - /* Postgres doesn't cope with ASC */ - if (pDb->Dbms() != dbmsPOSTGRES) - { - if (pIdxDefs[i].Ascending) - strcat(sqlStmt, " ASC"); - else - strcat(sqlStmt, " DESC"); - } - - if ((i + 1) < noIdxCols) - strcat(sqlStmt, ","); - } - - // Append closing parentheses - strcat(sqlStmt, ")"); - - pDb->WriteSqlLog(sqlStmt); +// char sqlStmt[DB_MAX_STATEMENT_LEN]; + wxString sqlStmt; + + // Drop the index first + if (attemptDrop && !DropIndex(idxName)) + return (FALSE); + + // Build a CREATE INDEX statement + sqlStmt = "CREATE "; + if (unique) + sqlStmt += "UNIQUE "; + + sqlStmt += "INDEX "; + sqlStmt += idxName; + sqlStmt += " ON "; + sqlStmt += tableName; + sqlStmt += " ("; + + // Append list of columns making up index + int i; + for (i = 0; i < noIdxCols; i++) + { + sqlStmt += pIdxDefs[i].ColName; + /* Postgres doesn't cope with ASC */ + if (pDb->Dbms() != dbmsPOSTGRES) + { + if (pIdxDefs[i].Ascending) + sqlStmt += " ASC"; + else + sqlStmt += " DESC"; + } + + if ((i + 1) < noIdxCols) + sqlStmt += ","; + } + + // Append closing parentheses + sqlStmt += ")"; + + pDb->WriteSqlLog(sqlStmt.GetData()); #ifdef DBDEBUG_CONSOLE - cout << endl << sqlStmt << endl << endl; + cout << endl << sqlStmt.GetData() << endl << endl; #endif - // Execute the CREATE INDEX statement - if (SQLExecDirect(hstmt, (UCHAR FAR *) sqlStmt, SQL_NTS) != SQL_SUCCESS) - { - pDb->DispAllErrors(henv, hdbc, hstmt); - pDb->RollbackTrans(); - CloseCursor(hstmt); - return(FALSE); - } + // Execute the CREATE INDEX statement + if (SQLExecDirect(hstmt, (UCHAR FAR *) sqlStmt.GetData(), SQL_NTS) != SQL_SUCCESS) + { + pDb->DispAllErrors(henv, hdbc, hstmt); + pDb->RollbackTrans(); + CloseCursor(hstmt); + return(FALSE); + } - // Commit the transaction and close the cursor - if (! pDb->CommitTrans()) - return(FALSE); - if (! CloseCursor(hstmt)) - return(FALSE); + // Commit the transaction and close the cursor + if (! pDb->CommitTrans()) + return(FALSE); + if (! CloseCursor(hstmt)) + return(FALSE); - // Index Created Successfully - return(TRUE); + // Index Created Successfully + return(TRUE); } // wxTable::CreateIndex() + /********** wxTable::DropIndex() **********/ -bool wxTable::DropIndex(char * idxName) +bool wxTable::DropIndex(const char * idxName) { - // NOTE: This function returns TRUE if the Index does not exist, but - // only for identified databases. Code will need to be added - // below for any other databases when those databases are defined - // to handle this situation consistently + // NOTE: This function returns TRUE if the Index does not exist, but + // only for identified databases. Code will need to be added + // below for any other databases when those databases are defined + // to handle this situation consistently - char sqlStmt[DB_MAX_STATEMENT_LEN]; + wxString sqlStmt; - if (pDb->Dbms() == dbmsACCESS) - sprintf(sqlStmt, "DROP INDEX %s ON %s",idxName,tableName); - else if (pDb->Dbms() == dbmsSYBASE_ASE) - sprintf(sqlStmt, "DROP INDEX %s.%s",tableName,idxName); - else - sprintf(sqlStmt, "DROP INDEX %s",idxName); + if (pDb->Dbms() == dbmsACCESS) + sqlStmt.sprintf("DROP INDEX %s ON %s",idxName,tableName); + else if (pDb->Dbms() == dbmsSYBASE_ASE) + sqlStmt.sprintf("DROP INDEX %s.%s",tableName,idxName); + else + sqlStmt.sprintf("DROP INDEX %s",idxName); - pDb->WriteSqlLog(sqlStmt); + pDb->WriteSqlLog(sqlStmt.GetData()); #ifdef DBDEBUG_CONSOLE - cout << endl << sqlStmt << endl; + cout << endl << sqlStmt.GetData() << endl; #endif - if (SQLExecDirect(hstmt, (UCHAR FAR *) sqlStmt, SQL_NTS) != SQL_SUCCESS) - { - // Check for "Index not found" error and ignore - pDb->GetNextError(henv, hdbc, hstmt); - if (strcmp(pDb->sqlState,"S0012")) // "Index not found" - { - // Check for product specific error codes - if (!((pDb->Dbms() == dbmsSYBASE_ASA && !strcmp(pDb->sqlState,"42000")) || // v5.x (and lower?) - (pDb->Dbms() == dbmsSYBASE_ASE && !strcmp(pDb->sqlState,"S0002")) || // Base table not found - (pDb->Dbms() == dbmsMY_SQL && !strcmp(pDb->sqlState,"42S02")) // untested - )) - { - pDb->DispNextError(); - pDb->DispAllErrors(henv, hdbc, hstmt); - pDb->RollbackTrans(); - CloseCursor(hstmt); - return(FALSE); - } - } - } - - // Commit the transaction and close the cursor - if (! pDb->CommitTrans()) - return(FALSE); - if (! CloseCursor(hstmt)) - return(FALSE); - - return(TRUE); + if (SQLExecDirect(hstmt, (UCHAR FAR *) sqlStmt.GetData(), SQL_NTS) != SQL_SUCCESS) + { + // Check for "Index not found" error and ignore + pDb->GetNextError(henv, hdbc, hstmt); + if (wxStrcmp(pDb->sqlState,"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,"S0002")) || // Base table not found + (pDb->Dbms() == dbmsMY_SQL && !wxStrcmp(pDb->sqlState,"42S02")) // untested + )) + { + pDb->DispNextError(); + pDb->DispAllErrors(henv, hdbc, hstmt); + pDb->RollbackTrans(); + CloseCursor(hstmt); + return(FALSE); + } + } + } + + // Commit the transaction and close the cursor + if (! pDb->CommitTrans()) + return(FALSE); + if (! CloseCursor(hstmt)) + return(FALSE); + + return(TRUE); } // wxTable::DropIndex() + /********** wxTable::Insert() **********/ int wxTable::Insert(void) { - assert(!queryOnly); - if (queryOnly) - return(DB_FAILURE); - - bindInsertParams(); - - // Insert the record by executing the already prepared insert statement - RETCODE retcode; - retcode=SQLExecute(hstmtInsert); - if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) - { - // Check to see if integrity constraint was violated - pDb->GetNextError(henv, hdbc, hstmtInsert); - if (! strcmp(pDb->sqlState, "23000")) // Integrity constraint violated - return(DB_ERR_INTEGRITY_CONSTRAINT_VIOL); - else - { - pDb->DispNextError(); - pDb->DispAllErrors(henv, hdbc, hstmtInsert); - return(DB_FAILURE); - } - } - - // Record inserted into the datasource successfully - return(DB_SUCCESS); + assert(!queryOnly); + if (queryOnly) + return(DB_FAILURE); + + bindInsertParams(); + + // Insert the record by executing the already prepared insert statement + RETCODE retcode; + retcode=SQLExecute(hstmtInsert); + if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) + { + // Check to see if integrity constraint was violated + pDb->GetNextError(henv, hdbc, hstmtInsert); + if (! wxStrcmp(pDb->sqlState, "23000")) // Integrity constraint violated + return(DB_ERR_INTEGRITY_CONSTRAINT_VIOL); + else + { + pDb->DispNextError(); + pDb->DispAllErrors(henv, hdbc, hstmtInsert); + return(DB_FAILURE); + } + } + + // Record inserted into the datasource successfully + return(DB_SUCCESS); } // wxTable::Insert() -/********** wxTable::Update(pSqlStmt) **********/ -bool wxTable::Update(char *pSqlStmt) -{ - assert(!queryOnly); - if (queryOnly) - return(FALSE); - - pDb->WriteSqlLog(pSqlStmt); - - return(execUpdate(pSqlStmt)); - -} // wxTable::Update(pSqlStmt) /********** wxTable::Update() **********/ bool wxTable::Update(void) { - assert(!queryOnly); - if (queryOnly) - return(FALSE); + assert(!queryOnly); + if (queryOnly) + return(FALSE); - char sqlStmt[DB_MAX_STATEMENT_LEN]; + char sqlStmt[DB_MAX_STATEMENT_LEN]; - // Build the SQL UPDATE statement - GetUpdateStmt(sqlStmt, DB_UPD_KEYFIELDS); + // Build the SQL UPDATE statement + GetUpdateStmt(sqlStmt, DB_UPD_KEYFIELDS); - pDb->WriteSqlLog(sqlStmt); + pDb->WriteSqlLog(sqlStmt); #ifdef DBDEBUG_CONSOLE - cout << endl << sqlStmt << endl << endl; + cout << endl << sqlStmt << endl << endl; #endif - // Execute the SQL UPDATE statement - return(execUpdate(sqlStmt)); + // Execute the SQL UPDATE statement + return(execUpdate(sqlStmt)); } // wxTable::Update() + +/********** wxTable::Update(pSqlStmt) **********/ +bool wxTable::Update(const char *pSqlStmt) +{ + assert(!queryOnly); + if (queryOnly) + return(FALSE); + + pDb->WriteSqlLog(pSqlStmt); + + return(execUpdate(pSqlStmt)); + +} // wxTable::Update(pSqlStmt) + + /********** wxTable::UpdateWhere() **********/ -bool wxTable::UpdateWhere(char *pWhereClause) +bool wxTable::UpdateWhere(const char *pWhereClause) { - assert(!queryOnly); - if (queryOnly) - return(FALSE); + assert(!queryOnly); + if (queryOnly) + return(FALSE); - char sqlStmt[DB_MAX_STATEMENT_LEN]; + char sqlStmt[DB_MAX_STATEMENT_LEN]; - // Build the SQL UPDATE statement - GetUpdateStmt(sqlStmt, DB_UPD_WHERE, pWhereClause); + // Build the SQL UPDATE statement + GetUpdateStmt(sqlStmt, DB_UPD_WHERE, pWhereClause); - pDb->WriteSqlLog(sqlStmt); + pDb->WriteSqlLog(sqlStmt); #ifdef DBDEBUG_CONSOLE - cout << endl << sqlStmt << endl << endl; + cout << endl << sqlStmt << endl << endl; #endif - // Execute the SQL UPDATE statement - return(execUpdate(sqlStmt)); + // Execute the SQL UPDATE statement + return(execUpdate(sqlStmt)); } // wxTable::UpdateWhere() + /********** wxTable::Delete() **********/ bool wxTable::Delete(void) { - assert(!queryOnly); - if (queryOnly) - return(FALSE); + assert(!queryOnly); + if (queryOnly) + return(FALSE); - char sqlStmt[DB_MAX_STATEMENT_LEN]; + char sqlStmt[DB_MAX_STATEMENT_LEN]; - // Build the SQL DELETE statement - GetDeleteStmt(sqlStmt, DB_DEL_KEYFIELDS); + // Build the SQL DELETE statement + GetDeleteStmt(sqlStmt, DB_DEL_KEYFIELDS); - pDb->WriteSqlLog(sqlStmt); + pDb->WriteSqlLog(sqlStmt); - // Execute the SQL DELETE statement - return(execDelete(sqlStmt)); + // Execute the SQL DELETE statement + return(execDelete(sqlStmt)); } // wxTable::Delete() + /********** wxTable::DeleteWhere() **********/ -bool wxTable::DeleteWhere(char *pWhereClause) +bool wxTable::DeleteWhere(const char *pWhereClause) { - assert(!queryOnly); - if (queryOnly) - return(FALSE); + assert(!queryOnly); + if (queryOnly) + return(FALSE); - char sqlStmt[DB_MAX_STATEMENT_LEN]; + char sqlStmt[DB_MAX_STATEMENT_LEN]; - // Build the SQL DELETE statement - GetDeleteStmt(sqlStmt, DB_DEL_WHERE, pWhereClause); + // Build the SQL DELETE statement + GetDeleteStmt(sqlStmt, DB_DEL_WHERE, pWhereClause); - pDb->WriteSqlLog(sqlStmt); + pDb->WriteSqlLog(sqlStmt); - // Execute the SQL DELETE statement - return(execDelete(sqlStmt)); + // Execute the SQL DELETE statement + return(execDelete(sqlStmt)); } // wxTable::DeleteWhere() + /********** wxTable::DeleteMatching() **********/ bool wxTable::DeleteMatching(void) { - assert(!queryOnly); - if (queryOnly) - return(FALSE); + assert(!queryOnly); + if (queryOnly) + return(FALSE); - char sqlStmt[DB_MAX_STATEMENT_LEN]; + char sqlStmt[DB_MAX_STATEMENT_LEN]; - // Build the SQL DELETE statement - GetDeleteStmt(sqlStmt, DB_DEL_MATCHING); + // Build the SQL DELETE statement + GetDeleteStmt(sqlStmt, DB_DEL_MATCHING); - pDb->WriteSqlLog(sqlStmt); + pDb->WriteSqlLog(sqlStmt); - // Execute the SQL DELETE statement - return(execDelete(sqlStmt)); + // Execute the SQL DELETE statement + return(execDelete(sqlStmt)); } // wxTable::DeleteMatching() -/********** wxTable::execDelete() **********/ -bool wxTable::execDelete(char *pSqlStmt) -{ - // Execute the DELETE statement - if (SQLExecDirect(hstmtDelete, (UCHAR FAR *) pSqlStmt, SQL_NTS) != SQL_SUCCESS) - return(pDb->DispAllErrors(henv, hdbc, hstmtDelete)); - - // Record deleted successfully - return(TRUE); - -} // wxTable::execDelete() - -/********** wxTable::execUpdate() **********/ -bool wxTable::execUpdate(char *pSqlStmt) -{ - // Execute the UPDATE statement - if (SQLExecDirect(hstmtUpdate, (UCHAR FAR *) pSqlStmt, SQL_NTS) != SQL_SUCCESS) - return(pDb->DispAllErrors(henv, hdbc, hstmtUpdate)); - - // Record deleted successfully - return(TRUE); - -} // wxTable::execUpdate() /********** wxTable::GetUpdateStmt() **********/ -void wxTable::GetUpdateStmt(char *pSqlStmt, int typeOfUpd, char *pWhereClause) +void wxTable::GetUpdateStmt(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) - strcat(pSqlStmt, ","); - else - firstColumn = FALSE; - strcat(pSqlStmt, colDefs[i].ColName); - strcat(pSqlStmt, " = ?"); - } - } - - // Append the WHERE clause to the SQL UPDATE statement - strcat(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[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, ROWID_LEN, &cb) == SQL_SUCCESS) - { - strcat(pSqlStmt, "ROWID = '"); - strcat(pSqlStmt, rowid); - strcat(pSqlStmt, "'"); - break; - } - } - // Unable to delete by ROWID, so build a WHERE - // clause based on the keyfields. - GetWhereClause(whereClause, DB_WHERE_KEYFIELDS); - strcat(pSqlStmt, whereClause); - break; - case DB_UPD_WHERE: - strcat(pSqlStmt, pWhereClause); - break; - } - + 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[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, 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. + GetWhereClause(whereClause, DB_WHERE_KEYFIELDS); + wxStrcat(pSqlStmt, whereClause); + break; + case DB_UPD_WHERE: + wxStrcat(pSqlStmt, pWhereClause); + break; + } } // GetUpdateStmt() + /********** wxTable::GetDeleteStmt() **********/ -void wxTable::GetDeleteStmt(char *pSqlStmt, int typeOfDel, char *pWhereClause) +void wxTable::GetDeleteStmt(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 || strlen(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[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, ROWID_LEN, &cb) == SQL_SUCCESS) - { - strcat(pSqlStmt, "ROWID = '"); - strcat(pSqlStmt, rowid); - strcat(pSqlStmt, "'"); - break; - } - } - // Unable to delete by ROWID, so build a WHERE - // clause based on the keyfields. - GetWhereClause(whereClause, DB_WHERE_KEYFIELDS); - strcat(pSqlStmt, whereClause); - break; - case DB_DEL_WHERE: - strcat(pSqlStmt, pWhereClause); - break; - case DB_DEL_MATCHING: - GetWhereClause(whereClause, DB_WHERE_MATCHING); - strcat(pSqlStmt, whereClause); - break; - } + 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[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, 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. + GetWhereClause(whereClause, DB_WHERE_KEYFIELDS); + wxStrcat(pSqlStmt, whereClause); + break; + case DB_DEL_WHERE: + wxStrcat(pSqlStmt, pWhereClause); + break; + case DB_DEL_MATCHING: + GetWhereClause(whereClause, DB_WHERE_MATCHING); + wxStrcat(pSqlStmt, whereClause); + break; + } } // GetDeleteStmt() + /********** wxTable::GetWhereClause() **********/ +void wxTable::GetWhereClause(char *pWhereClause, int typeOfWhere, const char *qualTableName) /* * Note: GetWhereClause() currently ignores timestamp columns. * They are not included as part of the where clause. */ - -void wxTable::GetWhereClause(char *pWhereClause, int typeOfWhere, char *qualTableName) { - 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) - strcat(pWhereClause, " AND "); - else - moreThanOneColumn = TRUE; - // Concatenate where phrase for the column - if (qualTableName && strlen(qualTableName)) - { - strcat(pWhereClause, qualTableName); - strcat(pWhereClause, "."); - } - strcat(pWhereClause, colDefs[i].ColName); - strcat(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; - } - strcat(pWhereClause, colValue); - } - } - + 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); + 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); + } + } } // wxTable::GetWhereClause() + /********** wxTable::IsColNull() **********/ bool wxTable::IsColNull(int colNo) { - switch(colDefs[colNo].SqlCtype) - { - case SQL_C_CHAR: - return(((UCHAR FAR *) colDefs[colNo].PtrDataObj)[0] == 0); - case SQL_C_SSHORT: - return(( *((SWORD *) colDefs[colNo].PtrDataObj)) == 0); - case SQL_C_USHORT: - return(( *((UWORD*) colDefs[colNo].PtrDataObj)) == 0); - case SQL_C_SLONG: - return(( *((SDWORD *) colDefs[colNo].PtrDataObj)) == 0); - case SQL_C_ULONG: - return(( *((UDWORD *) colDefs[colNo].PtrDataObj)) == 0); - case SQL_C_FLOAT: - return(( *((SFLOAT *) colDefs[colNo].PtrDataObj)) == 0); - case SQL_C_DOUBLE: - return((*((SDOUBLE *) colDefs[colNo].PtrDataObj)) == 0); - case SQL_C_TIMESTAMP: - TIMESTAMP_STRUCT *pDt; - pDt = (TIMESTAMP_STRUCT *) colDefs[colNo].PtrDataObj; - if (pDt->year == 0 && pDt->month == 0 && pDt->day == 0) - return(TRUE); - else - return(FALSE); - default: - return(TRUE); - } - + switch(colDefs[colNo].SqlCtype) + { + case SQL_C_CHAR: + return(((UCHAR FAR *) colDefs[colNo].PtrDataObj)[0] == 0); + case SQL_C_SSHORT: + return(( *((SWORD *) colDefs[colNo].PtrDataObj)) == 0); + case SQL_C_USHORT: + return(( *((UWORD*) colDefs[colNo].PtrDataObj)) == 0); + case SQL_C_SLONG: + return(( *((SDWORD *) colDefs[colNo].PtrDataObj)) == 0); + case SQL_C_ULONG: + return(( *((UDWORD *) colDefs[colNo].PtrDataObj)) == 0); + case SQL_C_FLOAT: + return(( *((SFLOAT *) colDefs[colNo].PtrDataObj)) == 0); + case SQL_C_DOUBLE: + return((*((SDOUBLE *) colDefs[colNo].PtrDataObj)) == 0); + case SQL_C_TIMESTAMP: + TIMESTAMP_STRUCT *pDt; + pDt = (TIMESTAMP_STRUCT *) colDefs[colNo].PtrDataObj; + if (pDt->year == 0 && pDt->month == 0 && pDt->day == 0) + return(TRUE); + else + return(FALSE); + default: + return(TRUE); + } } // wxTable::IsColNull() + /********** wxTable::CanSelectForUpdate() **********/ bool wxTable::CanSelectForUpdate(void) { - if (pDb->Dbms() == dbmsMY_SQL) - return FALSE; + if (pDb->Dbms() == dbmsMY_SQL) + return FALSE; - if (pDb->dbInf.posStmts & SQL_PS_SELECT_FOR_UPDATE) - return(TRUE); - else - return(FALSE); + if (pDb->dbInf.posStmts & SQL_PS_SELECT_FOR_UPDATE) + return(TRUE); + else + return(FALSE); } // wxTable::CanSelectForUpdate() + /********** wxTable::CanUpdByROWID() **********/ bool wxTable::CanUpdByROWID(void) { +/* + * NOTE: Returning FALSE for now until this can be debugged, + * as the ROWID is not getting updated correctly + */ + return FALSE; -//NOTE: Returning FALSE for now until this can be debugged, -// as the ROWID is not getting updated correctly - return FALSE; - - if (pDb->Dbms() == dbmsORACLE) - return(TRUE); - else - return(FALSE); + if (pDb->Dbms() == dbmsORACLE) + return(TRUE); + else + return(FALSE); } // wxTable::CanUpdByROWID() + /********** wxTable::IsCursorClosedOnCommit() **********/ bool wxTable::IsCursorClosedOnCommit(void) { - if (pDb->dbInf.cursorCommitBehavior == SQL_CB_PRESERVE) - return(FALSE); - else - return(TRUE); + if (pDb->dbInf.cursorCommitBehavior == SQL_CB_PRESERVE) + return(FALSE); + else + return(TRUE); } // wxTable::IsCursorClosedOnCommit() + /********** wxTable::ClearMemberVars() **********/ void wxTable::ClearMemberVars(void) { - // Loop through the columns setting each member variable to zero - int i; - for (i = 0; i < noCols; i++) - { - switch(colDefs[i].SqlCtype) - { - case SQL_C_CHAR: - ((UCHAR FAR *) colDefs[i].PtrDataObj)[0] = 0; - break; - case SQL_C_SSHORT: - *((SWORD *) colDefs[i].PtrDataObj) = 0; - break; - case SQL_C_USHORT: - *((UWORD*) colDefs[i].PtrDataObj) = 0; - break; - case SQL_C_SLONG: - *((SDWORD *) colDefs[i].PtrDataObj) = 0; - break; - case SQL_C_ULONG: - *((UDWORD *) colDefs[i].PtrDataObj) = 0; - break; - case SQL_C_FLOAT: - *((SFLOAT *) colDefs[i].PtrDataObj) = 0.0f; - break; - case SQL_C_DOUBLE: - *((SDOUBLE *) colDefs[i].PtrDataObj) = 0.0f; - break; - case SQL_C_TIMESTAMP: - TIMESTAMP_STRUCT *pDt; - pDt = (TIMESTAMP_STRUCT *) colDefs[i].PtrDataObj; - pDt->year = 0; - pDt->month = 0; - pDt->day = 0; - pDt->hour = 0; - pDt->minute = 0; - pDt->second = 0; - pDt->fraction = 0; - break; - } - } + // Loop through the columns setting each member variable to zero + int i; + for (i = 0; i < noCols; i++) + { + switch(colDefs[i].SqlCtype) + { + case SQL_C_CHAR: + ((UCHAR FAR *) colDefs[i].PtrDataObj)[0] = 0; + break; + case SQL_C_SSHORT: + *((SWORD *) colDefs[i].PtrDataObj) = 0; + break; + case SQL_C_USHORT: + *((UWORD*) colDefs[i].PtrDataObj) = 0; + break; + case SQL_C_SLONG: + *((SDWORD *) colDefs[i].PtrDataObj) = 0; + break; + case SQL_C_ULONG: + *((UDWORD *) colDefs[i].PtrDataObj) = 0; + break; + case SQL_C_FLOAT: + *((SFLOAT *) colDefs[i].PtrDataObj) = 0.0f; + break; + case SQL_C_DOUBLE: + *((SDOUBLE *) colDefs[i].PtrDataObj) = 0.0f; + break; + case SQL_C_TIMESTAMP: + TIMESTAMP_STRUCT *pDt; + pDt = (TIMESTAMP_STRUCT *) colDefs[i].PtrDataObj; + pDt->year = 0; + pDt->month = 0; + pDt->day = 0; + pDt->hour = 0; + pDt->minute = 0; + pDt->second = 0; + pDt->fraction = 0; + break; + + } + } } // wxTable::ClearMemberVars() + /********** wxTable::SetQueryTimeout() **********/ bool wxTable::SetQueryTimeout(UDWORD nSeconds) { - if (SQLSetStmtOption(hstmtInsert, SQL_QUERY_TIMEOUT, nSeconds) != SQL_SUCCESS) - return(pDb->DispAllErrors(henv, hdbc, hstmtInsert)); - if (SQLSetStmtOption(hstmtUpdate, SQL_QUERY_TIMEOUT, nSeconds) != SQL_SUCCESS) - return(pDb->DispAllErrors(henv, hdbc, hstmtUpdate)); - if (SQLSetStmtOption(hstmtDelete, SQL_QUERY_TIMEOUT, nSeconds) != SQL_SUCCESS) - return(pDb->DispAllErrors(henv, hdbc, hstmtDelete)); - if (SQLSetStmtOption(hstmtInternal, SQL_QUERY_TIMEOUT, nSeconds) != SQL_SUCCESS) - return(pDb->DispAllErrors(henv, hdbc, hstmtInternal)); - - // Completed Successfully - return(TRUE); + if (SQLSetStmtOption(hstmtInsert, SQL_QUERY_TIMEOUT, nSeconds) != SQL_SUCCESS) + return(pDb->DispAllErrors(henv, hdbc, hstmtInsert)); + if (SQLSetStmtOption(hstmtUpdate, SQL_QUERY_TIMEOUT, nSeconds) != SQL_SUCCESS) + return(pDb->DispAllErrors(henv, hdbc, hstmtUpdate)); + if (SQLSetStmtOption(hstmtDelete, SQL_QUERY_TIMEOUT, nSeconds) != SQL_SUCCESS) + return(pDb->DispAllErrors(henv, hdbc, hstmtDelete)); + if (SQLSetStmtOption(hstmtInternal, SQL_QUERY_TIMEOUT, nSeconds) != SQL_SUCCESS) + return(pDb->DispAllErrors(henv, hdbc, hstmtInternal)); + + // Completed Successfully + return(TRUE); } // wxTable::SetQueryTimeout() + /********** wxTable::SetColDefs() **********/ -void wxTable::SetColDefs (int index, char *fieldName, int dataType, void *pData, - int cType, int size, bool keyField, bool upd, - bool insAllow, bool derivedCol) +void wxTable::SetColDefs (int index, const char *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 (strlen(fieldName) > (unsigned int) DB_MAX_COLUMN_NAME_LEN) - { - strncpy (colDefs[index].ColName, fieldName, DB_MAX_COLUMN_NAME_LEN); - colDefs[index].ColName[DB_MAX_COLUMN_NAME_LEN] = 0; - } - else - strcpy(colDefs[index].ColName, fieldName); - - colDefs[index].DbDataType = dataType; - colDefs[index].PtrDataObj = pData; - colDefs[index].SqlCtype = cType; - colDefs[index].SzDataObj = size; - colDefs[index].KeyField = keyField; - colDefs[index].DerivedCol = derivedCol; - // Derived columns by definition would NOT be "Insertable" or "Updateable" - if (derivedCol) - { - colDefs[index].Updateable = FALSE; - colDefs[index].InsertAllowed = FALSE; - } - else - { - colDefs[index].Updateable = upd; - colDefs[index].InsertAllowed = insAllow; - } - - colDefs[index].Null = FALSE; - + if (!colDefs) // May happen if the database connection fails + return; + + if (wxStrlen(fieldName) > (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; + } + else + wxStrcpy(colDefs[index].ColName, fieldName); + + colDefs[index].DbDataType = dataType; + colDefs[index].PtrDataObj = pData; + colDefs[index].SqlCtype = cType; + colDefs[index].SzDataObj = size; + colDefs[index].KeyField = keyField; + colDefs[index].DerivedCol = derivedCol; + // Derived columns by definition would NOT be "Insertable" or "Updateable" + if (derivedCol) + { + colDefs[index].Updateable = FALSE; + colDefs[index].InsertAllowed = FALSE; + } + else + { + colDefs[index].Updateable = upd; + colDefs[index].InsertAllowed = insAllow; + } + + colDefs[index].Null = FALSE; + } // wxTable::SetColDefs() + +/********** wxTable::SetColDef() **********/ +wxColDataPtr* wxTable::SetColDefs (wxColInf *pColInfs, ULONG numCols) +{ + assert(pColInfs); + wxColDataPtr *pColDataPtrs = NULL; + + if (pColInfs) + { + ULONG index; + + + pColDataPtrs = new wxColDataPtr[numCols+1]; + + for (index = 0; index < numCols; index++) + { + // Process the fields + switch (pColInfs[index].dbDataType) + { + case DB_DATA_TYPE_VARCHAR: + { + pColDataPtrs[index].PtrDataObj = new char[pColInfs[index].bufferLength+1]; + pColDataPtrs[index].SzDataObj = pColInfs[index].columnSize; + pColDataPtrs[index].SqlCtype = SQL_C_CHAR; + break; + } + case DB_DATA_TYPE_INTEGER: + { + // Can be long or short + if (pColInfs[index].bufferLength == sizeof(long)) + { + pColDataPtrs[index].PtrDataObj = new long; + pColDataPtrs[index].SzDataObj = sizeof(long); + pColDataPtrs[index].SqlCtype = SQL_C_SLONG; + } + else + { + pColDataPtrs[index].PtrDataObj = new short; + pColDataPtrs[index].SzDataObj = sizeof(short); + pColDataPtrs[index].SqlCtype = SQL_C_SSHORT; + } + break; + } + case DB_DATA_TYPE_FLOAT: + { + // Can be float or double + if (pColInfs[index].bufferLength == sizeof(float)) + { + pColDataPtrs[index].PtrDataObj = new float; + pColDataPtrs[index].SzDataObj = sizeof(float); + pColDataPtrs[index].SqlCtype = SQL_C_FLOAT; + } + else + { + pColDataPtrs[index].PtrDataObj = new double; + pColDataPtrs[index].SzDataObj = sizeof(double); + pColDataPtrs[index].SqlCtype = SQL_C_DOUBLE; + } + break; + } + case DB_DATA_TYPE_DATE: + { + pColDataPtrs[index].PtrDataObj = new TIMESTAMP_STRUCT; + pColDataPtrs[index].SzDataObj = sizeof(TIMESTAMP_STRUCT); + pColDataPtrs[index].SqlCtype = SQL_C_TIMESTAMP; + break; + } + } + + SetColDefs (index,pColInfs[index].colName,pColInfs[index].dbDataType, pColDataPtrs[index].PtrDataObj, pColDataPtrs[index].SqlCtype, pColDataPtrs[index].SzDataObj); + } + } + return (pColDataPtrs); +} // wxTable::SetColDef() + + /********** wxTable::SetCursor() **********/ void wxTable::SetCursor(HSTMT *hstmtActivate) { - if (hstmtActivate == DEFAULT_CURSOR) - hstmt = *hstmtDefault; - else - hstmt = *hstmtActivate; + if (hstmtActivate == DEFAULT_CURSOR) + hstmt = *hstmtDefault; + else + hstmt = *hstmtActivate; } // wxTable::SetCursor() -/********** wxTable::Count() **********/ -ULONG wxTable::Count(void) + +/********** wxTable::Count(const char *) **********/ +ULONG wxTable::Count(const char *args) { - ULONG l; - char sqlStmt[DB_MAX_STATEMENT_LEN]; - SDWORD cb; - - // Build a "SELECT COUNT(*) FROM queryTableName [WHERE whereClause]" SQL Statement - strcpy(sqlStmt, "SELECT COUNT(*) FROM "); - strcat(sqlStmt, queryTableName); - - if (from && strlen(from)) - strcat(sqlStmt, from); - - // Add the where clause if one is provided - if (where && strlen(where)) - { - strcat(sqlStmt, " WHERE "); - strcat(sqlStmt, where); - } - - pDb->WriteSqlLog(sqlStmt); - - // Initialize the Count cursor if it's not already initialized - if (!hstmtCount) - { - hstmtCount = NewCursor(FALSE,FALSE); - assert(hstmtCount); - if (!hstmtCount) - return(0); - } - - // Execute the SQL statement - if (SQLExecDirect(*hstmtCount, (UCHAR FAR *) sqlStmt, SQL_NTS) != SQL_SUCCESS) - { - pDb->DispAllErrors(henv, hdbc, *hstmtCount); - return(0); - } - - // Fetch the record - if (SQLFetch(*hstmtCount) != SQL_SUCCESS) - { - pDb->DispAllErrors(henv, hdbc, *hstmtCount); - return(0); - } - - // Obtain the result - if (SQLGetData(*hstmtCount, 1, SQL_C_ULONG, &l, sizeof(l), &cb) != SQL_SUCCESS) - { - pDb->DispAllErrors(henv, hdbc, *hstmtCount); - return(0); - } - - // Free the cursor - if (SQLFreeStmt(*hstmtCount, SQL_CLOSE) != SQL_SUCCESS) - pDb->DispAllErrors(henv, hdbc, *hstmtCount); - - // Return the record count - return(l); + ULONG l; + wxString sqlStmt; + SDWORD cb; + + // Build a "SELECT COUNT(*) FROM queryTableName [WHERE whereClause]" SQL Statement + sqlStmt = "SELECT COUNT("; + sqlStmt += args; + sqlStmt += ") FROM "; + sqlStmt += queryTableName; + + if (from && wxStrlen(from)) + sqlStmt += from; + + // Add the where clause if one is provided + if (where && wxStrlen(where)) + { + sqlStmt += " WHERE "; + sqlStmt += where; + } + + pDb->WriteSqlLog(sqlStmt.GetData()); + + // Initialize the Count cursor if it's not already initialized + if (!hstmtCount) + { + hstmtCount = NewCursor(FALSE,FALSE); + assert(hstmtCount); + if (!hstmtCount) + return(0); + } + + // Execute the SQL statement + if (SQLExecDirect(*hstmtCount, (UCHAR FAR *) sqlStmt.GetData(), SQL_NTS) != SQL_SUCCESS) + { + pDb->DispAllErrors(henv, hdbc, *hstmtCount); + return(0); + } + + // Fetch the record + if (SQLFetch(*hstmtCount) != SQL_SUCCESS) + { + pDb->DispAllErrors(henv, hdbc, *hstmtCount); + return(0); + } + + // Obtain the result + if (SQLGetData(*hstmtCount, 1, SQL_C_ULONG, &l, sizeof(l), &cb) != SQL_SUCCESS) + { + pDb->DispAllErrors(henv, hdbc, *hstmtCount); + return(0); + } + + // Free the cursor + if (SQLFreeStmt(*hstmtCount, SQL_CLOSE) != SQL_SUCCESS) + pDb->DispAllErrors(henv, hdbc, *hstmtCount); + + // Return the record count + return(l); } // wxTable::Count() + /********** wxTable::Refresh() **********/ bool wxTable::Refresh(void) { - bool result = TRUE; - - // Switch to the internal cursor so any active cursors are not corrupted - HSTMT currCursor = GetCursor(); - hstmt = hstmtInternal; - - // Save the where and order by clauses - char *saveWhere = where; - char *saveOrderBy = orderBy; - - // 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]; - strcpy(whereClause, ""); - if (CanUpdByROWID()) - { - SDWORD cb; - char rowid[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, ROWID_LEN, &cb) == SQL_SUCCESS) - { - strcat(whereClause, queryTableName); - strcat(whereClause, ".ROWID = '"); - strcat(whereClause, rowid); - strcat(whereClause, "'"); - } - } - - // If unable to use the ROWID, build a where clause from the keyfields - if (strlen(whereClause) == 0) - GetWhereClause(whereClause, DB_WHERE_KEYFIELDS, queryTableName); - - // Requery the record - where = whereClause; - orderBy = 0; - if (!Query()) - result = FALSE; - - if (result && !GetNext()) - result = FALSE; - - // Switch back to original cursor - SetCursor(&currCursor); - - // Free the internal cursor - if (SQLFreeStmt(hstmtInternal, SQL_CLOSE) != SQL_SUCCESS) - pDb->DispAllErrors(henv, hdbc, hstmtInternal); - - // Restore the original where and order by clauses - where = saveWhere; - orderBy = saveOrderBy; - - return(result); + bool result = TRUE; + + // Switch to the internal cursor so any active cursors are not corrupted + HSTMT currCursor = GetCursor(); + hstmt = hstmtInternal; + + // Save the where and order by clauses + char *saveWhere = where; + char *saveOrderBy = orderBy; + + // 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, ""); + if (CanUpdByROWID()) + { + SDWORD cb; + char rowid[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, ROWID_LEN, &cb) == SQL_SUCCESS) + { + wxStrcat(whereClause, queryTableName); + wxStrcat(whereClause, ".ROWID = '"); + wxStrcat(whereClause, rowid); + wxStrcat(whereClause, "'"); + } + } + + // If unable to use the ROWID, build a where clause from the keyfields + if (wxStrlen(whereClause) == 0) + GetWhereClause(whereClause, DB_WHERE_KEYFIELDS, queryTableName); + + // Requery the record + where = whereClause; + orderBy = 0; + if (!Query()) + result = FALSE; + + if (result && !GetNext()) + result = FALSE; + + // Switch back to original cursor + SetCursor(&currCursor); + + // Free the internal cursor + if (SQLFreeStmt(hstmtInternal, SQL_CLOSE) != SQL_SUCCESS) + pDb->DispAllErrors(henv, hdbc, hstmtInternal); + + // Restore the original where and order by clauses + where = saveWhere; + orderBy = saveOrderBy; + + return(result); } // wxTable::Refresh() -/********** wxTable::SetNull(UINT colNo) **********/ + +/********** wxTable::SetNull(int colNo) **********/ bool wxTable::SetNull(int colNo) { - if (colNo < noCols) - return(colDefs[colNo].Null = TRUE); - else - return(FALSE); + if (colNo < noCols) + return(colDefs[colNo].Null = TRUE); + else + return(FALSE); + +} // wxTable::SetNull(int colNo) -} // wxTable::SetNull(UINT colNo) /********** wxTable::SetNull(char *colName) **********/ -bool wxTable::SetNull(char *colName) +bool wxTable::SetNull(const char *colName) { - int i; - for (i = 0; i < noCols; i++) - { - if (!stricmp(colName, colDefs[i].ColName)) - break; - } - - if (i < noCols) - return(colDefs[i].Null = TRUE); - else - return(FALSE); + int i; + for (i = 0; i < noCols; i++) + { + if (!wxStricmp(colName, colDefs[i].ColName)) + break; + } + + if (i < noCols) + return(colDefs[i].Null = TRUE); + else + return(FALSE); } // wxTable::SetNull(char *colName) + /********** wxTable::NewCursor() **********/ HSTMT *wxTable::NewCursor(bool setCursor, bool bindColumns) { - HSTMT *newHSTMT = new HSTMT; - assert(newHSTMT); - if (!newHSTMT) - return(0); - - if (SQLAllocStmt(hdbc, newHSTMT) != SQL_SUCCESS) - { - pDb->DispAllErrors(henv, hdbc); - delete newHSTMT; - return(0); - } - - if (SQLSetStmtOption(*newHSTMT, SQL_CURSOR_TYPE, cursorType) != SQL_SUCCESS) - { - pDb->DispAllErrors(henv, hdbc, *newHSTMT); - delete newHSTMT; - return(0); - } - - if (bindColumns) - { - if(!bindCols(*newHSTMT)) - { - delete newHSTMT; - return(0); - } - } - - if (setCursor) - SetCursor(newHSTMT); - - return(newHSTMT); + HSTMT *newHSTMT = new HSTMT; + assert(newHSTMT); + if (!newHSTMT) + return(0); + + if (SQLAllocStmt(hdbc, newHSTMT) != SQL_SUCCESS) + { + pDb->DispAllErrors(henv, hdbc); + delete newHSTMT; + return(0); + } + + if (SQLSetStmtOption(*newHSTMT, SQL_CURSOR_TYPE, cursorType) != SQL_SUCCESS) + { + pDb->DispAllErrors(henv, hdbc, *newHSTMT); + delete newHSTMT; + return(0); + } + + if (bindColumns) + { + if(!bindCols(*newHSTMT)) + { + delete newHSTMT; + return(0); + } + } + + if (setCursor) + SetCursor(newHSTMT); + + return(newHSTMT); } // wxTable::NewCursor() + /********** wxTable::DeleteCursor() **********/ bool wxTable::DeleteCursor(HSTMT *hstmtDel) { - bool result = TRUE; + bool result = TRUE; - if (!hstmtDel) // Cursor already deleted - return(result); + if (!hstmtDel) // Cursor already deleted + return(result); - if (SQLFreeStmt(*hstmtDel, SQL_DROP) != SQL_SUCCESS) - { - pDb->DispAllErrors(henv, hdbc); - result = FALSE; - } + if (SQLFreeStmt(*hstmtDel, SQL_DROP) != SQL_SUCCESS) + { + pDb->DispAllErrors(henv, hdbc); + result = FALSE; + } - delete hstmtDel; + delete hstmtDel; - return(result); + return(result); } // wxTable::DeleteCursor()