X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/9199e66fb56bc80b81b91f59250df78d7197052e..7dc3cc31af71522b8fc55b7f97bcba7f5ef9eac5:/src/common/dbtable.cpp diff --git a/src/common/dbtable.cpp b/src/common/dbtable.cpp index 3a11833ad8..edf1a0ce1c 100644 --- a/src/common/dbtable.cpp +++ b/src/common/dbtable.cpp @@ -95,14 +95,14 @@ ULONG lastTableID = 0; -#if __WXDEBUG__ > 0 +#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; @@ -125,14 +125,14 @@ wxTable::wxTable(wxDB *pwxDB, const char *tblName, const int nCols, assert (tblName); - strcpy(tableName, tblName); // Table Name + wxStrcpy(tableName, tblName); // Table Name if (tblPath) - strcpy(tablePath, tblPath); // Table Path - used for dBase files + wxStrcpy(tablePath, tblPath); // Table Path - used for dBase files if (qryTblName) // Name of the table/view to query - strcpy(queryTableName, qryTblName); + wxStrcpy(queryTableName, qryTblName); else - strcpy(queryTableName, tblName); + wxStrcpy(queryTableName, tblName); // assert(pDb); // Assert is placed after table name is assigned for error reporting reasons if (!pDb) @@ -144,7 +144,7 @@ wxTable::wxTable(wxDB *pwxDB, const char *tblName, const int nCols, tableID = ++lastTableID; sprintf(s, "wxTable constructor (%-20s) tableID:[%6lu] pDb:[%p]", tblName,tableID,pDb); -#if __WXDEBUG__ > 0 +#ifdef __WXDEBUG__ CstructTablesInUse *tableInUse; tableInUse = new CstructTablesInUse(); tableInUse->tableName = tblName; @@ -250,8 +250,7 @@ wxTable::~wxTable() pDb->WriteSqlLog(s); } -#ifndef PROGRAM_FP4UPG -#if __WXDEBUG__ > 0 +#ifdef __WXDEBUG__ if (tableID) { bool found = FALSE; @@ -276,7 +275,7 @@ wxTable::~wxTable() } } #endif -#endif + // Decrement the wxDB table count if (pDb) pDb->nTables--; @@ -310,6 +309,250 @@ wxTable::~wxTable() } // wxTable::~wxTable() +/***************************** PRIVATE FUNCTIONS *****************************/ + +/********** wxTable::bindInsertParams() **********/ +bool wxTable::bindInsertParams(void) +{ + 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() + +/********** 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); + +} // wxTable::bindUpdateParams() + +/********** wxTable::bindCols() **********/ +bool wxTable::bindCols(HSTMT cursor) +{ + 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); + +} // wxTable::bindCols() + +/********** 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); + +} // wxTable::getRec() + +/********** 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)); + + // 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::query() **********/ +bool wxTable::query(int queryType, bool forUpdate, bool distinct, char *pSqlStmt) +{ + 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 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); + + // 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)); + + // Completed successfully + return(TRUE); + +} // wxTable::query() + + + /********** wxTable::Open() **********/ bool wxTable::Open(void) { @@ -355,22 +598,22 @@ bool wxTable::Open(void) if (! colDefs[i].InsertAllowed) continue; if (needComma) - strcat(sqlStmt, ","); - strcat(sqlStmt, colDefs[i].ColName); + wxStrcat(sqlStmt, ","); + wxStrcat(sqlStmt, colDefs[i].ColName); needComma = TRUE; } needComma = FALSE; - strcat(sqlStmt, ") VALUES ("); + wxStrcat(sqlStmt, ") VALUES ("); for (i = 0; i < noCols; i++) { if (! colDefs[i].InsertAllowed) continue; if (needComma) - strcat(sqlStmt, ","); - strcat(sqlStmt, "?"); + wxStrcat(sqlStmt, ","); + wxStrcat(sqlStmt, "?"); needComma = TRUE; } - strcat(sqlStmt, ")"); + wxStrcat(sqlStmt, ")"); // pDb->WriteSqlLog(sqlStmt); @@ -417,40 +660,53 @@ bool wxTable::QueryOnKeyFields(bool forUpdate, bool distinct) } // wxTable::QueryOnKeyFields() -/********** wxTable::query() **********/ -bool wxTable::query(int queryType, bool forUpdate, bool distinct, char *pSqlStmt) +/********** wxTable::GetPrev() **********/ +bool wxTable::GetPrev(void) { - 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(); + if (pDb->FwdOnlyCursors()) + { + wxFAIL_MSG(wxT("GetPrev()::Backward scrolling cursors are not enabled for this instance of wxTable")); + return FALSE; + } else - selectForUpdate = FALSE; + return(getRec(SQL_FETCH_PRIOR)); +} // wxTable::GetPrev() - // 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); +/********** 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-- - // Make sure the cursor is closed first - if (! CloseCursor(hstmt)) - return(FALSE); - - // 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)); - - // Completed successfully - return(TRUE); +/********** 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::query() +/********** 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) @@ -460,16 +716,16 @@ void wxTable::GetSelectStmt(char *pSqlStmt, int typeOfSelect, bool distinct) whereClause[0] = 0; // Build a select statement to query the database - strcpy(pSqlStmt, "SELECT "); + wxStrcpy(pSqlStmt, "SELECT "); // SELECT DISTINCT values only? if (distinct) - strcat(pSqlStmt, "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 && strlen(from)) + if (typeOfSelect == DB_SELECT_WHERE && from && wxStrlen(from)) appendFromClause = TRUE; // Add the column list @@ -479,12 +735,12 @@ void wxTable::GetSelectStmt(char *pSqlStmt, int typeOfSelect, bool distinct) // If joining tables, the base table column names must be qualified to avoid ambiguity if (appendFromClause) { - strcat(pSqlStmt, queryTableName); - strcat(pSqlStmt, "."); + wxStrcat(pSqlStmt, queryTableName); + wxStrcat(pSqlStmt, "."); } - strcat(pSqlStmt, colDefs[i].ColName); + wxStrcat(pSqlStmt, colDefs[i].ColName); if (i + 1 < noCols) - strcat(pSqlStmt, ","); + wxStrcat(pSqlStmt, ","); } // If the datasource supports ROWID, get this column as well. Exception: Don't retrieve @@ -494,17 +750,17 @@ void wxTable::GetSelectStmt(char *pSqlStmt, int typeOfSelect, bool distinct) // If joining tables, the base table column names must be qualified to avoid ambiguity if (appendFromClause) { - strcat(pSqlStmt, ","); - strcat(pSqlStmt, queryTableName); - strcat(pSqlStmt, ".ROWID"); + wxStrcat(pSqlStmt, ","); + wxStrcat(pSqlStmt, queryTableName); + wxStrcat(pSqlStmt, ".ROWID"); } else - strcat(pSqlStmt, ",ROWID"); + wxStrcat(pSqlStmt, ",ROWID"); } // Append the FROM tablename portion - strcat(pSqlStmt, " FROM "); - strcat(pSqlStmt, queryTableName); + 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. @@ -512,88 +768,55 @@ void wxTable::GetSelectStmt(char *pSqlStmt, int typeOfSelect, bool distinct) // 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"); + wxStrcat(pSqlStmt, " HOLDLOCK"); if (appendFromClause) - strcat(pSqlStmt, from); + 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 && strlen(where)) // May not want a where clause!!! + if (where && wxStrlen(where)) // May not want a where clause!!! { - strcat(pSqlStmt, " WHERE "); - strcat(pSqlStmt, where); + wxStrcat(pSqlStmt, " WHERE "); + wxStrcat(pSqlStmt, where); } break; case DB_SELECT_KEYFIELDS: GetWhereClause(whereClause, DB_WHERE_KEYFIELDS); - if (strlen(whereClause)) + if (wxStrlen(whereClause)) { - strcat(pSqlStmt, " WHERE "); - strcat(pSqlStmt, whereClause); + wxStrcat(pSqlStmt, " WHERE "); + wxStrcat(pSqlStmt, whereClause); } break; case DB_SELECT_MATCHING: GetWhereClause(whereClause, DB_WHERE_MATCHING); - if (strlen(whereClause)) + if (wxStrlen(whereClause)) { - strcat(pSqlStmt, " WHERE "); - strcat(pSqlStmt, whereClause); + wxStrcat(pSqlStmt, " WHERE "); + wxStrcat(pSqlStmt, whereClause); } break; } // Append the ORDER BY clause - if (orderBy && strlen(orderBy)) + if (orderBy && wxStrlen(orderBy)) { - strcat(pSqlStmt, " ORDER BY "); - strcat(pSqlStmt, 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()) - strcat(pSqlStmt, " FOR UPDATE"); + wxStrcat(pSqlStmt, " FOR UPDATE"); } // wxTable::GetSelectStmt() -/********** wxTable::getRec() **********/ -bool wxTable::getRec(UWORD fetchType) -{ - RETCODE retcode; - -#if wxODBC_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); - -} // wxTable::getRec() - /********** wxTable::GetRowNum() **********/ UWORD wxTable::GetRowNum(void) { @@ -610,151 +833,6 @@ UWORD wxTable::GetRowNum(void) } // wxTable::GetRowNum() -/********** wxTable::bindInsertParams() **********/ -bool wxTable::bindInsertParams(void) -{ - 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() - -/********** 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); - -} // wxTable::bindUpdateParams() - -/********** wxTable::bindCols() **********/ -bool wxTable::bindCols(HSTMT cursor) -{ - 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); - -} // wxTable::bindCols() - /********** wxTable::CloseCursor() **********/ bool wxTable::CloseCursor(HSTMT cursor) { @@ -820,38 +898,38 @@ bool wxTable::CreateTable(bool attemptDrop) continue; // Comma Delimiter if (needComma) - strcat(sqlStmt, ","); + wxStrcat(sqlStmt, ","); // Column Name - strcat(sqlStmt, colDefs[i].ColName); - strcat(sqlStmt, " "); + wxStrcat(sqlStmt, colDefs[i].ColName); + wxStrcat(sqlStmt, " "); // Column Type switch(colDefs[i].DbDataType) { case DB_DATA_TYPE_VARCHAR: - strcat(sqlStmt, pDb->typeInfVarchar.TypeName); break; + wxStrcat(sqlStmt, pDb->typeInfVarchar.TypeName); break; case DB_DATA_TYPE_INTEGER: - strcat(sqlStmt, pDb->typeInfInteger.TypeName); break; + wxStrcat(sqlStmt, pDb->typeInfInteger.TypeName); break; case DB_DATA_TYPE_FLOAT: - strcat(sqlStmt, pDb->typeInfFloat.TypeName); break; + wxStrcat(sqlStmt, pDb->typeInfFloat.TypeName); break; case DB_DATA_TYPE_DATE: - strcat(sqlStmt, pDb->typeInfDate.TypeName); break; + wxStrcat(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, ")"); + // wxStrcat(sqlStmt, "("); + // wxStrcat(sqlStmt, itoa(colDefs[i].SzDataObj, s, 10)); + // wxStrcat(sqlStmt, ")"); sprintf(s, "(%d)", colDefs[i].SzDataObj); - strcat(sqlStmt, s); + wxStrcat(sqlStmt, s); } - + if (pDb->Dbms() == dbmsSYBASE_ASE || pDb->Dbms() == dbmsMY_SQL) { if (colDefs[i].KeyField) { - strcat(sqlStmt, " NOT NULL"); + wxStrcat(sqlStmt, " NOT NULL"); } } @@ -870,14 +948,14 @@ bool wxTable::CreateTable(bool attemptDrop) { if (pDb->Dbms() != dbmsMY_SQL) { - strcat(sqlStmt, ",CONSTRAINT "); - strcat(sqlStmt, tableName); - strcat(sqlStmt, "_PIDX PRIMARY KEY ("); + wxStrcat(sqlStmt, ",CONSTRAINT "); + wxStrcat(sqlStmt, tableName); + wxStrcat(sqlStmt, "_PIDX PRIMARY KEY ("); } else { /* MySQL goes out on this one. We also declare the relevant key NON NULL above */ - strcat(sqlStmt, ", PRIMARY KEY ("); + wxStrcat(sqlStmt, ", PRIMARY KEY ("); } // List column name(s) of column(s) comprising the primary key @@ -886,14 +964,14 @@ bool wxTable::CreateTable(bool attemptDrop) if (colDefs[i].KeyField) { if (j++) // Multi part key, comma separate names - strcat(sqlStmt, ","); - strcat(sqlStmt, colDefs[i].ColName); + wxStrcat(sqlStmt, ","); + wxStrcat(sqlStmt, colDefs[i].ColName); } } - strcat(sqlStmt, ")"); + wxStrcat(sqlStmt, ")"); } // Append the closing parentheses for the create table statement - strcat(sqlStmt, ")"); + wxStrcat(sqlStmt, ")"); pDb->WriteSqlLog(sqlStmt); @@ -969,7 +1047,7 @@ bool wxTable::DropTable() } // 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]; @@ -978,36 +1056,36 @@ bool wxTable::CreateIndex(char * idxName, bool unique, int noIdxCols, CidxDef *p return (FALSE); // Build a CREATE INDEX statement - strcpy(sqlStmt, "CREATE "); + wxStrcpy(sqlStmt, "CREATE "); if (unique) - strcat(sqlStmt, "UNIQUE "); + wxStrcat(sqlStmt, "UNIQUE "); - strcat(sqlStmt, "INDEX "); - strcat(sqlStmt, idxName); - strcat(sqlStmt, " ON "); - strcat(sqlStmt, tableName); - strcat(sqlStmt, " ("); + wxStrcat(sqlStmt, "INDEX "); + wxStrcat(sqlStmt, idxName); + wxStrcat(sqlStmt, " ON "); + wxStrcat(sqlStmt, tableName); + wxStrcat(sqlStmt, " ("); // Append list of columns making up index int i; for (i = 0; i < noIdxCols; i++) { - strcat(sqlStmt, pIdxDefs[i].ColName); + wxStrcat(sqlStmt, pIdxDefs[i].ColName); /* Postgres doesn't cope with ASC */ if (pDb->Dbms() != dbmsPOSTGRES) { if (pIdxDefs[i].Ascending) - strcat(sqlStmt, " ASC"); + wxStrcat(sqlStmt, " ASC"); else - strcat(sqlStmt, " DESC"); + wxStrcat(sqlStmt, " DESC"); } if ((i + 1) < noIdxCols) - strcat(sqlStmt, ","); + wxStrcat(sqlStmt, ","); } // Append closing parentheses - strcat(sqlStmt, ")"); + wxStrcat(sqlStmt, ")"); pDb->WriteSqlLog(sqlStmt); @@ -1036,7 +1114,7 @@ bool wxTable::CreateIndex(char * idxName, bool unique, int noIdxCols, CidxDef *p } // 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 @@ -1119,19 +1197,6 @@ int wxTable::Insert(void) } // 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) { @@ -1155,8 +1220,21 @@ bool wxTable::Update(void) } // 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) @@ -1198,7 +1276,7 @@ bool wxTable::Delete(void) } // wxTable::Delete() /********** wxTable::DeleteWhere() **********/ -bool wxTable::DeleteWhere(char *pWhereClause) +bool wxTable::DeleteWhere(const char *pWhereClause) { assert(!queryOnly); if (queryOnly) @@ -1235,32 +1313,8 @@ bool wxTable::DeleteMatching(void) } // 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) @@ -1280,16 +1334,16 @@ void wxTable::GetUpdateStmt(char *pSqlStmt, int typeOfUpd, char *pWhereClause) if (colDefs[i].Updateable) { if (! firstColumn) - strcat(pSqlStmt, ","); + wxStrcat(pSqlStmt, ","); else firstColumn = FALSE; - strcat(pSqlStmt, colDefs[i].ColName); - strcat(pSqlStmt, " = ?"); + wxStrcat(pSqlStmt, colDefs[i].ColName); + wxStrcat(pSqlStmt, " = ?"); } } // Append the WHERE clause to the SQL UPDATE statement - strcat(pSqlStmt, " WHERE "); + wxStrcat(pSqlStmt, " WHERE "); switch(typeOfUpd) { case DB_UPD_KEYFIELDS: @@ -1306,26 +1360,25 @@ void wxTable::GetUpdateStmt(char *pSqlStmt, int typeOfUpd, char *pWhereClause) // 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, "'"); + 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); - strcat(pSqlStmt, whereClause); + wxStrcat(pSqlStmt, whereClause); break; case DB_UPD_WHERE: - strcat(pSqlStmt, pWhereClause); + 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) @@ -1337,7 +1390,7 @@ void wxTable::GetDeleteStmt(char *pSqlStmt, int typeOfDel, char *pWhereClause) // 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)) + if (typeOfDel == DB_DEL_WHERE && (pWhereClause == 0 || wxStrlen(pWhereClause) == 0)) { sprintf(pSqlStmt, "DELETE FROM %s", tableName); return; @@ -1362,23 +1415,23 @@ void wxTable::GetDeleteStmt(char *pSqlStmt, int typeOfDel, char *pWhereClause) // 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, "'"); + 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); - strcat(pSqlStmt, whereClause); + wxStrcat(pSqlStmt, whereClause); break; case DB_DEL_WHERE: - strcat(pSqlStmt, pWhereClause); + wxStrcat(pSqlStmt, pWhereClause); break; case DB_DEL_MATCHING: GetWhereClause(whereClause, DB_WHERE_MATCHING); - strcat(pSqlStmt, whereClause); + wxStrcat(pSqlStmt, whereClause); break; } @@ -1390,7 +1443,7 @@ void wxTable::GetDeleteStmt(char *pSqlStmt, int typeOfDel, char *pWhereClause) * They are not included as part of the where clause. */ -void wxTable::GetWhereClause(char *pWhereClause, int typeOfWhere, char *qualTableName) +void wxTable::GetWhereClause(char *pWhereClause, int typeOfWhere, const char *qualTableName) { bool moreThanOneColumn = FALSE; char colValue[255]; @@ -1408,17 +1461,17 @@ void wxTable::GetWhereClause(char *pWhereClause, int typeOfWhere, char *qualTabl continue; // If there is more than 1 column, join them with the keyword "AND" if (moreThanOneColumn) - strcat(pWhereClause, " AND "); + wxStrcat(pWhereClause, " AND "); else moreThanOneColumn = TRUE; // Concatenate where phrase for the column - if (qualTableName && strlen(qualTableName)) + if (qualTableName && wxStrlen(qualTableName)) { - strcat(pWhereClause, qualTableName); - strcat(pWhereClause, "."); + wxStrcat(pWhereClause, qualTableName); + wxStrcat(pWhereClause, "."); } - strcat(pWhereClause, colDefs[i].ColName); - strcat(pWhereClause, " = "); + wxStrcat(pWhereClause, colDefs[i].ColName); + wxStrcat(pWhereClause, " = "); switch(colDefs[i].SqlCtype) { case SQL_C_CHAR: @@ -1443,7 +1496,7 @@ void wxTable::GetWhereClause(char *pWhereClause, int typeOfWhere, char *qualTabl sprintf(colValue, "%.6f", *((SDOUBLE *) colDefs[i].PtrDataObj)); break; } - strcat(pWhereClause, colValue); + wxStrcat(pWhereClause, colValue); } } @@ -1583,20 +1636,20 @@ bool wxTable::SetQueryTimeout(UDWORD nSeconds) } // wxTable::SetQueryTimeout() /********** wxTable::SetColDefs() **********/ -void wxTable::SetColDefs (int index, char *fieldName, int dataType, void *pData, +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) + if (wxStrlen(fieldName) > (unsigned int) DB_MAX_COLUMN_NAME_LEN) { - strncpy (colDefs[index].ColName, fieldName, 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 - strcpy(colDefs[index].ColName, fieldName); + wxStrcpy(colDefs[index].ColName, fieldName); colDefs[index].DbDataType = dataType; colDefs[index].PtrDataObj = pData; @@ -1630,25 +1683,27 @@ void wxTable::SetCursor(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); + wxStrcpy(sqlStmt, "SELECT COUNT("); + wxStrcat(sqlStmt, args); + wxStrcat(sqlStmt, ") FROM "); + wxStrcat(sqlStmt, queryTableName); - if (from && strlen(from)) - strcat(sqlStmt, from); + if (from && wxStrlen(from)) + wxStrcat(sqlStmt, from); // Add the where clause if one is provided - if (where && strlen(where)) + if (where && wxStrlen(where)) { - strcat(sqlStmt, " WHERE "); - strcat(sqlStmt, where); + wxStrcat(sqlStmt, " WHERE "); + wxStrcat(sqlStmt, where); } pDb->WriteSqlLog(sqlStmt); @@ -1708,7 +1763,7 @@ bool wxTable::Refresh(void) // 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, ""); + wxStrcpy(whereClause, ""); if (CanUpdByROWID()) { SDWORD cb; @@ -1719,15 +1774,15 @@ bool wxTable::Refresh(void) // 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, "'"); + 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 (strlen(whereClause) == 0) + if (wxStrlen(whereClause) == 0) GetWhereClause(whereClause, DB_WHERE_KEYFIELDS, queryTableName); // Requery the record @@ -1765,7 +1820,7 @@ bool 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++)