// Created: 9.96
// RCS-ID: $Id$
// Copyright: (c) 1996 Remstar International, Inc.
-// Licence: wxWindows licence, plus:
-// Notice: This class library and its intellectual design are free of charge for use,
-// modification, enhancement, debugging under the following conditions:
-// 1) These classes may only be used as part of the implementation of a
-// wxWindows-based application
-// 2) All enhancements and bug fixes are to be submitted back to the wxWindows
-// user groups free of all charges for use with the wxWindows library.
-// 3) These classes may not be distributed as part of any other class library,
-// DLL, text (written or electronic), other than a complete distribution of
-// the wxWindows GUI development toolkit.
+// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
/*
// SYNOPSIS STOP
*/
-// Use this line for wxWindows v1.x
-//#include "wx_ver.h"
-// Use this line for wxWindows v2.x
#include "wx/wxprec.h"
-#include "wx/version.h"
-#if wxMAJOR_VERSION == 2
- #ifdef __GNUG__
- #pragma implementation "dbtable.h"
- #endif
+#ifdef __BORLANDC__
+ #pragma hdrstop
#endif
#ifdef DBDEBUG_CONSOLE
- #include "wx/ioswrap.h"
+#if wxUSE_IOSTREAMH
+ #include <iostream.h>
+#else
+ #include <iostream>
#endif
-
-
-#ifdef __BORLANDC__
- #pragma hdrstop
-#endif //__BORLANDC__
-
-#if wxMAJOR_VERSION == 2
- #ifndef WX_PRECOMP
- #include "wx/string.h"
- #include "wx/object.h"
- #include "wx/list.h"
- #include "wx/utils.h"
- #include "wx/msgdlg.h"
- #include "wx/log.h"
- #endif
- #include "wx/filefn.h"
+ #include "wx/ioswrap.h"
#endif
-#if wxMAJOR_VERSION == 1
-# if defined(wx_msw) || defined(wx_x)
-# ifdef WX_PRECOMP
-# include "wx_prec.h"
-# else
-# include "wx.h"
-# endif
-# endif
-# define wxUSE_ODBC 1
+#ifndef WX_PRECOMP
+ #include "wx/string.h"
+ #include "wx/object.h"
+ #include "wx/list.h"
+ #include "wx/utils.h"
+ #include "wx/log.h"
#endif
-
+#include "wx/filefn.h"
#if wxUSE_ODBC
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-//#include <assert.h>
-#if wxMAJOR_VERSION == 1
- #include "table.h"
-#elif wxMAJOR_VERSION == 2
- #include "wx/dbtable.h"
-#endif
+#include "wx/dbtable.h"
#ifdef __UNIX__
// The HPUX preprocessor lines below were commented out on 8/20/97
#endif
+void csstrncpyt(wxChar *target, const wxChar *source, int n)
+{
+ while ( (*target++ = *source++) != '\0' && --n )
+ ;
+
+ *target = '\0';
+}
+
+
+
/********** wxDbColDef::wxDbColDef() Constructor **********/
wxDbColDef::wxDbColDef()
{
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()
/***** DEPRECATED: use wxDbTable::wxDbTable() format above *****/
+#if WXWIN_COMPATIBILITY_2_4
wxDbTable::wxDbTable(wxDb *pwxDb, const wxString &tblName, const UWORD numColumns,
const wxChar *qryTblName, bool qryOnly, const wxString &tblPath)
{
if (!initialize(pwxDb, tblName, numColumns, tempQryTblName, qryOnly, tblPath))
cleanup();
} // wxDbTable::wxDbTable()
+#endif // WXWIN_COMPATIBILITY_2_4
/********** wxDbTable::~wxDbTable() **********/
henv = 0;
hdbc = 0;
hstmt = 0;
+ m_hstmtGridQuery = 0;
hstmtDefault = 0; // Initialized below
hstmtCount = 0; // Initialized first time it is needed
hstmtInsert = 0;
hstmtInternal = 0;
colDefs = 0;
tableID = 0;
- noCols = numColumns; // Number of cols in the table
+ m_numCols = numColumns; // Number of columns in the table
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 ((pDb->Dbms() == dbmsORACLE) ||
+ (pDb->Dbms() == dbmsFIREBIRD) ||
+ (pDb->Dbms() == dbmsINTERBASE))
+ tableName = tableName.Upper();
+
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;
-
+
+ if ((pDb->Dbms() == dbmsORACLE) ||
+ (pDb->Dbms() == dbmsFIREBIRD) ||
+ (pDb->Dbms() == dbmsINTERBASE))
+ queryTableName = queryTableName.Upper();
+
pDb->incrementTableCount();
-
+
wxString s;
tableID = ++lastTableID;
s.Printf(wxT("wxDbTable constructor (%-20s) tableID:[%6lu] pDb:[%p]"), tblName.c_str(), tableID, pDb);
-
+
#ifdef __WXDEBUG__
wxTablesInUse *tableInUse;
tableInUse = new wxTablesInUse();
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
-
+ if (m_numCols)
+ colDefs = new wxDbColDef[m_numCols]; // 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;
+ bool found = false;
- wxNode *pNode;
- pNode = TablesInUse.First();
+ wxList::compatibility_iterator pNode;
+ pNode = TablesInUse.GetFirst();
while (pNode && !found)
{
- if (((wxTablesInUse *)pNode->Data())->tableID == tableID)
+ if (((wxTablesInUse *)pNode->GetData())->tableID == tableID)
{
- found = TRUE;
- if (!TablesInUse.DeleteNode(pNode))
- wxLogDebug (s,wxT("Unable to delete node!"));
+ found = true;
+ delete (wxTablesInUse *)pNode->GetData();
+ TablesInUse.Erase(pNode);
}
else
- pNode = pNode->Next();
+ pNode = pNode->GetNext();
}
if (!found)
{
wxString msg;
- msg.Printf(wxT("Unable to find the tableID in the linked\nlist of tables in use.\n\n%s"),s);
+ msg.Printf(wxT("Unable to find the tableID in the linked\nlist of tables in use.\n\n%s"),s.c_str());
wxLogDebug (msg,wxT("NOTICE..."));
}
}
if (hstmtCount)
DeleteCursor(hstmtCount);
+
+ if (m_hstmtGridQuery)
+ DeleteCursor(m_hstmtGridQuery);
+
} // wxDbTable::cleanup()
/***************************** PRIVATE FUNCTIONS *****************************/
+void wxDbTable::setCbValueForColumn(int columnIndex)
+{
+ switch(colDefs[columnIndex].DbDataType)
+ {
+ case DB_DATA_TYPE_VARCHAR:
+ case DB_DATA_TYPE_MEMO:
+ if (colDefs[columnIndex].Null)
+ colDefs[columnIndex].CbValue = SQL_NULL_DATA;
+ else
+ colDefs[columnIndex].CbValue = SQL_NTS;
+ break;
+ break;
+ case DB_DATA_TYPE_INTEGER:
+ if (colDefs[columnIndex].Null)
+ colDefs[columnIndex].CbValue = SQL_NULL_DATA;
+ else
+ colDefs[columnIndex].CbValue = 0;
+ break;
+ case DB_DATA_TYPE_FLOAT:
+ if (colDefs[columnIndex].Null)
+ colDefs[columnIndex].CbValue = SQL_NULL_DATA;
+ else
+ colDefs[columnIndex].CbValue = 0;
+ break;
+ case DB_DATA_TYPE_DATE:
+ if (colDefs[columnIndex].Null)
+ colDefs[columnIndex].CbValue = SQL_NULL_DATA;
+ else
+ colDefs[columnIndex].CbValue = 0;
+ break;
+ case DB_DATA_TYPE_BLOB:
+ if (colDefs[columnIndex].Null)
+ colDefs[columnIndex].CbValue = SQL_NULL_DATA;
+ else
+ if (colDefs[columnIndex].SqlCtype == SQL_C_WXCHAR)
+ colDefs[columnIndex].CbValue = SQL_NTS;
+ else
+ colDefs[columnIndex].CbValue = SQL_LEN_DATA_AT_EXEC(colDefs[columnIndex].SzDataObj);
+ break;
+ }
+}
+
/********** wxDbTable::bindParams() **********/
bool wxDbTable::bindParams(bool forUpdate)
{
wxASSERT(!queryOnly);
if (queryOnly)
- return(FALSE);
-
+ return false;
+
SWORD fSqlType = 0;
- UDWORD precision = 0;
+ SDWORD precision = 0;
SWORD scale = 0;
-
+
// Bind each column of the table that should be bound
// to a parameter marker
int i;
- UWORD colNo;
+ UWORD colNumber;
- for (i=0, colNo=1; i < noCols; i++)
+ for (i=0, colNumber=1; i < m_numCols; i++)
{
if (forUpdate)
{
fSqlType = pDb->GetTypeInfVarchar().FsqlType;
precision = colDefs[i].SzDataObj;
scale = 0;
- if (colDefs[i].Null)
- colDefs[i].CbValue = SQL_NULL_DATA;
- else
- colDefs[i].CbValue = SQL_NTS;
+ break;
+ case DB_DATA_TYPE_MEMO:
+ fSqlType = pDb->GetTypeInfMemo().FsqlType;
+ precision = colDefs[i].SzDataObj;
+ scale = 0;
break;
case DB_DATA_TYPE_INTEGER:
fSqlType = pDb->GetTypeInfInteger().FsqlType;
precision = pDb->GetTypeInfInteger().Precision;
scale = 0;
- if (colDefs[i].Null)
- colDefs[i].CbValue = SQL_NULL_DATA;
- else
- colDefs[i].CbValue = 0;
break;
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 (scale < 0)
// scale = (short) precision;
- if (colDefs[i].Null)
- colDefs[i].CbValue = SQL_NULL_DATA;
- else
- colDefs[i].CbValue = 0;
break;
case DB_DATA_TYPE_DATE:
fSqlType = pDb->GetTypeInfDate().FsqlType;
precision = pDb->GetTypeInfDate().Precision;
scale = 0;
- if (colDefs[i].Null)
- colDefs[i].CbValue = SQL_NULL_DATA;
- else
- colDefs[i].CbValue = 0;
break;
case DB_DATA_TYPE_BLOB:
fSqlType = pDb->GetTypeInfBlob().FsqlType;
- precision = 50000;
+ precision = colDefs[i].SzDataObj;
scale = 0;
- if (colDefs[i].Null)
- colDefs[i].CbValue = SQL_NULL_DATA;
- else
- colDefs[i].CbValue = SQL_LEN_DATA_AT_EXEC(colDefs[i].SzDataObj);
break;
}
+
+ setCbValueForColumn(i);
+
if (forUpdate)
{
- if (SQLBindParameter(hstmtUpdate, colNo++, SQL_PARAM_INPUT, colDefs[i].SqlCtype,
- fSqlType, precision, scale, (UCHAR*) colDefs[i].PtrDataObj,
+ if (SQLBindParameter(hstmtUpdate, colNumber++, 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));
}
else
{
- if (SQLBindParameter(hstmtInsert, colNo++, SQL_PARAM_INPUT, colDefs[i].SqlCtype,
- fSqlType, precision, scale, (UCHAR*) colDefs[i].PtrDataObj,
- precision+1,&colDefs[i].CbValue) != SQL_SUCCESS)
+ if (SQLBindParameter(hstmtInsert, colNumber++, 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);
+ 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()
/********** wxDbTable::bindCols() **********/
bool wxDbTable::bindCols(HSTMT cursor)
{
+ static SQLLEN cb;
+
// Bind each column of the table to a memory address for fetching data
UWORD i;
- for (i = 0; i < noCols; i++)
+ for (i = 0; i < m_numCols; i++)
{
+ cb = colDefs[i].CbValue;
if (SQLBindCol(cursor, (UWORD)(i+1), colDefs[i].SqlCtype, (UCHAR*) colDefs[i].PtrDataObj,
- colDefs[i].SzDataObj, &colDefs[i].CbValue ) != SQL_SUCCESS)
- {
+ colDefs[i].SzDataObj, &cb ) != SQL_SUCCESS)
return (pDb->DispAllErrors(henv, hdbc, cursor));
- }
}
// Completed successfully
- return(TRUE);
+ return true;
} // wxDbTable::bindCols()
if (!pDb->FwdOnlyCursors())
{
// Fetch the NEXT, PREV, FIRST or LAST record, depending on fetchType
- UDWORD cRowsFetched;
+ SQLULEN cRowsFetched;
UWORD rowStatus;
retcode = SQLExtendedFetch(hstmt, fetchType, 0, &cRowsFetched, &rowStatus);
- if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
+ 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));
}
// Set the Null member variable to indicate the Null state
// of each column just read in.
int i;
- for (i = 0; i < noCols; i++)
+ for (i = 0; i < m_numCols; i++)
colDefs[i].Null = (colDefs[i].CbValue == SQL_NULL_DATA);
}
}
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));
}
// Set the Null member variable to indicate the Null state
// of each column just read in.
int i;
- for (i = 0; i < noCols; i++)
+ for (i = 0; i < m_numCols; i++)
colDefs[i].Null = (colDefs[i].CbValue == SQL_NULL_DATA);
}
}
// Completed successfully
- return(TRUE);
+ return true;
} // wxDbTable::getRec()
RETCODE retcode;
// Execute the DELETE statement
- retcode = SQLExecDirect(hstmtDelete, (UCHAR FAR *) pSqlStmt.c_str(), SQL_NTS);
+ retcode = SQLExecDirect(hstmtDelete, (SQLTCHAR FAR *) pSqlStmt.c_str(), SQL_NTS);
if (retcode == SQL_SUCCESS ||
retcode == SQL_NO_DATA_FOUND ||
retcode == SQL_SUCCESS_WITH_INFO)
{
// Record deleted successfully
- return(TRUE);
+ return true;
}
// Problem deleting record
RETCODE retcode;
// Execute the UPDATE statement
- retcode = SQLExecDirect(hstmtUpdate, (UCHAR FAR *) pSqlStmt.c_str(), SQL_NTS);
+ retcode = SQLExecDirect(hstmtUpdate, (SQLTCHAR FAR *) pSqlStmt.c_str(), SQL_NTS);
if (retcode == SQL_SUCCESS ||
retcode == SQL_NO_DATA_FOUND ||
retcode == SQL_SUCCESS_WITH_INFO)
{
// Record updated successfully
- return(TRUE);
+ return true;
+ }
+ else if (retcode == SQL_NEED_DATA)
+ {
+ PTR pParmID;
+ retcode = SQLParamData(hstmtUpdate, &pParmID);
+ while (retcode == SQL_NEED_DATA)
+ {
+ // Find the parameter
+ int i;
+ for (i=0; i < m_numCols; i++)
+ {
+ if (colDefs[i].PtrDataObj == pParmID)
+ {
+ // We found it. Store the parameter.
+ retcode = SQLPutData(hstmtUpdate, pParmID, colDefs[i].SzDataObj);
+ if (retcode != SQL_SUCCESS)
+ {
+ pDb->DispNextError();
+ return pDb->DispAllErrors(henv, hdbc, hstmtUpdate);
+ }
+ break;
+ }
+ }
+ retcode = SQLParamData(hstmtUpdate, &pParmID);
+ }
+ if (retcode == SQL_SUCCESS ||
+ retcode == SQL_NO_DATA_FOUND ||
+ retcode == SQL_SUCCESS_WITH_INFO)
+ {
+ // Record updated successfully
+ 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,
BuildSelectStmt(sqlStmt, queryType, distinct);
pDb->WriteSqlLog(sqlStmt);
}
-/*
- This is the block of code that got added during the 2.2.1 merge with
- the 2.2 main branch that somehow got added here when it should not have. - gt
-
- else
- wxStrcpy(sqlStmt, pSqlStmt);
- SQLFreeStmt(hstmt, SQL_CLOSE);
- if (SQLExecDirect(hstmt, (UCHAR FAR *) sqlStmt, SQL_NTS) == SQL_SUCCESS)
- return(TRUE);
- else
- {
- pDb->DispAllErrors(henv, hdbc, hstmt);
- return(FALSE);
- }
-*/
// Make sure the cursor is closed first
if (!CloseCursor(hstmt))
- return(FALSE);
+ return false;
// Execute the SQL SELECT statement
- int retcode;
- retcode = SQLExecDirect(hstmt, (UCHAR FAR *) (queryType == DB_SELECT_STATEMENT ? pSqlStmt.c_str() : sqlStmt.c_str()), SQL_NTS);
+ int retcode;
+ retcode = SQLExecDirect(hstmt, (SQLTCHAR 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;
wxString s;
+ // Calculate the maximum size of the concatenated
+ // keys for use with wxDbGrid
+ m_keysize = 0;
+ for (i=0; i < m_numCols; i++)
+ {
+ if (colDefs[i].KeyField)
+ {
+ m_keysize += colDefs[i].SzDataObj;
+ }
+ }
+
s.Empty();
+
+ bool exists = true;
+ if (checkTableExists)
+ {
+ if (pDb->Dbms() == dbmsPOSTGRES)
+ exists = pDb->TableExists(tableName, NULL, tablePath);
+ else
+ exists = pDb->TableExists(tableName, pDb->GetUsername(), tablePath);
+ }
+
// Verify that the table exists in the database
- if (checkTableExists && !pDb->TableExists(tableName, pDb->GetUsername(), tablePath))
+ if (!exists)
{
s = wxT("Table/view does not exist in the database");
if ( *(pDb->dbInf.accessibleTables) == wxT('Y'))
else if (checkPrivileges)
{
// Verify the user has rights to access the table.
- // Shortcut boolean evaluation to optimize out call to
- // TablePrivileges
- //
- // Unfortunately this optimization doesn't seem to be
- // reliable!
- 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");
+ bool hasPrivs wxDUMMY_INITIALIZE(true);
+
+ if (pDb->Dbms() == dbmsPOSTGRES)
+ hasPrivs = pDb->TablePrivileges(tableName, wxT("SELECT"), pDb->GetUsername(), NULL, tablePath);
+ else
+ hasPrivs = pDb->TablePrivileges(tableName, wxT("SELECT"), pDb->GetUsername(), pDb->GetUsername(), tablePath);
+
+ if (!hasPrivs)
+ s = wxT("Connecting user does not have sufficient privileges to access this table.\n");
}
- if (!s.IsEmpty())
+ if (!s.empty())
{
wxString p;
- if (!tablePath.IsEmpty())
+ if (!tablePath.empty())
p.Printf(wxT("Error opening '%s/%s'.\n"),tablePath.c_str(),tableName.c_str());
else
p.Printf(wxT("Error opening '%s'.\n"), tableName.c_str());
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)
+ if (!queryOnly && m_numCols > 0)
{
- bool needComma = FALSE;
- sqlStmt.Printf(wxT("INSERT INTO %s ("), tableName.c_str());
- for (i = 0; i < noCols; i++)
+ bool needComma = false;
+ sqlStmt.Printf(wxT("INSERT INTO %s ("),
+ pDb->SQLTableName(tableName.c_str()).c_str());
+ for (i = 0; i < m_numCols; i++)
{
if (! colDefs[i].InsertAllowed)
continue;
if (needComma)
sqlStmt += wxT(",");
- sqlStmt += colDefs[i].ColName;
- needComma = TRUE;
+ sqlStmt += pDb->SQLColumnName(colDefs[i].ColName);
+ needComma = true;
}
- needComma = FALSE;
+ needComma = false;
sqlStmt += wxT(") VALUES (");
int insertableCount = 0;
- for (i = 0; i < noCols; i++)
+ for (i = 0; i < m_numCols; i++)
{
if (! colDefs[i].InsertAllowed)
continue;
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)
+ if (SQLPrepare(hstmtInsert, (SQLTCHAR 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)
// If the datasource supports the ROWID column, build
// the where on ROWID for efficiency purposes.
// e.g. DELETE FROM PARTS WHERE ROWID = '111.222.333'
- if (CanUpdByROWID())
+ if (CanUpdateByROWID())
{
- SDWORD cb;
+ SQLLEN cb;
wxChar rowid[wxDB_ROWID_LEN+1];
// Get the ROWID value. If not successful retreiving the ROWID,
// simply fall down through the code and build the WHERE clause
// based on the key fields.
- if (SQLGetData(hstmt, (UWORD)(noCols+1), SQL_C_CHAR, (UCHAR*) rowid, wxDB_ROWID_LEN, &cb) == SQL_SUCCESS)
+ if (SQLGetData(hstmt, (UWORD)(m_numCols+1), SQL_C_WXCHAR, (UCHAR*) rowid, sizeof(rowid), &cb) == SQL_SUCCESS)
{
pSqlStmt += wxT("ROWID = '");
pSqlStmt += rowid;
// 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
int i;
- for (i = 0; i < noCols; i++)
+ wxString tStr;
+ for (i = 0; i < m_numCols; i++)
{
+ tStr = colDefs[i].ColName;
// If joining tables, the base table column names must be qualified to avoid ambiguity
- if (appendFromClause || pDb->Dbms() == dbmsACCESS)
+ if ((appendFromClause || pDb->Dbms() == dbmsACCESS) && tStr.Find(wxT('.')) == wxNOT_FOUND)
{
- pSqlStmt += queryTableName;
+ pSqlStmt += pDb->SQLTableName(queryTableName.c_str());
pSqlStmt += wxT(".");
}
- pSqlStmt += colDefs[i].ColName;
- if (i + 1 < noCols)
+ pSqlStmt += pDb->SQLColumnName(colDefs[i].ColName);
+ if (i + 1 < m_numCols)
pSqlStmt += wxT(",");
}
// If the datasource supports ROWID, get this column as well. Exception: Don't retrieve
// the ROWID if querying distinct records. The rowid will always be unique.
- if (!distinct && CanUpdByROWID())
+ if (!distinct && CanUpdateByROWID())
{
// If joining tables, the base table column names must be qualified to avoid ambiguity
if (appendFromClause || pDb->Dbms() == dbmsACCESS)
{
pSqlStmt += wxT(",");
- pSqlStmt += queryTableName;
+ pSqlStmt += pDb->SQLTableName(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.
/********** wxDbTable::BuildUpdateStmt() **********/
-void wxDbTable::BuildUpdateStmt(wxString &pSqlStmt, int typeOfUpd, const wxString &pWhereClause)
+void wxDbTable::BuildUpdateStmt(wxString &pSqlStmt, int typeOfUpdate, const wxString &pWhereClause)
{
wxASSERT(!queryOnly);
if (queryOnly)
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;
- for (i = 0; i < noCols; i++)
+ for (i = 0; i < m_numCols; i++)
{
// Only append Updateable columns
if (colDefs[i].Updateable)
{
- if (! firstColumn)
+ 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(" = ?");
}
}
// Append the WHERE clause to the SQL UPDATE statement
pSqlStmt += wxT(" WHERE ");
- switch(typeOfUpd)
+ switch(typeOfUpdate)
{
case DB_UPD_KEYFIELDS:
// If the datasource supports the ROWID column, build
// the where on ROWID for efficiency purposes.
// e.g. UPDATE PARTS SET Col1 = ?, Col2 = ? WHERE ROWID = '111.222.333'
- if (CanUpdByROWID())
+ if (CanUpdateByROWID())
{
- SDWORD cb;
+ SQLLEN cb;
wxChar rowid[wxDB_ROWID_LEN+1];
// Get the ROWID value. If not successful retreiving the ROWID,
// simply fall down through the code and build the WHERE clause
// based on the key fields.
- if (SQLGetData(hstmt, (UWORD)(noCols+1), SQL_C_CHAR, (UCHAR*) rowid, wxDB_ROWID_LEN, &cb) == SQL_SUCCESS)
+ if (SQLGetData(hstmt, (UWORD)(m_numCols+1), SQL_C_WXCHAR, (UCHAR*) rowid, sizeof(rowid), &cb) == SQL_SUCCESS)
{
pSqlStmt += wxT("ROWID = '");
pSqlStmt += rowid;
/***** DEPRECATED: use wxDbTable::BuildUpdateStmt(wxString &....) form *****/
-void wxDbTable::BuildUpdateStmt(wxChar *pSqlStmt, int typeOfUpd, const wxString &pWhereClause)
+void wxDbTable::BuildUpdateStmt(wxChar *pSqlStmt, int typeOfUpdate, const wxString &pWhereClause)
{
wxString tempSqlStmt;
- BuildUpdateStmt(tempSqlStmt, typeOfUpd, pWhereClause);
+ BuildUpdateStmt(tempSqlStmt, typeOfUpdate, pWhereClause);
wxStrcpy(pSqlStmt, tempSqlStmt);
} // BuildUpdateStmt()
* 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
- int i;
- for (i = 0; i < noCols; i++)
+ int colNumber;
+ for (colNumber = 0; colNumber < m_numCols; colNumber++)
{
// Determine if this column should be included in the WHERE clause
- if ((typeOfWhere == DB_WHERE_KEYFIELDS && colDefs[i].KeyField) ||
- (typeOfWhere == DB_WHERE_MATCHING && (!IsColNull(i))))
+ if ((typeOfWhere == DB_WHERE_KEYFIELDS && colDefs[colNumber].KeyField) ||
+ (typeOfWhere == DB_WHERE_MATCHING && (!IsColNull((UWORD)colNumber))))
{
// Skip over timestamp columns
- if (colDefs[i].SqlCtype == SQL_C_TIMESTAMP)
+ if (colDefs[colNumber].SqlCtype == SQL_C_TIMESTAMP)
continue;
// If there is more than 1 column, join them with the keyword "AND"
if (moreThanOneColumn)
pWhereClause += wxT(" AND ");
else
- moreThanOneColumn = TRUE;
+ moreThanOneColumn = true;
+
// Concatenate where phrase for the column
- if (qualTableName.Length())
+ wxString tStr = colDefs[colNumber].ColName;
+
+ if (qualTableName.Length() && tStr.Find(wxT('.')) == wxNOT_FOUND)
{
- pWhereClause += qualTableName;
+ pWhereClause += pDb->SQLTableName(qualTableName);
pWhereClause += wxT(".");
}
- pWhereClause += colDefs[i].ColName;
- if (useLikeComparison && (colDefs[i].SqlCtype == SQL_C_CHAR))
+ pWhereClause += pDb->SQLColumnName(colDefs[colNumber].ColName);
+
+ if (useLikeComparison && (colDefs[colNumber].SqlCtype == SQL_C_WXCHAR))
pWhereClause += wxT(" LIKE ");
else
pWhereClause += wxT(" = ");
- switch(colDefs[i].SqlCtype)
+
+ switch(colDefs[colNumber].SqlCtype)
{
case SQL_C_CHAR:
- colValue.Printf(wxT("'%s'"), (UCHAR FAR *) colDefs[i].PtrDataObj);
+#ifdef SQL_C_WCHAR
+ case SQL_C_WCHAR:
+#endif
+ //case SQL_C_WXCHAR: SQL_C_WXCHAR is covered by either SQL_C_CHAR or SQL_C_WCHAR
+ colValue.Printf(wxT("'%s'"), (UCHAR FAR *) colDefs[colNumber].PtrDataObj);
break;
+ case SQL_C_SHORT:
case SQL_C_SSHORT:
- colValue.Printf(wxT("%hi"), *((SWORD *) colDefs[i].PtrDataObj));
+ colValue.Printf(wxT("%hi"), *((SWORD *) colDefs[colNumber].PtrDataObj));
break;
case SQL_C_USHORT:
- colValue.Printf(wxT("%hu"), *((UWORD *) colDefs[i].PtrDataObj));
+ colValue.Printf(wxT("%hu"), *((UWORD *) colDefs[colNumber].PtrDataObj));
break;
+ case SQL_C_LONG:
case SQL_C_SLONG:
- colValue.Printf(wxT("%li"), *((SDWORD *) colDefs[i].PtrDataObj));
+ colValue.Printf(wxT("%li"), *((SDWORD *) colDefs[colNumber].PtrDataObj));
break;
case SQL_C_ULONG:
- colValue.Printf(wxT("%lu"), *((UDWORD *) colDefs[i].PtrDataObj));
+ colValue.Printf(wxT("%lu"), *((UDWORD *) colDefs[colNumber].PtrDataObj));
break;
case SQL_C_FLOAT:
- colValue.Printf(wxT("%.6f"), *((SFLOAT *) colDefs[i].PtrDataObj));
+ colValue.Printf(wxT("%.6f"), *((SFLOAT *) colDefs[colNumber].PtrDataObj));
break;
case SQL_C_DOUBLE:
- colValue.Printf(wxT("%.6f"), *((SDOUBLE *) colDefs[i].PtrDataObj));
+ colValue.Printf(wxT("%.6f"), *((SDOUBLE *) colDefs[colNumber].PtrDataObj));
+ break;
+ default:
+ {
+ wxString strMsg;
+ strMsg.Printf(wxT("wxDbTable::bindParams(): Unknown column type for colDefs %d colName %s"),
+ colNumber,colDefs[colNumber].ColName);
+ wxFAIL_MSG(strMsg.c_str());
+ }
break;
}
pWhereClause += colValue;
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
- for (i = 0; i < noCols; i++)
+ for (i = 0; i < m_numCols; i++)
{
// Exclude derived columns since they are NOT part of the base table
if (colDefs[i].DerivedCol)
switch(colDefs[i].DbDataType)
{
case DB_DATA_TYPE_VARCHAR:
- cout << pDb->typeInfVarchar.TypeName << wxT("(") << colDefs[i].SzDataObj << wxT(")");
+ cout << pDb->GetTypeInfVarchar().TypeName << wxT("(") << (int)(colDefs[i].SzDataObj / sizeof(wxChar)) << wxT(")");
+ break;
+ case DB_DATA_TYPE_MEMO:
+ cout << pDb->GetTypeInfMemo().TypeName;
break;
case DB_DATA_TYPE_INTEGER:
- cout << pDb->typeInfInteger.TypeName;
+ cout << pDb->GetTypeInfInteger().TypeName;
break;
case DB_DATA_TYPE_FLOAT:
- cout << pDb->typeInfFloat.TypeName;
+ cout << pDb->GetTypeInfFloat().TypeName;
break;
case DB_DATA_TYPE_DATE:
- cout << pDb->typeInfDate.TypeName;
+ cout << pDb->GetTypeInfDate().TypeName;
break;
case DB_DATA_TYPE_BLOB:
- cout << pDb->typeInfBlob.TypeName;
+ cout << pDb->GetTypeInfBlob().TypeName;
break;
}
cout << endl;
#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++)
+ for (i = 0; i < m_numCols; i++)
{
// Exclude derived columns since they are NOT part of the base table
if (colDefs[i].DerivedCol)
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)
case DB_DATA_TYPE_VARCHAR:
sqlStmt += pDb->GetTypeInfVarchar().TypeName;
break;
+ case DB_DATA_TYPE_MEMO:
+ sqlStmt += pDb->GetTypeInfMemo().TypeName;
+ break;
case DB_DATA_TYPE_INTEGER:
sqlStmt += pDb->GetTypeInfInteger().TypeName;
break;
break;
}
// For varchars, append the size of the string
- if (colDefs[i].DbDataType == DB_DATA_TYPE_VARCHAR)// ||
+ if (colDefs[i].DbDataType == DB_DATA_TYPE_VARCHAR &&
+ (pDb->Dbms() != dbmsMY_SQL || pDb->GetTypeInfVarchar().TypeName != _T("text")))// ||
// colDefs[i].DbDataType == DB_DATA_TYPE_BLOB)
{
wxString s;
- s.Printf(wxT("(%d)"), colDefs[i].SzDataObj);
+ s.Printf(wxT("(%d)"), (int)(colDefs[i].SzDataObj / sizeof(wxChar)));
sqlStmt += s;
}
if (pDb->Dbms() == dbmsDB2 ||
pDb->Dbms() == dbmsMY_SQL ||
pDb->Dbms() == dbmsSYBASE_ASE ||
+ pDb->Dbms() == dbmsINTERBASE ||
+ pDb->Dbms() == dbmsFIREBIRD ||
pDb->Dbms() == dbmsMS_SQL_SERVER)
{
if (colDefs[i].KeyField)
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++)
+ for (i = j = 0; i < m_numCols; i++)
{
if (colDefs[i].KeyField)
{
break;
}
}
- if (j && pDb->Dbms() != dbmsDBASE) // Found a keyfield
+ if ( j && (pDb->Dbms() != dbmsDBASE)
+ && (pDb->Dbms() != dbmsXBASE_SEQUITER) ) // Found a keyfield
{
switch (pDb->Dbms())
{
+ case dbmsACCESS:
+ case dbmsINFORMIX:
case dbmsSYBASE_ASA:
case dbmsSYBASE_ASE:
case dbmsMY_SQL:
+ case dbmsFIREBIRD:
{
// MySQL goes out on this one. We also declare the relevant key NON NULL above
sqlStmt += wxT(",PRIMARY KEY (");
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;
}
// List column name(s) of column(s) comprising the primary key
- for (i = j = 0; i < noCols; i++)
+ for (i = j = 0; i < m_numCols; i++)
{
if (colDefs[i].KeyField)
{
if (j++) // Multi part key, comma separate names
sqlStmt += wxT(",");
- sqlStmt += colDefs[i].ColName;
+ sqlStmt += pDb->SQLColumnName(colDefs[i].ColName);
+
+ if (pDb->Dbms() == dbmsMY_SQL &&
+ colDefs[i].DbDataType == DB_DATA_TYPE_VARCHAR)
+ {
+ wxString s;
+ s.Printf(wxT("(%d)"), (int)(colDefs[i].SzDataObj / sizeof(wxChar)));
+ sqlStmt += s;
+ }
}
}
sqlStmt += wxT(")");
- if (pDb->Dbms() == dbmsSYBASE_ASA ||
+ if (pDb->Dbms() == dbmsINFORMIX ||
+ pDb->Dbms() == dbmsSYBASE_ASA ||
pDb->Dbms() == dbmsSYBASE_ASE)
{
sqlStmt += wxT(" CONSTRAINT ");
- sqlStmt += tableName;
+ sqlStmt += pDb->SQLTableName(tableName);
+// sqlStmt += tableName;
sqlStmt += wxT("_PIDX");
}
}
#endif
// Execute the CREATE TABLE statement
- RETCODE retcode = SQLExecDirect(hstmt, (UCHAR FAR *) sqlStmt.c_str(), SQL_NTS);
+ RETCODE retcode = SQLExecDirect(hstmt, (SQLTCHAR FAR *) sqlStmt.c_str(), SQL_NTS);
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
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);
+ RETCODE retcode = SQLExecDirect(hstmt, (SQLTCHAR 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);
+// CloseCursor(hstmt);
+ 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()
/********** wxDbTable::CreateIndex() **********/
-bool wxDbTable::CreateIndex(const wxString &idxName, bool unique, UWORD noIdxCols,
- wxDbIdxDef *pIdxDefs, bool attemptDrop)
+bool wxDbTable::CreateIndex(const wxString &indexName, bool unique, UWORD numIndexColumns,
+ wxDbIdxDef *pIndexDefs, bool attemptDrop)
{
wxString sqlStmt;
// Drop the index first
- if (attemptDrop && !DropIndex(idxName))
- return (FALSE);
+ if (attemptDrop && !DropIndex(indexName))
+ 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;
- for (i = 0; i < noIdxCols && ok; i++)
+ bool ok = true;
+ for (i = 0; i < numIndexColumns && 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
// this information
- while (!found && (j < this->noCols))
+ while (!found && (j < this->m_numCols))
{
- if (wxStrcmp(colDefs[j].ColName,pIdxDefs[i].ColName) == 0)
- found = TRUE;
+ if (wxStrcmp(colDefs[j].ColName,pIndexDefs[i].ColName) == 0)
+ found = true;
if (!found)
j++;
}
-
+
if (found)
{
- ok = pDb->ModifyColumn(tableName, pIdxDefs[i].ColName,
- colDefs[j].DbDataType, colDefs[j].SzDataObj,
+ ok = pDb->ModifyColumn(tableName, pIndexDefs[i].ColName,
+ colDefs[j].DbDataType, (int)(colDefs[j].SzDataObj / sizeof(wxChar)),
wxT("NOT NULL"));
if (!ok)
{
+ #if 0
+ // retcode is not used
wxODBC_ERRORS retcode;
// Oracle returns a DB_ERR_GENERAL_ERROR if the column is already
// defined to be NOT NULL, but reportedly MySQL doesn't mind.
// This line is just here for debug checking of the value
retcode = (wxODBC_ERRORS)pDb->DB_STATUS;
+ #endif
}
}
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(indexName);
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++)
+ for (i = 0; i < numIndexColumns; i++)
{
- sqlStmt += pIdxDefs[i].ColName;
- /* Postgres doesn't cope with ASC */
- if (pDb->Dbms() != dbmsPOSTGRES)
+ sqlStmt += pDb->SQLColumnName(pIndexDefs[i].ColName);
+// sqlStmt += pIndexDefs[i].ColName;
+
+ // MySQL requires a key length on VARCHAR keys
+ if ( pDb->Dbms() == dbmsMY_SQL )
{
- if (pIdxDefs[i].Ascending)
+ // Find the details on this column
+ int j;
+ for ( j = 0; j < m_numCols; ++j )
+ {
+ if ( wxStrcmp( pIndexDefs[i].ColName, colDefs[j].ColName ) == 0 )
+ {
+ break;
+ }
+ }
+ if ( colDefs[j].DbDataType == DB_DATA_TYPE_VARCHAR)
+ {
+ wxString s;
+ s.Printf(wxT("(%d)"), (int)(colDefs[i].SzDataObj / sizeof(wxChar)));
+ sqlStmt += s;
+ }
+ }
+
+ // Postgres and SQL Server 7 do not support the ASC/DESC keywords for index columns
+ if (!((pDb->Dbms() == dbmsMS_SQL_SERVER) && (wxStrncmp(pDb->dbInf.dbmsVer,_T("07"),2)==0)) &&
+ !(pDb->Dbms() == dbmsFIREBIRD) &&
+ !(pDb->Dbms() == dbmsPOSTGRES))
+ {
+ if (pIndexDefs[i].Ascending)
sqlStmt += wxT(" ASC");
else
sqlStmt += wxT(" DESC");
}
+ else
+ wxASSERT_MSG(pIndexDefs[i].Ascending, _T("Datasource does not support DESCending index columns"));
- if ((i + 1) < noIdxCols)
+ if ((i + 1) < numIndexColumns)
sqlStmt += wxT(",");
}
-
+
// Append closing parentheses
sqlStmt += wxT(")");
#endif
// Execute the CREATE INDEX statement
- if (SQLExecDirect(hstmt, (UCHAR FAR *) sqlStmt.c_str(), SQL_NTS) != SQL_SUCCESS)
+ RETCODE retcode = SQLExecDirect(hstmt, (SQLTCHAR FAR *) sqlStmt.c_str(), SQL_NTS);
+ if (retcode != SQL_SUCCESS)
{
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)
+bool wxDbTable::DropIndex(const wxString &indexName)
{
- // 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
+ // below for any other databases when those databases are defined
// to handle this situation consistently
wxString sqlStmt;
- if (pDb->Dbms() == dbmsACCESS || pDb->Dbms() == dbmsMY_SQL)
- sqlStmt.Printf(wxT("DROP INDEX %s ON %s"),idxName.c_str(), tableName.c_str());
+ 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"),
+ pDb->SQLTableName(indexName.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());
+ (pDb->Dbms() == dbmsSYBASE_ASE) ||
+ (pDb->Dbms() == dbmsXBASE_SEQUITER))
+ sqlStmt.Printf(wxT("DROP INDEX %s.%s"),
+ pDb->SQLTableName(tableName.c_str()).c_str(),
+ pDb->SQLTableName(indexName.c_str()).c_str());
else
- sqlStmt.Printf(wxT("DROP INDEX %s"),idxName.c_str());
+ sqlStmt.Printf(wxT("DROP INDEX %s"),
+ pDb->SQLTableName(indexName.c_str()).c_str());
pDb->WriteSqlLog(sqlStmt);
#ifdef DBDEBUG_CONSOLE
cout << endl << sqlStmt.c_str() << endl;
#endif
-
- if (SQLExecDirect(hstmt, (UCHAR FAR *) sqlStmt.c_str(), SQL_NTS) != SQL_SUCCESS)
+ RETCODE retcode = SQLExecDirect(hstmt, (SQLTCHAR FAR *) sqlStmt.c_str(), SQL_NTS);
+ if (retcode != SQL_SUCCESS)
{
// Check for "Index not found" error and ignore
pDb->GetNextError(henv, hdbc, hstmt);
if (!((pDb->Dbms() == dbmsSYBASE_ASA && !wxStrcmp(pDb->sqlState,wxT("42000"))) || // v5.x (and lower?)
(pDb->Dbms() == dbmsSYBASE_ASE && !wxStrcmp(pDb->sqlState,wxT("37000"))) ||
(pDb->Dbms() == dbmsMS_SQL_SERVER && !wxStrcmp(pDb->sqlState,wxT("S1000"))) ||
+ (pDb->Dbms() == dbmsINTERBASE && !wxStrcmp(pDb->sqlState,wxT("S1000"))) ||
+ (pDb->Dbms() == dbmsMAXDB && !wxStrcmp(pDb->sqlState,wxT("S1000"))) ||
+ (pDb->Dbms() == dbmsFIREBIRD && !wxStrcmp(pDb->sqlState,wxT("HY000"))) ||
(pDb->Dbms() == dbmsSYBASE_ASE && !wxStrcmp(pDb->sqlState,wxT("S0002"))) || // Base table not found
(pDb->Dbms() == dbmsMY_SQL && !wxStrcmp(pDb->sqlState,wxT("42S12"))) || // tested by Christopher Ludwik Marino-Cebulski using v3.23.21beta
(pDb->Dbms() == dbmsPOSTGRES && !wxStrcmp(pDb->sqlState,wxT("08S01")))
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()
/********** wxDbTable::SetOrderByColNums() **********/
bool wxDbTable::SetOrderByColNums(UWORD first, ... )
{
- int colNo = first; // using 'int' to be able to look for wxDB_NO_MORE_COLUN_NUMBERS
+ int colNumber = 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. */
- while (!abort && (colNo != wxDB_NO_MORE_COLUMN_NUMBERS))
+ while (!abort && (colNumber != wxDB_NO_MORE_COLUMN_NUMBERS))
{
// Make sure the passed in column number
// is within the valid range of columns
//
- // Valid columns are 0 thru noCols-1
- if (colNo >= noCols || colNo < 0)
+ // Valid columns are 0 thru m_numCols-1
+ if (colNumber >= m_numCols || colNumber < 0)
{
- abort = TRUE;
+ abort = true;
continue;
}
- if (colNo != first)
+ if (colNumber != first)
tempStr += wxT(",");
- tempStr += colDefs[colNo].ColName;
- colNo = va_arg (argptr, int);
+ tempStr += colDefs[colNumber].ColName;
+ colNumber = va_arg (argptr, int);
}
va_end (argptr); /* Reset variable arguments. */
// Insert the record by executing the already prepared insert statement
RETCODE retcode;
- retcode=SQLExecute(hstmtInsert);
- if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
+ retcode = SQLExecute(hstmtInsert);
+ if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO &&
+ retcode != SQL_NEED_DATA)
{
// Check to see if integrity constraint was violated
pDb->GetNextError(henv, hdbc, hstmtInsert);
return(DB_FAILURE);
}
}
+ if (retcode == SQL_NEED_DATA)
+ {
+ PTR pParmID;
+ retcode = SQLParamData(hstmtInsert, &pParmID);
+ while (retcode == SQL_NEED_DATA)
+ {
+ // Find the parameter
+ int i;
+ for (i=0; i < m_numCols; i++)
+ {
+ if (colDefs[i].PtrDataObj == pParmID)
+ {
+ // We found it. Store the parameter.
+ retcode = SQLPutData(hstmtInsert, pParmID, colDefs[i].SzDataObj);
+ if (retcode != SQL_SUCCESS)
+ {
+ pDb->DispNextError();
+ pDb->DispAllErrors(henv, hdbc, hstmtInsert);
+ return(DB_FAILURE);
+ }
+ break;
+ }
+ }
+ retcode = SQLParamData(hstmtInsert, &pParmID);
+ if (retcode != SQL_SUCCESS &&
+ retcode != SQL_SUCCESS_WITH_INFO)
+ {
+ // record was not inserted
+ pDb->DispNextError();
+ pDb->DispAllErrors(henv, hdbc, hstmtInsert);
+ return(DB_FAILURE);
+ }
+ }
+ }
// Record inserted into the datasource successfully
return(DB_SUCCESS);
{
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();
/********** wxDbTable::IsColNull() **********/
-bool wxDbTable::IsColNull(UWORD colNo)
+bool wxDbTable::IsColNull(UWORD colNumber) 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)
+ switch(colDefs[colNumber].SqlCtype)
{
case SQL_C_CHAR:
- return(((UCHAR FAR *) colDefs[colNo].PtrDataObj)[0] == 0);
+ case SQL_C_WCHAR:
+ //case SQL_C_WXCHAR: SQL_C_WXCHAR is covered by either SQL_C_CHAR or SQL_C_WCHAR
+ return(((UCHAR FAR *) colDefs[colNumber].PtrDataObj)[0] == 0);
case SQL_C_SSHORT:
- return(( *((SWORD *) colDefs[colNo].PtrDataObj)) == 0);
+ return(( *((SWORD *) colDefs[colNumber].PtrDataObj)) == 0);
case SQL_C_USHORT:
- return(( *((UWORD*) colDefs[colNo].PtrDataObj)) == 0);
+ return(( *((UWORD*) colDefs[colNumber].PtrDataObj)) == 0);
case SQL_C_SLONG:
- return(( *((SDWORD *) colDefs[colNo].PtrDataObj)) == 0);
+ return(( *((SDWORD *) colDefs[colNumber].PtrDataObj)) == 0);
case SQL_C_ULONG:
- return(( *((UDWORD *) colDefs[colNo].PtrDataObj)) == 0);
+ return(( *((UDWORD *) colDefs[colNumber].PtrDataObj)) == 0);
case SQL_C_FLOAT:
- return(( *((SFLOAT *) colDefs[colNo].PtrDataObj)) == 0);
+ return(( *((SFLOAT *) colDefs[colNumber].PtrDataObj)) == 0);
case SQL_C_DOUBLE:
- return((*((SDOUBLE *) colDefs[colNo].PtrDataObj)) == 0);
+ return((*((SDOUBLE *) colDefs[colNumber].PtrDataObj)) == 0);
case SQL_C_TIMESTAMP:
TIMESTAMP_STRUCT *pDt;
- pDt = (TIMESTAMP_STRUCT *) colDefs[colNo].PtrDataObj;
+ pDt = (TIMESTAMP_STRUCT *) colDefs[colNumber].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);
+ return (colDefs[colNumber].Null);
} // wxDbTable::IsColNull()
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()
-/********** wxDbTable::CanUpdByROWID() **********/
-bool wxDbTable::CanUpdByROWID(void)
+/********** wxDbTable::CanUpdateByROWID() **********/
+bool wxDbTable::CanUpdateByROWID(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()
+} // wxDbTable::CanUpdateByROWID()
/********** wxDbTable::IsCursorClosedOnCommit() **********/
bool wxDbTable::IsCursorClosedOnCommit(void)
{
if (pDb->dbInf.cursorCommitBehavior == SQL_CB_PRESERVE)
- return(FALSE);
+ return false;
else
- return(TRUE);
+ return true;
} // wxDbTable::IsCursorClosedOnCommit()
/********** wxDbTable::ClearMemberVar() **********/
-void wxDbTable::ClearMemberVar(UWORD colNo, bool setToNull)
+void wxDbTable::ClearMemberVar(UWORD colNumber, bool setToNull)
{
- wxASSERT(colNo < noCols);
+ wxASSERT(colNumber < m_numCols);
- switch(colDefs[colNo].SqlCtype)
+ switch(colDefs[colNumber].SqlCtype)
{
case SQL_C_CHAR:
- ((UCHAR FAR *) colDefs[colNo].PtrDataObj)[0] = 0;
+#ifdef SQL_C_WCHAR
+ case SQL_C_WCHAR:
+#endif
+ //case SQL_C_WXCHAR: SQL_C_WXCHAR is covered by either SQL_C_CHAR or SQL_C_WCHAR
+ ((UCHAR FAR *) colDefs[colNumber].PtrDataObj)[0] = 0;
break;
case SQL_C_SSHORT:
- *((SWORD *) colDefs[colNo].PtrDataObj) = 0;
+ *((SWORD *) colDefs[colNumber].PtrDataObj) = 0;
break;
case SQL_C_USHORT:
- *((UWORD*) colDefs[colNo].PtrDataObj) = 0;
+ *((UWORD*) colDefs[colNumber].PtrDataObj) = 0;
break;
+ case SQL_C_LONG:
case SQL_C_SLONG:
- *((SDWORD *) colDefs[colNo].PtrDataObj) = 0;
+ *((SDWORD *) colDefs[colNumber].PtrDataObj) = 0;
break;
case SQL_C_ULONG:
- *((UDWORD *) colDefs[colNo].PtrDataObj) = 0;
+ *((UDWORD *) colDefs[colNumber].PtrDataObj) = 0;
break;
case SQL_C_FLOAT:
- *((SFLOAT *) colDefs[colNo].PtrDataObj) = 0.0f;
+ *((SFLOAT *) colDefs[colNumber].PtrDataObj) = 0.0f;
break;
case SQL_C_DOUBLE:
- *((SDOUBLE *) colDefs[colNo].PtrDataObj) = 0.0f;
+ *((SDOUBLE *) colDefs[colNumber].PtrDataObj) = 0.0f;
break;
case SQL_C_TIMESTAMP:
TIMESTAMP_STRUCT *pDt;
- pDt = (TIMESTAMP_STRUCT *) colDefs[colNo].PtrDataObj;
+ pDt = (TIMESTAMP_STRUCT *) colDefs[colNumber].PtrDataObj;
pDt->year = 0;
pDt->month = 0;
pDt->day = 0;
}
if (setToNull)
- SetColNull(colNo);
+ SetColNull(colNumber);
} // wxDbTable::ClearMemberVar()
int i;
// Loop through the columns setting each member variable to zero
- for (i=0; i < noCols; i++)
- ClearMemberVar(i,setToNull);
+ for (i=0; i < m_numCols; i++)
+ ClearMemberVar((UWORD)i,setToNull);
} // wxDbTable::ClearMemberVars()
return(pDb->DispAllErrors(henv, hdbc, hstmtInternal));
// Completed Successfully
- return(TRUE);
+ return true;
} // wxDbTable::SetQueryTimeout()
/********** wxDbTable::SetColDefs() **********/
-void wxDbTable::SetColDefs(UWORD index, const wxString &fieldName, int dataType, void *pData,
- SWORD cType, int size, bool keyField, bool upd,
- bool insAllow, bool derivedCol)
+bool wxDbTable::SetColDefs(UWORD index, const wxString &fieldName, int dataType, void *pData,
+ SWORD cType, int size, bool keyField, bool updateable,
+ bool insertAllowed, bool derivedColumn)
{
+ wxString tmpStr;
+
+ if (index >= m_numCols) // Columns numbers are zero based....
+ {
+ tmpStr.Printf(wxT("Specified column index (%d) exceeds the maximum number of columns (%d) registered for this table definition. Column definition not added."), index, m_numCols);
+ wxFAIL_MSG(tmpStr);
+ wxLogDebug(tmpStr);
+ return false;
+ }
+
if (!colDefs) // May happen if the database connection fails
- return;
+ return false;
if (fieldName.Length() > (unsigned int) DB_MAX_COLUMN_NAME_LEN)
{
- wxStrncpy (colDefs[index].ColName, fieldName, DB_MAX_COLUMN_NAME_LEN);
- colDefs[index].ColName[DB_MAX_COLUMN_NAME_LEN] = 0;
+ wxStrncpy(colDefs[index].ColName, fieldName, DB_MAX_COLUMN_NAME_LEN);
+ colDefs[index].ColName[DB_MAX_COLUMN_NAME_LEN] = 0; // Prevent buffer overrun
+
+ tmpStr.Printf(wxT("Column name '%s' is too long. Truncated to '%s'."),
+ fieldName.c_str(),colDefs[index].ColName);
+ wxFAIL_MSG(tmpStr);
+ wxLogDebug(tmpStr);
}
else
wxStrcpy(colDefs[index].ColName, fieldName);
colDefs[index].DbDataType = dataType;
colDefs[index].PtrDataObj = pData;
colDefs[index].SqlCtype = cType;
- colDefs[index].SzDataObj = size;
+ colDefs[index].SzDataObj = size; //TODO: glt ??? * sizeof(wxChar) ???
colDefs[index].KeyField = keyField;
- colDefs[index].DerivedCol = derivedCol;
+ colDefs[index].DerivedCol = derivedColumn;
// Derived columns by definition would NOT be "Insertable" or "Updateable"
- if (derivedCol)
+ if (derivedColumn)
{
- colDefs[index].Updateable = FALSE;
- colDefs[index].InsertAllowed = FALSE;
+ colDefs[index].Updateable = false;
+ colDefs[index].InsertAllowed = false;
}
else
{
- colDefs[index].Updateable = upd;
- colDefs[index].InsertAllowed = insAllow;
+ colDefs[index].Updateable = updateable;
+ colDefs[index].InsertAllowed = insertAllowed;
}
- colDefs[index].Null = FALSE;
-
+ colDefs[index].Null = false;
+
+ return true;
+
} // wxDbTable::SetColDefs()
if (pColInfs)
{
UWORD index;
-
+
pColDataPtrs = new wxDbColDataPtr[numCols+1];
for (index = 0; index < numCols; index++)
switch (pColInfs[index].dbDataType)
{
case DB_DATA_TYPE_VARCHAR:
- pColDataPtrs[index].PtrDataObj = new wxChar[pColInfs[index].bufferLength+1];
- pColDataPtrs[index].SzDataObj = pColInfs[index].columnSize;
- pColDataPtrs[index].SqlCtype = SQL_C_CHAR;
+ pColDataPtrs[index].PtrDataObj = new wxChar[pColInfs[index].bufferSize+(1*sizeof(wxChar))];
+ pColDataPtrs[index].SzDataObj = pColInfs[index].bufferSize+(1*sizeof(wxChar));
+ pColDataPtrs[index].SqlCtype = SQL_C_WXCHAR;
+ break;
+ case DB_DATA_TYPE_MEMO:
+ pColDataPtrs[index].PtrDataObj = new wxChar[pColInfs[index].bufferSize+(1*sizeof(wxChar))];
+ pColDataPtrs[index].SzDataObj = pColInfs[index].bufferSize+(1*sizeof(wxChar));
+ pColDataPtrs[index].SqlCtype = SQL_C_WXCHAR;
break;
case DB_DATA_TYPE_INTEGER:
// Can be long or short
- if (pColInfs[index].bufferLength == sizeof(long))
+ if (pColInfs[index].bufferSize == sizeof(long))
{
pColDataPtrs[index].PtrDataObj = new long;
pColDataPtrs[index].SzDataObj = sizeof(long);
break;
case DB_DATA_TYPE_FLOAT:
// Can be float or double
- if (pColInfs[index].bufferLength == sizeof(float))
+ if (pColInfs[index].bufferSize == sizeof(float))
{
pColDataPtrs[index].PtrDataObj = new float;
pColDataPtrs[index].SzDataObj = sizeof(float);
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
{
ULONG count;
wxString sqlStmt;
- SDWORD cb;
+ SQLLEN cb;
// Build a "SELECT COUNT(*) FROM queryTableName [WHERE whereClause]" SQL Statement
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);
}
// Execute the SQL statement
- if (SQLExecDirect(*hstmtCount, (UCHAR FAR *) sqlStmt.c_str(), SQL_NTS) != SQL_SUCCESS)
+ if (SQLExecDirect(*hstmtCount, (SQLTCHAR FAR *) sqlStmt.c_str(), SQL_NTS) != SQL_SUCCESS)
{
pDb->DispAllErrors(henv, hdbc, *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();
hstmt = hstmtInternal;
#if wxODBC_BACKWARD_COMPATABILITY
// Save the where and order by clauses
- char *saveWhere = where;
- char *saveOrderBy = orderBy;
+ wxChar *saveWhere = where;
+ wxChar *saveOrderBy = orderBy;
#else
wxString saveWhere = where;
wxString saveOrderBy = orderBy;
wxString whereClause;
whereClause.Empty();
- if (CanUpdByROWID())
+ if (CanUpdateByROWID())
{
- SDWORD cb;
- wxChar rowid[wxDB_ROWID_LEN+1];
+ SQLLEN cb;
+ wxChar rowid[wxDB_ROWID_LEN+1];
// Get the ROWID value. If not successful retreiving the ROWID,
// simply fall down through the code and build the WHERE clause
// based on the key fields.
- if (SQLGetData(hstmt, (UWORD)(noCols+1), SQL_C_CHAR, (UCHAR*) rowid, wxDB_ROWID_LEN, &cb) == SQL_SUCCESS)
+ if (SQLGetData(hstmt, (UWORD)(m_numCols+1), SQL_C_WXCHAR, (UCHAR*) rowid, sizeof(rowid), &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);
/********** wxDbTable::SetColNull() **********/
-bool wxDbTable::SetColNull(UWORD colNo, bool set)
+bool wxDbTable::SetColNull(UWORD colNumber, bool set)
{
- if (colNo < noCols)
+ if (colNumber < m_numCols)
{
- colDefs[colNo].Null = set;
+ colDefs[colNumber].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(colNumber, false); // Must call with false here, or infinite recursion will happen
+
+ setCbValueForColumn(colNumber);
+
+ return true;
}
else
- return(FALSE);
+ return false;
} // wxDbTable::SetColNull()
/********** wxDbTable::SetColNull() **********/
bool wxDbTable::SetColNull(const wxString &colName, bool set)
{
- int i;
- for (i = 0; i < noCols; i++)
+ int colNumber;
+ for (colNumber = 0; colNumber < m_numCols; colNumber++)
{
- if (!wxStricmp(colName, colDefs[i].ColName))
+ if (!wxStricmp(colName, colDefs[colNumber].ColName))
break;
}
- if (i < noCols)
+ if (colNumber < m_numCols)
{
- colDefs[i].Null = set;
+ colDefs[colNumber].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((UWORD)colNumber,false); // Must call with false here, or infinite recursion will happen
+
+ setCbValueForColumn(colNumber);
+
+ return true;
}
else
- return(FALSE);
+ return false;
} // wxDbTable::SetColNull()
if (bindColumns)
{
- if(!bindCols(*newHSTMT))
+ if (!bindCols(*newHSTMT))
{
delete newHSTMT;
return(0);
/********** 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;
} // wxDbTable::DeleteCursor()
+//////////////////////////////////////////////////////////////
+// wxDbGrid support functions
+//////////////////////////////////////////////////////////////
+
+void wxDbTable::SetRowMode(const rowmode_t rowmode)
+{
+ if (!m_hstmtGridQuery)
+ {
+ m_hstmtGridQuery = GetNewCursor(false,false);
+ if (!bindCols(*m_hstmtGridQuery))
+ return;
+ }
+
+ m_rowmode = rowmode;
+ switch (m_rowmode)
+ {
+ case WX_ROW_MODE_QUERY:
+ SetCursor(m_hstmtGridQuery);
+ break;
+ case WX_ROW_MODE_INDIVIDUAL:
+ SetCursor(hstmtDefault);
+ break;
+ default:
+ wxASSERT(0);
+ }
+} // wxDbTable::SetRowMode()
+
+
+wxVariant wxDbTable::GetColumn(const int colNumber) const
+{
+ wxVariant val;
+ if ((colNumber < m_numCols) && (!IsColNull((UWORD)colNumber)))
+ {
+ switch (colDefs[colNumber].SqlCtype)
+ {
+#if wxUSE_UNICODE
+ #if defined(SQL_WCHAR)
+ case SQL_WCHAR:
+ #endif
+ #if defined(SQL_WVARCHAR)
+ case SQL_WVARCHAR:
+ #endif
+#endif
+ case SQL_CHAR:
+ case SQL_VARCHAR:
+ val = (wxChar *)(colDefs[colNumber].PtrDataObj);
+ break;
+ case SQL_C_LONG:
+ case SQL_C_SLONG:
+ val = *(long *)(colDefs[colNumber].PtrDataObj);
+ break;
+ case SQL_C_SHORT:
+ case SQL_C_SSHORT:
+ val = (long int )(*(short *)(colDefs[colNumber].PtrDataObj));
+ break;
+ case SQL_C_ULONG:
+ val = (long)(*(unsigned long *)(colDefs[colNumber].PtrDataObj));
+ break;
+ case SQL_C_TINYINT:
+ val = (long)(*(wxChar *)(colDefs[colNumber].PtrDataObj));
+ break;
+ case SQL_C_UTINYINT:
+ val = (long)(*(wxChar *)(colDefs[colNumber].PtrDataObj));
+ break;
+ case SQL_C_USHORT:
+ val = (long)(*(UWORD *)(colDefs[colNumber].PtrDataObj));
+ break;
+ case SQL_C_DATE:
+ val = (DATE_STRUCT *)(colDefs[colNumber].PtrDataObj);
+ break;
+ case SQL_C_TIME:
+ val = (TIME_STRUCT *)(colDefs[colNumber].PtrDataObj);
+ break;
+ case SQL_C_TIMESTAMP:
+ val = (TIMESTAMP_STRUCT *)(colDefs[colNumber].PtrDataObj);
+ break;
+ case SQL_C_DOUBLE:
+ val = *(double *)(colDefs[colNumber].PtrDataObj);
+ break;
+ default:
+ assert(0);
+ }
+ }
+ return val;
+} // wxDbTable::GetCol()
+
+
+void wxDbTable::SetColumn(const int colNumber, const wxVariant val)
+{
+ //FIXME: Add proper wxDateTime support to wxVariant..
+ wxDateTime dateval;
+
+ SetColNull((UWORD)colNumber, val.IsNull());
+
+ if (!val.IsNull())
+ {
+ if ((colDefs[colNumber].SqlCtype == SQL_C_DATE)
+ || (colDefs[colNumber].SqlCtype == SQL_C_TIME)
+ || (colDefs[colNumber].SqlCtype == SQL_C_TIMESTAMP))
+ {
+ //Returns null if invalid!
+ if (!dateval.ParseDate(val.GetString()))
+ SetColNull((UWORD)colNumber, true);
+ }
+
+ switch (colDefs[colNumber].SqlCtype)
+ {
+#if wxUSE_UNICODE
+ #if defined(SQL_WCHAR)
+ case SQL_WCHAR:
+ #endif
+ #if defined(SQL_WVARCHAR)
+ case SQL_WVARCHAR:
+ #endif
+#endif
+ case SQL_CHAR:
+ case SQL_VARCHAR:
+ csstrncpyt((wxChar *)(colDefs[colNumber].PtrDataObj),
+ val.GetString().c_str(),
+ colDefs[colNumber].SzDataObj-1); //TODO: glt ??? * sizeof(wxChar) ???
+ break;
+ case SQL_C_LONG:
+ case SQL_C_SLONG:
+ *(long *)(colDefs[colNumber].PtrDataObj) = val;
+ break;
+ case SQL_C_SHORT:
+ case SQL_C_SSHORT:
+ *(short *)(colDefs[colNumber].PtrDataObj) = (short)val.GetLong();
+ break;
+ case SQL_C_ULONG:
+ *(unsigned long *)(colDefs[colNumber].PtrDataObj) = val.GetLong();
+ break;
+ case SQL_C_TINYINT:
+ *(wxChar *)(colDefs[colNumber].PtrDataObj) = val.GetChar();
+ break;
+ case SQL_C_UTINYINT:
+ *(wxChar *)(colDefs[colNumber].PtrDataObj) = val.GetChar();
+ break;
+ case SQL_C_USHORT:
+ *(unsigned short *)(colDefs[colNumber].PtrDataObj) = (unsigned short)val.GetLong();
+ break;
+ //FIXME: Add proper wxDateTime support to wxVariant..
+ case SQL_C_DATE:
+ {
+ DATE_STRUCT *dataptr =
+ (DATE_STRUCT *)colDefs[colNumber].PtrDataObj;
+
+ dataptr->year = (SWORD)dateval.GetYear();
+ dataptr->month = (UWORD)(dateval.GetMonth()+1);
+ dataptr->day = (UWORD)dateval.GetDay();
+ }
+ break;
+ case SQL_C_TIME:
+ {
+ TIME_STRUCT *dataptr =
+ (TIME_STRUCT *)colDefs[colNumber].PtrDataObj;
+
+ dataptr->hour = dateval.GetHour();
+ dataptr->minute = dateval.GetMinute();
+ dataptr->second = dateval.GetSecond();
+ }
+ break;
+ case SQL_C_TIMESTAMP:
+ {
+ TIMESTAMP_STRUCT *dataptr =
+ (TIMESTAMP_STRUCT *)colDefs[colNumber].PtrDataObj;
+ dataptr->year = (SWORD)dateval.GetYear();
+ dataptr->month = (UWORD)(dateval.GetMonth()+1);
+ dataptr->day = (UWORD)dateval.GetDay();
+
+ dataptr->hour = dateval.GetHour();
+ dataptr->minute = dateval.GetMinute();
+ dataptr->second = dateval.GetSecond();
+ }
+ break;
+ case SQL_C_DOUBLE:
+ *(double *)(colDefs[colNumber].PtrDataObj) = val;
+ break;
+ default:
+ assert(0);
+ } // switch
+ } // if (!val.IsNull())
+} // wxDbTable::SetCol()
+
+
+GenericKey wxDbTable::GetKey()
+{
+ void *blk;
+ wxChar *blkptr;
+
+ blk = malloc(m_keysize);
+ blkptr = (wxChar *) blk;
+
+ int i;
+ for (i=0; i < m_numCols; i++)
+ {
+ if (colDefs[i].KeyField)
+ {
+ memcpy(blkptr,colDefs[i].PtrDataObj, colDefs[i].SzDataObj);
+ blkptr += colDefs[i].SzDataObj;
+ }
+ }
+
+ GenericKey k = GenericKey(blk, m_keysize);
+ free(blk);
+
+ return k;
+} // wxDbTable::GetKey()
+
+
+void wxDbTable::SetKey(const GenericKey& k)
+{
+ void *blk;
+ wxChar *blkptr;
+
+ blk = k.GetBlk();
+ blkptr = (wxChar *)blk;
+
+ int i;
+ for (i=0; i < m_numCols; i++)
+ {
+ if (colDefs[i].KeyField)
+ {
+ SetColNull((UWORD)i, false);
+ memcpy(colDefs[i].PtrDataObj, blkptr, colDefs[i].SzDataObj);
+ blkptr += colDefs[i].SzDataObj;
+ }
+ }
+} // wxDbTable::SetKey()
+
+
#endif // wxUSE_ODBC
projects / wxWidgets.git / blobdiff