Fix [ 1574240 ] wx.RadioButton doesn't navigate correctly

[wxWidgets.git] / src / common / dbtable.cpp

diff --git a/src/common/dbtable.cpp b/src/common/dbtable.cpp
index a9cd88abb1d72314b1c0f2e9facfcb6c2aae6625..54637134197428520161af9e2d0c4887bd01b059 100644 (file)
--- a/src/common/dbtable.cpp
+++ b/src/common/dbtable.cpp
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        dbtable.cpp
+// Name:        src/common/dbtable.cpp

 // Purpose:     Implementation of the wxDbTable class.
 // Author:      Doug Card
 // Modified by: George Tasker
 // Purpose:     Implementation of the wxDbTable class.
 // Author:      Doug Card
 // Modified by: George Tasker


@@ -8,80 +8,41 @@
 // Created:     9.96
 // RCS-ID:      $Id$
 // Copyright:   (c) 1996 Remstar International, Inc.
 // 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 START
-// 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/wxprec.h"

-#include "wx/version.h"
-
-#if wxMAJOR_VERSION == 2
-    #ifdef __GNUG__
-        #pragma implementation "dbtable.h"
-    #endif
-#endif

 
 

-#ifdef DBDEBUG_CONSOLE
-    #include "wx/ioswrap.h"
+#ifdef __BORLANDC__
+    #pragma hdrstop

 #endif
 
 #endif
 

+#if wxUSE_ODBC

 
 

-#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"
+#ifndef WX_PRECOMP
+    #include "wx/object.h"
+    #include "wx/list.h"
+    #include "wx/string.h"
+    #include "wx/utils.h"
+    #include "wx/log.h"

 #endif
 
 #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
+#ifdef DBDEBUG_CONSOLE
+#if wxUSE_IOSTREAMH
+    #include <iostream.h>
+#else
+    #include <iostream>
+#endif
+    #include "wx/ioswrap.h"

 #endif
 
 #endif
 

-
-#if wxUSE_ODBC
+#include "wx/filefn.h"

 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #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
 
 #ifdef __UNIX__
 // The HPUX preprocessor lines below were commented out on 8/20/97


@@ -102,6 +63,16 @@ ULONG lastTableID = 0;
 #endif
 
 
 #endif
 
 

+void csstrncpyt(wxChar *target, const wxChar *source, int n)
+{
+    while ( (*target++ = *source++) != '\0' && --n != 0 )
+        ;
+
+    *target = '\0';
+}
+
+
+

 /********** wxDbColDef::wxDbColDef() Constructor **********/
 wxDbColDef::wxDbColDef()
 {
 /********** wxDbColDef::wxDbColDef() Constructor **********/
 wxDbColDef::wxDbColDef()
 {


@@ -116,14 +87,14 @@ bool wxDbColDef::Initialize()
     SqlCtype        = SQL_C_LONG;
     PtrDataObj      = NULL;
     SzDataObj       = 0;
     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;
     CbValue         = 0;

-    Null = FALSE;
+    Null            = false;

 
 

-    return TRUE;
+    return true;

 }  // wxDbColDef::Initialize()
 
 
 }  // wxDbColDef::Initialize()
 
 


@@ -137,6 +108,7 @@ wxDbTable::wxDbTable(wxDb *pwxDb, const wxString &tblName, const UWORD numColumn
 
 
 /***** DEPRECATED: use wxDbTable::wxDbTable() format above *****/
 
 
 /***** 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)
 {
 wxDbTable::wxDbTable(wxDb *pwxDb, const wxString &tblName, const UWORD numColumns,
                     const wxChar *qryTblName, bool qryOnly, const wxString &tblPath)
 {


@@ -145,6 +117,7 @@ wxDbTable::wxDbTable(wxDb *pwxDb, const wxString &tblName, const UWORD numColumn
     if (!initialize(pwxDb, tblName, numColumns, tempQryTblName, qryOnly, tblPath))
         cleanup();
 }  // wxDbTable::wxDbTable()
     if (!initialize(pwxDb, tblName, numColumns, tempQryTblName, qryOnly, tblPath))
         cleanup();
 }  // wxDbTable::wxDbTable()

+#endif // WXWIN_COMPATIBILITY_2_4

 
 
 /********** wxDbTable::~wxDbTable() **********/
 
 
 /********** wxDbTable::~wxDbTable() **********/


@@ -162,6 +135,7 @@ bool wxDbTable::initialize(wxDb *pwxDb, const wxString &tblName, const UWORD num
     henv                = 0;
     hdbc                = 0;
     hstmt               = 0;
     henv                = 0;
     hdbc                = 0;
     hstmt               = 0;

+    m_hstmtGridQuery               = 0;

     hstmtDefault        = 0;                        // Initialized below
     hstmtCount          = 0;                        // Initialized first time it is needed
     hstmtInsert         = 0;
     hstmtDefault        = 0;                        // Initialized below
     hstmtCount          = 0;                        // Initialized first time it is needed
     hstmtInsert         = 0;


@@ -170,40 +144,51 @@ bool wxDbTable::initialize(wxDb *pwxDb, const wxString &tblName, const UWORD num
     hstmtInternal       = 0;
     colDefs             = 0;
     tableID             = 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
     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;
     queryOnly           = qryOnly;

-    insertable          = TRUE;
+    insertable          = true;

     tablePath.Empty();
     tableName.Empty();
     queryTableName.Empty();
 
     tablePath.Empty();
     tableName.Empty();
     queryTableName.Empty();
 

-    wxASSERT(tblName.Length());
+    wxASSERT(tblName.length());

     wxASSERT(pDb);
 
     if (!pDb)
     wxASSERT(pDb);
 
     if (!pDb)

-        return FALSE;
+        return false;

 
     tableName = tblName;                        // Table Name
 
     tableName = tblName;                        // Table Name

-    if (tblPath.Length())
+    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();
         tablePath = tblPath;                    // Table Path - used for dBase files
     else
         tablePath.Empty();

-    
-    if (qryTblName.Length())                    // Name of the table/view to query
+
+    if (qryTblName.length())                    // Name of the table/view to query

         queryTableName = qryTblName;
     else
         queryTableName = tblName;
         queryTableName = qryTblName;
     else
         queryTableName = tblName;

-    
+
+    if ((pDb->Dbms() == dbmsORACLE) ||
+        (pDb->Dbms() == dbmsFIREBIRD) ||
+        (pDb->Dbms() == dbmsINTERBASE))
+        queryTableName = queryTableName.Upper();
+

     pDb->incrementTableCount();
     pDb->incrementTableCount();

-    
+

     wxString s;
     tableID = ++lastTableID;
     wxString s;
     tableID = ++lastTableID;

-    s.Printf(wxT("wxDbTable constructor (%-20s) tableID:[%6lu] pDb:[%p]"), tblName.c_str(), tableID, pDb);
-    
+    s.Printf(wxT("wxDbTable constructor (%-20s) tableID:[%6lu] pDb:[%p]"),
+             tblName.c_str(), tableID, wx_static_cast(void*, pDb));
+

 #ifdef __WXDEBUG__
     wxTablesInUse *tableInUse;
     tableInUse            = new wxTablesInUse();
 #ifdef __WXDEBUG__
     wxTablesInUse *tableInUse;
     tableInUse            = new wxTablesInUse();


@@ -212,17 +197,17 @@ bool wxDbTable::initialize(wxDb *pwxDb, const wxString &tblName, const UWORD num
     tableInUse->pDb       = pDb;
     TablesInUse.Append(tableInUse);
 #endif
     tableInUse->pDb       = pDb;
     TablesInUse.Append(tableInUse);
 #endif

-    
+

     pDb->WriteSqlLog(s);
     pDb->WriteSqlLog(s);

-    
+

     // Grab the HENV and HDBC from the wxDb object
     henv = pDb->GetHENV();
     hdbc = pDb->GetHDBC();
     // Grab the HENV and HDBC from the wxDb object
     henv = pDb->GetHENV();
     hdbc = pDb->GetHDBC();

-    
+

     // Allocate space for column definitions
     // 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 statement handles for the table
     if (!queryOnly)
     {


@@ -239,12 +224,12 @@ bool wxDbTable::initialize(wxDb *pwxDb, const wxString &tblName, const UWORD num
     // Allocate a separate statement handle for internal use
     if (SQLAllocStmt(hdbc, &hstmtInternal) != SQL_SUCCESS)
         pDb->DispAllErrors(henv, hdbc);
     // 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;
     // Set the cursor type for the statement handles
     cursorType = SQL_CURSOR_STATIC;

-    
+

     if (SQLSetStmtOption(hstmtInternal, SQL_CURSOR_TYPE, cursorType) != SQL_SUCCESS)
     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
         // Check to see if cursor type is supported
         pDb->GetNextError(henv, hdbc, hstmtInternal);
         if (! wxStrcmp(pDb->sqlState, wxT("01S02")))  // Option Value Changed


@@ -282,7 +267,7 @@ bool wxDbTable::initialize(wxDb *pwxDb, const wxString &tblName, const UWORD num
                 {
                     // Should never happen
                     pDb->GetNextError(henv, hdbc, hstmtInternal);
                 {
                     // Should never happen
                     pDb->GetNextError(henv, hdbc, hstmtInternal);

-                    return FALSE;
+                    return false;

                 }
             }
         }
                 }
             }
         }


@@ -296,7 +281,7 @@ bool wxDbTable::initialize(wxDb *pwxDb, const wxString &tblName, const UWORD num
     else
         cout << wxT("Cursor Type set to STATIC") << endl << endl;
 #endif
     else
         cout << wxT("Cursor Type set to STATIC") << endl << endl;
 #endif

-    
+

     if (!queryOnly)
     {
         // Set the cursor type for the INSERT statement handle
     if (!queryOnly)
     {
         // Set the cursor type for the INSERT statement handle


@@ -309,13 +294,13 @@ bool wxDbTable::initialize(wxDb *pwxDb, const wxString &tblName, const UWORD num
         if (SQLSetStmtOption(hstmtUpdate, SQL_CURSOR_TYPE, SQL_CURSOR_FORWARD_ONLY) != SQL_SUCCESS)
             pDb->DispAllErrors(henv, hdbc, hstmtUpdate);
     }
         if (SQLSetStmtOption(hstmtUpdate, SQL_CURSOR_TYPE, SQL_CURSOR_FORWARD_ONLY) != SQL_SUCCESS)
             pDb->DispAllErrors(henv, hdbc, hstmtUpdate);
     }

-    
+

     // Make the default cursor the active cursor
     // Make the default cursor the active cursor

-    hstmtDefault = GetNewCursor(FALSE,FALSE);
+    hstmtDefault = GetNewCursor(false,false);

     wxASSERT(hstmtDefault);
     hstmt = *hstmtDefault;
 
     wxASSERT(hstmtDefault);
     hstmt = *hstmtDefault;
 

-    return TRUE;
+    return true;

 
 }  // wxDbTable::initialize()
 
 
 }  // wxDbTable::initialize()
 


@@ -325,33 +310,33 @@ void wxDbTable::cleanup()
     wxString s;
     if (pDb)
     {
     wxString s;
     if (pDb)
     {

-        s.Printf(wxT("wxDbTable destructor (%-20s) tableID:[%6lu] pDb:[%p]"), tableName.c_str(), tableID, pDb);
+        s.Printf(wxT("wxDbTable destructor (%-20s) tableID:[%6lu] pDb:[%p]"),
+                 tableName.c_str(), tableID, wx_static_cast(void*, pDb));

         pDb->WriteSqlLog(s);
     }
 
 #ifdef __WXDEBUG__
     if (tableID)
     {
         pDb->WriteSqlLog(s);
     }
 
 #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)
         {
         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
             }
             else

-                pNode = pNode->Next();
+                pNode = pNode->GetNext();

         }
         if (!found)
         {
             wxString msg;
         }
         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..."));
         }
     }
             wxLogDebug (msg,wxT("NOTICE..."));
         }
     }


@@ -411,37 +396,83 @@ ODBC 3.0 says to use this form
 
     if (hstmtCount)
         DeleteCursor(hstmtCount);
 
     if (hstmtCount)
         DeleteCursor(hstmtCount);

+
+    if (m_hstmtGridQuery)
+        DeleteCursor(m_hstmtGridQuery);
+

 }  // wxDbTable::cleanup()
 
 
 /***************************** PRIVATE FUNCTIONS *****************************/
 
 
 }  // wxDbTable::cleanup()
 
 
 /***************************** PRIVATE FUNCTIONS *****************************/
 
 

-/********** wxDbTable::bindUpdateParams() **********/
+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;
+        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)
 bool wxDbTable::bindParams(bool forUpdate)
 {
     wxASSERT(!queryOnly);
     if (queryOnly)

-        return(FALSE);
-    
+        return false;
+

     SWORD   fSqlType    = 0;
     SWORD   fSqlType    = 0;

-    UDWORD  precision   = 0;
+    SDWORD  precision   = 0;

     SWORD   scale       = 0;
     SWORD   scale       = 0;

-    
+

     // Bind each column of the table that should be bound
     // to a parameter marker
     int i;
     // Bind each column of the table that should be bound
     // to a parameter marker
     int i;

-        UWORD colNo;
-    for (i = 0, colNo = 1; i < noCols; i++)
+    UWORD colNumber;
+
+    for (i=0, colNumber=1; i < m_numCols; i++)

     {
         if (forUpdate)
         {
     {
         if (forUpdate)
         {

-            if (! colDefs[i].Updateable)
+            if (!colDefs[i].Updateable)

                 continue;
         }
         else
         {
                 continue;
         }
         else
         {

-            if (! colDefs[i].InsertAllowed)
+            if (!colDefs[i].InsertAllowed)

                 continue;
         }
 
                 continue;
         }
 


@@ -451,57 +482,45 @@ bool wxDbTable::bindParams(bool forUpdate)
                 fSqlType = pDb->GetTypeInfVarchar().FsqlType;
                 precision = colDefs[i].SzDataObj;
                 scale = 0;
                 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;
                 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;
                 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;
                 // 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;
                 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;
                 break;
             case DB_DATA_TYPE_BLOB:
                 fSqlType = pDb->GetTypeInfBlob().FsqlType;

-                precision = 50000;
+                precision = colDefs[i].SzDataObj;

                 scale = 0;
                 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;
         }
                 break;
         }

+
+        setCbValueForColumn(i);
+

         if (forUpdate)
         {
         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));
                                  precision+1, &colDefs[i].CbValue) != SQL_SUCCESS)
             {
                 return(pDb->DispAllErrors(henv, hdbc, hstmtUpdate));


@@ -509,17 +528,17 @@ bool wxDbTable::bindParams(bool forUpdate)
         }
         else
         {
         }
         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));
             }
         }
     }
             {
                 return(pDb->DispAllErrors(henv, hdbc, hstmtInsert));
             }
         }
     }

-    
+

     // Completed successfully
     // Completed successfully

-    return(TRUE);
+    return true;

 
 }  // wxDbTable::bindParams()
 
 
 }  // wxDbTable::bindParams()
 


@@ -527,35 +546,34 @@ bool wxDbTable::bindParams(bool forUpdate)
 /********** wxDbTable::bindInsertParams() **********/
 bool wxDbTable::bindInsertParams(void)
 {
 /********** wxDbTable::bindInsertParams() **********/
 bool wxDbTable::bindInsertParams(void)
 {

-    return bindParams(FALSE);
+    return bindParams(false);

 }  // wxDbTable::bindInsertParams()
 
 
 /********** wxDbTable::bindUpdateParams() **********/
 bool wxDbTable::bindUpdateParams(void)
 {
 }  // wxDbTable::bindInsertParams()
 
 
 /********** wxDbTable::bindUpdateParams() **********/
 bool wxDbTable::bindUpdateParams(void)
 {

-    return bindParams(TRUE);
+    return bindParams(true);

 }  // wxDbTable::bindUpdateParams()
 
 
 /********** wxDbTable::bindCols() **********/
 bool wxDbTable::bindCols(HSTMT cursor)
 {
 }  // wxDbTable::bindUpdateParams()
 
 
 /********** wxDbTable::bindCols() **********/
 bool wxDbTable::bindCols(HSTMT cursor)
 {

-//RG-NULL    static SDWORD  cb;
-    
+    static SQLLEN cb;
+

     // Bind each column of the table to a memory address for fetching data
     UWORD i;
     // 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,
         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));
           return (pDb->DispAllErrors(henv, hdbc, cursor));

-        }

     }
 
     // Completed successfully
     }
 
     // Completed successfully

-    return(TRUE);
+    return true;

 
 }  // wxDbTable::bindCols()
 
 
 }  // wxDbTable::bindCols()
 


@@ -568,14 +586,14 @@ bool wxDbTable::getRec(UWORD fetchType)
     if (!pDb->FwdOnlyCursors())
     {
         // Fetch the NEXT, PREV, FIRST or LAST record, depending on fetchType
     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);
         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)
         {
             if (retcode == SQL_NO_DATA_FOUND)

-                return(FALSE);
+                return false;

             else
                 return(pDb->DispAllErrors(henv, hdbc, hstmt));
         }
             else
                 return(pDb->DispAllErrors(henv, hdbc, hstmt));
         }


@@ -584,7 +602,7 @@ bool wxDbTable::getRec(UWORD fetchType)
             // Set the Null member variable to indicate the Null state
             // of each column just read in.
             int i;
             // 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);
         }
     }
                 colDefs[i].Null = (colDefs[i].CbValue == SQL_NULL_DATA);
         }
     }


@@ -595,7 +613,7 @@ bool wxDbTable::getRec(UWORD fetchType)
         if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
         {
             if (retcode == SQL_NO_DATA_FOUND)
         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));
         }
             else
                 return(pDb->DispAllErrors(henv, hdbc, hstmt));
         }


@@ -604,13 +622,13 @@ bool wxDbTable::getRec(UWORD fetchType)
             // Set the Null member variable to indicate the Null state
             // of each column just read in.
             int i;
             // 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
                 colDefs[i].Null = (colDefs[i].CbValue == SQL_NULL_DATA);
         }
     }
 
     // Completed successfully

-    return(TRUE);
+    return true;

 
 }  // wxDbTable::getRec()
 
 
 }  // wxDbTable::getRec()
 


@@ -618,12 +636,21 @@ bool wxDbTable::getRec(UWORD fetchType)
 /********** wxDbTable::execDelete() **********/
 bool wxDbTable::execDelete(const wxString &pSqlStmt)
 {
 /********** wxDbTable::execDelete() **********/
 bool wxDbTable::execDelete(const wxString &pSqlStmt)
 {

+    RETCODE retcode;
+

     // Execute the DELETE statement
     // Execute the DELETE statement

-    if (SQLExecDirect(hstmtDelete, (UCHAR FAR *) pSqlStmt.c_str(), SQL_NTS) != SQL_SUCCESS)
-        return(pDb->DispAllErrors(henv, hdbc, hstmtDelete));
+    retcode = SQLExecDirect(hstmtDelete, (SQLTCHAR FAR *) pSqlStmt.c_str(), SQL_NTS);

 
 

-    // Record deleted successfully
-    return(TRUE);
+    if (retcode == SQL_SUCCESS ||
+        retcode == SQL_NO_DATA_FOUND ||
+        retcode == SQL_SUCCESS_WITH_INFO)
+    {
+        // Record deleted successfully
+        return true;
+    }
+
+    // Problem deleting record
+    return(pDb->DispAllErrors(henv, hdbc, hstmtDelete));

 
 }  // wxDbTable::execDelete()
 
 
 }  // wxDbTable::execDelete()
 


@@ -631,12 +658,53 @@ bool wxDbTable::execDelete(const wxString &pSqlStmt)
 /********** wxDbTable::execUpdate() **********/
 bool wxDbTable::execUpdate(const wxString &pSqlStmt)
 {
 /********** wxDbTable::execUpdate() **********/
 bool wxDbTable::execUpdate(const wxString &pSqlStmt)
 {

+    RETCODE retcode;
+

     // Execute the UPDATE statement
     // Execute the UPDATE statement

-    if (SQLExecDirect(hstmtUpdate, (UCHAR FAR *) pSqlStmt.c_str(), SQL_NTS) != SQL_SUCCESS)
-        return(pDb->DispAllErrors(henv, hdbc, hstmtUpdate));
+    retcode = SQLExecDirect(hstmtUpdate, (SQLTCHAR FAR *) pSqlStmt.c_str(), SQL_NTS);

 
 

-    // Record deleted successfully
-    return(TRUE);
+    if (retcode == SQL_SUCCESS ||
+        retcode == SQL_NO_DATA_FOUND ||
+        retcode == SQL_SUCCESS_WITH_INFO)
+    {
+        // Record updated successfully
+        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
+    return(pDb->DispAllErrors(henv, hdbc, hstmtUpdate));

 
 }  // wxDbTable::execUpdate()
 
 
 }  // wxDbTable::execUpdate()
 


@@ -650,7 +718,7 @@ bool wxDbTable::query(int queryType, bool forUpdate, bool distinct, const wxStri
         // The user may wish to select for update, but the DBMS may not be capable
         selectForUpdate = CanSelectForUpdate();
     else
         // 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,
 
     // Set the SQL SELECT string
     if (queryType != DB_SELECT_STATEMENT)               // A select statement was not passed in,


@@ -658,34 +726,19 @@ bool wxDbTable::query(int queryType, bool forUpdate, bool distinct, const wxStri
         BuildSelectStmt(sqlStmt, queryType, distinct);
         pDb->WriteSqlLog(sqlStmt);
     }
         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))
     // Make sure the cursor is closed first
     if (!CloseCursor(hstmt))

-        return(FALSE);
+        return false;

 
     // Execute the SQL SELECT statement
 
     // 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
     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
         return(pDb->DispAllErrors(henv, hdbc, hstmt));
 
     // Completed successfully

-    return(TRUE);
+    return true;

 
 }  // wxDbTable::query()
 
 
 }  // wxDbTable::query()
 


@@ -697,15 +750,36 @@ bool wxDbTable::query(int queryType, bool forUpdate, bool distinct, const wxStri
 bool wxDbTable::Open(bool checkPrivileges, bool checkTableExists)
 {
     if (!pDb)
 bool wxDbTable::Open(bool checkPrivileges, bool checkTableExists)
 {
     if (!pDb)

-        return FALSE;   
+        return false;

 
     int i;
     wxString sqlStmt;
     wxString s;
 
 
     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();
     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
     // 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'))
     {
         s = wxT("Table/view does not exist in the database");
         if ( *(pDb->dbInf.accessibleTables) == wxT('Y'))


@@ -716,21 +790,22 @@ bool wxDbTable::Open(bool checkPrivileges, bool checkTableExists)
     else if (checkPrivileges)
     {
         // Verify the user has rights to access the table.
     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;
 
     {
         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.Printf(wxT("Error opening '%s/%s'.\n"),tablePath.c_str(),tableName.c_str());
         else
             p.Printf(wxT("Error opening '%s'.\n"), tableName.c_str());


@@ -738,7 +813,7 @@ bool wxDbTable::Open(bool checkPrivileges, bool checkTableExists)
         p += s;
         pDb->LogError(p.GetData());
 
         p += s;
         pDb->LogError(p.GetData());
 

-        return(FALSE);
+        return false;

     }
 
     // Bind the member variables for field exchange between
     }
 
     // Bind the member variables for field exchange between


@@ -746,65 +821,66 @@ bool wxDbTable::Open(bool checkPrivileges, bool checkTableExists)
     if (!queryOnly)
     {
         if (!bindInsertParams())                    // Inserts
     if (!queryOnly)
     {
         if (!bindInsertParams())                    // Inserts

-            return(FALSE);
-       
+            return false;
+

         if (!bindUpdateParams())                    // Updates
         if (!bindUpdateParams())                    // Updates

-            return(FALSE);
+            return false;

     }
 
     if (!bindCols(*hstmtDefault))                   // Selects
     }
 
     if (!bindCols(*hstmtDefault))                   // Selects

-        return(FALSE);
-    
+        return false;
+

     if (!bindCols(hstmtInternal))                   // Internal use only
     if (!bindCols(hstmtInternal))                   // Internal use only

-        return(FALSE);
+        return false;

 
      /*
      * Do NOT bind the hstmtCount cursor!!!
      */
 
     // Build an insert statement using parameter markers
 
      /*
      * 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(",");
         {
             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;
 
         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("?");
         {
             if (! colDefs[i].InsertAllowed)
                 continue;
             if (needComma)
                 sqlStmt += wxT(",");
             sqlStmt += wxT("?");

-            needComma = TRUE;
+            needComma = true;

             insertableCount++;
         }
         sqlStmt += wxT(")");
             insertableCount++;
         }
         sqlStmt += wxT(")");

-        
+

         // Prepare the insert statement for execution
         // 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));
         }
                 return(pDb->DispAllErrors(henv, hdbc, hstmtInsert));
         }

-        else 
-            insertable= FALSE;
+        else
+            insertable = false;

     }
     }

-    
+

     // Completed successfully
     // Completed successfully

-    return(TRUE);
+    return true;

 
 }  // wxDbTable::Open()
 
 
 }  // wxDbTable::Open()
 


@@ -823,7 +899,7 @@ bool wxDbTable::QueryBySqlStmt(const wxString &pSqlStmt)
 {
     pDb->WriteSqlLog(pSqlStmt);
 
 {
     pDb->WriteSqlLog(pSqlStmt);
 

-    return(query(DB_SELECT_STATEMENT, FALSE, FALSE, pSqlStmt));
+    return(query(DB_SELECT_STATEMENT, false, false, pSqlStmt));

 
 }  // wxDbTable::QueryBySqlStmt()
 
 
 }  // wxDbTable::QueryBySqlStmt()
 


@@ -852,7 +928,7 @@ bool wxDbTable::GetPrev(void)
     if (pDb->FwdOnlyCursors())
     {
         wxFAIL_MSG(wxT("GetPrev()::Backward scrolling cursors are not enabled for this instance of wxDbTable"));
     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));
     }
     else
         return(getRec(SQL_FETCH_PRIOR));


@@ -866,7 +942,7 @@ bool wxDbTable::operator--(int)
     if (pDb->FwdOnlyCursors())
     {
         wxFAIL_MSG(wxT("operator--:Backward scrolling cursors are not enabled for this instance of wxDbTable"));
     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));
     }
     else
         return(getRec(SQL_FETCH_PRIOR));


@@ -880,7 +956,7 @@ bool wxDbTable::GetFirst(void)
     if (pDb->FwdOnlyCursors())
     {
         wxFAIL_MSG(wxT("GetFirst():Backward scrolling cursors are not enabled for this instance of wxDbTable"));
     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));
     }
     else
         return(getRec(SQL_FETCH_FIRST));


@@ -894,9 +970,9 @@ bool wxDbTable::GetLast(void)
     if (pDb->FwdOnlyCursors())
     {
         wxFAIL_MSG(wxT("GetLast()::Backward scrolling cursors are not enabled for this instance of wxDbTable"));
     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()
         return(getRec(SQL_FETCH_LAST));
 
 }  // wxDbTable::GetLast()


@@ -915,13 +991,15 @@ void wxDbTable::BuildDeleteStmt(wxString &pSqlStmt, int typeOfDel, const wxStrin
 
     // Handle the case of DeleteWhere() and the where clause is blank.  It should
     // delete all records from the database in this case.
 
     // Handle the case of DeleteWhere() and the where clause is blank.  It should
     // delete all records from the database in this case.

-    if (typeOfDel == DB_DEL_WHERE && (pWhereClause.Length() == 0))
+    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;
     }
 
         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)
 
     // Append the WHERE clause to the SQL DELETE statement
     switch(typeOfDel)


@@ -930,15 +1008,15 @@ void wxDbTable::BuildDeleteStmt(wxString &pSqlStmt, int typeOfDel, const wxStrin
             // 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 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.
                 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;
                 {
                     pSqlStmt += wxT("ROWID = '");
                     pSqlStmt += rowid;


@@ -987,39 +1065,41 @@ void wxDbTable::BuildSelectStmt(wxString &pSqlStmt, int typeOfSelect, bool disti
 
     // Was a FROM clause specified to join tables to the base table?
     // Available for ::Query() only!!!
 
     // 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))
 #if wxODBC_BACKWARD_COMPATABILITY
     if (typeOfSelect == DB_SELECT_WHERE && from && wxStrlen(from))

-        appendFromClause = TRUE;
+        appendFromClause = true;

 #else
 #else

-    if (typeOfSelect == DB_SELECT_WHERE && from.Length())
-        appendFromClause = TRUE;
+    if (typeOfSelect == DB_SELECT_WHERE && from.length())
+        appendFromClause = true;

 #endif
 
     // Add the column list
     int i;
 #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 joining tables, the base table column names must be qualified to avoid ambiguity

-        if (appendFromClause)
+        if ((appendFromClause || pDb->Dbms() == dbmsACCESS) && tStr.Find(wxT('.')) == wxNOT_FOUND)

         {
         {

-            pSqlStmt += queryTableName;
+            pSqlStmt += pDb->SQLTableName(queryTableName.c_str());

             pSqlStmt += wxT(".");
         }
             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.
             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 joining tables, the base table column names must be qualified to avoid ambiguity

-        if (appendFromClause)
+        if (appendFromClause || pDb->Dbms() == dbmsACCESS)

         {
             pSqlStmt += wxT(",");
         {
             pSqlStmt += wxT(",");

-            pSqlStmt += queryTableName;
+            pSqlStmt += pDb->SQLTableName(queryTableName);

             pSqlStmt += wxT(".ROWID");
         }
         else
             pSqlStmt += wxT(".ROWID");
         }
         else


@@ -1028,7 +1108,8 @@ void wxDbTable::BuildSelectStmt(wxString &pSqlStmt, int typeOfSelect, bool disti
 
     // Append the FROM tablename portion
     pSqlStmt += wxT(" FROM ");
 
     // 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.
 
     // Sybase uses the HOLDLOCK keyword to lock a record during query.
     // The HOLDLOCK keyword follows the table name in the from clause.


@@ -1049,7 +1130,7 @@ void wxDbTable::BuildSelectStmt(wxString &pSqlStmt, int typeOfSelect, bool disti
 #if wxODBC_BACKWARD_COMPATABILITY
             if (where && wxStrlen(where))   // May not want a where clause!!!
 #else
 #if wxODBC_BACKWARD_COMPATABILITY
             if (where && wxStrlen(where))   // May not want a where clause!!!
 #else

-            if (where.Length())   // May not want a where clause!!!
+            if (where.length())   // May not want a where clause!!!

 #endif
             {
                 pSqlStmt += wxT(" WHERE ");
 #endif
             {
                 pSqlStmt += wxT(" WHERE ");


@@ -1058,7 +1139,7 @@ void wxDbTable::BuildSelectStmt(wxString &pSqlStmt, int typeOfSelect, bool disti
             break;
         case DB_SELECT_KEYFIELDS:
             BuildWhereClause(whereClause, DB_WHERE_KEYFIELDS);
             break;
         case DB_SELECT_KEYFIELDS:
             BuildWhereClause(whereClause, DB_WHERE_KEYFIELDS);

-            if (whereClause.Length())
+            if (whereClause.length())

             {
                 pSqlStmt += wxT(" WHERE ");
                 pSqlStmt += whereClause;
             {
                 pSqlStmt += wxT(" WHERE ");
                 pSqlStmt += whereClause;


@@ -1066,7 +1147,7 @@ void wxDbTable::BuildSelectStmt(wxString &pSqlStmt, int typeOfSelect, bool disti
             break;
         case DB_SELECT_MATCHING:
             BuildWhereClause(whereClause, DB_WHERE_MATCHING);
             break;
         case DB_SELECT_MATCHING:
             BuildWhereClause(whereClause, DB_WHERE_MATCHING);

-            if (whereClause.Length())
+            if (whereClause.length())

             {
                 pSqlStmt += wxT(" WHERE ");
                 pSqlStmt += whereClause;
             {
                 pSqlStmt += wxT(" WHERE ");
                 pSqlStmt += whereClause;


@@ -1078,7 +1159,7 @@ void wxDbTable::BuildSelectStmt(wxString &pSqlStmt, int typeOfSelect, bool disti
 #if wxODBC_BACKWARD_COMPATABILITY
     if (orderBy && wxStrlen(orderBy))
 #else
 #if wxODBC_BACKWARD_COMPATABILITY
     if (orderBy && wxStrlen(orderBy))
 #else

-    if (orderBy.Length())
+    if (orderBy.length())

 #endif
     {
         pSqlStmt += wxT(" ORDER BY ");
 #endif
     {
         pSqlStmt += wxT(" ORDER BY ");


@@ -1104,7 +1185,7 @@ void wxDbTable::BuildSelectStmt(wxChar *pSqlStmt, int typeOfSelect, bool distinc
 
 
 /********** wxDbTable::BuildUpdateStmt() **********/
 
 
 /********** 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)
 {
     wxASSERT(!queryOnly);
     if (queryOnly)


@@ -1113,43 +1194,46 @@ void wxDbTable::BuildUpdateStmt(wxString &pSqlStmt, int typeOfUpd, const wxStrin
     wxString whereClause;
     whereClause.Empty();
 
     wxString whereClause;
     whereClause.Empty();
 

-    bool firstColumn = TRUE;
+    bool firstColumn = true;

 
 

-    pSqlStmt.Printf(wxT("UPDATE %s SET "), tableName.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;
 
     // 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)
         {
     {
         // Only append Updateable columns
         if (colDefs[i].Updateable)
         {

-            if (! firstColumn)
+            if (!firstColumn)

                 pSqlStmt += wxT(",");
             else
                 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 ");
             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'
     {
         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.
                 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;
                 {
                     pSqlStmt += wxT("ROWID = '");
                     pSqlStmt += rowid;


@@ -1170,10 +1254,10 @@ void wxDbTable::BuildUpdateStmt(wxString &pSqlStmt, int typeOfUpd, const wxStrin
 
 
 /***** DEPRECATED: use wxDbTable::BuildUpdateStmt(wxString &....) form *****/
 
 
 /***** 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;
 {
     wxString tempSqlStmt;

-    BuildUpdateStmt(tempSqlStmt, typeOfUpd, pWhereClause);
+    BuildUpdateStmt(tempSqlStmt, typeOfUpdate, pWhereClause);

     wxStrcpy(pSqlStmt, tempSqlStmt);
 }  // BuildUpdateStmt()
 
     wxStrcpy(pSqlStmt, tempSqlStmt);
 }  // BuildUpdateStmt()
 


@@ -1186,58 +1270,77 @@ void wxDbTable::BuildWhereClause(wxString &pWhereClause, int typeOfWhere,
  *       They are not included as part of the where clause.
  */
 {
  *       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
     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
     {
         // 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
         {
             // 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
                 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
             // 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 += 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(" = ");
                 pWhereClause += wxT(" LIKE ");
             else
                 pWhereClause += wxT(" = ");

-            switch(colDefs[i].SqlCtype)
+
+            switch(colDefs[colNumber].SqlCtype)

             {
                 case SQL_C_CHAR:
             {
                 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;
                     break;

+                case SQL_C_SHORT:

                 case SQL_C_SSHORT:
                 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:
                     break;
                 case SQL_C_USHORT:

-                    colValue.Printf(wxT("%hu"), *((UWORD *) colDefs[i].PtrDataObj));
+                    colValue.Printf(wxT("%hu"), *((UWORD *) colDefs[colNumber].PtrDataObj));

                     break;
                     break;

+                case SQL_C_LONG:

                 case SQL_C_SLONG:
                 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:
                     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:
                     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:
                     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;
                     break;
             }
             pWhereClause += colValue;


@@ -1280,7 +1383,7 @@ bool wxDbTable::CloseCursor(HSTMT cursor)
         return(pDb->DispAllErrors(henv, hdbc, cursor));
 
     // Completed successfully
         return(pDb->DispAllErrors(henv, hdbc, cursor));
 
     // Completed successfully

-    return(TRUE);
+    return true;

 
 }  // wxDbTable::CloseCursor()
 
 
 }  // wxDbTable::CloseCursor()
 


@@ -1289,7 +1392,7 @@ bool wxDbTable::CloseCursor(HSTMT cursor)
 bool wxDbTable::CreateTable(bool attemptDrop)
 {
     if (!pDb)
 bool wxDbTable::CreateTable(bool attemptDrop)
 {
     if (!pDb)

-        return FALSE;
+        return false;

 
     int i, j;
     wxString sqlStmt;
 
     int i, j;
     wxString sqlStmt;


@@ -1300,11 +1403,11 @@ bool wxDbTable::CreateTable(bool attemptDrop)
 
     // Drop table first
     if (attemptDrop && !DropTable())
 
     // Drop table first
     if (attemptDrop && !DropTable())

-        return FALSE;
+        return false;

 
     // Create the table
 #ifdef DBDEBUG_CONSOLE
 
     // 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)
     {
         // Exclude derived columns since they are NOT part of the base table
         if (colDefs[i].DerivedCol)


@@ -1313,19 +1416,22 @@ bool wxDbTable::CreateTable(bool attemptDrop)
         switch(colDefs[i].DbDataType)
         {
             case DB_DATA_TYPE_VARCHAR:
         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:
                 break;
             case DB_DATA_TYPE_INTEGER:

-                cout << pDb->typeInfInteger.TypeName;
+                cout << pDb->GetTypeInfInteger().TypeName;

                 break;
             case DB_DATA_TYPE_FLOAT:
                 break;
             case DB_DATA_TYPE_FLOAT:

-                cout << pDb->typeInfFloat.TypeName;
+                cout << pDb->GetTypeInfFloat().TypeName;

                 break;
             case DB_DATA_TYPE_DATE:
                 break;
             case DB_DATA_TYPE_DATE:

-                cout << pDb->typeInfDate.TypeName;
+                cout << pDb->GetTypeInfDate().TypeName;

                 break;
             case DB_DATA_TYPE_BLOB:
                 break;
             case DB_DATA_TYPE_BLOB:

-                cout << pDb->typeInfBlob.TypeName;
+                cout << pDb->GetTypeInfBlob().TypeName;

                 break;
         }
         cout << endl;
                 break;
         }
         cout << endl;


@@ -1333,10 +1439,12 @@ bool wxDbTable::CreateTable(bool attemptDrop)
 #endif
 
     // Build a CREATE TABLE string from the colDefs structure.
 #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)
     {
         // Exclude derived columns since they are NOT part of the base table
         if (colDefs[i].DerivedCol)


@@ -1345,7 +1453,8 @@ bool wxDbTable::CreateTable(bool attemptDrop)
         if (needComma)
             sqlStmt += wxT(",");
         // Column Name
         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(" ");
         // Column Type
         switch(colDefs[i].DbDataType)


@@ -1353,6 +1462,9 @@ bool wxDbTable::CreateTable(bool attemptDrop)
             case DB_DATA_TYPE_VARCHAR:
                 sqlStmt += pDb->GetTypeInfVarchar().TypeName;
                 break;
             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;
             case DB_DATA_TYPE_INTEGER:
                 sqlStmt += pDb->GetTypeInfInteger().TypeName;
                 break;


@@ -1367,17 +1479,20 @@ bool wxDbTable::CreateTable(bool attemptDrop)
                 break;
         }
         // For varchars, append the size of the string
                 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;
 //            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  ||
             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)
             pDb->Dbms() == dbmsMS_SQL_SERVER)
         {
             if (colDefs[i].KeyField)


@@ -1385,11 +1500,11 @@ bool wxDbTable::CreateTable(bool attemptDrop)
                 sqlStmt += wxT(" NOT NULL");
             }
         }
                 sqlStmt += wxT(" NOT NULL");
             }
         }

-        
-        needComma = TRUE;
+
+        needComma = true;

     }
     // If there is a primary key defined, include it in the create statement
     }
     // 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)
         {
     {
         if (colDefs[i].KeyField)
         {


@@ -1397,46 +1512,70 @@ bool wxDbTable::CreateTable(bool attemptDrop)
             break;
         }
     }
             break;
         }
     }

-    if (j && pDb->Dbms() != dbmsDBASE)  // Found a keyfield
+    if ( j && (pDb->Dbms() != dbmsDBASE)
+        && (pDb->Dbms() != dbmsXBASE_SEQUITER) )  // Found a keyfield

     {
         switch (pDb->Dbms())
         {
     {
         switch (pDb->Dbms())
         {

+            case dbmsACCESS:
+            case dbmsINFORMIX:

             case dbmsSYBASE_ASA:
             case dbmsSYBASE_ASE:
             case dbmsMY_SQL:
             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 */
+                // MySQL goes out on this one. We also declare the relevant key NON NULL above

                 sqlStmt += wxT(",PRIMARY KEY (");
                 break;
             }
             default:
             {
                 sqlStmt += wxT(",CONSTRAINT ");
                 sqlStmt += wxT(",PRIMARY KEY (");
                 break;
             }
             default:
             {
                 sqlStmt += wxT(",CONSTRAINT ");

-                sqlStmt += tableName;
+                //  DB2 is limited to 18 characters for index names
+                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 += pDb->SQLTableName(tableName.substr(0, 13).c_str());
+//                    sqlStmt += tableName.substr(0, 13);
+                }
+                else
+                    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
                 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(",");
         {
             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(")");
+        sqlStmt += wxT(")");

 
 

-       if (pDb->Dbms() == dbmsSYBASE_ASA ||
-           pDb->Dbms() == dbmsSYBASE_ASE)
-       {
-        sqlStmt += wxT(" CONSTRAINT ");
-        sqlStmt += tableName;
-        sqlStmt += wxT("_PIDX");
-       }
+        if (pDb->Dbms() == dbmsINFORMIX ||
+            pDb->Dbms() == dbmsSYBASE_ASA ||
+            pDb->Dbms() == dbmsSYBASE_ASE)
+        {
+            sqlStmt += wxT(" CONSTRAINT ");
+            sqlStmt += pDb->SQLTableName(tableName);
+//            sqlStmt += tableName;
+            sqlStmt += wxT("_PIDX");
+        }

     }
     // Append the closing parentheses for the create table statement
     sqlStmt += wxT(")");
     }
     // Append the closing parentheses for the create table statement
     sqlStmt += wxT(")");


@@ -1448,23 +1587,23 @@ bool wxDbTable::CreateTable(bool attemptDrop)
 #endif
 
     // Execute the CREATE TABLE statement
 #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);
     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())
     }
 
     // Commit the transaction and close the cursor
     if (!pDb->CommitTrans())

-        return(FALSE);
+        return false;

     if (!CloseCursor(hstmt))
     if (!CloseCursor(hstmt))

-        return(FALSE);
+        return false;

 
     // Database table created successfully
 
     // Database table created successfully

-    return(TRUE);
+    return true;

 
 } // wxDbTable::CreateTable()
 
 
 } // wxDbTable::CreateTable()
 


@@ -1472,14 +1611,15 @@ bool wxDbTable::CreateTable(bool attemptDrop)
 /********** wxDbTable::DropTable() **********/
 bool wxDbTable::DropTable()
 {
 /********** 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;
 
     //       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);
 
 
     pDb->WriteSqlLog(sqlStmt);
 


@@ -1487,46 +1627,48 @@ bool wxDbTable::DropTable()
     cout << endl << sqlStmt.c_str() << endl;
 #endif
 
     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 "Base table not found" error and ignore
     {
         // Check for "Base table not found" error and ignore

-        pDb->GetNextError(henv, hdbc, hstmt);   
-        if (wxStrcmp(pDb->sqlState, wxT("S0002")) &&
-            wxStrcmp(pDb->sqlState, wxT("S1000")))  // "Base table not found" 
-        {    
+        pDb->GetNextError(henv, hdbc, hstmt);
+        if (wxStrcmp(pDb->sqlState, wxT("S0002")) /*&&
+            wxStrcmp(pDb->sqlState, wxT("S1000"))*/)  // "Base table not found"
+        {

             // Check for product specific error codes
             // 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() == dbmsPOSTGRES      && !wxStrcmp(pDb->sqlState,wxT("08S01")))))     
+            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() == dbmsPERVASIVE_SQL && !wxStrcmp(pDb->sqlState,wxT("S1000")))   ||  // Returns an S1000 then an S0002
+                  (pDb->Dbms() == dbmsPOSTGRES      && !wxStrcmp(pDb->sqlState,wxT("08S01")))))

             {
                 pDb->DispNextError();
                 pDb->DispAllErrors(henv, hdbc, hstmt);
                 pDb->RollbackTrans();
             {
                 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())
             }
         }
     }
 
     // Commit the transaction and close the cursor
     if (! pDb->CommitTrans())

-        return(FALSE);
+        return false;

     if (! CloseCursor(hstmt))
     if (! CloseCursor(hstmt))

-        return(FALSE);
+        return false;

 
 

-    return(TRUE);
+    return true;

 }  // wxDbTable::DropTable()
 
 
 /********** wxDbTable::CreateIndex() **********/
 }  // 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
 {
     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,
 
     // 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,


@@ -1540,79 +1682,110 @@ bool wxDbTable::CreateIndex(const wxString &idxName, bool unique, UWORD noIdxCol
     {
         wxString sqlStmt;
         int i;
     {
         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;
         {
             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
             // 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)
                     j++;
             }

-            
+

             if (found)
             {
             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)
                 {
                                         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;
                     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
                 }
             }
             else

-                ok = FALSE;
+                ok = false;

         }
         if (ok)
             pDb->CommitTrans();
         else
         {
             pDb->RollbackTrans();
         }
         if (ok)
             pDb->CommitTrans();
         else
         {
             pDb->RollbackTrans();

-            return(FALSE);
+            return false;

         }
     }
         }
     }

-    
+

     // Build a CREATE INDEX statement
     sqlStmt = wxT("CREATE ");
     if (unique)
         sqlStmt += wxT("UNIQUE ");
     // Build a CREATE INDEX statement
     sqlStmt = wxT("CREATE ");
     if (unique)
         sqlStmt += wxT("UNIQUE ");

-    
+

     sqlStmt += wxT("INDEX ");
     sqlStmt += wxT("INDEX ");

-    sqlStmt += idxName;
+    sqlStmt += pDb->SQLTableName(indexName);

     sqlStmt += wxT(" ON ");
     sqlStmt += wxT(" ON ");

-    sqlStmt += tableName;
+
+    sqlStmt += pDb->SQLTableName(tableName);
+//    sqlStmt += tableName;

     sqlStmt += wxT(" (");
     sqlStmt += wxT(" (");

-    
+

     // Append list of columns making up index
     int i;
     // 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");
         }
                 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(",");
     }
             sqlStmt += wxT(",");
     }

-    
+

     // Append closing parentheses
     sqlStmt += wxT(")");
 
     // Append closing parentheses
     sqlStmt += wxT(")");
 


@@ -1623,51 +1796,59 @@ bool wxDbTable::CreateIndex(const wxString &idxName, bool unique, UWORD noIdxCol
 #endif
 
     // Execute the CREATE INDEX statement
 #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);
     {
         pDb->DispAllErrors(henv, hdbc, hstmt);
         pDb->RollbackTrans();
         CloseCursor(hstmt);

-        return(FALSE);
+        return false;

     }
 
     // Commit the transaction and close the cursor
     if (! pDb->CommitTrans())
     }
 
     // Commit the transaction and close the cursor
     if (! pDb->CommitTrans())

-        return(FALSE);
+        return false;

     if (! CloseCursor(hstmt))
     if (! CloseCursor(hstmt))

-        return(FALSE);
+        return false;

 
     // Index Created Successfully
 
     // Index Created Successfully

-    return(TRUE);
+    return true;

 
 }  // wxDbTable::CreateIndex()
 
 
 /********** wxDbTable::DropIndex() **********/
 
 }  // 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
     //       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;
 
     //       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) ||
     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
     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
 
     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);
     {
         // Check for "Index not found" error and ignore
         pDb->GetNextError(henv, hdbc, hstmt);


@@ -1677,6 +1858,9 @@ bool wxDbTable::DropIndex(const wxString &idxName)
             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"))) ||
             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->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")))


@@ -1686,48 +1870,48 @@ bool wxDbTable::DropIndex(const wxString &idxName)
                 pDb->DispAllErrors(henv, hdbc, hstmt);
                 pDb->RollbackTrans();
                 CloseCursor(hstmt);
                 pDb->DispAllErrors(henv, hdbc, hstmt);
                 pDb->RollbackTrans();
                 CloseCursor(hstmt);

-                return(FALSE);
+                return false;

             }
         }
     }
 
     // Commit the transaction and close the cursor
     if (! pDb->CommitTrans())
             }
         }
     }
 
     // Commit the transaction and close the cursor
     if (! pDb->CommitTrans())

-        return(FALSE);
+        return false;

     if (! CloseCursor(hstmt))
     if (! CloseCursor(hstmt))

-        return(FALSE);
+        return false;

 
 

-    return(TRUE);
+    return true;

 }  // wxDbTable::DropIndex()
 
 
 /********** wxDbTable::SetOrderByColNums() **********/
 bool wxDbTable::SetOrderByColNums(UWORD first, ... )
 {
 }  // 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;
 
     va_list     argptr;
 

-    bool        abort = FALSE;
+    bool        abort = false;

     wxString    tempStr;
 
     va_start(argptr, first);     /* Initialize variable arguments. */
     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
         //
     {
         // 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;
         }
 
             continue;
         }
 

-        if (colNo != first)
+        if (colNumber != first)

             tempStr += wxT(",");
 
             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.      */
 
     }
     va_end (argptr);              /* Reset variable arguments.      */
 


@@ -1748,8 +1932,9 @@ int wxDbTable::Insert(void)
 
     // Insert the record by executing the already prepared insert statement
     RETCODE retcode;
 
     // 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);
     {
         // Check to see if integrity constraint was violated
         pDb->GetNextError(henv, hdbc, hstmtInsert);


@@ -1762,6 +1947,40 @@ int wxDbTable::Insert(void)
             return(DB_FAILURE);
         }
     }
             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);
 
     // Record inserted into the datasource successfully
     return(DB_SUCCESS);


@@ -1774,7 +1993,7 @@ bool wxDbTable::Update(void)
 {
     wxASSERT(!queryOnly);
     if (queryOnly)
 {
     wxASSERT(!queryOnly);
     if (queryOnly)

-        return(FALSE);
+        return false;

 
     wxString sqlStmt;
 
 
     wxString sqlStmt;
 


@@ -1798,7 +2017,7 @@ bool wxDbTable::Update(const wxString &pSqlStmt)
 {
     wxASSERT(!queryOnly);
     if (queryOnly)
 {
     wxASSERT(!queryOnly);
     if (queryOnly)

-        return(FALSE);
+        return false;

 
     pDb->WriteSqlLog(pSqlStmt);
 
 
     pDb->WriteSqlLog(pSqlStmt);
 


@@ -1812,7 +2031,7 @@ bool wxDbTable::UpdateWhere(const wxString &pWhereClause)
 {
     wxASSERT(!queryOnly);
     if (queryOnly)
 {
     wxASSERT(!queryOnly);
     if (queryOnly)

-        return(FALSE);
+        return false;

 
     wxString sqlStmt;
 
 
     wxString sqlStmt;
 


@@ -1836,7 +2055,7 @@ bool wxDbTable::Delete(void)
 {
     wxASSERT(!queryOnly);
     if (queryOnly)
 {
     wxASSERT(!queryOnly);
     if (queryOnly)

-        return(FALSE);
+        return false;

 
     wxString sqlStmt;
     sqlStmt.Empty();
 
     wxString sqlStmt;
     sqlStmt.Empty();


@@ -1857,7 +2076,7 @@ bool wxDbTable::DeleteWhere(const wxString &pWhereClause)
 {
     wxASSERT(!queryOnly);
     if (queryOnly)
 {
     wxASSERT(!queryOnly);
     if (queryOnly)

-        return(FALSE);
+        return false;

 
     wxString sqlStmt;
     sqlStmt.Empty();
 
     wxString sqlStmt;
     sqlStmt.Empty();


@@ -1878,7 +2097,7 @@ bool wxDbTable::DeleteMatching(void)
 {
     wxASSERT(!queryOnly);
     if (queryOnly)
 {
     wxASSERT(!queryOnly);
     if (queryOnly)

-        return(FALSE);
+        return false;

 
     wxString sqlStmt;
     sqlStmt.Empty();
 
     wxString sqlStmt;
     sqlStmt.Empty();


@@ -1895,40 +2114,42 @@ bool wxDbTable::DeleteMatching(void)
 
 
 /********** wxDbTable::IsColNull() **********/
 
 
 /********** 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.
 
     if a numeric field were set to a value of 0.
 

-    switch(colDefs[colNo].SqlCtype)
+    switch(colDefs[colNumber].SqlCtype)

     {
         case SQL_C_CHAR:
     {
         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:
         case SQL_C_SSHORT:

-            return((  *((SWORD *) colDefs[colNo].PtrDataObj))   == 0);
+            return((  *((SWORD *) colDefs[colNumber].PtrDataObj))   == 0);

         case SQL_C_USHORT:
         case SQL_C_USHORT:

-            return((   *((UWORD*) colDefs[colNo].PtrDataObj))   == 0);
+            return((   *((UWORD*) colDefs[colNumber].PtrDataObj))   == 0);

         case SQL_C_SLONG:
         case SQL_C_SLONG:

-            return(( *((SDWORD *) colDefs[colNo].PtrDataObj))   == 0);
+            return(( *((SDWORD *) colDefs[colNumber].PtrDataObj))   == 0);

         case SQL_C_ULONG:
         case SQL_C_ULONG:

-            return(( *((UDWORD *) colDefs[colNo].PtrDataObj))   == 0);
+            return(( *((UDWORD *) colDefs[colNumber].PtrDataObj))   == 0);

         case SQL_C_FLOAT:
         case SQL_C_FLOAT:

-            return(( *((SFLOAT *) colDefs[colNo].PtrDataObj))   == 0);
+            return(( *((SFLOAT *) colDefs[colNumber].PtrDataObj))   == 0);

         case SQL_C_DOUBLE:
         case SQL_C_DOUBLE:

-            return((*((SDOUBLE *) colDefs[colNo].PtrDataObj))   == 0);
+            return((*((SDOUBLE *) colDefs[colNumber].PtrDataObj))   == 0);

         case SQL_C_TIMESTAMP:
             TIMESTAMP_STRUCT *pDt;
         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)
             if (pDt->year == 0 && pDt->month == 0 && pDt->day == 0)

-                return(TRUE);
+                return true;

             else
             else

-                return(FALSE);
+                return false;

         default:
         default:

-            return(TRUE);
+            return true;

     }
 */
     }
 */

-    return (colDefs[colNo].Null);
+    return (colDefs[colNumber].Null);

 }  // wxDbTable::IsColNull()
 
 
 }  // wxDbTable::IsColNull()
 
 


@@ -1936,80 +2157,85 @@ bool wxDbTable::IsColNull(UWORD colNo)
 bool wxDbTable::CanSelectForUpdate(void)
 {
     if (queryOnly)
 bool wxDbTable::CanSelectForUpdate(void)
 {
     if (queryOnly)

-        return FALSE;
+        return false;

 
     if (pDb->Dbms() == dbmsMY_SQL)
 
     if (pDb->Dbms() == dbmsMY_SQL)

-        return FALSE;
+        return false;

 
     if ((pDb->Dbms() == dbmsORACLE) ||
         (pDb->dbInf.posStmts & SQL_PS_SELECT_FOR_UPDATE))
 
     if ((pDb->Dbms() == dbmsORACLE) ||
         (pDb->dbInf.posStmts & SQL_PS_SELECT_FOR_UPDATE))

-        return(TRUE);
+        return true;

     else
     else

-        return(FALSE);
+        return false;

 
 }  // wxDbTable::CanSelectForUpdate()
 
 
 
 }  // 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
  */
  *        as the ROWID is not getting updated correctly
  */

-    return FALSE;
+    return false;

 /*
     if (pDb->Dbms() == dbmsORACLE)
 /*
     if (pDb->Dbms() == dbmsORACLE)

-        return(TRUE);
+        return true;

     else
     else

-        return(FALSE);
+        return false;

 */
 */

-}  // wxDbTable::CanUpdByROWID()
+}  // wxDbTable::CanUpdateByROWID()

 
 
 /********** wxDbTable::IsCursorClosedOnCommit() **********/
 bool wxDbTable::IsCursorClosedOnCommit(void)
 {
     if (pDb->dbInf.cursorCommitBehavior == SQL_CB_PRESERVE)
 
 
 /********** wxDbTable::IsCursorClosedOnCommit() **********/
 bool wxDbTable::IsCursorClosedOnCommit(void)
 {
     if (pDb->dbInf.cursorCommitBehavior == SQL_CB_PRESERVE)

-        return(FALSE);
+        return false;

     else
     else

-        return(TRUE);
+        return true;

 
 }  // wxDbTable::IsCursorClosedOnCommit()
 
 
 
 /********** wxDbTable::ClearMemberVar() **********/
 
 }  // 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:
     {
         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:
             break;
         case SQL_C_SSHORT:

-            *((SWORD *) colDefs[colNo].PtrDataObj)          = 0;
+            *((SWORD *) colDefs[colNumber].PtrDataObj)          = 0;

             break;
         case SQL_C_USHORT:
             break;
         case SQL_C_USHORT:

-            *((UWORD*) colDefs[colNo].PtrDataObj)           = 0;
+            *((UWORD*) colDefs[colNumber].PtrDataObj)           = 0;

             break;
             break;

+        case SQL_C_LONG:

         case SQL_C_SLONG:
         case SQL_C_SLONG:

-            *((SDWORD *) colDefs[colNo].PtrDataObj)         = 0;
+            *((SDWORD *) colDefs[colNumber].PtrDataObj)         = 0;

             break;
         case SQL_C_ULONG:
             break;
         case SQL_C_ULONG:

-            *((UDWORD *) colDefs[colNo].PtrDataObj)         = 0;
+            *((UDWORD *) colDefs[colNumber].PtrDataObj)         = 0;

             break;
         case SQL_C_FLOAT:
             break;
         case SQL_C_FLOAT:

-            *((SFLOAT *) colDefs[colNo].PtrDataObj)         = 0.0f;
+            *((SFLOAT *) colDefs[colNumber].PtrDataObj)         = 0.0f;

             break;
         case SQL_C_DOUBLE:
             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;
             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;
             pDt->year = 0;
             pDt->month = 0;
             pDt->day = 0;


@@ -2018,10 +2244,24 @@ void wxDbTable::ClearMemberVar(UWORD colNo, bool setToNull)
             pDt->second = 0;
             pDt->fraction = 0;
             break;
             pDt->second = 0;
             pDt->fraction = 0;
             break;

+        case SQL_C_DATE:
+            DATE_STRUCT *pDtd;
+            pDtd = (DATE_STRUCT *) colDefs[colNumber].PtrDataObj;
+            pDtd->year = 0;
+            pDtd->month = 0;
+            pDtd->day = 0;
+            break;
+        case SQL_C_TIME:
+            TIME_STRUCT *pDtt;
+            pDtt = (TIME_STRUCT *) colDefs[colNumber].PtrDataObj;
+            pDtt->hour = 0;
+            pDtt->minute = 0;
+            pDtt->second = 0;
+            break;

     }
 
     if (setToNull)
     }
 
     if (setToNull)

-        SetColNull(colNo);
+        SetColNull(colNumber);

 }  // wxDbTable::ClearMemberVar()
 
 
 }  // wxDbTable::ClearMemberVar()
 
 


@@ -2031,8 +2271,8 @@ void wxDbTable::ClearMemberVars(bool setToNull)
     int i;
 
     // Loop through the columns setting each member variable to zero
     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()
 
 
 }  // wxDbTable::ClearMemberVars()
 


@@ -2050,23 +2290,38 @@ bool wxDbTable::SetQueryTimeout(UDWORD nSeconds)
         return(pDb->DispAllErrors(henv, hdbc, hstmtInternal));
 
     // Completed Successfully
         return(pDb->DispAllErrors(henv, hdbc, hstmtInternal));
 
     // Completed Successfully

-    return(TRUE);
+    return true;

 
 }  // wxDbTable::SetQueryTimeout()
 
 
 /********** wxDbTable::SetColDefs() **********/
 
 }  // 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
     if (!colDefs)  // May happen if the database connection fails

-        return;
+        return false;

 
 

-    if (fieldName.Length() > (unsigned int) DB_MAX_COLUMN_NAME_LEN)
+    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);
     }
     else
         wxStrcpy(colDefs[index].ColName, fieldName);


@@ -2074,23 +2329,25 @@ void wxDbTable::SetColDefs(UWORD index, const wxString &fieldName, int dataType,
     colDefs[index].DbDataType       = dataType;
     colDefs[index].PtrDataObj       = pData;
     colDefs[index].SqlCtype         = cType;
     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].KeyField         = keyField;

-    colDefs[index].DerivedCol       = derivedCol;
+    colDefs[index].DerivedCol       = derivedColumn;

     // Derived columns by definition would NOT be "Insertable" or "Updateable"
     // 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
     {
     }
     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()
 
 
 }  // wxDbTable::SetColDefs()
 
 


@@ -2103,7 +2360,7 @@ wxDbColDataPtr* wxDbTable::SetColDefs(wxDbColInf *pColInfs, UWORD numCols)
     if (pColInfs)
     {
         UWORD index;
     if (pColInfs)
     {
         UWORD index;

-       
+

         pColDataPtrs = new wxDbColDataPtr[numCols+1];
 
         for (index = 0; index < numCols; index++)
         pColDataPtrs = new wxDbColDataPtr[numCols+1];
 
         for (index = 0; index < numCols; index++)


@@ -2112,13 +2369,18 @@ wxDbColDataPtr* wxDbTable::SetColDefs(wxDbColInf *pColInfs, UWORD numCols)
             switch (pColInfs[index].dbDataType)
             {
                 case DB_DATA_TYPE_VARCHAR:
             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
                    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);
                     {
                       pColDataPtrs[index].PtrDataObj = new long;
                       pColDataPtrs[index].SzDataObj  = sizeof(long);


@@ -2133,7 +2395,7 @@ wxDbColDataPtr* wxDbTable::SetColDefs(wxDbColInf *pColInfs, UWORD numCols)
                     break;
                 case DB_DATA_TYPE_FLOAT:
                     // Can be float or double
                     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 float;
                         pColDataPtrs[index].SzDataObj  = sizeof(float);


@@ -2144,7 +2406,7 @@ wxDbColDataPtr* wxDbTable::SetColDefs(wxDbColInf *pColInfs, UWORD numCols)
                         pColDataPtrs[index].PtrDataObj = new double;
                         pColDataPtrs[index].SzDataObj  = sizeof(double);
                         pColDataPtrs[index].SqlCtype   = SQL_C_DOUBLE;
                         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;
                     break;
                 case DB_DATA_TYPE_DATE:
                     pColDataPtrs[index].PtrDataObj = new TIMESTAMP_STRUCT;


@@ -2152,8 +2414,7 @@ wxDbColDataPtr* wxDbTable::SetColDefs(wxDbColInf *pColInfs, UWORD numCols)
                     pColDataPtrs[index].SqlCtype   = SQL_C_TIMESTAMP;
                     break;
                 case DB_DATA_TYPE_BLOB:
                     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;
                     pColDataPtrs[index].PtrDataObj = /*BLOB ADDITION NEEDED*/NULL;
                     pColDataPtrs[index].SzDataObj  = /*BLOB ADDITION NEEDED*/sizeof(void *);
                     pColDataPtrs[index].SqlCtype   = SQL_VARBINARY;


@@ -2163,7 +2424,7 @@ wxDbColDataPtr* wxDbTable::SetColDefs(wxDbColInf *pColInfs, UWORD numCols)
                 SetColDefs (index,pColInfs[index].colName,pColInfs[index].dbDataType, pColDataPtrs[index].PtrDataObj, pColDataPtrs[index].SqlCtype, pColDataPtrs[index].SzDataObj);
             else
             {
                 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
                 // 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


@@ -2195,17 +2456,18 @@ ULONG wxDbTable::Count(const wxString &args)
 {
     ULONG count;
     wxString sqlStmt;
 {
     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 ");
 
     // 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
 #if wxODBC_BACKWARD_COMPATABILITY
     if (from && wxStrlen(from))
 #else

-    if (from.Length())
+    if (from.length())

 #endif
         sqlStmt += from;
 
 #endif
         sqlStmt += from;
 


@@ -2213,7 +2475,7 @@ ULONG wxDbTable::Count(const wxString &args)
 #if wxODBC_BACKWARD_COMPATABILITY
     if (where && wxStrlen(where))
 #else
 #if wxODBC_BACKWARD_COMPATABILITY
     if (where && wxStrlen(where))
 #else

-    if (where.Length())
+    if (where.length())

 #endif
     {
         sqlStmt += wxT(" WHERE ");
 #endif
     {
         sqlStmt += wxT(" WHERE ");


@@ -2225,14 +2487,14 @@ ULONG wxDbTable::Count(const wxString &args)
     // Initialize the Count cursor if it's not already initialized
     if (!hstmtCount)
     {
     // 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
         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);
     {
         pDb->DispAllErrors(henv, hdbc, *hstmtCount);
         return(0);


@@ -2265,15 +2527,15 @@ ULONG wxDbTable::Count(const wxString &args)
 /********** wxDbTable::Refresh() **********/
 bool wxDbTable::Refresh(void)
 {
 /********** 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
 
     // 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;
 #else
     wxString saveWhere = where;
     wxString saveOrderBy = orderBy;


@@ -2283,17 +2545,18 @@ bool wxDbTable::Refresh(void)
     wxString whereClause;
     whereClause.Empty();
 
     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.
 
         // 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("'");
             whereClause += wxT(".ROWID = '");
             whereClause += rowid;
             whereClause += wxT("'");


@@ -2308,10 +2571,10 @@ bool wxDbTable::Refresh(void)
     where = whereClause;
     orderBy.Empty();
     if (!Query())
     where = whereClause;
     orderBy.Empty();
     if (!Query())

-        result = FALSE;
+        result = false;

 
     if (result && !GetNext())
 
     if (result && !GetNext())

-        result = FALSE;
+        result = false;

 
     // Switch back to original cursor
     SetCursor(&currCursor);
 
     // Switch back to original cursor
     SetCursor(&currCursor);


@@ -2330,17 +2593,20 @@ bool wxDbTable::Refresh(void)
 
 
 /********** wxDbTable::SetColNull() **********/
 
 
 /********** 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
         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
     }
     else

-        return(FALSE);
+        return false;

 
 }  // wxDbTable::SetColNull()
 
 
 }  // wxDbTable::SetColNull()
 


@@ -2348,22 +2614,25 @@ bool wxDbTable::SetColNull(UWORD colNo, bool set)
 /********** wxDbTable::SetColNull() **********/
 bool wxDbTable::SetColNull(const wxString &colName, bool set)
 {
 /********** 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;
     }
 
             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
         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
     }
     else

-        return(FALSE);
+        return false;

 
 }  // wxDbTable::SetColNull()
 
 
 }  // wxDbTable::SetColNull()
 


@@ -2392,7 +2661,7 @@ HSTMT *wxDbTable::GetNewCursor(bool setCursor, bool bindColumns)
 
     if (bindColumns)
     {
 
     if (bindColumns)
     {

-        if(!bindCols(*newHSTMT))
+        if (!bindCols(*newHSTMT))

         {
             delete newHSTMT;
             return(0);
         {
             delete newHSTMT;
             return(0);


@@ -2410,7 +2679,7 @@ HSTMT *wxDbTable::GetNewCursor(bool setCursor, bool bindColumns)
 /********** wxDbTable::DeleteCursor() **********/
 bool wxDbTable::DeleteCursor(HSTMT *hstmtDel)
 {
 /********** wxDbTable::DeleteCursor() **********/
 bool wxDbTable::DeleteCursor(HSTMT *hstmtDel)
 {

-    bool result = TRUE;
+    bool result = true;

 
     if (!hstmtDel)  // Cursor already deleted
         return(result);
 
     if (!hstmtDel)  // Cursor already deleted
         return(result);


@@ -2418,12 +2687,12 @@ bool wxDbTable::DeleteCursor(HSTMT *hstmtDel)
 /*
 ODBC 3.0 says to use this form
     if (SQLFreeHandle(*hstmtDel, SQL_DROP) != SQL_SUCCESS)
 /*
 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);
 */
     if (SQLFreeStmt(*hstmtDel, SQL_DROP) != SQL_SUCCESS)
     {
         pDb->DispAllErrors(henv, hdbc);

-        result = FALSE;
+        result = false;

     }
 
     delete hstmtDel;
     }
 
     delete hstmtDel;


@@ -2432,5 +2701,235 @@ ODBC 3.0 says to use this form
 
 }  // wxDbTable::DeleteCursor()
 
 
 }  // wxDbTable::DeleteCursor()
 

-#endif  // wxUSE_ODBC
+//////////////////////////////////////////////////////////////
+// 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