Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replaced all the strxxx() function calls with wxStrxxx() function calls.

Browse Source 
wxTable:Count() function now has an optional parameter to allow the count to be done on DISTINCT columns rather than all columns.


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4677 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
George Tasker
1999-11-24 18:40:02 +00:00
parent 848bc5ba18
commit 285c163f98
1 changed files with 114 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

226
src/common/dbtable.cpp
View File

@@ -125,14 +125,14 @@ wxTable::wxTable(wxDB *pwxDB, const char *tblName, const int nCols,
assert (tblName); assert (tblName);
strcpy(tableName, tblName); // Table Name wxStrcpy(tableName, tblName); // Table Name
if (tblPath) 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 if (qryTblName) // Name of the table/view to query
strcpy(queryTableName, qryTblName); wxStrcpy(queryTableName, qryTblName);
else else
strcpy(queryTableName, tblName); wxStrcpy(queryTableName, tblName);
// assert(pDb); // Assert is placed after table name is assigned for error reporting reasons // assert(pDb); // Assert is placed after table name is assigned for error reporting reasons
if (!pDb) if (!pDb)
@@ -354,22 +354,22 @@ bool wxTable::Open(void)
if (! colDefs[i].InsertAllowed) if (! colDefs[i].InsertAllowed)
continue; continue;
if (needComma) if (needComma)
strcat(sqlStmt, ","); wxStrcat(sqlStmt, ",");
strcat(sqlStmt, colDefs[i].ColName); wxStrcat(sqlStmt, colDefs[i].ColName);
needComma = TRUE; needComma = TRUE;
} }
needComma = FALSE; needComma = FALSE;
strcat(sqlStmt, ") VALUES ("); wxStrcat(sqlStmt, ") VALUES (");
for (i = 0; i < noCols; i++) for (i = 0; i < noCols; i++)
{ {
if (! colDefs[i].InsertAllowed) if (! colDefs[i].InsertAllowed)
continue; continue;
if (needComma) if (needComma)
strcat(sqlStmt, ","); wxStrcat(sqlStmt, ",");
strcat(sqlStmt, "?"); wxStrcat(sqlStmt, "?");
needComma = TRUE; needComma = TRUE;
} }
strcat(sqlStmt, ")"); wxStrcat(sqlStmt, ")");
// pDb->WriteSqlLog(sqlStmt); // pDb->WriteSqlLog(sqlStmt);
@@ -459,16 +459,16 @@ void wxTable::GetSelectStmt(char *pSqlStmt, int typeOfSelect, bool distinct)
whereClause[0] = 0; whereClause[0] = 0;
// Build a select statement to query the database // Build a select statement to query the database
strcpy(pSqlStmt, "SELECT "); wxStrcpy(pSqlStmt, "SELECT ");
// SELECT DISTINCT values only? // SELECT DISTINCT values only?
if (distinct) if (distinct)
strcat(pSqlStmt, "DISTINCT "); wxStrcat(pSqlStmt, "DISTINCT ");
// Was a FROM clause specified to join tables to the base table? // Was a FROM clause specified to join tables to the base table?
// Available for ::Query() only!!! // Available for ::Query() only!!!
bool appendFromClause = FALSE; bool appendFromClause = FALSE;
if (typeOfSelect == DB_SELECT_WHERE && from && strlen(from)) if (typeOfSelect == DB_SELECT_WHERE && from && wxStrlen(from))
appendFromClause = TRUE; appendFromClause = TRUE;
// Add the column list // Add the column list
@@ -478,12 +478,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 joining tables, the base table column names must be qualified to avoid ambiguity
if (appendFromClause) if (appendFromClause)
{ {
strcat(pSqlStmt, queryTableName); wxStrcat(pSqlStmt, queryTableName);
strcat(pSqlStmt, "."); wxStrcat(pSqlStmt, ".");
} }
strcat(pSqlStmt, colDefs[i].ColName); wxStrcat(pSqlStmt, colDefs[i].ColName);
if (i + 1 < noCols) if (i + 1 < noCols)
strcat(pSqlStmt, ","); wxStrcat(pSqlStmt, ",");
} }
// If the datasource supports ROWID, get this column as well. Exception: Don't retrieve // If the datasource supports ROWID, get this column as well. Exception: Don't retrieve
@@ -493,17 +493,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 joining tables, the base table column names must be qualified to avoid ambiguity
if (appendFromClause) if (appendFromClause)
{ {
strcat(pSqlStmt, ","); wxStrcat(pSqlStmt, ",");
strcat(pSqlStmt, queryTableName); wxStrcat(pSqlStmt, queryTableName);
strcat(pSqlStmt, ".ROWID"); wxStrcat(pSqlStmt, ".ROWID");
} }
else else
strcat(pSqlStmt, ",ROWID"); wxStrcat(pSqlStmt, ",ROWID");
} }
// Append the FROM tablename portion // Append the FROM tablename portion
strcat(pSqlStmt, " FROM "); wxStrcat(pSqlStmt, " FROM ");
strcat(pSqlStmt, queryTableName); wxStrcat(pSqlStmt, queryTableName);
// Sybase uses the HOLDLOCK keyword to lock a record during query. // Sybase uses the HOLDLOCK keyword to lock a record during query.
// The HOLDLOCK keyword follows the table name in the from clause. // The HOLDLOCK keyword follows the table name in the from clause.
@@ -511,52 +511,52 @@ void wxTable::GetSelectStmt(char *pSqlStmt, int typeOfSelect, bool distinct)
// NOHOLDLOCK (the default). Note: The "FOR UPDATE" clause // NOHOLDLOCK (the default). Note: The "FOR UPDATE" clause
// is parsed but ignored in SYBASE Transact-SQL. // is parsed but ignored in SYBASE Transact-SQL.
if (selectForUpdate && (pDb->Dbms() == dbmsSYBASE_ASA || pDb->Dbms() == dbmsSYBASE_ASE)) if (selectForUpdate && (pDb->Dbms() == dbmsSYBASE_ASA || pDb->Dbms() == dbmsSYBASE_ASE))
strcat(pSqlStmt, " HOLDLOCK"); wxStrcat(pSqlStmt, " HOLDLOCK");
if (appendFromClause) if (appendFromClause)
strcat(pSqlStmt, from); wxStrcat(pSqlStmt, from);
// Append the WHERE clause. Either append the where clause for the class // Append the WHERE clause. Either append the where clause for the class
// or build a where clause. The typeOfSelect determines this. // or build a where clause. The typeOfSelect determines this.
switch(typeOfSelect) switch(typeOfSelect)
{ {
case DB_SELECT_WHERE: 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 "); wxStrcat(pSqlStmt, " WHERE ");
strcat(pSqlStmt, where); wxStrcat(pSqlStmt, where);
} }
break; break;
case DB_SELECT_KEYFIELDS: case DB_SELECT_KEYFIELDS:
GetWhereClause(whereClause, DB_WHERE_KEYFIELDS); GetWhereClause(whereClause, DB_WHERE_KEYFIELDS);
if (strlen(whereClause)) if (wxStrlen(whereClause))
{ {
strcat(pSqlStmt, " WHERE "); wxStrcat(pSqlStmt, " WHERE ");
strcat(pSqlStmt, whereClause); wxStrcat(pSqlStmt, whereClause);
} }
break; break;
case DB_SELECT_MATCHING: case DB_SELECT_MATCHING:
GetWhereClause(whereClause, DB_WHERE_MATCHING); GetWhereClause(whereClause, DB_WHERE_MATCHING);
if (strlen(whereClause)) if (wxStrlen(whereClause))
{ {
strcat(pSqlStmt, " WHERE "); wxStrcat(pSqlStmt, " WHERE ");
strcat(pSqlStmt, whereClause); wxStrcat(pSqlStmt, whereClause);
} }
break; break;
} }
// Append the ORDER BY clause // Append the ORDER BY clause
if (orderBy && strlen(orderBy)) if (orderBy && wxStrlen(orderBy))
{ {
strcat(pSqlStmt, " ORDER BY "); wxStrcat(pSqlStmt, " ORDER BY ");
strcat(pSqlStmt, orderBy); wxStrcat(pSqlStmt, orderBy);
} }
// SELECT FOR UPDATE if told to do so and the datasource is capable. Sybase // 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 // parses the FOR UPDATE clause but ignores it. See the comment above on the
// HOLDLOCK for Sybase. // HOLDLOCK for Sybase.
if (selectForUpdate && CanSelectForUpdate()) if (selectForUpdate && CanSelectForUpdate())
strcat(pSqlStmt, " FOR UPDATE"); wxStrcat(pSqlStmt, " FOR UPDATE");
} // wxTable::GetSelectStmt() } // wxTable::GetSelectStmt()
@@ -822,38 +822,38 @@ bool wxTable::CreateTable(bool attemptDrop)
continue; continue;
// Comma Delimiter // Comma Delimiter
if (needComma) if (needComma)
strcat(sqlStmt, ","); wxStrcat(sqlStmt, ",");
// Column Name // Column Name
strcat(sqlStmt, colDefs[i].ColName); wxStrcat(sqlStmt, colDefs[i].ColName);
strcat(sqlStmt, " "); wxStrcat(sqlStmt, " ");
// Column Type // Column Type
switch(colDefs[i].DbDataType) switch(colDefs[i].DbDataType)
{ {
case DB_DATA_TYPE_VARCHAR: case DB_DATA_TYPE_VARCHAR:
strcat(sqlStmt, pDb->typeInfVarchar.TypeName); break; wxStrcat(sqlStmt, pDb->typeInfVarchar.TypeName); break;
case DB_DATA_TYPE_INTEGER: case DB_DATA_TYPE_INTEGER:
strcat(sqlStmt, pDb->typeInfInteger.TypeName); break; wxStrcat(sqlStmt, pDb->typeInfInteger.TypeName); break;
case DB_DATA_TYPE_FLOAT: case DB_DATA_TYPE_FLOAT:
strcat(sqlStmt, pDb->typeInfFloat.TypeName); break; wxStrcat(sqlStmt, pDb->typeInfFloat.TypeName); break;
case DB_DATA_TYPE_DATE: 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 // For varchars, append the size of the string
if (colDefs[i].DbDataType == DB_DATA_TYPE_VARCHAR) if (colDefs[i].DbDataType == DB_DATA_TYPE_VARCHAR)
{ {
char s[10]; char s[10];
// strcat(sqlStmt, "("); // wxStrcat(sqlStmt, "(");
// strcat(sqlStmt, itoa(colDefs[i].SzDataObj, s, 10)); // wxStrcat(sqlStmt, itoa(colDefs[i].SzDataObj, s, 10));
// strcat(sqlStmt, ")"); // wxStrcat(sqlStmt, ")");
sprintf(s, "(%d)", colDefs[i].SzDataObj); sprintf(s, "(%d)", colDefs[i].SzDataObj);
strcat(sqlStmt, s); wxStrcat(sqlStmt, s);
} }
if (pDb->Dbms() == dbmsSYBASE_ASE || pDb->Dbms() == dbmsMY_SQL) if (pDb->Dbms() == dbmsSYBASE_ASE || pDb->Dbms() == dbmsMY_SQL)
{ {
if (colDefs[i].KeyField) if (colDefs[i].KeyField)
{ {
strcat(sqlStmt, " NOT NULL"); wxStrcat(sqlStmt, " NOT NULL");
} }
} }
@@ -872,14 +872,14 @@ bool wxTable::CreateTable(bool attemptDrop)
{ {
if (pDb->Dbms() != dbmsMY_SQL) if (pDb->Dbms() != dbmsMY_SQL)
{ {
strcat(sqlStmt, ",CONSTRAINT "); wxStrcat(sqlStmt, ",CONSTRAINT ");
strcat(sqlStmt, tableName); wxStrcat(sqlStmt, tableName);
strcat(sqlStmt, "_PIDX PRIMARY KEY ("); wxStrcat(sqlStmt, "_PIDX PRIMARY KEY (");
} }
else else
{ {
/* MySQL goes out on this one. We also declare the relevant key NON NULL above */ /* 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 // List column name(s) of column(s) comprising the primary key
@@ -888,14 +888,14 @@ bool wxTable::CreateTable(bool attemptDrop)
if (colDefs[i].KeyField) if (colDefs[i].KeyField)
{ {
if (j++) // Multi part key, comma separate names if (j++) // Multi part key, comma separate names
strcat(sqlStmt, ","); wxStrcat(sqlStmt, ",");
strcat(sqlStmt, colDefs[i].ColName); wxStrcat(sqlStmt, colDefs[i].ColName);
} }
} }
strcat(sqlStmt, ")"); wxStrcat(sqlStmt, ")");
} }
// Append the closing parentheses for the create table statement // Append the closing parentheses for the create table statement
strcat(sqlStmt, ")"); wxStrcat(sqlStmt, ")");
pDb->WriteSqlLog(sqlStmt); pDb->WriteSqlLog(sqlStmt);
@@ -980,36 +980,36 @@ bool wxTable::CreateIndex(char * idxName, bool unique, int noIdxCols, CidxDef *p
return (FALSE); return (FALSE);
// Build a CREATE INDEX statement // Build a CREATE INDEX statement
strcpy(sqlStmt, "CREATE "); wxStrcpy(sqlStmt, "CREATE ");
if (unique) if (unique)
strcat(sqlStmt, "UNIQUE "); wxStrcat(sqlStmt, "UNIQUE ");
strcat(sqlStmt, "INDEX "); wxStrcat(sqlStmt, "INDEX ");
strcat(sqlStmt, idxName); wxStrcat(sqlStmt, idxName);
strcat(sqlStmt, " ON "); wxStrcat(sqlStmt, " ON ");
strcat(sqlStmt, tableName); wxStrcat(sqlStmt, tableName);
strcat(sqlStmt, " ("); wxStrcat(sqlStmt, " (");
// Append list of columns making up index // Append list of columns making up index
int i; int i;
for (i = 0; i < noIdxCols; i++) for (i = 0; i < noIdxCols; i++)
{ {
strcat(sqlStmt, pIdxDefs[i].ColName); wxStrcat(sqlStmt, pIdxDefs[i].ColName);
/* Postgres doesn't cope with ASC */ /* Postgres doesn't cope with ASC */
if (pDb->Dbms() != dbmsPOSTGRES) if (pDb->Dbms() != dbmsPOSTGRES)
{ {
if (pIdxDefs[i].Ascending) if (pIdxDefs[i].Ascending)
strcat(sqlStmt, " ASC"); wxStrcat(sqlStmt, " ASC");
else else
strcat(sqlStmt, " DESC"); wxStrcat(sqlStmt, " DESC");
} }
if ((i + 1) < noIdxCols) if ((i + 1) < noIdxCols)
strcat(sqlStmt, ","); wxStrcat(sqlStmt, ",");
} }
// Append closing parentheses // Append closing parentheses
strcat(sqlStmt, ")"); wxStrcat(sqlStmt, ")");
pDb->WriteSqlLog(sqlStmt); pDb->WriteSqlLog(sqlStmt);
@@ -1282,16 +1282,16 @@ void wxTable::GetUpdateStmt(char *pSqlStmt, int typeOfUpd, char *pWhereClause)
if (colDefs[i].Updateable) if (colDefs[i].Updateable)
{ {
if (! firstColumn) if (! firstColumn)
strcat(pSqlStmt, ","); wxStrcat(pSqlStmt, ",");
else else
firstColumn = FALSE; firstColumn = FALSE;
strcat(pSqlStmt, colDefs[i].ColName); wxStrcat(pSqlStmt, colDefs[i].ColName);
strcat(pSqlStmt, " = ?"); wxStrcat(pSqlStmt, " = ?");
} }
} }
// Append the WHERE clause to the SQL UPDATE statement // Append the WHERE clause to the SQL UPDATE statement
strcat(pSqlStmt, " WHERE "); wxStrcat(pSqlStmt, " WHERE ");
switch(typeOfUpd) switch(typeOfUpd)
{ {
case DB_UPD_KEYFIELDS: case DB_UPD_KEYFIELDS:
@@ -1308,19 +1308,19 @@ void wxTable::GetUpdateStmt(char *pSqlStmt, int typeOfUpd, char *pWhereClause)
// based on the key fields. // based on the key fields.
if (SQLGetData(hstmt, noCols+1, SQL_C_CHAR, (UCHAR*) rowid, ROWID_LEN, &cb) == SQL_SUCCESS) if (SQLGetData(hstmt, noCols+1, SQL_C_CHAR, (UCHAR*) rowid, ROWID_LEN, &cb) == SQL_SUCCESS)
{ {
strcat(pSqlStmt, "ROWID = '"); wxStrcat(pSqlStmt, "ROWID = '");
strcat(pSqlStmt, rowid); wxStrcat(pSqlStmt, rowid);
strcat(pSqlStmt, "'"); wxStrcat(pSqlStmt, "'");
break; break;
} }
} }
// Unable to delete by ROWID, so build a WHERE // Unable to delete by ROWID, so build a WHERE
// clause based on the keyfields. // clause based on the keyfields.
GetWhereClause(whereClause, DB_WHERE_KEYFIELDS); GetWhereClause(whereClause, DB_WHERE_KEYFIELDS);
strcat(pSqlStmt, whereClause); wxStrcat(pSqlStmt, whereClause);
break; break;
case DB_UPD_WHERE: case DB_UPD_WHERE:
strcat(pSqlStmt, pWhereClause); wxStrcat(pSqlStmt, pWhereClause);
break; break;
} }
@@ -1339,7 +1339,7 @@ void wxTable::GetDeleteStmt(char *pSqlStmt, int typeOfDel, char *pWhereClause)
// Handle the case of DeleteWhere() and the where clause is blank. It should // Handle the case of DeleteWhere() and the where clause is blank. It should
// delete all records from the database in this case. // 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); sprintf(pSqlStmt, "DELETE FROM %s", tableName);
return; return;
@@ -1364,23 +1364,23 @@ void wxTable::GetDeleteStmt(char *pSqlStmt, int typeOfDel, char *pWhereClause)
// based on the key fields. // based on the key fields.
if (SQLGetData(hstmt, noCols+1, SQL_C_CHAR, (UCHAR*) rowid, ROWID_LEN, &cb) == SQL_SUCCESS) if (SQLGetData(hstmt, noCols+1, SQL_C_CHAR, (UCHAR*) rowid, ROWID_LEN, &cb) == SQL_SUCCESS)
{ {
strcat(pSqlStmt, "ROWID = '"); wxStrcat(pSqlStmt, "ROWID = '");
strcat(pSqlStmt, rowid); wxStrcat(pSqlStmt, rowid);
strcat(pSqlStmt, "'"); wxStrcat(pSqlStmt, "'");
break; break;
} }
} }
// Unable to delete by ROWID, so build a WHERE // Unable to delete by ROWID, so build a WHERE
// clause based on the keyfields. // clause based on the keyfields.
GetWhereClause(whereClause, DB_WHERE_KEYFIELDS); GetWhereClause(whereClause, DB_WHERE_KEYFIELDS);
strcat(pSqlStmt, whereClause); wxStrcat(pSqlStmt, whereClause);
break; break;
case DB_DEL_WHERE: case DB_DEL_WHERE:
strcat(pSqlStmt, pWhereClause); wxStrcat(pSqlStmt, pWhereClause);
break; break;
case DB_DEL_MATCHING: case DB_DEL_MATCHING:
GetWhereClause(whereClause, DB_WHERE_MATCHING); GetWhereClause(whereClause, DB_WHERE_MATCHING);
strcat(pSqlStmt, whereClause); wxStrcat(pSqlStmt, whereClause);
break; break;
} }
@@ -1410,17 +1410,17 @@ void wxTable::GetWhereClause(char *pWhereClause, int typeOfWhere, char *qualTabl
continue; continue;
// If there is more than 1 column, join them with the keyword "AND" // If there is more than 1 column, join them with the keyword "AND"
if (moreThanOneColumn) if (moreThanOneColumn)
strcat(pWhereClause, " AND "); wxStrcat(pWhereClause, " AND ");
else else
moreThanOneColumn = TRUE; moreThanOneColumn = TRUE;
// Concatenate where phrase for the column // Concatenate where phrase for the column
if (qualTableName && strlen(qualTableName)) if (qualTableName && wxStrlen(qualTableName))
{ {
strcat(pWhereClause, qualTableName); wxStrcat(pWhereClause, qualTableName);
strcat(pWhereClause, "."); wxStrcat(pWhereClause, ".");
} }
strcat(pWhereClause, colDefs[i].ColName); wxStrcat(pWhereClause, colDefs[i].ColName);
strcat(pWhereClause, " = "); wxStrcat(pWhereClause, " = ");
switch(colDefs[i].SqlCtype) switch(colDefs[i].SqlCtype)
{ {
case SQL_C_CHAR: case SQL_C_CHAR:
@@ -1445,7 +1445,7 @@ void wxTable::GetWhereClause(char *pWhereClause, int typeOfWhere, char *qualTabl
sprintf(colValue, "%.6f", *((SDOUBLE *) colDefs[i].PtrDataObj)); sprintf(colValue, "%.6f", *((SDOUBLE *) colDefs[i].PtrDataObj));
break; break;
} }
strcat(pWhereClause, colValue); wxStrcat(pWhereClause, colValue);
} }
} }
@@ -1592,13 +1592,13 @@ void wxTable::SetColDefs (int index, char *fieldName, int dataType, void *pData,
if (!colDefs) // May happen if the database connection fails if (!colDefs) // May happen if the database connection fails
return; 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; colDefs[index].ColName[DB_MAX_COLUMN_NAME_LEN] = 0;
} }
else else
strcpy(colDefs[index].ColName, fieldName); wxStrcpy(colDefs[index].ColName, fieldName);
colDefs[index].DbDataType = dataType; colDefs[index].DbDataType = dataType;
colDefs[index].PtrDataObj = pData; colDefs[index].PtrDataObj = pData;
@@ -1632,25 +1632,27 @@ void wxTable::SetCursor(HSTMT *hstmtActivate)
} // wxTable::SetCursor() } // wxTable::SetCursor()
/********** wxTable::Count() **********/ /********** wxTable::Count(const char *) **********/
ULONG wxTable::Count(void) ULONG wxTable::Count(const char *args)
{ {
ULONG l; ULONG l;
char sqlStmt[DB_MAX_STATEMENT_LEN]; char sqlStmt[DB_MAX_STATEMENT_LEN];
SDWORD cb; SDWORD cb;
// Build a "SELECT COUNT(*) FROM queryTableName [WHERE whereClause]" SQL Statement // Build a "SELECT COUNT(*) FROM queryTableName [WHERE whereClause]" SQL Statement
strcpy(sqlStmt, "SELECT COUNT(*) FROM "); wxStrcpy(sqlStmt, "SELECT COUNT(");
strcat(sqlStmt, queryTableName); wxStrcat(sqlStmt, args);
wxStrcat(sqlStmt, ") FROM ");
wxStrcat(sqlStmt, queryTableName);
if (from && strlen(from)) if (from && wxStrlen(from))
strcat(sqlStmt, from); wxStrcat(sqlStmt, from);
// Add the where clause if one is provided // Add the where clause if one is provided
if (where && strlen(where)) if (where && wxStrlen(where))
{ {
strcat(sqlStmt, " WHERE "); wxStrcat(sqlStmt, " WHERE ");
strcat(sqlStmt, where); wxStrcat(sqlStmt, where);
} }
pDb->WriteSqlLog(sqlStmt); pDb->WriteSqlLog(sqlStmt);
@@ -1710,7 +1712,7 @@ bool wxTable::Refresh(void)
// Build a where clause to refetch the record with. Try and use the // Build a where clause to refetch the record with. Try and use the
// ROWID if it's available, ow use the key fields. // ROWID if it's available, ow use the key fields.
char whereClause[DB_MAX_WHERE_CLAUSE_LEN+1]; char whereClause[DB_MAX_WHERE_CLAUSE_LEN+1];
strcpy(whereClause, ""); wxStrcpy(whereClause, "");
if (CanUpdByROWID()) if (CanUpdByROWID())
{ {
SDWORD cb; SDWORD cb;
@@ -1721,15 +1723,15 @@ bool wxTable::Refresh(void)
// based on the key fields. // based on the key fields.
if (SQLGetData(hstmt, noCols+1, SQL_C_CHAR, (UCHAR*) rowid, ROWID_LEN, &cb) == SQL_SUCCESS) if (SQLGetData(hstmt, noCols+1, SQL_C_CHAR, (UCHAR*) rowid, ROWID_LEN, &cb) == SQL_SUCCESS)
{ {
strcat(whereClause, queryTableName); wxStrcat(whereClause, queryTableName);
strcat(whereClause, ".ROWID = '"); wxStrcat(whereClause, ".ROWID = '");
strcat(whereClause, rowid); wxStrcat(whereClause, rowid);
strcat(whereClause, "'"); wxStrcat(whereClause, "'");
} }
} }
// If unable to use the ROWID, build a where clause from the keyfields // 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); GetWhereClause(whereClause, DB_WHERE_KEYFIELDS, queryTableName);
// Requery the record // Requery the record