#endif
#ifdef DBDEBUG_CONSOLE
- #include "iostream.h"
+#if wxUSE_IOSTREAMH
+ #include <iostream.h>
+#else
+ #include <iostream>
+#endif
#include "wx/ioswrap.h"
#endif
#include "wx/object.h"
#include "wx/list.h"
#include "wx/utils.h"
- #include "wx/msgdlg.h"
+ #if wxUSE_GUI
+ #include "wx/msgdlg.h"
+ #endif
#include "wx/log.h"
#endif
#include "wx/filefn.h"
SqlCtype = SQL_C_LONG;
PtrDataObj = NULL;
SzDataObj = 0;
- KeyField = false;
- Updateable = false;
- InsertAllowed = false;
- DerivedCol = false;
+ KeyField = FALSE;
+ Updateable = FALSE;
+ InsertAllowed = FALSE;
+ DerivedCol = FALSE;
CbValue = 0;
- Null = false;
+ Null = FALSE;
- return true;
+ return TRUE;
} // wxDbColDef::Initialize()
where.Empty(); // Where clause
orderBy.Empty(); // Order By clause
from.Empty(); // From clause
- selectForUpdate = false; // SELECT ... FOR UPDATE; Indicates whether to include the FOR UPDATE phrase
+ selectForUpdate = FALSE; // SELECT ... FOR UPDATE; Indicates whether to include the FOR UPDATE phrase
queryOnly = qryOnly;
- insertable = true;
+ insertable = TRUE;
tablePath.Empty();
tableName.Empty();
queryTableName.Empty();
wxASSERT(pDb);
if (!pDb)
- return false;
+ return FALSE;
tableName = tblName; // Table Name
if (tblPath.Length())
tablePath = tblPath; // Table Path - used for dBase files
else
tablePath.Empty();
-
+
if (qryTblName.Length()) // Name of the table/view to query
queryTableName = qryTblName;
else
queryTableName = tblName;
-
+
pDb->incrementTableCount();
-
+
wxString s;
tableID = ++lastTableID;
s.Printf(wxT("wxDbTable constructor (%-20s) tableID:[%6lu] pDb:[%p]"), tblName.c_str(), tableID, pDb);
tableInUse->pDb = pDb;
TablesInUse.Append(tableInUse);
#endif
-
+
pDb->WriteSqlLog(s);
-
+
// Grab the HENV and HDBC from the wxDb object
henv = pDb->GetHENV();
hdbc = pDb->GetHDBC();
-
+
// Allocate space for column definitions
if (noCols)
colDefs = new wxDbColDef[noCols]; // Points to the first column definition
-
+
// Allocate statement handles for the table
if (!queryOnly)
{
// 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, wxT("01S02"))) // Option Value Changed
{
// Should never happen
pDb->GetNextError(henv, hdbc, hstmtInternal);
- return false;
+ return FALSE;
}
}
}
else
cout << wxT("Cursor Type set to STATIC") << endl << endl;
#endif
-
+
if (!queryOnly)
{
// Set the cursor type for the INSERT 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 = GetNewCursor(false,false);
+ hstmtDefault = GetNewCursor(FALSE,FALSE);
wxASSERT(hstmtDefault);
hstmt = *hstmtDefault;
- return true;
+ return TRUE;
} // wxDbTable::initialize()
#ifdef __WXDEBUG__
if (tableID)
{
- TablesInUse.DeleteContents(true);
- bool found = false;
+ TablesInUse.DeleteContents(TRUE);
+ bool found = FALSE;
wxNode *pNode;
pNode = TablesInUse.First();
{
if (((wxTablesInUse *)pNode->Data())->tableID == tableID)
{
- found = true;
+ found = TRUE;
if (!TablesInUse.DeleteNode(pNode))
wxLogDebug (s,wxT("Unable to delete node!"));
}
{
wxASSERT(!queryOnly);
if (queryOnly)
- return(false);
-
+ return(FALSE);
+
SWORD fSqlType = 0;
UDWORD precision = 0;
SWORD scale = 0;
-
+
// Bind each column of the table that should be bound
// to a parameter marker
int i;
case DB_DATA_TYPE_FLOAT:
fSqlType = pDb->GetTypeInfFloat().FsqlType;
precision = pDb->GetTypeInfFloat().Precision;
- scale = pDb->GetTypeInfFloat().MaximumScale;
+ scale = pDb->GetTypeInfFloat().MaximumScale;
// SQL Sybase Anywhere v5.5 returned a negative number for the
// MaxScale. This caused ODBC to kick out an error on ibscale.
// I check for this here and set the scale = precision.
if (forUpdate)
{
if (SQLBindParameter(hstmtUpdate, colNo++, SQL_PARAM_INPUT, colDefs[i].SqlCtype,
- fSqlType, precision, scale, (UCHAR*) colDefs[i].PtrDataObj,
+ fSqlType, precision, scale, (UCHAR*) colDefs[i].PtrDataObj,
precision+1, &colDefs[i].CbValue) != SQL_SUCCESS)
{
return(pDb->DispAllErrors(henv, hdbc, hstmtUpdate));
else
{
if (SQLBindParameter(hstmtInsert, colNo++, SQL_PARAM_INPUT, colDefs[i].SqlCtype,
- fSqlType, precision, scale, (UCHAR*) colDefs[i].PtrDataObj,
+ fSqlType, precision, scale, (UCHAR*) colDefs[i].PtrDataObj,
precision+1,&colDefs[i].CbValue) != SQL_SUCCESS)
{
return(pDb->DispAllErrors(henv, hdbc, hstmtInsert));
}
}
}
-
+
// Completed successfully
- return(true);
+ return(TRUE);
} // wxDbTable::bindParams()
/********** wxDbTable::bindInsertParams() **********/
bool wxDbTable::bindInsertParams(void)
{
- return bindParams(false);
+ return bindParams(FALSE);
} // wxDbTable::bindInsertParams()
/********** wxDbTable::bindUpdateParams() **********/
bool wxDbTable::bindUpdateParams(void)
{
- return bindParams(true);
+ return bindParams(TRUE);
} // wxDbTable::bindUpdateParams()
}
// Completed successfully
- return(true);
+ return(TRUE);
} // wxDbTable::bindCols()
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
if (retcode == SQL_NO_DATA_FOUND)
- return(false);
+ return(FALSE);
else
return(pDb->DispAllErrors(henv, hdbc, hstmt));
}
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
if (retcode == SQL_NO_DATA_FOUND)
- return(false);
+ return(FALSE);
else
return(pDb->DispAllErrors(henv, hdbc, hstmt));
}
}
// Completed successfully
- return(true);
+ return(TRUE);
} // wxDbTable::getRec()
retcode == SQL_SUCCESS_WITH_INFO)
{
// Record deleted successfully
- return(true);
+ return(TRUE);
}
// Problem deleting record
retcode == SQL_SUCCESS_WITH_INFO)
{
// Record updated successfully
- return(true);
+ return(TRUE);
}
// Problem updating record
// The user may wish to select for update, but the DBMS may not be capable
selectForUpdate = CanSelectForUpdate();
else
- selectForUpdate = false;
+ selectForUpdate = FALSE;
// Set the SQL SELECT string
if (queryType != DB_SELECT_STATEMENT) // A select statement was not passed in,
// Make sure the cursor is closed first
if (!CloseCursor(hstmt))
- return(false);
+ return(FALSE);
// Execute the SQL SELECT statement
- int retcode;
+ int retcode;
retcode = SQLExecDirect(hstmt, (UCHAR FAR *) (queryType == DB_SELECT_STATEMENT ? pSqlStmt.c_str() : sqlStmt.c_str()), SQL_NTS);
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
return(pDb->DispAllErrors(henv, hdbc, hstmt));
// Completed successfully
- return(true);
+ return(TRUE);
} // wxDbTable::query()
bool wxDbTable::Open(bool checkPrivileges, bool checkTableExists)
{
if (!pDb)
- return false;
+ return FALSE;
int i;
wxString sqlStmt;
else if (checkPrivileges)
{
// Verify the user has rights to access the table.
- // Shortcut boolean evaluation to optimize out call to
+ // Shortcut boolean evaluation to optimize out call to
// TablePrivileges
//
// Unfortunately this optimization doesn't seem to be
// reliable!
- if (// *(pDb->dbInf.accessibleTables) == 'N' &&
+ if (// *(pDb->dbInf.accessibleTables) == 'N' &&
!pDb->TablePrivileges(tableName,wxT("SELECT"), pDb->GetUsername(), pDb->GetUsername(), tablePath))
s = wxT("Current logged in user does not have sufficient privileges to access this table.\n");
}
p += s;
pDb->LogError(p.GetData());
- return(false);
+ return(FALSE);
}
// Bind the member variables for field exchange between
if (!queryOnly)
{
if (!bindInsertParams()) // Inserts
- return(false);
-
+ return(FALSE);
+
if (!bindUpdateParams()) // Updates
- return(false);
+ return(FALSE);
}
if (!bindCols(*hstmtDefault)) // Selects
- return(false);
-
+ return(FALSE);
+
if (!bindCols(hstmtInternal)) // Internal use only
- return(false);
+ return(FALSE);
/*
* Do NOT bind the hstmtCount cursor!!!
// Build an insert statement using parameter markers
if (!queryOnly && noCols > 0)
{
- bool needComma = false;
- sqlStmt.Printf(wxT("INSERT INTO %s ("), tableName.c_str());
+ bool needComma = FALSE;
+ sqlStmt.Printf(wxT("INSERT INTO %s ("),
+ pDb->SQLTableName(tableName.c_str()).c_str());
for (i = 0; i < noCols; i++)
{
if (! colDefs[i].InsertAllowed)
continue;
if (needComma)
sqlStmt += wxT(",");
- sqlStmt += colDefs[i].ColName;
- needComma = true;
+ sqlStmt += pDb->SQLColumnName(colDefs[i].ColName);
+// sqlStmt += colDefs[i].ColName;
+ needComma = TRUE;
}
- needComma = false;
+ needComma = FALSE;
sqlStmt += wxT(") VALUES (");
int insertableCount = 0;
if (needComma)
sqlStmt += wxT(",");
sqlStmt += wxT("?");
- needComma = true;
+ needComma = TRUE;
insertableCount++;
}
sqlStmt += wxT(")");
-
+
// Prepare the insert statement for execution
- if (insertableCount)
+ if (insertableCount)
{
if (SQLPrepare(hstmtInsert, (UCHAR FAR *) sqlStmt.c_str(), SQL_NTS) != SQL_SUCCESS)
return(pDb->DispAllErrors(henv, hdbc, hstmtInsert));
}
- else
- insertable= false;
+ else
+ insertable= FALSE;
}
-
+
// Completed successfully
- return(true);
+ return(TRUE);
} // wxDbTable::Open()
{
pDb->WriteSqlLog(pSqlStmt);
- return(query(DB_SELECT_STATEMENT, false, false, pSqlStmt));
+ return(query(DB_SELECT_STATEMENT, FALSE, FALSE, pSqlStmt));
} // wxDbTable::QueryBySqlStmt()
if (pDb->FwdOnlyCursors())
{
wxFAIL_MSG(wxT("GetPrev()::Backward scrolling cursors are not enabled for this instance of wxDbTable"));
- return false;
+ return FALSE;
}
else
return(getRec(SQL_FETCH_PRIOR));
if (pDb->FwdOnlyCursors())
{
wxFAIL_MSG(wxT("operator--:Backward scrolling cursors are not enabled for this instance of wxDbTable"));
- return false;
+ return FALSE;
}
else
return(getRec(SQL_FETCH_PRIOR));
if (pDb->FwdOnlyCursors())
{
wxFAIL_MSG(wxT("GetFirst():Backward scrolling cursors are not enabled for this instance of wxDbTable"));
- return false;
+ return FALSE;
}
else
return(getRec(SQL_FETCH_FIRST));
if (pDb->FwdOnlyCursors())
{
wxFAIL_MSG(wxT("GetLast()::Backward scrolling cursors are not enabled for this instance of wxDbTable"));
- return false;
+ return FALSE;
}
- else
+ else
return(getRec(SQL_FETCH_LAST));
} // wxDbTable::GetLast()
// delete all records from the database in this case.
if (typeOfDel == DB_DEL_WHERE && (pWhereClause.Length() == 0))
{
- pSqlStmt.Printf(wxT("DELETE FROM %s"), tableName.c_str());
+ pSqlStmt.Printf(wxT("DELETE FROM %s"),
+ pDb->SQLTableName(tableName.c_str()).c_str());
return;
}
- pSqlStmt.Printf(wxT("DELETE FROM %s WHERE "), tableName.c_str());
+ pSqlStmt.Printf(wxT("DELETE FROM %s WHERE "),
+ pDb->SQLTableName(tableName.c_str()).c_str());
// Append the WHERE clause to the SQL DELETE statement
switch(typeOfDel)
// Was a FROM clause specified to join tables to the base table?
// Available for ::Query() only!!!
- bool appendFromClause = false;
+ bool appendFromClause = FALSE;
#if wxODBC_BACKWARD_COMPATABILITY
if (typeOfSelect == DB_SELECT_WHERE && from && wxStrlen(from))
- appendFromClause = true;
+ appendFromClause = TRUE;
#else
if (typeOfSelect == DB_SELECT_WHERE && from.Length())
- appendFromClause = true;
+ appendFromClause = TRUE;
#endif
// Add the column list
// If joining tables, the base table column names must be qualified to avoid ambiguity
if (appendFromClause || pDb->Dbms() == dbmsACCESS)
{
- pSqlStmt += queryTableName;
+ pSqlStmt += pDb->SQLTableName(queryTableName.c_str());
+// pSqlStmt += queryTableName;
pSqlStmt += wxT(".");
}
- pSqlStmt += colDefs[i].ColName;
+ pSqlStmt += pDb->SQLColumnName(colDefs[i].ColName);
+// pSqlStmt += colDefs[i].ColName;
if (i + 1 < noCols)
pSqlStmt += wxT(",");
}
if (appendFromClause || pDb->Dbms() == dbmsACCESS)
{
pSqlStmt += wxT(",");
- pSqlStmt += queryTableName;
+ pSqlStmt += pDb->SQLTableName(queryTableName);
+// pSqlStmt += queryTableName;
pSqlStmt += wxT(".ROWID");
}
else
// Append the FROM tablename portion
pSqlStmt += wxT(" FROM ");
- pSqlStmt += queryTableName;
+ pSqlStmt += pDb->SQLTableName(queryTableName);
+// pSqlStmt += queryTableName;
// Sybase uses the HOLDLOCK keyword to lock a record during query.
// The HOLDLOCK keyword follows the table name in the from clause.
wxString whereClause;
whereClause.Empty();
- bool firstColumn = true;
+ bool firstColumn = TRUE;
- pSqlStmt.Printf(wxT("UPDATE %s SET "), tableName.Upper().c_str());
+ pSqlStmt.Printf(wxT("UPDATE %s SET "),
+ pDb->SQLTableName(tableName.c_str()).c_str());
// Append a list of columns to be updated
int i;
if (!firstColumn)
pSqlStmt += wxT(",");
else
- firstColumn = false;
- pSqlStmt += colDefs[i].ColName;
+ firstColumn = FALSE;
+
+ pSqlStmt += pDb->SQLColumnName(colDefs[i].ColName);
+// pSqlStmt += colDefs[i].ColName;
pSqlStmt += wxT(" = ?");
}
}
* They are not included as part of the where clause.
*/
{
- bool moreThanOneColumn = false;
+ bool moreThanOneColumn = FALSE;
wxString colValue;
// Loop through the columns building a where clause as you go
if (moreThanOneColumn)
pWhereClause += wxT(" AND ");
else
- moreThanOneColumn = true;
+ moreThanOneColumn = TRUE;
// Concatenate where phrase for the column
if (qualTableName.Length())
{
- pWhereClause += qualTableName;
+ pWhereClause += pDb->SQLTableName(qualTableName);
+// pWhereClause += qualTableName;
pWhereClause += wxT(".");
}
- pWhereClause += colDefs[i].ColName;
+ pWhereClause += pDb->SQLColumnName(colDefs[i].ColName);
+// pWhereClause += colDefs[i].ColName;
if (useLikeComparison && (colDefs[i].SqlCtype == SQL_C_CHAR))
pWhereClause += wxT(" LIKE ");
else
return(pDb->DispAllErrors(henv, hdbc, cursor));
// Completed successfully
- return(true);
+ return(TRUE);
} // wxDbTable::CloseCursor()
bool wxDbTable::CreateTable(bool attemptDrop)
{
if (!pDb)
- return false;
+ return FALSE;
int i, j;
wxString sqlStmt;
// Drop table first
if (attemptDrop && !DropTable())
- return false;
+ return FALSE;
// Create the table
#ifdef DBDEBUG_CONSOLE
#endif
// Build a CREATE TABLE string from the colDefs structure.
- bool needComma = false;
- sqlStmt.Printf(wxT("CREATE TABLE %s ("), tableName.c_str());
+ bool needComma = FALSE;
+
+ sqlStmt.Printf(wxT("CREATE TABLE %s ("),
+ pDb->SQLTableName(tableName.c_str()).c_str());
for (i = 0; i < noCols; i++)
{
if (needComma)
sqlStmt += wxT(",");
// Column Name
- sqlStmt += colDefs[i].ColName;
+ sqlStmt += pDb->SQLColumnName(colDefs[i].ColName);
+// sqlStmt += colDefs[i].ColName;
sqlStmt += wxT(" ");
// Column Type
switch(colDefs[i].DbDataType)
sqlStmt += wxT(" NOT NULL");
}
}
-
- needComma = true;
+
+ needComma = TRUE;
}
// If there is a primary key defined, include it in the create statement
for (i = j = 0; i < noCols; i++)
{
switch (pDb->Dbms())
{
+ case dbmsACCESS:
case dbmsINFORMIX:
case dbmsSYBASE_ASA:
case dbmsSYBASE_ASE:
if (pDb->Dbms() == dbmsDB2)
{
wxASSERT_MSG((tableName && wxStrlen(tableName) <= 13), wxT("DB2 table/index names must be no longer than 13 characters in length.\n\nTruncating table name to 13 characters."));
- sqlStmt += tableName.substr(0, 13);
+ sqlStmt += pDb->SQLTableName(tableName.substr(0, 13).c_str());
+// sqlStmt += tableName.substr(0, 13);
}
else
- sqlStmt += tableName;
+ sqlStmt += pDb->SQLTableName(tableName.c_str());
+// sqlStmt += tableName;
sqlStmt += wxT("_PIDX PRIMARY KEY (");
break;
{
if (j++) // Multi part key, comma separate names
sqlStmt += wxT(",");
- sqlStmt += colDefs[i].ColName;
+ sqlStmt += pDb->SQLColumnName(colDefs[i].ColName);
+// sqlStmt += colDefs[i].ColName;
}
}
sqlStmt += wxT(")");
pDb->Dbms() == dbmsSYBASE_ASE)
{
sqlStmt += wxT(" CONSTRAINT ");
- sqlStmt += tableName;
+ sqlStmt += pDb->SQLTableName(tableName);
+// sqlStmt += tableName;
sqlStmt += wxT("_PIDX");
}
}
pDb->DispAllErrors(henv, hdbc, hstmt);
pDb->RollbackTrans();
CloseCursor(hstmt);
- return(false);
+ return(FALSE);
}
// Commit the transaction and close the cursor
if (!pDb->CommitTrans())
- return(false);
+ return(FALSE);
if (!CloseCursor(hstmt))
- return(false);
+ return(FALSE);
// Database table created successfully
- return(true);
+ return(TRUE);
} // wxDbTable::CreateTable()
/********** wxDbTable::DropTable() **********/
bool wxDbTable::DropTable()
{
- // NOTE: This function returns true if the Table does not exist, but
+ // 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
wxString sqlStmt;
- sqlStmt.Printf(wxT("DROP TABLE %s"), tableName.c_str());
+ sqlStmt.Printf(wxT("DROP TABLE %s"),
+ pDb->SQLTableName(tableName.c_str()).c_str());
pDb->WriteSqlLog(sqlStmt);
cout << endl << sqlStmt.c_str() << endl;
#endif
-
-
-
RETCODE retcode = SQLExecDirect(hstmt, (UCHAR FAR *) sqlStmt.c_str(), SQL_NTS);
if (retcode != SQL_SUCCESS)
{
// Check for "Base table not found" error and ignore
- pDb->GetNextError(henv, hdbc, hstmt);
+ pDb->GetNextError(henv, hdbc, hstmt);
if (wxStrcmp(pDb->sqlState, wxT("S0002")) /*&&
- wxStrcmp(pDb->sqlState, wxT("S1000"))*/) // "Base table not found"
+ wxStrcmp(pDb->sqlState, wxT("S1000"))*/) // "Base table not found"
{
// Check for product specific error codes
if (!((pDb->Dbms() == dbmsSYBASE_ASA && !wxStrcmp(pDb->sqlState,wxT("42000"))) || // 5.x (and lower?)
- (pDb->Dbms() == dbmsSYBASE_ASE && !wxStrcmp(pDb->sqlState,wxT("37000"))) ||
+ (pDb->Dbms() == dbmsSYBASE_ASE && !wxStrcmp(pDb->sqlState,wxT("37000"))) ||
(pDb->Dbms() == dbmsPERVASIVE_SQL && !wxStrcmp(pDb->sqlState,wxT("S1000"))) || // Returns an S1000 then an S0002
- (pDb->Dbms() == dbmsPOSTGRES && !wxStrcmp(pDb->sqlState,wxT("08S01")))))
+ (pDb->Dbms() == dbmsPOSTGRES && !wxStrcmp(pDb->sqlState,wxT("08S01")))))
{
pDb->DispNextError();
pDb->DispAllErrors(henv, hdbc, hstmt);
pDb->RollbackTrans();
// CloseCursor(hstmt);
- return(false);
+ return(FALSE);
}
}
}
// Commit the transaction and close the cursor
if (! pDb->CommitTrans())
- return(false);
+ return(FALSE);
if (! CloseCursor(hstmt))
- return(false);
+ return(FALSE);
- return(true);
+ return(TRUE);
} // wxDbTable::DropTable()
// Drop the index first
if (attemptDrop && !DropIndex(idxName))
- return (false);
+ return (FALSE);
// MySQL (and possibly Sybase ASE?? - gt) require that any columns which are used as portions
// of an index have the columns defined as "NOT NULL". During initial table creation though,
{
wxString sqlStmt;
int i;
- bool ok = true;
+ bool ok = TRUE;
for (i = 0; i < noIdxCols && ok; i++)
{
int j = 0;
- bool found = false;
+ bool found = FALSE;
// Find the column definition that has the ColName that matches the
// index column name. We need to do this to get the DB_DATA_TYPE of
// the index column, as MySQL's syntax for the ALTER column requires
while (!found && (j < this->noCols))
{
if (wxStrcmp(colDefs[j].ColName,pIdxDefs[i].ColName) == 0)
- found = true;
+ found = TRUE;
if (!found)
j++;
}
-
+
if (found)
{
ok = pDb->ModifyColumn(tableName, pIdxDefs[i].ColName,
}
}
else
- ok = false;
+ ok = FALSE;
}
if (ok)
pDb->CommitTrans();
else
{
pDb->RollbackTrans();
- return(false);
+ return(FALSE);
}
}
-
+
// Build a CREATE INDEX statement
sqlStmt = wxT("CREATE ");
if (unique)
sqlStmt += wxT("UNIQUE ");
-
+
sqlStmt += wxT("INDEX ");
- sqlStmt += idxName;
+ sqlStmt += pDb->SQLTableName(idxName);
sqlStmt += wxT(" ON ");
- sqlStmt += tableName;
+
+ sqlStmt += pDb->SQLTableName(tableName);
+// sqlStmt += tableName;
sqlStmt += wxT(" (");
-
+
// Append list of columns making up index
int i;
for (i = 0; i < noIdxCols; i++)
{
- sqlStmt += pIdxDefs[i].ColName;
+ sqlStmt += pDb->SQLColumnName(pIdxDefs[i].ColName);
+// sqlStmt += pIdxDefs[i].ColName;
// Postgres and SQL Server 7 do not support the ASC/DESC keywords for index columns
if (!((pDb->Dbms() == dbmsMS_SQL_SERVER) && (strncmp(pDb->dbInf.dbmsVer,"07",2)==0)) &&
if ((i + 1) < noIdxCols)
sqlStmt += wxT(",");
}
-
+
// Append closing parentheses
sqlStmt += wxT(")");
pDb->DispAllErrors(henv, hdbc, hstmt);
pDb->RollbackTrans();
CloseCursor(hstmt);
- return(false);
+ return(FALSE);
}
// Commit the transaction and close the cursor
if (! pDb->CommitTrans())
- return(false);
+ return(FALSE);
if (! CloseCursor(hstmt))
- return(false);
+ return(FALSE);
// Index Created Successfully
- return(true);
+ return(TRUE);
} // wxDbTable::CreateIndex()
/********** wxDbTable::DropIndex() **********/
bool wxDbTable::DropIndex(const wxString &idxName)
{
- // NOTE: This function returns true if the Index does not exist, but
+ // 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
if (pDb->Dbms() == dbmsACCESS || pDb->Dbms() == dbmsMY_SQL ||
pDb->Dbms() == dbmsDBASE /*|| Paradox needs this syntax too when we add support*/)
- sqlStmt.Printf(wxT("DROP INDEX %s ON %s"),idxName.c_str(), tableName.c_str());
+ sqlStmt.Printf(wxT("DROP INDEX %s ON %s"),
+ pDb->SQLTableName(idxName.c_str()).c_str(),
+ pDb->SQLTableName(tableName.c_str()).c_str());
else if ((pDb->Dbms() == dbmsMS_SQL_SERVER) ||
(pDb->Dbms() == dbmsSYBASE_ASE))
- sqlStmt.Printf(wxT("DROP INDEX %s.%s"),tableName.c_str(), idxName.c_str());
+ sqlStmt.Printf(wxT("DROP INDEX %s.%s"),
+ pDb->SQLTableName(tableName.c_str()).c_str(),
+ pDb->SQLTableName(idxName.c_str()).c_str());
else
- sqlStmt.Printf(wxT("DROP INDEX %s"),idxName.c_str());
+ sqlStmt.Printf(wxT("DROP INDEX %s"),
+ pDb->SQLTableName(idxName.c_str()).c_str());
pDb->WriteSqlLog(sqlStmt);
pDb->DispAllErrors(henv, hdbc, hstmt);
pDb->RollbackTrans();
CloseCursor(hstmt);
- return(false);
+ return(FALSE);
}
}
}
// Commit the transaction and close the cursor
if (! pDb->CommitTrans())
- return(false);
+ return(FALSE);
if (! CloseCursor(hstmt))
- return(false);
+ return(FALSE);
- return(true);
+ return(TRUE);
} // wxDbTable::DropIndex()
int colNo = first; // using 'int' to be able to look for wxDB_NO_MORE_COLUN_NUMBERS
va_list argptr;
- bool abort = false;
+ bool abort = FALSE;
wxString tempStr;
va_start(argptr, first); /* Initialize variable arguments. */
// Valid columns are 0 thru noCols-1
if (colNo >= noCols || colNo < 0)
{
- abort = true;
+ abort = TRUE;
continue;
}
{
wxASSERT(!queryOnly);
if (queryOnly)
- return(false);
+ return(FALSE);
wxString sqlStmt;
{
wxASSERT(!queryOnly);
if (queryOnly)
- return(false);
+ return(FALSE);
pDb->WriteSqlLog(pSqlStmt);
{
wxASSERT(!queryOnly);
if (queryOnly)
- return(false);
+ return(FALSE);
wxString sqlStmt;
{
wxASSERT(!queryOnly);
if (queryOnly)
- return(false);
+ return(FALSE);
wxString sqlStmt;
sqlStmt.Empty();
{
wxASSERT(!queryOnly);
if (queryOnly)
- return(false);
+ return(FALSE);
wxString sqlStmt;
sqlStmt.Empty();
{
wxASSERT(!queryOnly);
if (queryOnly)
- return(false);
+ return(FALSE);
wxString sqlStmt;
sqlStmt.Empty();
bool wxDbTable::IsColNull(UWORD colNo) const
{
/*
- This logic is just not right. It would indicate true
+ This logic is just not right. It would indicate TRUE
if a numeric field were set to a value of 0.
switch(colDefs[colNo].SqlCtype)
TIMESTAMP_STRUCT *pDt;
pDt = (TIMESTAMP_STRUCT *) colDefs[colNo].PtrDataObj;
if (pDt->year == 0 && pDt->month == 0 && pDt->day == 0)
- return(true);
+ return(TRUE);
else
- return(false);
+ return(FALSE);
default:
- return(true);
+ return(TRUE);
}
*/
return (colDefs[colNo].Null);
bool wxDbTable::CanSelectForUpdate(void)
{
if (queryOnly)
- return false;
+ return FALSE;
if (pDb->Dbms() == dbmsMY_SQL)
- return false;
+ return FALSE;
if ((pDb->Dbms() == dbmsORACLE) ||
(pDb->dbInf.posStmts & SQL_PS_SELECT_FOR_UPDATE))
- return(true);
+ return(TRUE);
else
- return(false);
+ return(FALSE);
} // wxDbTable::CanSelectForUpdate()
bool wxDbTable::CanUpdByROWID(void)
{
/*
- * NOTE: Returning false for now until this can be debugged,
+ * NOTE: Returning FALSE for now until this can be debugged,
* as the ROWID is not getting updated correctly
*/
- return false;
+ return FALSE;
/*
if (pDb->Dbms() == dbmsORACLE)
- return(true);
+ return(TRUE);
else
- return(false);
+ return(FALSE);
*/
} // wxDbTable::CanUpdByROWID()
bool wxDbTable::IsCursorClosedOnCommit(void)
{
if (pDb->dbInf.cursorCommitBehavior == SQL_CB_PRESERVE)
- return(false);
+ return(FALSE);
else
- return(true);
+ return(TRUE);
} // wxDbTable::IsCursorClosedOnCommit()
return(pDb->DispAllErrors(henv, hdbc, hstmtInternal));
// Completed Successfully
- return(true);
+ return(TRUE);
} // wxDbTable::SetQueryTimeout()
if (fieldName.Length() > (unsigned int) DB_MAX_COLUMN_NAME_LEN)
{
- int assertColumnNameTooLong = 0;
wxStrncpy(colDefs[index].ColName, fieldName, DB_MAX_COLUMN_NAME_LEN);
colDefs[index].ColName[DB_MAX_COLUMN_NAME_LEN] = 0;
+
+#ifdef __WXDEBUG__
wxString tmpMsg;
- tmpMsg.Printf("Column name '%s' is too long. Truncated to '%s'.",fieldName.c_str(),colDefs[index].ColName);
- wxASSERT_MSG(assertColumnNameTooLong,tmpMsg.c_str());
+ tmpMsg.Printf(_T("Column name '%s' is too long. Truncated to '%s'."),
+ fieldName.c_str(),colDefs[index].ColName);
+ wxFAIL_MSG(tmpMsg);
+#endif // __WXDEBUG__
}
else
wxStrcpy(colDefs[index].ColName, fieldName);
// Derived columns by definition would NOT be "Insertable" or "Updateable"
if (derivedCol)
{
- colDefs[index].Updateable = false;
- colDefs[index].InsertAllowed = false;
+ colDefs[index].Updateable = FALSE;
+ colDefs[index].InsertAllowed = FALSE;
}
else
{
colDefs[index].InsertAllowed = insAllow;
}
- colDefs[index].Null = false;
-
+ colDefs[index].Null = FALSE;
+
} // wxDbTable::SetColDefs()
if (pColInfs)
{
UWORD index;
-
+
pColDataPtrs = new wxDbColDataPtr[numCols+1];
for (index = 0; index < numCols; index++)
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].SqlCtype = SQL_C_TIMESTAMP;
break;
case DB_DATA_TYPE_BLOB:
- int notSupportedYet = 0;
- wxASSERT_MSG(notSupportedYet, wxT("This form of ::SetColDefs() cannot be used with BLOB columns"));
+ wxFAIL_MSG(wxT("This form of ::SetColDefs() cannot be used with BLOB columns"));
pColDataPtrs[index].PtrDataObj = /*BLOB ADDITION NEEDED*/NULL;
pColDataPtrs[index].SzDataObj = /*BLOB ADDITION NEEDED*/sizeof(void *);
pColDataPtrs[index].SqlCtype = SQL_VARBINARY;
SetColDefs (index,pColInfs[index].colName,pColInfs[index].dbDataType, pColDataPtrs[index].PtrDataObj, pColDataPtrs[index].SqlCtype, pColDataPtrs[index].SzDataObj);
else
{
- // Unable to build all the column definitions, as either one of
+ // Unable to build all the column definitions, as either one of
// the calls to "new" failed above, or there was a BLOB field
// to have a column definition for. If BLOBs are to be used,
// the other form of ::SetColDefs() must be used, as it is impossible
sqlStmt = wxT("SELECT COUNT(");
sqlStmt += args;
sqlStmt += wxT(") FROM ");
- sqlStmt += queryTableName;
+ sqlStmt += pDb->SQLTableName(queryTableName);
+// sqlStmt += queryTableName;
#if wxODBC_BACKWARD_COMPATABILITY
if (from && wxStrlen(from))
#else
// Initialize the Count cursor if it's not already initialized
if (!hstmtCount)
{
- hstmtCount = GetNewCursor(false,false);
+ hstmtCount = GetNewCursor(FALSE,FALSE);
wxASSERT(hstmtCount);
if (!hstmtCount)
return(0);
/********** wxDbTable::Refresh() **********/
bool wxDbTable::Refresh(void)
{
- bool result = true;
+ bool result = TRUE;
// Switch to the internal cursor so any active cursors are not corrupted
HSTMT currCursor = GetCursor();
// based on the key fields.
if (SQLGetData(hstmt, (UWORD)(noCols+1), SQL_C_CHAR, (UCHAR*) rowid, wxDB_ROWID_LEN, &cb) == SQL_SUCCESS)
{
- whereClause += queryTableName;
+ whereClause += pDb->SQLTableName(queryTableName);
+// whereClause += queryTableName;
whereClause += wxT(".ROWID = '");
whereClause += rowid;
whereClause += wxT("'");
where = whereClause;
orderBy.Empty();
if (!Query())
- result = false;
+ result = FALSE;
if (result && !GetNext())
- result = false;
+ result = FALSE;
// Switch back to original cursor
SetCursor(&currCursor);
{
colDefs[colNo].Null = set;
if (set) // Blank out the values in the member variable
- ClearMemberVar(colNo,false); // Must call with false, or infinite recursion will happen
- return(true);
+ ClearMemberVar(colNo,FALSE); // Must call with FALSE, or infinite recursion will happen
+ return(TRUE);
}
else
- return(false);
+ return(FALSE);
} // wxDbTable::SetColNull()
{
colDefs[i].Null = set;
if (set) // Blank out the values in the member variable
- ClearMemberVar(i,false); // Must call with false, or infinite recursion will happen
- return(true);
+ ClearMemberVar(i,FALSE); // Must call with FALSE, or infinite recursion will happen
+ return(TRUE);
}
else
- return(false);
+ return(FALSE);
} // wxDbTable::SetColNull()
/********** wxDbTable::DeleteCursor() **********/
bool wxDbTable::DeleteCursor(HSTMT *hstmtDel)
{
- bool result = true;
+ bool result = TRUE;
if (!hstmtDel) // Cursor already deleted
return(result);
/*
ODBC 3.0 says to use this form
if (SQLFreeHandle(*hstmtDel, SQL_DROP) != SQL_SUCCESS)
-
+
*/
if (SQLFreeStmt(*hstmtDel, SQL_DROP) != SQL_SUCCESS)
{
pDb->DispAllErrors(henv, hdbc);
- result = false;
+ result = FALSE;
}
delete hstmtDel;
{
if (!m_hstmtGridQuery)
{
- m_hstmtGridQuery = GetNewCursor(false,false);
+ m_hstmtGridQuery = GetNewCursor(FALSE,FALSE);
if (!bindCols(*m_hstmtGridQuery))
return;
}
} // wxDbTable::SetRowMode()
-wxVariant wxDbTable::GetCol(const int col) const
+wxVariant wxDbTable::GetCol(const int colNo) const
{
wxVariant val;
- if ((col < noCols) && (!IsColNull(col)))
+ if ((colNo < noCols) && (!IsColNull(colNo)))
{
- switch (colDefs[col].SqlCtype)
+ switch (colDefs[colNo].SqlCtype)
{
case SQL_CHAR:
case SQL_VARCHAR:
- val = (char *)(colDefs[col].PtrDataObj);
+ val = (wxChar *)(colDefs[colNo].PtrDataObj);
break;
case SQL_C_LONG:
case SQL_C_SLONG:
- val = *(long *)(colDefs[col].PtrDataObj);
+ val = *(long *)(colDefs[colNo].PtrDataObj);
break;
case SQL_C_SHORT:
case SQL_C_SSHORT:
- val = (long int )(*(short *)(colDefs[col].PtrDataObj));
+ val = (long int )(*(short *)(colDefs[colNo].PtrDataObj));
break;
case SQL_C_ULONG:
- val = (long)(*(unsigned long *)(colDefs[col].PtrDataObj));
+ val = (long)(*(unsigned long *)(colDefs[colNo].PtrDataObj));
break;
case SQL_C_TINYINT:
- val = (long)(*(char *)(colDefs[col].PtrDataObj));
+ val = (long)(*(char *)(colDefs[colNo].PtrDataObj));
break;
case SQL_C_UTINYINT:
- val = (long)(*(unsigned char *)(colDefs[col].PtrDataObj));
+ val = (long)(*(unsigned char *)(colDefs[colNo].PtrDataObj));
break;
case SQL_C_USHORT:
- val = (long)(*(UWORD *)(colDefs[col].PtrDataObj));
+ val = (long)(*(UWORD *)(colDefs[colNo].PtrDataObj));
break;
case SQL_C_DATE:
- val = (DATE_STRUCT *)(colDefs[col].PtrDataObj);
+ val = (DATE_STRUCT *)(colDefs[colNo].PtrDataObj);
break;
case SQL_C_TIME:
- val = (TIME_STRUCT *)(colDefs[col].PtrDataObj);
+ val = (TIME_STRUCT *)(colDefs[colNo].PtrDataObj);
break;
case SQL_C_TIMESTAMP:
- val = (TIMESTAMP_STRUCT *)(colDefs[col].PtrDataObj);
+ val = (TIMESTAMP_STRUCT *)(colDefs[colNo].PtrDataObj);
break;
case SQL_C_DOUBLE:
- val = *(double *)(colDefs[col].PtrDataObj);
+ val = *(double *)(colDefs[colNo].PtrDataObj);
break;
default:
assert(0);
*s = '\0';
}
-void wxDbTable::SetCol(const int col, const wxVariant val)
+void wxDbTable::SetCol(const int colNo, const wxVariant val)
{
//FIXME: Add proper wxDateTime support to wxVariant..
wxDateTime dateval;
- SetColNull(col, val.IsNull());
+ SetColNull(colNo, val.IsNull());
if (!val.IsNull())
{
- if ((colDefs[col].SqlCtype == SQL_C_DATE)
- || (colDefs[col].SqlCtype == SQL_C_TIME)
- || (colDefs[col].SqlCtype == SQL_C_TIMESTAMP))
+ if ((colDefs[colNo].SqlCtype == SQL_C_DATE)
+ || (colDefs[colNo].SqlCtype == SQL_C_TIME)
+ || (colDefs[colNo].SqlCtype == SQL_C_TIMESTAMP))
{
//Returns null if invalid!
if (!dateval.ParseDate(val.GetString()))
- SetColNull(col,true);
- }
+ SetColNull(colNo, TRUE);
+ }
- switch (colDefs[col].SqlCtype)
+ switch (colDefs[colNo].SqlCtype)
{
case SQL_CHAR:
case SQL_VARCHAR:
- csstrncpyt((char *)(colDefs[col].PtrDataObj),
- val.GetString().c_str(),
- colDefs[col].SzDataObj-1);
+ csstrncpyt((char *)(colDefs[colNo].PtrDataObj),
+ val.GetString().c_str(),
+ colDefs[colNo].SzDataObj-1);
break;
case SQL_C_LONG:
case SQL_C_SLONG:
- *(long *)(colDefs[col].PtrDataObj) = val;
+ *(long *)(colDefs[colNo].PtrDataObj) = val;
break;
case SQL_C_SHORT:
case SQL_C_SSHORT:
- *(short *)(colDefs[col].PtrDataObj) = val.GetLong();
+ *(short *)(colDefs[colNo].PtrDataObj) = val.GetLong();
break;
case SQL_C_ULONG:
- *(unsigned long *)(colDefs[col].PtrDataObj) = val.GetLong();
+ *(unsigned long *)(colDefs[colNo].PtrDataObj) = val.GetLong();
break;
case SQL_C_TINYINT:
- *(char *)(colDefs[col].PtrDataObj) = val.GetChar();
+ *(char *)(colDefs[colNo].PtrDataObj) = val.GetChar();
break;
case SQL_C_UTINYINT:
- *(unsigned char *)(colDefs[col].PtrDataObj) = val.GetChar();
+ *(unsigned char *)(colDefs[colNo].PtrDataObj) = val.GetChar();
break;
case SQL_C_USHORT:
- *(unsigned short *)(colDefs[col].PtrDataObj) = val.GetLong();
+ *(unsigned short *)(colDefs[colNo].PtrDataObj) = val.GetLong();
break;
//FIXME: Add proper wxDateTime support to wxVariant..
case SQL_C_DATE:
{
DATE_STRUCT *dataptr =
- (DATE_STRUCT *)colDefs[col].PtrDataObj;
-
+ (DATE_STRUCT *)colDefs[colNo].PtrDataObj;
+
dataptr->year = dateval.GetYear();
dataptr->month = dateval.GetMonth()+1;
dataptr->day = dateval.GetDay();
case SQL_C_TIME:
{
TIME_STRUCT *dataptr =
- (TIME_STRUCT *)colDefs[col].PtrDataObj;
-
+ (TIME_STRUCT *)colDefs[colNo].PtrDataObj;
+
dataptr->hour = dateval.GetHour();
dataptr->minute = dateval.GetMinute();
dataptr->second = dateval.GetSecond();
case SQL_C_TIMESTAMP:
{
TIMESTAMP_STRUCT *dataptr =
- (TIMESTAMP_STRUCT *)colDefs[col].PtrDataObj;
+ (TIMESTAMP_STRUCT *)colDefs[colNo].PtrDataObj;
dataptr->year = dateval.GetYear();
dataptr->month = dateval.GetMonth()+1;
dataptr->day = dateval.GetDay();
-
+
dataptr->hour = dateval.GetHour();
dataptr->minute = dateval.GetMinute();
dataptr->second = dateval.GetSecond();
}
break;
case SQL_C_DOUBLE:
- *(double *)(colDefs[col].PtrDataObj) = val;
+ *(double *)(colDefs[colNo].PtrDataObj) = val;
break;
default:
assert(0);
GenericKey wxDbTable::GetKey()
{
void *blk;
- char *blkptr;
-
+ wxChar *blkptr;
+
blk = malloc(m_keysize);
- blkptr = (char *) blk;
-
+ blkptr = (wxChar *) blk;
+
int i;
for (i=0; i < noCols; i++)
{
void wxDbTable::SetKey(const GenericKey& k)
{
- void *blk;
- char *blkptr;
-
+ void *blk;
+ wxChar *blkptr;
+
blk = k.GetBlk();
- blkptr = (char *)blk;
+ blkptr = (wxChar *)blk;
int i;
for (i=0; i < noCols; i++)
{
if (colDefs[i].KeyField)
{
- SetColNull(i, false);
+ SetColNull(i, FALSE);
memcpy(colDefs[i].PtrDataObj, blkptr, colDefs[i].SzDataObj);
blkptr += colDefs[i].SzDataObj;
}
projects / wxWidgets.git / blobdiff