#include "wx/dbtable.h"
#endif
-#ifdef __MWERKS__
-#ifdef __WXMSW__
-#define stricmp _stricmp
-#define strnicmp _strnicmp
-#else
-int strcasecmp(const char *str_1, const char *str_2) ;
-int strncasecmp(const char *str_1, const char *str_2, size_t maxchar) ;
-#define stricmp strcasecmp
-#define strnicmp strncasecmp
-#endif
-#endif
-
#ifdef __UNIX__
// The HPUX preprocessor lines below were commented out on 8/20/97
// because macros.h currently redefines DEBUG and is unneeded.
/********** 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;
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)
} // 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)
{
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);
} // 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)
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
// 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
// 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.
// 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)
- 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));
- }
-#endif
-
- // Completed successfully
- return(TRUE);
-
-} // wxTable::getRec()
-
/********** wxTable::GetRowNum() **********/
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)
{
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");
}
}
{
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
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);
} // 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];
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);
} // 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
} // 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)
{
} // 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)
} // wxTable::Delete()
/********** wxTable::DeleteWhere() **********/
-bool wxTable::DeleteWhere(char *pWhereClause)
+bool wxTable::DeleteWhere(const char *pWhereClause)
{
assert(!queryOnly);
if (queryOnly)
} // 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)
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:
// 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)
// 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;
// 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;
}
* 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];
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:
sprintf(colValue, "%.6f", *((SDOUBLE *) colDefs[i].PtrDataObj));
break;
}
- strcat(pWhereClause, colValue);
+ wxStrcat(pWhereClause, colValue);
}
}
} // 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;
} // 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);
// 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;
// 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
} // 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++)
projects / wxWidgets.git / blobdiff