src/common/db.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        db.cpp
   3 // Purpose:     Implementation of the wxDb class.  The wxDb class represents a connection
   4 //              to an ODBC data source.  The wxDb class allows operations on the data
   5 //              source such as opening and closing the data source.
   6 // Author:      Doug Card
   7 // Modified by: George Tasker
   8 //              Bart Jourquin
   9 //              Mark Johnson, wxWindows@mj10777.de
  10 // Mods:        Dec, 1998:
  11 //                -Added support for SQL statement logging and database cataloging
  12 // Mods:        April, 1999
  13 //                -Added QUERY_ONLY mode support to reduce default number of cursors
  14 //                -Added additional SQL logging code
  15 //                -Added DEBUG-ONLY tracking of wxTable objects to detect orphaned DB connections
  16 //                -Set ODBC option to only read committed writes to the DB so all
  17 //                   databases operate the same in that respect
  18 // Created:     9.96
  19 // RCS-ID:      $Id$
  20 // Copyright:   (c) 1996 Remstar International, Inc.
  21 // Licence:     wxWindows licence
  22 ///////////////////////////////////////////////////////////////////////////////
  23
  24 /*
  25 // SYNOPSIS START
  26 // SYNOPSIS STOP
  27 */
  28 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  29     #pragma implementation "db.h"
  30 #endif
  31
  32 #include "wx/wxprec.h"
  33
  34 #ifdef __BORLANDC__
  35     #pragma hdrstop
  36 #endif
  37
  38 #ifdef DBDEBUG_CONSOLE
  39     #include "wx/ioswrap.h"
  40 #endif
  41
  42 #ifndef WX_PRECOMP
  43     #include "wx/string.h"
  44     #include "wx/object.h"
  45     #include "wx/list.h"
  46     #include "wx/utils.h"
  47     #include "wx/log.h"
  48 #endif
  49 #include "wx/filefn.h"
  50 #include "wx/wxchar.h"
  51
  52 #if wxUSE_ODBC
  53
  54 #include <stdio.h>
  55 #include <string.h>
  56 #include <assert.h>
  57 #include <stdlib.h>
  58 #include <ctype.h>
  59
  60 #include "wx/db.h"
  61
  62 // DLL options compatibility check:
  63 #include "wx/app.h"
  64 WX_CHECK_BUILD_OPTIONS("wxODBC")
  65
  66 WXDLLIMPEXP_DATA_ODBC(wxDbList*) PtrBegDbList = 0;
  67
  68 wxChar const *SQL_LOG_FILENAME         = wxT("sqllog.txt");
  69 wxChar const *SQL_CATALOG_FILENAME     = wxT("catalog.txt");
  70
  71 #ifdef __WXDEBUG__
  72     extern wxList TablesInUse;
  73 #endif
  74
  75 // SQL Log defaults to be used by GetDbConnection
  76 wxDbSqlLogState SQLLOGstate = sqlLogOFF;
  77
  78 static wxString SQLLOGfn = SQL_LOG_FILENAME;
  79
  80 // The wxDb::errorList is copied to this variable when the wxDb object
  81 // is closed.  This way, the error list is still available after the
  82 // database object is closed.  This is necessary if the database
  83 // connection fails so the calling application can show the operator
  84 // why the connection failed.  Note: as each wxDb object is closed, it
  85 // will overwrite the errors of the previously destroyed wxDb object in
  86 // this variable.  NOTE: This occurs during a CLOSE, not a FREEing of the
  87 // connection
  88 wxChar DBerrorList[DB_MAX_ERROR_HISTORY][DB_MAX_ERROR_MSG_LEN];
  89
  90
  91 // This type defines the return row-struct form
  92 // SQLTablePrivileges, and is used by wxDB::TablePrivileges.
  93 typedef struct
  94 {
  95    wxChar        tableQual[128+1];
  96    wxChar        tableOwner[128+1];
  97    wxChar        tableName[128+1];
  98    wxChar        grantor[128+1];
  99    wxChar        grantee[128+1];
 100    wxChar        privilege[128+1];
 101    wxChar        grantable[3+1];
 102 } wxDbTablePrivilegeInfo;
 103
 104
 105 /********** wxDbConnectInf Constructor - form 1 **********/
 106 wxDbConnectInf::wxDbConnectInf()
 107 {
 108     Henv = 0;
 109     freeHenvOnDestroy = false;
 110
 111     Initialize();
 112 }  // Constructor
 113
 114
 115 /********** wxDbConnectInf Constructor - form 2 **********/
 116 wxDbConnectInf::wxDbConnectInf(HENV henv, const wxString &dsn, const wxString &userID,
 117                        const wxString &password, const wxString &defaultDir,
 118                        const wxString &fileType, const wxString &description)
 119 {
 120     Henv = 0;
 121     freeHenvOnDestroy = false;
 122
 123     Initialize();
 124
 125     if (henv)
 126         SetHenv(henv);
 127     else
 128         AllocHenv();
 129
 130     SetDsn(dsn);
 131     SetUserID(userID);
 132     SetPassword(password);
 133     SetDescription(description);
 134     SetFileType(fileType);
 135     SetDefaultDir(defaultDir);
 136 }  // wxDbConnectInf Constructor
 137
 138
 139 wxDbConnectInf::~wxDbConnectInf()
 140 {
 141     if (freeHenvOnDestroy)
 142     {
 143         FreeHenv();
 144     }
 145 }  // wxDbConnectInf Destructor
 146
 147
 148
 149 /********** wxDbConnectInf::Initialize() **********/
 150 bool wxDbConnectInf::Initialize()
 151 {
 152     freeHenvOnDestroy = false;
 153
 154     if (freeHenvOnDestroy && Henv)
 155         FreeHenv();
 156
 157     Henv = 0;
 158     Dsn[0] = 0;
 159     Uid[0] = 0;
 160     AuthStr[0] = 0;
 161     ConnectionStr[0] = 0;
 162     Description.Empty();
 163     FileType.Empty();
 164     DefaultDir.Empty();
 165
 166     useConnectionStr = false;
 167
 168     return true;
 169 }  // wxDbConnectInf::Initialize()
 170
 171
 172 /********** wxDbConnectInf::AllocHenv() **********/
 173 bool wxDbConnectInf::AllocHenv()
 174 {
 175     // This is here to help trap if you are getting a new henv
 176     // without releasing an existing henv
 177     wxASSERT(!Henv);
 178
 179     // Initialize the ODBC Environment for Database Operations
 180     if (SQLAllocEnv(&Henv) != SQL_SUCCESS)
 181     {
 182         wxLogDebug(wxT("A problem occured while trying to get a connection to the data source"));
 183         return false;
 184     }
 185
 186     freeHenvOnDestroy = true;
 187
 188     return true;
 189 }  // wxDbConnectInf::AllocHenv()
 190
 191
 192 void wxDbConnectInf::FreeHenv()
 193 {
 194     wxASSERT(Henv);
 195
 196     if (Henv)
 197         SQLFreeEnv(Henv);
 198
 199     Henv = 0;
 200     freeHenvOnDestroy = false;
 201
 202 }  // wxDbConnectInf::FreeHenv()
 203
 204
 205 void wxDbConnectInf::SetDsn(const wxString &dsn)
 206 {
 207     wxASSERT(dsn.Length() < sizeof(Dsn));
 208
 209     wxStrcpy(Dsn,dsn);
 210 }  // wxDbConnectInf::SetDsn()
 211
 212
 213 void wxDbConnectInf::SetUserID(const wxString &uid)
 214 {
 215     wxASSERT(uid.Length() < sizeof(Uid));
 216     wxStrcpy(Uid, uid);
 217 }  // wxDbConnectInf::SetUserID()
 218
 219
 220 void wxDbConnectInf::SetPassword(const wxString &password)
 221 {
 222     wxASSERT(password.Length() < sizeof(AuthStr));
 223
 224     wxStrcpy(AuthStr, password);
 225 }  // wxDbConnectInf::SetPassword()
 226
 227 void wxDbConnectInf::SetConnectionStr(const wxString &connectStr)
 228 {
 229     wxASSERT(connectStr.Length() < sizeof(ConnectionStr));
 230
 231     useConnectionStr = wxStrlen(connectStr) > 0;
 232
 233     wxStrcpy(ConnectionStr, connectStr);
 234 }  // wxDbConnectInf::SetConnectionStr()
 235
 236
 237 /********** wxDbColFor Constructor **********/
 238 wxDbColFor::wxDbColFor()
 239 {
 240     Initialize();
 241 }  // wxDbColFor::wxDbColFor()
 242
 243
 244 /********** wxDbColFor::Initialize() **********/
 245 void wxDbColFor::Initialize()
 246 {
 247     s_Field.Empty();
 248     int i;
 249     for (i=0; i<7; i++)
 250     {
 251         s_Format[i].Empty();
 252         s_Amount[i].Empty();
 253         i_Amount[i] = 0;
 254     }
 255     i_Nation      = 0;                     // 0=EU, 1=UK, 2=International, 3=US
 256     i_dbDataType  = 0;
 257     i_sqlDataType = 0;
 258     Format(1,DB_DATA_TYPE_VARCHAR,0,0,0);  // the Function that does the work
 259 }  // wxDbColFor::Initialize()
 260
 261
 262 /********** wxDbColFor::Format() **********/
 263 int wxDbColFor::Format(int Nation, int dbDataType, SWORD sqlDataType,
 264                        short columnSize, short decimalDigits)
 265 {
 266     // ----------------------------------------------------------------------------------------
 267     // -- 19991224 : mj10777 : Create
 268     // There is still a lot of work to do here, but it is a start
 269     // It handles all the basic data-types that I have run into up to now
 270     // The main work will have be with Dates and float Formatting
 271     //    (US 1,000.00 ; EU 1.000,00)
 272     // There are wxWindow plans for locale support and the new wxDateTime.  If
 273     //    they define some constants (wxEUROPEAN) that can be gloably used,
 274     //    they should be used here.
 275     // ----------------------------------------------------------------------------------------
 276     // There should also be a function to scan in a string to fill the variable
 277     // ----------------------------------------------------------------------------------------
 278     wxString tempStr;
 279     i_Nation      = Nation;                                       // 0 = timestamp , 1=EU, 2=UK, 3=International, 4=US
 280     i_dbDataType  = dbDataType;
 281     i_sqlDataType = sqlDataType;
 282     s_Field.Printf(wxT("%s%d"),s_Amount[1].c_str(),i_Amount[1]);  // OK for VARCHAR, INTEGER and FLOAT
 283
 284     if (i_dbDataType == 0)                                        // Filter unsupported dbDataTypes
 285     {
 286         if ((i_sqlDataType == SQL_VARCHAR) || (i_sqlDataType == SQL_LONGVARCHAR))
 287             i_dbDataType = DB_DATA_TYPE_VARCHAR;
 288         if ((i_sqlDataType == SQL_C_DATE) || (i_sqlDataType == SQL_C_TIMESTAMP))
 289             i_dbDataType = DB_DATA_TYPE_DATE;
 290         if (i_sqlDataType == SQL_C_BIT)
 291             i_dbDataType = DB_DATA_TYPE_INTEGER;
 292         if (i_sqlDataType == SQL_NUMERIC)
 293             i_dbDataType = DB_DATA_TYPE_VARCHAR;
 294         if (i_sqlDataType == SQL_REAL)
 295             i_dbDataType = DB_DATA_TYPE_FLOAT;
 296         if (i_sqlDataType == SQL_C_BINARY)
 297             i_dbDataType = DB_DATA_TYPE_BLOB;
 298     }
 299
 300     if ((i_dbDataType == DB_DATA_TYPE_INTEGER) && (i_sqlDataType == SQL_C_DOUBLE))
 301     {   // DBASE Numeric
 302         i_dbDataType = DB_DATA_TYPE_FLOAT;
 303     }
 304
 305     switch(i_dbDataType)     // TBD: Still a lot of proper formatting to do
 306     {
 307         case DB_DATA_TYPE_VARCHAR:
 308             s_Field = wxT("%s");
 309             break;
 310         case DB_DATA_TYPE_INTEGER:
 311             s_Field = wxT("%d");
 312             break;
 313         case DB_DATA_TYPE_FLOAT:
 314             if (decimalDigits == 0)
 315                 decimalDigits = 2;
 316             tempStr = wxT("%");
 317             tempStr.Printf(wxT("%s%d.%d"),tempStr.c_str(),columnSize,decimalDigits);
 318             s_Field.Printf(wxT("%sf"),tempStr.c_str());
 319             break;
 320         case DB_DATA_TYPE_DATE:
 321             if (i_Nation == 0)      // timestamp       YYYY-MM-DD HH:MM:SS.SSS (tested for SYBASE)
 322             {
 323                 s_Field = wxT("%04d-%02d-%02d %02d:%02d:%02d.%03d");
 324             }
 325             if (i_Nation == 1)      // European        DD.MM.YYYY HH:MM:SS.SSS
 326             {
 327                 s_Field = wxT("%02d.%02d.%04d %02d:%02d:%02d.%03d");
 328             }
 329             if (i_Nation == 2)      // UK              DD/MM/YYYY HH:MM:SS.SSS
 330             {
 331                 s_Field = wxT("%02d/%02d/%04d %02d:%02d:%02d.%03d");
 332             }
 333             if (i_Nation == 3)      // International   YYYY-MM-DD HH:MM:SS.SSS
 334             {
 335                 s_Field = wxT("%04d-%02d-%02d %02d:%02d:%02d.%03d");
 336             }
 337             if (i_Nation == 4)      // US              MM/DD/YYYY HH:MM:SS.SSS
 338             {
 339                 s_Field = wxT("%02d/%02d/%04d %02d:%02d:%02d.%03d");
 340             }
 341             break;
 342           case DB_DATA_TYPE_BLOB:
 343             s_Field.Printf(wxT("Unable to format(%d)-SQL(%d)"),dbDataType,sqlDataType);        //
 344                 break;
 345         default:
 346             s_Field.Printf(wxT("Unknown Format(%d)-SQL(%d)"),dbDataType,sqlDataType);        //
 347             break;
 348     };
 349     return TRUE;
 350 }  // wxDbColFor::Format()
 351
 352
 353
 354 /********** wxDbColInf Constructor **********/
 355 wxDbColInf::wxDbColInf()
 356 {
 357     Initialize();
 358 }  // wxDbColInf::wxDbColInf()
 359
 360
 361 /********** wxDbColInf Destructor ********/
 362 wxDbColInf::~wxDbColInf()
 363 {
 364     if (pColFor)
 365         delete pColFor;
 366     pColFor = NULL;
 367 }  // wxDbColInf::~wxDbColInf()
 368
 369
 370 bool wxDbColInf::Initialize()
 371 {
 372     catalog[0]      = 0;
 373     schema[0]       = 0;
 374     tableName[0]    = 0;
 375     colName[0]      = 0;
 376     sqlDataType     = 0;
 377     typeName[0]     = 0;
 378     columnSize      = 0;
 379     bufferLength    = 0;
 380     decimalDigits   = 0;
 381     numPrecRadix    = 0;
 382     nullable        = 0;
 383     remarks[0]      = 0;
 384     dbDataType      = 0;
 385     PkCol           = 0;
 386     PkTableName[0]  = 0;
 387     FkCol           = 0;
 388     FkTableName[0]  = 0;
 389     pColFor         = NULL;
 390
 391     return true;
 392 }  // wxDbColInf::Initialize()
 393
 394
 395 /********** wxDbTableInf Constructor ********/
 396 wxDbTableInf::wxDbTableInf()
 397 {
 398     Initialize();
 399 }  // wxDbTableInf::wxDbTableInf()
 400
 401
 402 /********** wxDbTableInf Constructor ********/
 403 wxDbTableInf::~wxDbTableInf()
 404 {
 405     if (pColInf)
 406         delete [] pColInf;
 407     pColInf = NULL;
 408 }  // wxDbTableInf::~wxDbTableInf()
 409
 410
 411 bool wxDbTableInf::Initialize()
 412 {
 413     tableName[0]    = 0;
 414     tableType[0]    = 0;
 415     tableRemarks[0] = 0;
 416     numCols         = 0;
 417     pColInf         = NULL;
 418
 419     return true;
 420 }  // wxDbTableInf::Initialize()
 421
 422
 423 /********** wxDbInf Constructor *************/
 424 wxDbInf::wxDbInf()
 425 {
 426     Initialize();
 427 }  // wxDbInf::wxDbInf()
 428
 429
 430 /********** wxDbInf Destructor *************/
 431 wxDbInf::~wxDbInf()
 432 {
 433   if (pTableInf)
 434     delete [] pTableInf;
 435   pTableInf = NULL;
 436 }  // wxDbInf::~wxDbInf()
 437
 438
 439 /********** wxDbInf::Initialize() *************/
 440 bool wxDbInf::Initialize()
 441 {
 442     catalog[0]      = 0;
 443     schema[0]       = 0;
 444     numTables       = 0;
 445     pTableInf       = NULL;
 446
 447     return true;
 448 }  // wxDbInf::Initialize()
 449
 450
 451 /********** wxDb Constructor **********/
 452 wxDb::wxDb(const HENV &aHenv, bool FwdOnlyCursors)
 453 {
 454     // Copy the HENV into the db class
 455     henv = aHenv;
 456     fwdOnlyCursors = FwdOnlyCursors;
 457
 458     initialize();
 459 } // wxDb::wxDb()
 460
 461
 462 /********** wxDb Destructor **********/
 463 wxDb::~wxDb()
 464 {
 465     wxASSERT_MSG(!IsCached(),wxT("Cached connections must not be manually deleted, use\nwxDbFreeConnection() or wxDbCloseConnections()."));
 466
 467     if (IsOpen())
 468     {
 469         Close();
 470     }
 471 }  // wxDb destructor
 472
 473
 474
 475 /********** PRIVATE! wxDb::initialize PRIVATE! **********/
 476 /********** wxDb::initialize() **********/
 477 void wxDb::initialize()
 478 /*
 479  * Private member function that sets all wxDb member variables to
 480  * known values at creation of the wxDb
 481  */
 482 {
 483     int i;
 484
 485     fpSqlLog      = 0;            // Sql Log file pointer
 486     sqlLogState   = sqlLogOFF;    // By default, logging is turned off
 487     nTables       = 0;
 488     dbmsType      = dbmsUNIDENTIFIED;
 489
 490     wxStrcpy(sqlState,wxEmptyString);
 491     wxStrcpy(errorMsg,wxEmptyString);
 492     nativeError = cbErrorMsg = 0;
 493     for (i = 0; i < DB_MAX_ERROR_HISTORY; i++)
 494         wxStrcpy(errorList[i], wxEmptyString);
 495
 496     // Init typeInf structures
 497     typeInfVarchar.TypeName.Empty();
 498     typeInfVarchar.FsqlType      = 0;
 499     typeInfVarchar.Precision     = 0;
 500     typeInfVarchar.CaseSensitive = 0;
 501     typeInfVarchar.MaximumScale  = 0;
 502
 503     typeInfInteger.TypeName.Empty();
 504     typeInfInteger.FsqlType      = 0;
 505     typeInfInteger.Precision     = 0;
 506     typeInfInteger.CaseSensitive = 0;
 507     typeInfInteger.MaximumScale  = 0;
 508
 509     typeInfFloat.TypeName.Empty();
 510     typeInfFloat.FsqlType      = 0;
 511     typeInfFloat.Precision     = 0;
 512     typeInfFloat.CaseSensitive = 0;
 513     typeInfFloat.MaximumScale  = 0;
 514
 515     typeInfDate.TypeName.Empty();
 516     typeInfDate.FsqlType      = 0;
 517     typeInfDate.Precision     = 0;
 518     typeInfDate.CaseSensitive = 0;
 519     typeInfDate.MaximumScale  = 0;
 520
 521     typeInfBlob.TypeName.Empty();
 522     typeInfBlob.FsqlType      = 0;
 523     typeInfBlob.Precision     = 0;
 524     typeInfBlob.CaseSensitive = 0;
 525     typeInfBlob.MaximumScale  = 0;
 526
 527     // Error reporting is turned OFF by default
 528     silent = true;
 529
 530     // Allocate a data source connection handle
 531     if (SQLAllocConnect(henv, &hdbc) != SQL_SUCCESS)
 532         DispAllErrors(henv);
 533
 534     // Initialize the db status flag
 535     DB_STATUS = 0;
 536
 537     // Mark database as not open as of yet
 538     dbIsOpen = false;
 539     dbIsCached = false;
 540     dbOpenedWithConnectionString = false;
 541 }  // wxDb::initialize()
 542
 543
 544 /********** PRIVATE! wxDb::convertUserID PRIVATE! **********/
 545 //
 546 // NOTE: Return value from this function MUST be copied
 547 //       immediately, as the value is not good after
 548 //       this function has left scope.
 549 //
 550 const wxChar *wxDb::convertUserID(const wxChar *userID, wxString &UserID)
 551 {
 552     if (userID)
 553     {
 554         if (!wxStrlen(userID))
 555             UserID = uid;
 556         else
 557             UserID = userID;
 558     }
 559     else
 560         UserID.Empty();
 561
 562     // dBase does not use user names, and some drivers fail if you try to pass one
 563     if ( Dbms() == dbmsDBASE
 564          || Dbms() == dbmsXBASE_SEQUITER )
 565         UserID.Empty();
 566
 567     // Oracle user names may only be in uppercase, so force
 568     // the name to uppercase
 569     if (Dbms() == dbmsORACLE)
 570         UserID = UserID.Upper();
 571
 572     return UserID.c_str();
 573 }  // wxDb::convertUserID()
 574
 575
 576 bool wxDb::open(bool failOnDataTypeUnsupported)
 577 {
 578 /*
 579     If using Intersolv branded ODBC drivers, this is the place where you would substitute
 580     your branded driver license information
 581
 582     SQLSetConnectOption(hdbc, 1041, (UDWORD) wxEmptyString);
 583     SQLSetConnectOption(hdbc, 1042, (UDWORD) wxEmptyString);
 584 */
 585
 586     // Mark database as open
 587     dbIsOpen = true;
 588
 589     // Allocate a statement handle for the database connection
 590     if (SQLAllocStmt(hdbc, &hstmt) != SQL_SUCCESS)
 591         return(DispAllErrors(henv, hdbc));
 592
 593     // Set Connection Options
 594     if (!setConnectionOptions())
 595         return false;
 596
 597     // Query the data source for inf. about itself
 598     if (!getDbInfo(failOnDataTypeUnsupported))
 599         return false;
 600
 601     // Query the data source regarding data type information
 602
 603     //
 604     // The way it was determined which SQL data types to use was by calling SQLGetInfo
 605     // for all of the possible SQL data types to see which ones were supported.  If
 606     // a type is not supported, the SQLFetch() that's called from getDataTypeInfo()
 607     // fails with SQL_NO_DATA_FOUND.  This is ugly because I'm sure the three SQL data
 608     // types I've selected below will not alway's be what we want.  These are just
 609     // what happened to work against an Oracle 7/Intersolv combination.  The following is
 610     // a complete list of the results I got back against the Oracle 7 database:
 611     //
 612     // SQL_BIGINT             SQL_NO_DATA_FOUND
 613     // SQL_BINARY             SQL_NO_DATA_FOUND
 614     // SQL_BIT                SQL_NO_DATA_FOUND
 615     // SQL_CHAR               type name = 'CHAR', Precision = 255
 616     // SQL_DATE               SQL_NO_DATA_FOUND
 617     // SQL_DECIMAL            type name = 'NUMBER', Precision = 38
 618     // SQL_DOUBLE             type name = 'NUMBER', Precision = 15
 619     // SQL_FLOAT              SQL_NO_DATA_FOUND
 620     // SQL_INTEGER            SQL_NO_DATA_FOUND
 621     // SQL_LONGVARBINARY      type name = 'LONG RAW', Precision = 2 billion
 622     // SQL_LONGVARCHAR        type name = 'LONG', Precision = 2 billion
 623     // SQL_NUMERIC            SQL_NO_DATA_FOUND
 624     // SQL_REAL               SQL_NO_DATA_FOUND
 625     // SQL_SMALLINT           SQL_NO_DATA_FOUND
 626     // SQL_TIME               SQL_NO_DATA_FOUND
 627     // SQL_TIMESTAMP          type name = 'DATE', Precision = 19
 628     // SQL_VARBINARY          type name = 'RAW', Precision = 255
 629     // SQL_VARCHAR            type name = 'VARCHAR2', Precision = 2000
 630     // =====================================================================
 631     // Results from a Microsoft Access 7.0 db, using a driver from Microsoft
 632     //
 633     // SQL_VARCHAR            type name = 'TEXT', Precision = 255
 634     // SQL_TIMESTAMP          type name = 'DATETIME'
 635     // SQL_DECIMAL            SQL_NO_DATA_FOUND
 636     // SQL_NUMERIC            type name = 'CURRENCY', Precision = 19
 637     // SQL_FLOAT              SQL_NO_DATA_FOUND
 638     // SQL_REAL               type name = 'SINGLE', Precision = 7
 639     // SQL_DOUBLE             type name = 'DOUBLE', Precision = 15
 640     // SQL_INTEGER            type name = 'LONG', Precision = 10
 641
 642     // VARCHAR = Variable length character string
 643     if (!getDataTypeInfo(SQL_VARCHAR, typeInfVarchar))
 644         if (!getDataTypeInfo(SQL_CHAR, typeInfVarchar))
 645             return false;
 646         else
 647             typeInfVarchar.FsqlType = SQL_CHAR;
 648     else
 649         typeInfVarchar.FsqlType = SQL_VARCHAR;
 650
 651     // Float
 652     if (!getDataTypeInfo(SQL_DOUBLE,typeInfFloat))
 653         if (!getDataTypeInfo(SQL_REAL,typeInfFloat))
 654             if (!getDataTypeInfo(SQL_FLOAT,typeInfFloat))
 655                 if (!getDataTypeInfo(SQL_DECIMAL,typeInfFloat))
 656                     if (!getDataTypeInfo(SQL_NUMERIC,typeInfFloat))
 657                     {
 658                         if (failOnDataTypeUnsupported)
 659                             return false;
 660                     }
 661                     else
 662                         typeInfFloat.FsqlType = SQL_NUMERIC;
 663                 else
 664                     typeInfFloat.FsqlType = SQL_DECIMAL;
 665             else
 666                 typeInfFloat.FsqlType = SQL_FLOAT;
 667         else
 668             typeInfFloat.FsqlType = SQL_REAL;
 669     else
 670         typeInfFloat.FsqlType = SQL_DOUBLE;
 671
 672     // Integer
 673     if (!getDataTypeInfo(SQL_INTEGER, typeInfInteger))
 674     {
 675         // If SQL_INTEGER is not supported, use the floating point
 676         // data type to store integers as well as floats
 677         if (!getDataTypeInfo(typeInfFloat.FsqlType, typeInfInteger))
 678         {
 679             if (failOnDataTypeUnsupported)
 680                 return false;
 681         }
 682         else
 683             typeInfInteger.FsqlType = typeInfFloat.FsqlType;
 684     }
 685     else
 686         typeInfInteger.FsqlType = SQL_INTEGER;
 687
 688     // Date/Time
 689     if (!getDataTypeInfo(SQL_TIMESTAMP,typeInfDate))
 690     {
 691         if (!getDataTypeInfo(SQL_DATE,typeInfDate))
 692         {
 693 #ifdef SQL_DATETIME
 694             if (getDataTypeInfo(SQL_DATETIME,typeInfDate))
 695             {
 696                 typeInfDate.FsqlType = SQL_TIME;
 697             }
 698             else
 699 #endif // SQL_DATETIME defined
 700             {
 701                 if (failOnDataTypeUnsupported)
 702                     return false;
 703             }
 704         }
 705         else
 706             typeInfDate.FsqlType = SQL_DATE;
 707     }
 708     else
 709         typeInfDate.FsqlType = SQL_TIMESTAMP;
 710
 711
 712     if (!getDataTypeInfo(SQL_LONGVARBINARY, typeInfBlob))
 713     {
 714         if (!getDataTypeInfo(SQL_VARBINARY,typeInfBlob))
 715         {
 716             if (failOnDataTypeUnsupported)
 717                 return false;
 718         }
 719         else
 720             typeInfBlob.FsqlType = SQL_VARBINARY;
 721     }
 722     else
 723         typeInfBlob.FsqlType = SQL_LONGVARBINARY;
 724
 725
 726 #ifdef DBDEBUG_CONSOLE
 727     cout << wxT("VARCHAR DATA TYPE: ") << typeInfVarchar.TypeName << endl;
 728     cout << wxT("INTEGER DATA TYPE: ") << typeInfInteger.TypeName << endl;
 729     cout << wxT("FLOAT   DATA TYPE: ") << typeInfFloat.TypeName << endl;
 730     cout << wxT("DATE    DATA TYPE: ") << typeInfDate.TypeName << endl;
 731     cout << wxT("BLOB    DATA TYPE: ") << typeInfBlob.TypeName << endl;
 732     cout << endl;
 733 #endif
 734
 735     // Completed Successfully
 736     return true;
 737 }
 738
 739 bool wxDb::Open(const wxString& inConnectStr, bool failOnDataTypeUnsupported)
 740 {
 741     wxASSERT(inConnectStr.Length());
 742     dsn        = wxT("");
 743     uid        = wxT("");
 744     authStr    = wxT("");
 745
 746     RETCODE retcode;
 747
 748     if (!FwdOnlyCursors())
 749     {
 750         // Specify that the ODBC cursor library be used, if needed.  This must be
 751         // specified before the connection is made.
 752         retcode = SQLSetConnectOption(hdbc, SQL_ODBC_CURSORS, SQL_CUR_USE_IF_NEEDED);
 753
 754 #ifdef DBDEBUG_CONSOLE
 755         if (retcode == SQL_SUCCESS)
 756             cout << wxT("SQLSetConnectOption(CURSOR_LIB) successful") << endl;
 757         else
 758             cout << wxT("SQLSetConnectOption(CURSOR_LIB) failed") << endl;
 759 #else
 760         wxUnusedVar(retcode);
 761 #endif
 762     }
 763
 764     // Connect to the data source
 765     SQLTCHAR outConnectBuffer[SQL_MAX_CONNECTSTR_LEN+1];  // MS recommends at least 1k buffer
 766     short outConnectBufferLen;
 767
 768     inConnectionStr = inConnectStr;
 769
 770     retcode = SQLDriverConnect(hdbc, NULL, (SQLTCHAR FAR *)inConnectionStr.c_str(),
 771                         (SWORD)inConnectionStr.Length(), (SQLTCHAR FAR *)outConnectBuffer,
 772                         sizeof(outConnectBuffer), &outConnectBufferLen, SQL_DRIVER_COMPLETE );
 773
 774     if ((retcode != SQL_SUCCESS) &&
 775         (retcode != SQL_SUCCESS_WITH_INFO))
 776         return(DispAllErrors(henv, hdbc));
 777
 778     outConnectBuffer[outConnectBufferLen] = 0;
 779     outConnectionStr = outConnectBuffer;
 780     dbOpenedWithConnectionString = true;
 781
 782     return open(failOnDataTypeUnsupported);
 783 }
 784
 785 /********** wxDb::Open() **********/
 786 bool wxDb::Open(const wxString &Dsn, const wxString &Uid, const wxString &AuthStr, bool failOnDataTypeUnsupported)
 787 {
 788     wxASSERT(Dsn.Length());
 789     dsn        = Dsn;
 790     uid        = Uid;
 791     authStr    = AuthStr;
 792
 793     inConnectionStr = wxT("");
 794     outConnectionStr = wxT("");
 795
 796     RETCODE retcode;
 797
 798     if (!FwdOnlyCursors())
 799     {
 800         // Specify that the ODBC cursor library be used, if needed.  This must be
 801         // specified before the connection is made.
 802         retcode = SQLSetConnectOption(hdbc, SQL_ODBC_CURSORS, SQL_CUR_USE_IF_NEEDED);
 803
 804 #ifdef DBDEBUG_CONSOLE
 805         if (retcode == SQL_SUCCESS)
 806             cout << wxT("SQLSetConnectOption(CURSOR_LIB) successful") << endl;
 807         else
 808             cout << wxT("SQLSetConnectOption(CURSOR_LIB) failed") << endl;
 809 #else
 810         wxUnusedVar( retcode );
 811 #endif
 812     }
 813
 814     // Connect to the data source
 815     retcode = SQLConnect(hdbc, (SQLTCHAR FAR *) dsn.c_str(), SQL_NTS,
 816                          (SQLTCHAR FAR *) uid.c_str(), SQL_NTS,
 817                          (SQLTCHAR FAR *) authStr.c_str(), SQL_NTS);
 818
 819     if ((retcode != SQL_SUCCESS) &&
 820         (retcode != SQL_SUCCESS_WITH_INFO))
 821         return(DispAllErrors(henv, hdbc));
 822
 823     return open(failOnDataTypeUnsupported);
 824
 825 } // wxDb::Open()
 826
 827
 828 bool wxDb::Open(wxDbConnectInf *dbConnectInf, bool failOnDataTypeUnsupported)
 829 {
 830     wxASSERT(dbConnectInf);
 831
 832     // Use the connection string if one is present
 833     if (dbConnectInf->UseConnectionStr())
 834         return Open(GetConnectionInStr(), failOnDataTypeUnsupported);
 835     else
 836         return Open(dbConnectInf->GetDsn(), dbConnectInf->GetUserID(),
 837                     dbConnectInf->GetPassword(), failOnDataTypeUnsupported);
 838 }  // wxDb::Open()
 839
 840
 841 bool wxDb::Open(wxDb *copyDb)
 842 {
 843     dsn              = copyDb->GetDatasourceName();
 844     uid              = copyDb->GetUsername();
 845     authStr          = copyDb->GetPassword();
 846     inConnectionStr  = copyDb->GetConnectionInStr();
 847     outConnectionStr = copyDb->GetConnectionOutStr();
 848
 849     RETCODE retcode;
 850
 851     if (!FwdOnlyCursors())
 852     {
 853         // Specify that the ODBC cursor library be used, if needed.  This must be
 854         // specified before the connection is made.
 855         retcode = SQLSetConnectOption(hdbc, SQL_ODBC_CURSORS, SQL_CUR_USE_IF_NEEDED);
 856
 857 #ifdef DBDEBUG_CONSOLE
 858         if (retcode == SQL_SUCCESS)
 859             cout << wxT("SQLSetConnectOption(CURSOR_LIB) successful") << endl;
 860         else
 861             cout << wxT("SQLSetConnectOption(CURSOR_LIB) failed") << endl;
 862 #else
 863         wxUnusedVar( retcode );
 864 #endif
 865     }
 866
 867     if (copyDb->OpenedWithConnectionString())
 868     {
 869         // Connect to the data source
 870         SQLTCHAR outConnectBuffer[SQL_MAX_CONNECTSTR_LEN+1];
 871         short outConnectBufferLen;
 872
 873         inConnectionStr = copyDb->GetConnectionInStr();
 874
 875         retcode = SQLDriverConnect(hdbc, NULL, (SQLTCHAR FAR *)inConnectionStr.c_str(),
 876                             (SWORD)inConnectionStr.Length(), (SQLTCHAR FAR *)outConnectBuffer,
 877                             sizeof(outConnectBuffer), &outConnectBufferLen, SQL_DRIVER_COMPLETE);
 878
 879         if ((retcode != SQL_SUCCESS) &&
 880             (retcode != SQL_SUCCESS_WITH_INFO))
 881             return(DispAllErrors(henv, hdbc));
 882
 883         outConnectBuffer[outConnectBufferLen] = 0;
 884         outConnectionStr = outConnectBuffer;
 885         dbOpenedWithConnectionString = true;
 886     }
 887     else
 888     {
 889         // Connect to the data source
 890         retcode = SQLConnect(hdbc, (SQLTCHAR FAR *) dsn.c_str(), SQL_NTS,
 891                              (SQLTCHAR FAR *) uid.c_str(), SQL_NTS,
 892                              (SQLTCHAR FAR *) authStr.c_str(), SQL_NTS);
 893     }
 894
 895     if ((retcode != SQL_SUCCESS) &&
 896         (retcode != SQL_SUCCESS_WITH_INFO))
 897         return(DispAllErrors(henv, hdbc));
 898
 899 /*
 900     If using Intersolv branded ODBC drivers, this is the place where you would substitute
 901     your branded driver license information
 902
 903     SQLSetConnectOption(hdbc, 1041, (UDWORD) wxEmptyString);
 904     SQLSetConnectOption(hdbc, 1042, (UDWORD) wxEmptyString);
 905 */
 906
 907     // Mark database as open
 908     dbIsOpen = true;
 909
 910     // Allocate a statement handle for the database connection
 911     if (SQLAllocStmt(hdbc, &hstmt) != SQL_SUCCESS)
 912         return(DispAllErrors(henv, hdbc));
 913
 914     // Set Connection Options
 915     if (!setConnectionOptions())
 916         return false;
 917
 918     // Instead of Querying the data source for info about itself, it can just be copied
 919     // from the wxDb instance that was passed in (copyDb).
 920     wxStrcpy(dbInf.serverName,copyDb->dbInf.serverName);
 921     wxStrcpy(dbInf.databaseName,copyDb->dbInf.databaseName);
 922     wxStrcpy(dbInf.dbmsName,copyDb->dbInf.dbmsName);
 923     wxStrcpy(dbInf.dbmsVer,copyDb->dbInf.dbmsVer);
 924     dbInf.maxConnections = copyDb->dbInf.maxConnections;
 925     dbInf.maxStmts = copyDb->dbInf.maxStmts;
 926     wxStrcpy(dbInf.driverName,copyDb->dbInf.driverName);
 927     wxStrcpy(dbInf.odbcVer,copyDb->dbInf.odbcVer);
 928     wxStrcpy(dbInf.drvMgrOdbcVer,copyDb->dbInf.drvMgrOdbcVer);
 929     wxStrcpy(dbInf.driverVer,copyDb->dbInf.driverVer);
 930     dbInf.apiConfLvl = copyDb->dbInf.apiConfLvl;
 931     dbInf.cliConfLvl = copyDb->dbInf.cliConfLvl;
 932     dbInf.sqlConfLvl = copyDb->dbInf.sqlConfLvl;
 933     wxStrcpy(dbInf.outerJoins,copyDb->dbInf.outerJoins);
 934     wxStrcpy(dbInf.procedureSupport,copyDb->dbInf.procedureSupport);
 935     wxStrcpy(dbInf.accessibleTables,copyDb->dbInf.accessibleTables);
 936     dbInf.cursorCommitBehavior = copyDb->dbInf.cursorCommitBehavior;
 937     dbInf.cursorRollbackBehavior = copyDb->dbInf.cursorRollbackBehavior;
 938     dbInf.supportNotNullClause = copyDb->dbInf.supportNotNullClause;
 939     wxStrcpy(dbInf.supportIEF,copyDb->dbInf.supportIEF);
 940     dbInf.txnIsolation = copyDb->dbInf.txnIsolation;
 941     dbInf.txnIsolationOptions = copyDb->dbInf.txnIsolationOptions;
 942     dbInf.fetchDirections = copyDb->dbInf.fetchDirections;
 943     dbInf.lockTypes = copyDb->dbInf.lockTypes;
 944     dbInf.posOperations = copyDb->dbInf.posOperations;
 945     dbInf.posStmts = copyDb->dbInf.posStmts;
 946     dbInf.scrollConcurrency = copyDb->dbInf.scrollConcurrency;
 947     dbInf.scrollOptions = copyDb->dbInf.scrollOptions;
 948     dbInf.staticSensitivity = copyDb->dbInf.staticSensitivity;
 949     dbInf.txnCapable = copyDb->dbInf.txnCapable;
 950     dbInf.loginTimeout = copyDb->dbInf.loginTimeout;
 951
 952     // VARCHAR = Variable length character string
 953     typeInfVarchar.FsqlType         = copyDb->typeInfVarchar.FsqlType;
 954     typeInfVarchar.TypeName         = copyDb->typeInfVarchar.TypeName;
 955     typeInfVarchar.Precision        = copyDb->typeInfVarchar.Precision;
 956     typeInfVarchar.CaseSensitive    = copyDb->typeInfVarchar.CaseSensitive;
 957     typeInfVarchar.MaximumScale     = copyDb->typeInfVarchar.MaximumScale;
 958
 959     // Float
 960     typeInfFloat.FsqlType         = copyDb->typeInfFloat.FsqlType;
 961     typeInfFloat.TypeName         = copyDb->typeInfFloat.TypeName;
 962     typeInfFloat.Precision        = copyDb->typeInfFloat.Precision;
 963     typeInfFloat.CaseSensitive    = copyDb->typeInfFloat.CaseSensitive;
 964     typeInfFloat.MaximumScale     = copyDb->typeInfFloat.MaximumScale;
 965
 966     // Integer
 967     typeInfInteger.FsqlType         = copyDb->typeInfInteger.FsqlType;
 968     typeInfInteger.TypeName         = copyDb->typeInfInteger.TypeName;
 969     typeInfInteger.Precision        = copyDb->typeInfInteger.Precision;
 970     typeInfInteger.CaseSensitive    = copyDb->typeInfInteger.CaseSensitive;
 971     typeInfInteger.MaximumScale     = copyDb->typeInfInteger.MaximumScale;
 972
 973     // Date/Time
 974     typeInfDate.FsqlType         = copyDb->typeInfDate.FsqlType;
 975     typeInfDate.TypeName         = copyDb->typeInfDate.TypeName;
 976     typeInfDate.Precision        = copyDb->typeInfDate.Precision;
 977     typeInfDate.CaseSensitive    = copyDb->typeInfDate.CaseSensitive;
 978     typeInfDate.MaximumScale     = copyDb->typeInfDate.MaximumScale;
 979
 980     // Blob
 981     typeInfBlob.FsqlType         = copyDb->typeInfBlob.FsqlType;
 982     typeInfBlob.TypeName         = copyDb->typeInfBlob.TypeName;
 983     typeInfBlob.Precision        = copyDb->typeInfBlob.Precision;
 984     typeInfBlob.CaseSensitive    = copyDb->typeInfBlob.CaseSensitive;
 985     typeInfBlob.MaximumScale     = copyDb->typeInfBlob.MaximumScale;
 986
 987 #ifdef DBDEBUG_CONSOLE
 988     cout << wxT("VARCHAR DATA TYPE: ") << typeInfVarchar.TypeName << endl;
 989     cout << wxT("INTEGER DATA TYPE: ") << typeInfInteger.TypeName << endl;
 990     cout << wxT("FLOAT   DATA TYPE: ") << typeInfFloat.TypeName << endl;
 991     cout << wxT("DATE    DATA TYPE: ") << typeInfDate.TypeName << endl;
 992     cout << wxT("BLOB    DATA TYPE: ") << typeInfBlob.TypeName << endl;
 993     cout << endl;
 994 #endif
 995
 996     // Completed Successfully
 997     return true;
 998 } // wxDb::Open() 2
 999
1000
1001 /********** wxDb::setConnectionOptions() **********/
1002 bool wxDb::setConnectionOptions(void)
1003 /*
1004  * NOTE: The Intersolv/Oracle 7 driver was "Not Capable" of setting the login timeout.
1005  */
1006 {
1007     SWORD cb;
1008
1009     // I need to get the DBMS name here, because some of the connection options
1010     // are database specific and need to call the Dbms() function.
1011     if (SQLGetInfo(hdbc, SQL_DBMS_NAME, (UCHAR*) dbInf.dbmsName, 40, &cb) != SQL_SUCCESS)
1012         return(DispAllErrors(henv, hdbc));
1013
1014     SQLSetConnectOption(hdbc, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF);
1015     SQLSetConnectOption(hdbc, SQL_OPT_TRACE, SQL_OPT_TRACE_OFF);
1016 //  SQLSetConnectOption(hdbc, SQL_TXN_ISOLATION, SQL_TXN_READ_COMMITTED);  // No dirty reads
1017
1018     // By default, MS Sql Server closes cursors on commit and rollback.  The following
1019     // call to SQLSetConnectOption() is needed to force SQL Server to preserve cursors
1020     // after a transaction.  This is a driver specific option and is not part of the
1021     // ODBC standard.  Note: this behavior is specific to the ODBC interface to SQL Server.
1022     // The database settings don't have any effect one way or the other.
1023     if (Dbms() == dbmsMS_SQL_SERVER)
1024     {
1025         const long SQL_PRESERVE_CURSORS = 1204L;
1026         const long SQL_PC_ON = 1L;
1027         SQLSetConnectOption(hdbc, SQL_PRESERVE_CURSORS, SQL_PC_ON);
1028     }
1029
1030     // Display the connection options to verify them
1031 #ifdef DBDEBUG_CONSOLE
1032     long l;
1033     cout << wxT("****** CONNECTION OPTIONS ******") << endl;
1034
1035     if (SQLGetConnectOption(hdbc, SQL_AUTOCOMMIT, &l) != SQL_SUCCESS)
1036         return(DispAllErrors(henv, hdbc));
1037     cout << wxT("AUTOCOMMIT: ") << (l == SQL_AUTOCOMMIT_OFF ? "OFF" : "ON") << endl;
1038
1039     if (SQLGetConnectOption(hdbc, SQL_ODBC_CURSORS, &l) != SQL_SUCCESS)
1040         return(DispAllErrors(henv, hdbc));
1041     cout << wxT("ODBC CURSORS: ");
1042     switch(l)
1043         {
1044         case(SQL_CUR_USE_IF_NEEDED):
1045             cout << wxT("SQL_CUR_USE_IF_NEEDED");
1046             break;
1047         case(SQL_CUR_USE_ODBC):
1048             cout << wxT("SQL_CUR_USE_ODBC");
1049             break;
1050         case(SQL_CUR_USE_DRIVER):
1051             cout << wxT("SQL_CUR_USE_DRIVER");
1052             break;
1053         }
1054         cout << endl;
1055
1056     if (SQLGetConnectOption(hdbc, SQL_OPT_TRACE, &l) != SQL_SUCCESS)
1057         return(DispAllErrors(henv, hdbc));
1058     cout << wxT("TRACING: ") << (l == SQL_OPT_TRACE_OFF ? wxT("OFF") : wxT("ON")) << endl;
1059
1060     cout << endl;
1061 #endif
1062
1063     // Completed Successfully
1064     return true;
1065
1066 } // wxDb::setConnectionOptions()
1067
1068
1069 /********** wxDb::getDbInfo() **********/
1070 bool wxDb::getDbInfo(bool failOnDataTypeUnsupported)
1071 {
1072     SWORD cb;
1073     RETCODE retcode;
1074
1075     retcode = SQLGetInfo(hdbc, SQL_SERVER_NAME, (UCHAR*) dbInf.serverName, 80, &cb);
1076     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1077     {
1078         DispAllErrors(henv, hdbc);
1079         if (failOnDataTypeUnsupported)
1080             return false;
1081     }
1082
1083     retcode = SQLGetInfo(hdbc, SQL_DATABASE_NAME, (UCHAR*) dbInf.databaseName, 128, &cb);
1084     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1085     {
1086         DispAllErrors(henv, hdbc);
1087         if (failOnDataTypeUnsupported)
1088             return false;
1089     }
1090
1091     retcode = SQLGetInfo(hdbc, SQL_DBMS_NAME, (UCHAR*) dbInf.dbmsName, 40, &cb);
1092     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1093     {
1094         DispAllErrors(henv, hdbc);
1095         if (failOnDataTypeUnsupported)
1096             return false;
1097     }
1098
1099     // 16-Mar-1999
1100     // After upgrading to MSVC6, the original 20 char buffer below was insufficient,
1101     // causing database connectivity to fail in some cases.
1102     retcode = SQLGetInfo(hdbc, SQL_DBMS_VER, (UCHAR*) dbInf.dbmsVer, 64, &cb);
1103     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1104     {
1105         DispAllErrors(henv, hdbc);
1106         if (failOnDataTypeUnsupported)
1107             return false;
1108     }
1109
1110     retcode = SQLGetInfo(hdbc, SQL_ACTIVE_CONNECTIONS, (UCHAR*) &dbInf.maxConnections, sizeof(dbInf.maxConnections), &cb);
1111     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1112     {
1113         DispAllErrors(henv, hdbc);
1114         if (failOnDataTypeUnsupported)
1115             return false;
1116     }
1117
1118     retcode = SQLGetInfo(hdbc, SQL_ACTIVE_STATEMENTS, (UCHAR*) &dbInf.maxStmts, sizeof(dbInf.maxStmts), &cb);
1119     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1120     {
1121         DispAllErrors(henv, hdbc);
1122         if (failOnDataTypeUnsupported)
1123             return false;
1124     }
1125
1126     retcode = SQLGetInfo(hdbc, SQL_DRIVER_NAME, (UCHAR*) dbInf.driverName, 40, &cb);
1127     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1128     {
1129         DispAllErrors(henv, hdbc);
1130         if (failOnDataTypeUnsupported)
1131             return false;
1132     }
1133
1134     retcode = SQLGetInfo(hdbc, SQL_DRIVER_ODBC_VER, (UCHAR*) dbInf.odbcVer, 60, &cb);
1135     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1136     {
1137         DispAllErrors(henv, hdbc);
1138         if (failOnDataTypeUnsupported)
1139             return false;
1140     }
1141
1142     retcode = SQLGetInfo(hdbc, SQL_ODBC_VER, (UCHAR*) dbInf.drvMgrOdbcVer, 60, &cb);
1143     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
1144     {
1145         DispAllErrors(henv, hdbc);
1146         if (failOnDataTypeUnsupported)
1147             return false;
1148     }
1149
1150     retcode = SQLGetInfo(hdbc, SQL_DRIVER_VER, (UCHAR*) dbInf.driverVer, 60, &cb);
1151     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1152     {
1153         DispAllErrors(henv, hdbc);
1154         if (failOnDataTypeUnsupported)
1155             return false;
1156     }
1157
1158     retcode = SQLGetInfo(hdbc, SQL_ODBC_API_CONFORMANCE, (UCHAR*) &dbInf.apiConfLvl, sizeof(dbInf.apiConfLvl), &cb);
1159     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1160     {
1161         DispAllErrors(henv, hdbc);
1162         if (failOnDataTypeUnsupported)
1163             return false;
1164     }
1165
1166     retcode = SQLGetInfo(hdbc, SQL_ODBC_SAG_CLI_CONFORMANCE, (UCHAR*) &dbInf.cliConfLvl, sizeof(dbInf.cliConfLvl), &cb);
1167     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1168     {
1169         // Not all drivers support this call - Nick Gorham(unixODBC)
1170         dbInf.cliConfLvl = 0;
1171         DispAllErrors(henv, hdbc);
1172         if (failOnDataTypeUnsupported)
1173             return false;
1174     }
1175
1176     retcode = SQLGetInfo(hdbc, SQL_ODBC_SQL_CONFORMANCE, (UCHAR*) &dbInf.sqlConfLvl, sizeof(dbInf.sqlConfLvl), &cb);
1177     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1178     {
1179         DispAllErrors(henv, hdbc);
1180         if (failOnDataTypeUnsupported)
1181             return false;
1182     }
1183
1184     retcode = SQLGetInfo(hdbc, SQL_OUTER_JOINS, (UCHAR*) dbInf.outerJoins, 2, &cb);
1185     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1186     {
1187         DispAllErrors(henv, hdbc);
1188         if (failOnDataTypeUnsupported)
1189             return false;
1190     }
1191
1192     retcode = SQLGetInfo(hdbc, SQL_PROCEDURES, (UCHAR*) dbInf.procedureSupport, 2, &cb);
1193     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1194     {
1195         DispAllErrors(henv, hdbc);
1196         if (failOnDataTypeUnsupported)
1197             return false;
1198     }
1199
1200     retcode = SQLGetInfo(hdbc, SQL_ACCESSIBLE_TABLES, (UCHAR*) dbInf.accessibleTables, 2, &cb);
1201     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1202     {
1203         DispAllErrors(henv, hdbc);
1204         if (failOnDataTypeUnsupported)
1205             return false;
1206     }
1207
1208     retcode = SQLGetInfo(hdbc, SQL_CURSOR_COMMIT_BEHAVIOR, (UCHAR*) &dbInf.cursorCommitBehavior, sizeof(dbInf.cursorCommitBehavior), &cb);
1209     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1210     {
1211         DispAllErrors(henv, hdbc);
1212         if (failOnDataTypeUnsupported)
1213             return false;
1214     }
1215
1216     retcode = SQLGetInfo(hdbc, SQL_CURSOR_ROLLBACK_BEHAVIOR, (UCHAR*) &dbInf.cursorRollbackBehavior, sizeof(dbInf.cursorRollbackBehavior), &cb);
1217     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1218     {
1219         DispAllErrors(henv, hdbc);
1220         if (failOnDataTypeUnsupported)
1221             return false;
1222     }
1223
1224     retcode = SQLGetInfo(hdbc, SQL_NON_NULLABLE_COLUMNS, (UCHAR*) &dbInf.supportNotNullClause, sizeof(dbInf.supportNotNullClause), &cb);
1225     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1226     {
1227         DispAllErrors(henv, hdbc);
1228         if (failOnDataTypeUnsupported)
1229             return false;
1230     }
1231
1232     retcode = SQLGetInfo(hdbc, SQL_ODBC_SQL_OPT_IEF, (UCHAR*) dbInf.supportIEF, 2, &cb);
1233     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1234     {
1235         DispAllErrors(henv, hdbc);
1236         if (failOnDataTypeUnsupported)
1237             return false;
1238     }
1239
1240     retcode = SQLGetInfo(hdbc, SQL_DEFAULT_TXN_ISOLATION, (UCHAR*) &dbInf.txnIsolation, sizeof(dbInf.txnIsolation), &cb);
1241     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1242     {
1243         DispAllErrors(henv, hdbc);
1244         if (failOnDataTypeUnsupported)
1245             return false;
1246     }
1247
1248     retcode = SQLGetInfo(hdbc, SQL_TXN_ISOLATION_OPTION, (UCHAR*) &dbInf.txnIsolationOptions, sizeof(dbInf.txnIsolationOptions), &cb);
1249     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1250     {
1251         DispAllErrors(henv, hdbc);
1252         if (failOnDataTypeUnsupported)
1253             return false;
1254     }
1255
1256     retcode = SQLGetInfo(hdbc, SQL_FETCH_DIRECTION, (UCHAR*) &dbInf.fetchDirections, sizeof(dbInf.fetchDirections), &cb);
1257     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1258     {
1259         DispAllErrors(henv, hdbc);
1260         if (failOnDataTypeUnsupported)
1261             return false;
1262     }
1263
1264     retcode = SQLGetInfo(hdbc, SQL_LOCK_TYPES, (UCHAR*) &dbInf.lockTypes, sizeof(dbInf.lockTypes), &cb);
1265     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1266     {
1267         DispAllErrors(henv, hdbc);
1268         if (failOnDataTypeUnsupported)
1269             return false;
1270     }
1271
1272     retcode = SQLGetInfo(hdbc, SQL_POS_OPERATIONS, (UCHAR*) &dbInf.posOperations, sizeof(dbInf.posOperations), &cb);
1273     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1274     {
1275         DispAllErrors(henv, hdbc);
1276         if (failOnDataTypeUnsupported)
1277             return false;
1278     }
1279
1280     retcode = SQLGetInfo(hdbc, SQL_POSITIONED_STATEMENTS, (UCHAR*) &dbInf.posStmts, sizeof(dbInf.posStmts), &cb);
1281     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1282     {
1283         DispAllErrors(henv, hdbc);
1284         if (failOnDataTypeUnsupported)
1285             return false;
1286     }
1287
1288     retcode = SQLGetInfo(hdbc, SQL_SCROLL_CONCURRENCY, (UCHAR*) &dbInf.scrollConcurrency, sizeof(dbInf.scrollConcurrency), &cb);
1289     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1290     {
1291         DispAllErrors(henv, hdbc);
1292         if (failOnDataTypeUnsupported)
1293             return false;
1294     }
1295
1296     retcode = SQLGetInfo(hdbc, SQL_SCROLL_OPTIONS, (UCHAR*) &dbInf.scrollOptions, sizeof(dbInf.scrollOptions), &cb);
1297     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1298     {
1299         DispAllErrors(henv, hdbc);
1300         if (failOnDataTypeUnsupported)
1301             return false;
1302     }
1303
1304     retcode = SQLGetInfo(hdbc, SQL_STATIC_SENSITIVITY, (UCHAR*) &dbInf.staticSensitivity, sizeof(dbInf.staticSensitivity), &cb);
1305     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1306     {
1307         DispAllErrors(henv, hdbc);
1308         if (failOnDataTypeUnsupported)
1309             return false;
1310     }
1311
1312     retcode = SQLGetInfo(hdbc, SQL_TXN_CAPABLE, (UCHAR*) &dbInf.txnCapable, sizeof(dbInf.txnCapable), &cb);
1313     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1314     {
1315         DispAllErrors(henv, hdbc);
1316         if (failOnDataTypeUnsupported)
1317             return false;
1318     }
1319
1320     retcode = SQLGetInfo(hdbc, SQL_LOGIN_TIMEOUT, (UCHAR*) &dbInf.loginTimeout, sizeof(dbInf.loginTimeout), &cb);
1321     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO )
1322     {
1323         DispAllErrors(henv, hdbc);
1324         if (failOnDataTypeUnsupported)
1325             return false;
1326     }
1327
1328 #ifdef DBDEBUG_CONSOLE
1329     cout << wxT("***** DATA SOURCE INFORMATION *****") << endl;
1330     cout << wxT(wxT("SERVER Name: ") << dbInf.serverName << endl;
1331     cout << wxT("DBMS Name: ") << dbInf.dbmsName << wxT("; DBMS Version: ") << dbInf.dbmsVer << endl;
1332     cout << wxT("ODBC Version: ") << dbInf.odbcVer << wxT("; Driver Version: ") << dbInf.driverVer << endl;
1333
1334     cout << wxT("API Conf. Level: ");
1335     switch(dbInf.apiConfLvl)
1336     {
1337         case SQL_OAC_NONE:      cout << wxT("None");       break;
1338         case SQL_OAC_LEVEL1:    cout << wxT("Level 1");    break;
1339         case SQL_OAC_LEVEL2:    cout << wxT("Level 2");    break;
1340     }
1341     cout << endl;
1342
1343     cout << wxT("SAG CLI Conf. Level: ");
1344     switch(dbInf.cliConfLvl)
1345     {
1346         case SQL_OSCC_NOT_COMPLIANT:    cout << wxT("Not Compliant");    break;
1347         case SQL_OSCC_COMPLIANT:        cout << wxT("Compliant");        break;
1348     }
1349     cout << endl;
1350
1351     cout << wxT("SQL Conf. Level: ");
1352     switch(dbInf.sqlConfLvl)
1353     {
1354         case SQL_OSC_MINIMUM:     cout << wxT("Minimum Grammar");     break;
1355         case SQL_OSC_CORE:        cout << wxT("Core Grammar");        break;
1356         case SQL_OSC_EXTENDED:    cout << wxT("Extended Grammar");    break;
1357     }
1358     cout << endl;
1359
1360     cout << wxT("Max. Connections: ")       << dbInf.maxConnections   << endl;
1361     cout << wxT("Outer Joins: ")            << dbInf.outerJoins       << endl;
1362     cout << wxT("Support for Procedures: ") << dbInf.procedureSupport << endl;
1363     cout << wxT("All tables accessible : ") << dbInf.accessibleTables << endl;
1364     cout << wxT("Cursor COMMIT Behavior: ");
1365     switch(dbInf.cursorCommitBehavior)
1366     {
1367         case SQL_CB_DELETE:        cout << wxT("Delete cursors");      break;
1368         case SQL_CB_CLOSE:         cout << wxT("Close cursors");       break;
1369         case SQL_CB_PRESERVE:      cout << wxT("Preserve cursors");    break;
1370     }
1371     cout << endl;
1372
1373     cout << wxT("Cursor ROLLBACK Behavior: ");
1374     switch(dbInf.cursorRollbackBehavior)
1375     {
1376         case SQL_CB_DELETE:      cout << wxT("Delete cursors");      break;
1377         case SQL_CB_CLOSE:       cout << wxT("Close cursors");       break;
1378         case SQL_CB_PRESERVE:    cout << wxT("Preserve cursors");    break;
1379     }
1380     cout << endl;
1381
1382     cout << wxT("Support NOT NULL clause: ");
1383     switch(dbInf.supportNotNullClause)
1384     {
1385         case SQL_NNC_NULL:        cout << wxT("No");        break;
1386         case SQL_NNC_NON_NULL:    cout << wxT("Yes");       break;
1387     }
1388     cout << endl;
1389
1390     cout << wxT("Support IEF (Ref. Integrity): ") << dbInf.supportIEF   << endl;
1391     cout << wxT("Login Timeout: ")                << dbInf.loginTimeout << endl;
1392
1393     cout << endl << endl << wxT("more ...") << endl;
1394     getchar();
1395
1396     cout << wxT("Default Transaction Isolation: ";
1397     switch(dbInf.txnIsolation)
1398     {
1399         case SQL_TXN_READ_UNCOMMITTED:  cout << wxT("Read Uncommitted");    break;
1400         case SQL_TXN_READ_COMMITTED:    cout << wxT("Read Committed");      break;
1401         case SQL_TXN_REPEATABLE_READ:   cout << wxT("Repeatable Read");     break;
1402         case SQL_TXN_SERIALIZABLE:      cout << wxT("Serializable");        break;
1403 #ifdef ODBC_V20
1404         case SQL_TXN_VERSIONING:        cout << wxT("Versioning");          break;
1405 #endif
1406     }
1407     cout << endl;
1408
1409     cout << wxT("Transaction Isolation Options: ");
1410     if (dbInf.txnIsolationOptions & SQL_TXN_READ_UNCOMMITTED)
1411         cout << wxT("Read Uncommitted, ");
1412     if (dbInf.txnIsolationOptions & SQL_TXN_READ_COMMITTED)
1413         cout << wxT("Read Committed, ");
1414     if (dbInf.txnIsolationOptions & SQL_TXN_REPEATABLE_READ)
1415         cout << wxT("Repeatable Read, ");
1416     if (dbInf.txnIsolationOptions & SQL_TXN_SERIALIZABLE)
1417         cout << wxT("Serializable, ");
1418 #ifdef ODBC_V20
1419     if (dbInf.txnIsolationOptions & SQL_TXN_VERSIONING)
1420         cout << wxT("Versioning");
1421 #endif
1422     cout << endl;
1423
1424     cout << wxT("Fetch Directions Supported:") << endl << wxT("   ");
1425     if (dbInf.fetchDirections & SQL_FD_FETCH_NEXT)
1426         cout << wxT("Next, ");
1427     if (dbInf.fetchDirections & SQL_FD_FETCH_PRIOR)
1428         cout << wxT("Prev, ");
1429     if (dbInf.fetchDirections & SQL_FD_FETCH_FIRST)
1430         cout << wxT("First, ");
1431     if (dbInf.fetchDirections & SQL_FD_FETCH_LAST)
1432         cout << wxT("Last, ");
1433     if (dbInf.fetchDirections & SQL_FD_FETCH_ABSOLUTE)
1434         cout << wxT("Absolute, ");
1435     if (dbInf.fetchDirections & SQL_FD_FETCH_RELATIVE)
1436         cout << wxT("Relative, ");
1437 #ifdef ODBC_V20
1438     if (dbInf.fetchDirections & SQL_FD_FETCH_RESUME)
1439         cout << wxT("Resume, ");
1440 #endif
1441     if (dbInf.fetchDirections & SQL_FD_FETCH_BOOKMARK)
1442         cout << wxT("Bookmark");
1443     cout << endl;
1444
1445     cout << wxT("Lock Types Supported (SQLSetPos): ");
1446     if (dbInf.lockTypes & SQL_LCK_NO_CHANGE)
1447         cout << wxT("No Change, ");
1448     if (dbInf.lockTypes & SQL_LCK_EXCLUSIVE)
1449         cout << wxT("Exclusive, ");
1450     if (dbInf.lockTypes & SQL_LCK_UNLOCK)
1451         cout << wxT("UnLock");
1452     cout << endl;
1453
1454     cout << wxT("Position Operations Supported (SQLSetPos): ");
1455     if (dbInf.posOperations & SQL_POS_POSITION)
1456         cout << wxT("Position, ");
1457     if (dbInf.posOperations & SQL_POS_REFRESH)
1458         cout << wxT("Refresh, ");
1459     if (dbInf.posOperations & SQL_POS_UPDATE)
1460         cout << wxT("Upd, "));
1461     if (dbInf.posOperations & SQL_POS_DELETE)
1462         cout << wxT("Del, ");
1463     if (dbInf.posOperations & SQL_POS_ADD)
1464         cout << wxT("Add");
1465     cout << endl;
1466
1467     cout << wxT("Positioned Statements Supported: ");
1468     if (dbInf.posStmts & SQL_PS_POSITIONED_DELETE)
1469         cout << wxT("Pos delete, ");
1470     if (dbInf.posStmts & SQL_PS_POSITIONED_UPDATE)
1471         cout << wxT("Pos update, ");
1472     if (dbInf.posStmts & SQL_PS_SELECT_FOR_UPDATE)
1473         cout << wxT("Select for update");
1474     cout << endl;
1475
1476     cout << wxT("Scroll Concurrency: ");
1477     if (dbInf.scrollConcurrency & SQL_SCCO_READ_ONLY)
1478         cout << wxT("Read Only, ");
1479     if (dbInf.scrollConcurrency & SQL_SCCO_LOCK)
1480         cout << wxT("Lock, ");
1481     if (dbInf.scrollConcurrency & SQL_SCCO_OPT_ROWVER)
1482         cout << wxT("Opt. Rowver, ");
1483     if (dbInf.scrollConcurrency & SQL_SCCO_OPT_VALUES)
1484         cout << wxT("Opt. Values");
1485     cout << endl;
1486
1487     cout << wxT("Scroll Options: ");
1488     if (dbInf.scrollOptions & SQL_SO_FORWARD_ONLY)
1489         cout << wxT("Fwd Only, ");
1490     if (dbInf.scrollOptions & SQL_SO_STATIC)
1491         cout << wxT("Static, ");
1492     if (dbInf.scrollOptions & SQL_SO_KEYSET_DRIVEN)
1493         cout << wxT("Keyset Driven, ");
1494     if (dbInf.scrollOptions & SQL_SO_DYNAMIC)
1495         cout << wxT("Dynamic, ");
1496     if (dbInf.scrollOptions & SQL_SO_MIXED)
1497         cout << wxT("Mixed");
1498     cout << endl;
1499
1500     cout << wxT("Static Sensitivity: ");
1501     if (dbInf.staticSensitivity & SQL_SS_ADDITIONS)
1502         cout << wxT("Additions, ");
1503     if (dbInf.staticSensitivity & SQL_SS_DELETIONS)
1504         cout << wxT("Deletions, ");
1505     if (dbInf.staticSensitivity & SQL_SS_UPDATES)
1506         cout << wxT("Updates");
1507     cout << endl;
1508
1509     cout << wxT("Transaction Capable?: ");
1510     switch(dbInf.txnCapable)
1511     {
1512         case SQL_TC_NONE:          cout << wxT("No");            break;
1513         case SQL_TC_DML:           cout << wxT("DML Only");      break;
1514         case SQL_TC_DDL_COMMIT:    cout << wxT("DDL Commit");    break;
1515         case SQL_TC_DDL_IGNORE:    cout << wxT("DDL Ignore");    break;
1516         case SQL_TC_ALL:           cout << wxT("DDL & DML");     break;
1517     }
1518     cout << endl;
1519
1520     cout << endl;
1521 #endif
1522
1523     // Completed Successfully
1524     return true;
1525
1526 } // wxDb::getDbInfo()
1527
1528
1529 /********** wxDb::getDataTypeInfo() **********/
1530 bool wxDb::getDataTypeInfo(SWORD fSqlType, wxDbSqlTypeInfo &structSQLTypeInfo)
1531 {
1532 /*
1533  * fSqlType will be something like SQL_VARCHAR.  This parameter determines
1534  * the data type inf. is gathered for.
1535  *
1536  * wxDbSqlTypeInfo is a structure that is filled in with data type information,
1537  */
1538     RETCODE retcode;
1539     SDWORD  cbRet;
1540
1541     // Get information about the data type specified
1542     if (SQLGetTypeInfo(hstmt, fSqlType) != SQL_SUCCESS)
1543         return(DispAllErrors(henv, hdbc, hstmt));
1544
1545     // Fetch the record
1546     retcode = SQLFetch(hstmt);
1547     if (retcode != SQL_SUCCESS)
1548     {
1549 #ifdef DBDEBUG_CONSOLE
1550         if (retcode == SQL_NO_DATA_FOUND)
1551             cout << wxT("SQL_NO_DATA_FOUND fetching inf. about data type.") << endl;
1552 #endif
1553         DispAllErrors(henv, hdbc, hstmt);
1554         SQLFreeStmt(hstmt, SQL_CLOSE);
1555         return false;
1556     }
1557
1558     wxChar typeName[DB_TYPE_NAME_LEN+1];
1559
1560     // Obtain columns from the record
1561     if (SQLGetData(hstmt, 1, SQL_C_CHAR, (UCHAR*) typeName, DB_TYPE_NAME_LEN, &cbRet) != SQL_SUCCESS)
1562         return(DispAllErrors(henv, hdbc, hstmt));
1563
1564     structSQLTypeInfo.TypeName = typeName;
1565
1566     // BJO 20000503: no more needed with new GetColumns...
1567 #if  OLD_GETCOLUMNS
1568     // BJO 991209
1569     if (Dbms() == dbmsMY_SQL)
1570     {
1571         if (structSQLTypeInfo.TypeName == wxT("middleint"))
1572             structSQLTypeInfo.TypeName = wxT("mediumint");
1573         else if (structSQLTypeInfo.TypeName == wxT("middleint unsigned"))
1574             structSQLTypeInfo.TypeName = wxT("mediumint unsigned");
1575         else if (structSQLTypeInfo.TypeName == wxT("integer"))
1576             structSQLTypeInfo.TypeName = wxT("int");
1577         else if (structSQLTypeInfo.TypeName == wxT("integer unsigned"))
1578             structSQLTypeInfo.TypeName = wxT("int unsigned");
1579         else if (structSQLTypeInfo.TypeName == wxT("middleint"))
1580             structSQLTypeInfo.TypeName = wxT("mediumint");
1581         else if (structSQLTypeInfo.TypeName == wxT("varchar"))
1582             structSQLTypeInfo.TypeName = wxT("char");
1583     }
1584
1585     // BJO 20000427 : OpenLink driver
1586     if (!wxStrncmp(dbInf.driverName, wxT("oplodbc"), 7) ||
1587         !wxStrncmp(dbInf.driverName, wxT("OLOD"), 4))
1588     {
1589         if (structSQLTypeInfo.TypeName == wxT("double precision"))
1590             structSQLTypeInfo.TypeName = wxT("real");
1591     }
1592 #endif
1593
1594     if (SQLGetData(hstmt, 3, SQL_C_LONG, (UCHAR*) &structSQLTypeInfo.Precision, 0, &cbRet) != SQL_SUCCESS)
1595         return(DispAllErrors(henv, hdbc, hstmt));
1596     if (SQLGetData(hstmt, 8, SQL_C_SHORT, (UCHAR*) &structSQLTypeInfo.CaseSensitive, 0, &cbRet) != SQL_SUCCESS)
1597         return(DispAllErrors(henv, hdbc, hstmt));
1598 //    if (SQLGetData(hstmt, 14, SQL_C_SHORT, (UCHAR*) &structSQLTypeInfo.MinimumScale, 0, &cbRet) != SQL_SUCCESS)
1599 //        return(DispAllErrors(henv, hdbc, hstmt));
1600
1601     if (SQLGetData(hstmt, 15, SQL_C_SHORT,(UCHAR*)  &structSQLTypeInfo.MaximumScale, 0, &cbRet) != SQL_SUCCESS)
1602         return(DispAllErrors(henv, hdbc, hstmt));
1603
1604     if (structSQLTypeInfo.MaximumScale < 0)
1605         structSQLTypeInfo.MaximumScale = 0;
1606
1607     // Close the statement handle which closes open cursors
1608     if (SQLFreeStmt(hstmt, SQL_CLOSE) != SQL_SUCCESS)
1609         return(DispAllErrors(henv, hdbc, hstmt));
1610
1611     // Completed Successfully
1612     return true;
1613
1614 } // wxDb::getDataTypeInfo()
1615
1616
1617 /********** wxDb::Close() **********/
1618 void wxDb::Close(void)
1619 {
1620     // Close the Sql Log file
1621     if (fpSqlLog)
1622     {
1623         fclose(fpSqlLog);
1624         fpSqlLog = 0;
1625     }
1626
1627     // Free statement handle
1628     if (dbIsOpen)
1629     {
1630         if (SQLFreeStmt(hstmt, SQL_DROP) != SQL_SUCCESS)
1631             DispAllErrors(henv, hdbc);
1632     }
1633
1634     // Disconnect from the datasource
1635     if (SQLDisconnect(hdbc) != SQL_SUCCESS)
1636         DispAllErrors(henv, hdbc);
1637
1638     // Free the connection to the datasource
1639     if (SQLFreeConnect(hdbc) != SQL_SUCCESS)
1640         DispAllErrors(henv, hdbc);
1641
1642     // There should be zero Ctable objects still connected to this db object
1643     wxASSERT(nTables == 0);
1644
1645 #ifdef __WXDEBUG__
1646     wxTablesInUse *tiu;
1647     wxList::compatibility_iterator pNode;
1648     pNode = TablesInUse.GetFirst();
1649     wxString s,s2;
1650     while (pNode)
1651     {
1652         tiu = (wxTablesInUse *)pNode->GetData();
1653         if (tiu->pDb == this)
1654         {
1655             s.Printf(wxT("(%-20s)     tableID:[%6lu]     pDb:[%p]"), tiu->tableName,tiu->tableID,tiu->pDb);
1656             s2.Printf(wxT("Orphaned table found using pDb:[%p]"),this);
1657             wxLogDebug(s.c_str(),s2.c_str());
1658         }
1659         pNode = pNode->GetNext();
1660     }
1661 #endif
1662
1663     // Copy the error messages to a global variable
1664     int i;
1665     for (i = 0; i < DB_MAX_ERROR_HISTORY; i++)
1666         wxStrcpy(DBerrorList[i], errorList[i]);
1667
1668     dbmsType = dbmsUNIDENTIFIED;
1669     dbIsOpen = false;
1670
1671 } // wxDb::Close()
1672
1673
1674 /********** wxDb::CommitTrans() **********/
1675 bool wxDb::CommitTrans(void)
1676 {
1677     if (this)
1678     {
1679         // Commit the transaction
1680         if (SQLTransact(henv, hdbc, SQL_COMMIT) != SQL_SUCCESS)
1681             return(DispAllErrors(henv, hdbc));
1682     }
1683
1684     // Completed successfully
1685     return true;
1686
1687 } // wxDb::CommitTrans()
1688
1689
1690 /********** wxDb::RollbackTrans() **********/
1691 bool wxDb::RollbackTrans(void)
1692 {
1693     // Rollback the transaction
1694     if (SQLTransact(henv, hdbc, SQL_ROLLBACK) != SQL_SUCCESS)
1695         return(DispAllErrors(henv, hdbc));
1696
1697     // Completed successfully
1698     return true;
1699
1700 } // wxDb::RollbackTrans()
1701
1702
1703 /********** wxDb::DispAllErrors() **********/
1704 bool wxDb::DispAllErrors(HENV aHenv, HDBC aHdbc, HSTMT aHstmt)
1705 /*
1706  * This function is called internally whenever an error condition prevents the user's
1707  * request from being executed.  This function will query the datasource as to the
1708  * actual error(s) that just occured on the previous request of the datasource.
1709  *
1710  * The function will retrieve each error condition from the datasource and
1711  * Printf the codes/text values into a string which it then logs via logError().
1712  * If in DBDEBUG_CONSOLE mode, the constructed string will be displayed in the console
1713  * window and program execution will be paused until the user presses a key.
1714  *
1715  * This function always returns a false, so that functions which call this function
1716  * can have a line like "return (DispAllErrors(henv, hdbc));" to indicate the failure
1717  * of the users request, so that the calling code can then process the error msg log
1718  */
1719 {
1720     wxString odbcErrMsg;
1721
1722 #ifdef __VMS
1723    while (SQLError(aHenv, aHdbc, aHstmt, (SQLTCHAR FAR *) sqlState, (SQLINTEGER *) &nativeError, (SQLTCHAR FAR *) errorMsg, SQL_MAX_MESSAGE_LENGTH - 1, &cbErrorMsg) == SQL_SUCCESS)
1724 #else
1725    while (SQLError(aHenv, aHdbc, aHstmt, (SQLTCHAR FAR *) sqlState, (long*) &nativeError, (SQLTCHAR FAR *) errorMsg, SQL_MAX_MESSAGE_LENGTH - 1, &cbErrorMsg) == SQL_SUCCESS)
1726 #endif
1727      {
1728         odbcErrMsg.Printf(wxT("SQL State = %s\nNative Error Code = %li\nError Message = %s\n"), sqlState, nativeError, errorMsg);
1729         logError(odbcErrMsg, sqlState);
1730         if (!silent)
1731         {
1732 #ifdef DBDEBUG_CONSOLE
1733             // When run in console mode, use standard out to display errors.
1734             cout << odbcErrMsg.c_str() << endl;
1735             cout << wxT("Press any key to continue...") << endl;
1736             getchar();
1737 #endif
1738
1739 #ifdef __WXDEBUG__
1740             wxLogDebug(odbcErrMsg,wxT("ODBC DEBUG MESSAGE from DispAllErrors()"));
1741 #endif
1742         }
1743     }
1744
1745     return false;  // This function always returns false.
1746
1747 } // wxDb::DispAllErrors()
1748
1749
1750 /********** wxDb::GetNextError() **********/
1751 bool wxDb::GetNextError(HENV aHenv, HDBC aHdbc, HSTMT aHstmt)
1752 {
1753 #ifdef __VMS
1754    if (SQLError(aHenv, aHdbc, aHstmt, (SQLTCHAR FAR *) sqlState, (SQLINTEGER *) &nativeError, (SQLTCHAR FAR *) errorMsg, SQL_MAX_MESSAGE_LENGTH - 1, &cbErrorMsg) == SQL_SUCCESS)
1755 #else
1756    if (SQLError(aHenv, aHdbc, aHstmt, (SQLTCHAR FAR *) sqlState, (long*) &nativeError, (SQLTCHAR FAR *) errorMsg, SQL_MAX_MESSAGE_LENGTH - 1, &cbErrorMsg) == SQL_SUCCESS)
1757 #endif
1758      return true;
1759     else
1760         return false;
1761
1762 } // wxDb::GetNextError()
1763
1764
1765 /********** wxDb::DispNextError() **********/
1766 void wxDb::DispNextError(void)
1767 {
1768     wxString odbcErrMsg;
1769
1770     odbcErrMsg.Printf(wxT("SQL State = %s\nNative Error Code = %li\nError Message = %s\n"), sqlState, nativeError, errorMsg);
1771     logError(odbcErrMsg, sqlState);
1772
1773     if (silent)
1774         return;
1775
1776 #ifdef DBDEBUG_CONSOLE
1777     // When run in console mode, use standard out to display errors.
1778     cout << odbcErrMsg.c_str() << endl;
1779     cout << wxT("Press any key to continue...")  << endl;
1780     getchar();
1781 #endif
1782
1783 #ifdef __WXDEBUG__
1784     wxLogDebug(odbcErrMsg,wxT("ODBC DEBUG MESSAGE"));
1785 #endif  // __WXDEBUG__
1786
1787 } // wxDb::DispNextError()
1788
1789
1790 /********** wxDb::logError() **********/
1791 void wxDb::logError(const wxString &errMsg, const wxString &SQLState)
1792 {
1793     wxASSERT(errMsg.Length());
1794
1795     static int pLast = -1;
1796     int dbStatus;
1797
1798     if (++pLast == DB_MAX_ERROR_HISTORY)
1799     {
1800         int i;
1801         for (i = 0; i < DB_MAX_ERROR_HISTORY; i++)
1802             wxStrcpy(errorList[i], errorList[i+1]);
1803         pLast--;
1804     }
1805
1806     wxStrcpy(errorList[pLast], errMsg);
1807
1808     if (SQLState.Length())
1809         if ((dbStatus = TranslateSqlState(SQLState)) != DB_ERR_FUNCTION_SEQUENCE_ERROR)
1810             DB_STATUS = dbStatus;
1811
1812     // Add the errmsg to the sql log
1813     WriteSqlLog(errMsg);
1814
1815 }  // wxDb::logError()
1816
1817
1818 /**********wxDb::TranslateSqlState()  **********/
1819 int wxDb::TranslateSqlState(const wxString &SQLState)
1820 {
1821     if (!wxStrcmp(SQLState, wxT("01000")))
1822         return(DB_ERR_GENERAL_WARNING);
1823     if (!wxStrcmp(SQLState, wxT("01002")))
1824         return(DB_ERR_DISCONNECT_ERROR);
1825     if (!wxStrcmp(SQLState, wxT("01004")))
1826         return(DB_ERR_DATA_TRUNCATED);
1827     if (!wxStrcmp(SQLState, wxT("01006")))
1828         return(DB_ERR_PRIV_NOT_REVOKED);
1829     if (!wxStrcmp(SQLState, wxT("01S00")))
1830         return(DB_ERR_INVALID_CONN_STR_ATTR);
1831     if (!wxStrcmp(SQLState, wxT("01S01")))
1832         return(DB_ERR_ERROR_IN_ROW);
1833     if (!wxStrcmp(SQLState, wxT("01S02")))
1834         return(DB_ERR_OPTION_VALUE_CHANGED);
1835     if (!wxStrcmp(SQLState, wxT("01S03")))
1836         return(DB_ERR_NO_ROWS_UPD_OR_DEL);
1837     if (!wxStrcmp(SQLState, wxT("01S04")))
1838         return(DB_ERR_MULTI_ROWS_UPD_OR_DEL);
1839     if (!wxStrcmp(SQLState, wxT("07001")))
1840         return(DB_ERR_WRONG_NO_OF_PARAMS);
1841     if (!wxStrcmp(SQLState, wxT("07006")))
1842         return(DB_ERR_DATA_TYPE_ATTR_VIOL);
1843     if (!wxStrcmp(SQLState, wxT("08001")))
1844         return(DB_ERR_UNABLE_TO_CONNECT);
1845     if (!wxStrcmp(SQLState, wxT("08002")))
1846         return(DB_ERR_CONNECTION_IN_USE);
1847     if (!wxStrcmp(SQLState, wxT("08003")))
1848         return(DB_ERR_CONNECTION_NOT_OPEN);
1849     if (!wxStrcmp(SQLState, wxT("08004")))
1850         return(DB_ERR_REJECTED_CONNECTION);
1851     if (!wxStrcmp(SQLState, wxT("08007")))
1852         return(DB_ERR_CONN_FAIL_IN_TRANS);
1853     if (!wxStrcmp(SQLState, wxT("08S01")))
1854         return(DB_ERR_COMM_LINK_FAILURE);
1855     if (!wxStrcmp(SQLState, wxT("21S01")))
1856         return(DB_ERR_INSERT_VALUE_LIST_MISMATCH);
1857     if (!wxStrcmp(SQLState, wxT("21S02")))
1858         return(DB_ERR_DERIVED_TABLE_MISMATCH);
1859     if (!wxStrcmp(SQLState, wxT("22001")))
1860         return(DB_ERR_STRING_RIGHT_TRUNC);
1861     if (!wxStrcmp(SQLState, wxT("22003")))
1862         return(DB_ERR_NUMERIC_VALUE_OUT_OF_RNG);
1863     if (!wxStrcmp(SQLState, wxT("22005")))
1864         return(DB_ERR_ERROR_IN_ASSIGNMENT);
1865     if (!wxStrcmp(SQLState, wxT("22008")))
1866         return(DB_ERR_DATETIME_FLD_OVERFLOW);
1867     if (!wxStrcmp(SQLState, wxT("22012")))
1868         return(DB_ERR_DIVIDE_BY_ZERO);
1869     if (!wxStrcmp(SQLState, wxT("22026")))
1870         return(DB_ERR_STR_DATA_LENGTH_MISMATCH);
1871     if (!wxStrcmp(SQLState, wxT("23000")))
1872         return(DB_ERR_INTEGRITY_CONSTRAINT_VIOL);
1873     if (!wxStrcmp(SQLState, wxT("24000")))
1874         return(DB_ERR_INVALID_CURSOR_STATE);
1875     if (!wxStrcmp(SQLState, wxT("25000")))
1876         return(DB_ERR_INVALID_TRANS_STATE);
1877     if (!wxStrcmp(SQLState, wxT("28000")))
1878         return(DB_ERR_INVALID_AUTH_SPEC);
1879     if (!wxStrcmp(SQLState, wxT("34000")))
1880         return(DB_ERR_INVALID_CURSOR_NAME);
1881     if (!wxStrcmp(SQLState, wxT("37000")))
1882         return(DB_ERR_SYNTAX_ERROR_OR_ACCESS_VIOL);
1883     if (!wxStrcmp(SQLState, wxT("3C000")))
1884         return(DB_ERR_DUPLICATE_CURSOR_NAME);
1885     if (!wxStrcmp(SQLState, wxT("40001")))
1886         return(DB_ERR_SERIALIZATION_FAILURE);
1887     if (!wxStrcmp(SQLState, wxT("42000")))
1888         return(DB_ERR_SYNTAX_ERROR_OR_ACCESS_VIOL2);
1889     if (!wxStrcmp(SQLState, wxT("70100")))
1890         return(DB_ERR_OPERATION_ABORTED);
1891     if (!wxStrcmp(SQLState, wxT("IM001")))
1892         return(DB_ERR_UNSUPPORTED_FUNCTION);
1893     if (!wxStrcmp(SQLState, wxT("IM002")))
1894         return(DB_ERR_NO_DATA_SOURCE);
1895     if (!wxStrcmp(SQLState, wxT("IM003")))
1896         return(DB_ERR_DRIVER_LOAD_ERROR);
1897     if (!wxStrcmp(SQLState, wxT("IM004")))
1898         return(DB_ERR_SQLALLOCENV_FAILED);
1899     if (!wxStrcmp(SQLState, wxT("IM005")))
1900         return(DB_ERR_SQLALLOCCONNECT_FAILED);
1901     if (!wxStrcmp(SQLState, wxT("IM006")))
1902         return(DB_ERR_SQLSETCONNECTOPTION_FAILED);
1903     if (!wxStrcmp(SQLState, wxT("IM007")))
1904         return(DB_ERR_NO_DATA_SOURCE_DLG_PROHIB);
1905     if (!wxStrcmp(SQLState, wxT("IM008")))
1906         return(DB_ERR_DIALOG_FAILED);
1907     if (!wxStrcmp(SQLState, wxT("IM009")))
1908         return(DB_ERR_UNABLE_TO_LOAD_TRANSLATION_DLL);
1909     if (!wxStrcmp(SQLState, wxT("IM010")))
1910         return(DB_ERR_DATA_SOURCE_NAME_TOO_LONG);
1911     if (!wxStrcmp(SQLState, wxT("IM011")))
1912         return(DB_ERR_DRIVER_NAME_TOO_LONG);
1913     if (!wxStrcmp(SQLState, wxT("IM012")))
1914         return(DB_ERR_DRIVER_KEYWORD_SYNTAX_ERROR);
1915     if (!wxStrcmp(SQLState, wxT("IM013")))
1916         return(DB_ERR_TRACE_FILE_ERROR);
1917     if (!wxStrcmp(SQLState, wxT("S0001")))
1918         return(DB_ERR_TABLE_OR_VIEW_ALREADY_EXISTS);
1919     if (!wxStrcmp(SQLState, wxT("S0002")))
1920         return(DB_ERR_TABLE_NOT_FOUND);
1921     if (!wxStrcmp(SQLState, wxT("S0011")))
1922         return(DB_ERR_INDEX_ALREADY_EXISTS);
1923     if (!wxStrcmp(SQLState, wxT("S0012")))
1924         return(DB_ERR_INDEX_NOT_FOUND);
1925     if (!wxStrcmp(SQLState, wxT("S0021")))
1926         return(DB_ERR_COLUMN_ALREADY_EXISTS);
1927     if (!wxStrcmp(SQLState, wxT("S0022")))
1928         return(DB_ERR_COLUMN_NOT_FOUND);
1929     if (!wxStrcmp(SQLState, wxT("S0023")))
1930         return(DB_ERR_NO_DEFAULT_FOR_COLUMN);
1931     if (!wxStrcmp(SQLState, wxT("S1000")))
1932         return(DB_ERR_GENERAL_ERROR);
1933     if (!wxStrcmp(SQLState, wxT("S1001")))
1934         return(DB_ERR_MEMORY_ALLOCATION_FAILURE);
1935     if (!wxStrcmp(SQLState, wxT("S1002")))
1936         return(DB_ERR_INVALID_COLUMN_NUMBER);
1937     if (!wxStrcmp(SQLState, wxT("S1003")))
1938         return(DB_ERR_PROGRAM_TYPE_OUT_OF_RANGE);
1939     if (!wxStrcmp(SQLState, wxT("S1004")))
1940         return(DB_ERR_SQL_DATA_TYPE_OUT_OF_RANGE);
1941     if (!wxStrcmp(SQLState, wxT("S1008")))
1942         return(DB_ERR_OPERATION_CANCELLED);
1943     if (!wxStrcmp(SQLState, wxT("S1009")))
1944         return(DB_ERR_INVALID_ARGUMENT_VALUE);
1945     if (!wxStrcmp(SQLState, wxT("S1010")))
1946         return(DB_ERR_FUNCTION_SEQUENCE_ERROR);
1947     if (!wxStrcmp(SQLState, wxT("S1011")))
1948         return(DB_ERR_OPERATION_INVALID_AT_THIS_TIME);
1949     if (!wxStrcmp(SQLState, wxT("S1012")))
1950         return(DB_ERR_INVALID_TRANS_OPERATION_CODE);
1951     if (!wxStrcmp(SQLState, wxT("S1015")))
1952         return(DB_ERR_NO_CURSOR_NAME_AVAIL);
1953     if (!wxStrcmp(SQLState, wxT("S1090")))
1954         return(DB_ERR_INVALID_STR_OR_BUF_LEN);
1955     if (!wxStrcmp(SQLState, wxT("S1091")))
1956         return(DB_ERR_DESCRIPTOR_TYPE_OUT_OF_RANGE);
1957     if (!wxStrcmp(SQLState, wxT("S1092")))
1958         return(DB_ERR_OPTION_TYPE_OUT_OF_RANGE);
1959     if (!wxStrcmp(SQLState, wxT("S1093")))
1960         return(DB_ERR_INVALID_PARAM_NO);
1961     if (!wxStrcmp(SQLState, wxT("S1094")))
1962         return(DB_ERR_INVALID_SCALE_VALUE);
1963     if (!wxStrcmp(SQLState, wxT("S1095")))
1964         return(DB_ERR_FUNCTION_TYPE_OUT_OF_RANGE);
1965     if (!wxStrcmp(SQLState, wxT("S1096")))
1966         return(DB_ERR_INF_TYPE_OUT_OF_RANGE);
1967     if (!wxStrcmp(SQLState, wxT("S1097")))
1968         return(DB_ERR_COLUMN_TYPE_OUT_OF_RANGE);
1969     if (!wxStrcmp(SQLState, wxT("S1098")))
1970         return(DB_ERR_SCOPE_TYPE_OUT_OF_RANGE);
1971     if (!wxStrcmp(SQLState, wxT("S1099")))
1972         return(DB_ERR_NULLABLE_TYPE_OUT_OF_RANGE);
1973     if (!wxStrcmp(SQLState, wxT("S1100")))
1974         return(DB_ERR_UNIQUENESS_OPTION_TYPE_OUT_OF_RANGE);
1975     if (!wxStrcmp(SQLState, wxT("S1101")))
1976         return(DB_ERR_ACCURACY_OPTION_TYPE_OUT_OF_RANGE);
1977     if (!wxStrcmp(SQLState, wxT("S1103")))
1978         return(DB_ERR_DIRECTION_OPTION_OUT_OF_RANGE);
1979     if (!wxStrcmp(SQLState, wxT("S1104")))
1980         return(DB_ERR_INVALID_PRECISION_VALUE);
1981     if (!wxStrcmp(SQLState, wxT("S1105")))
1982         return(DB_ERR_INVALID_PARAM_TYPE);
1983     if (!wxStrcmp(SQLState, wxT("S1106")))
1984         return(DB_ERR_FETCH_TYPE_OUT_OF_RANGE);
1985     if (!wxStrcmp(SQLState, wxT("S1107")))
1986         return(DB_ERR_ROW_VALUE_OUT_OF_RANGE);
1987     if (!wxStrcmp(SQLState, wxT("S1108")))
1988         return(DB_ERR_CONCURRENCY_OPTION_OUT_OF_RANGE);
1989     if (!wxStrcmp(SQLState, wxT("S1109")))
1990         return(DB_ERR_INVALID_CURSOR_POSITION);
1991     if (!wxStrcmp(SQLState, wxT("S1110")))
1992         return(DB_ERR_INVALID_DRIVER_COMPLETION);
1993     if (!wxStrcmp(SQLState, wxT("S1111")))
1994         return(DB_ERR_INVALID_BOOKMARK_VALUE);
1995     if (!wxStrcmp(SQLState, wxT("S1C00")))
1996         return(DB_ERR_DRIVER_NOT_CAPABLE);
1997     if (!wxStrcmp(SQLState, wxT("S1T00")))
1998         return(DB_ERR_TIMEOUT_EXPIRED);
1999
2000     // No match
2001     return(0);
2002
2003 }  // wxDb::TranslateSqlState()
2004
2005
2006 /**********  wxDb::Grant() **********/
2007 bool wxDb::Grant(int privileges, const wxString &tableName, const wxString &userList)
2008 {
2009     wxString sqlStmt;
2010
2011     // Build the grant statement
2012     sqlStmt  = wxT("GRANT ");
2013     if (privileges == DB_GRANT_ALL)
2014         sqlStmt += wxT("ALL");
2015     else
2016     {
2017         int c = 0;
2018         if (privileges & DB_GRANT_SELECT)
2019         {
2020             sqlStmt += wxT("SELECT");
2021             c++;
2022         }
2023         if (privileges & DB_GRANT_INSERT)
2024         {
2025             if (c++)
2026                 sqlStmt += wxT(", ");
2027             sqlStmt += wxT("INSERT");
2028         }
2029         if (privileges & DB_GRANT_UPDATE)
2030         {
2031             if (c++)
2032                 sqlStmt += wxT(", ");
2033             sqlStmt += wxT("UPDATE");
2034         }
2035         if (privileges & DB_GRANT_DELETE)
2036         {
2037             if (c++)
2038                 sqlStmt += wxT(", ");
2039             sqlStmt += wxT("DELETE");
2040         }
2041     }
2042
2043     sqlStmt += wxT(" ON ");
2044     sqlStmt += SQLTableName(tableName);
2045     sqlStmt += wxT(" TO ");
2046     sqlStmt += userList;
2047
2048 #ifdef DBDEBUG_CONSOLE
2049     cout << endl << sqlStmt.c_str() << endl;
2050 #endif
2051
2052     WriteSqlLog(sqlStmt);
2053
2054     return(ExecSql(sqlStmt));
2055
2056 }  // wxDb::Grant()
2057
2058
2059 /********** wxDb::CreateView() **********/
2060 bool wxDb::CreateView(const wxString &viewName, const wxString &colList,
2061                       const wxString &pSqlStmt, bool attemptDrop)
2062 {
2063     wxString sqlStmt;
2064
2065     // Drop the view first
2066     if (attemptDrop && !DropView(viewName))
2067         return false;
2068
2069     // Build the create view statement
2070     sqlStmt  = wxT("CREATE VIEW ");
2071     sqlStmt += viewName;
2072
2073     if (colList.Length())
2074     {
2075         sqlStmt += wxT(" (");
2076         sqlStmt += colList;
2077         sqlStmt += wxT(")");
2078     }
2079
2080     sqlStmt += wxT(" AS ");
2081     sqlStmt += pSqlStmt;
2082
2083     WriteSqlLog(sqlStmt);
2084
2085 #ifdef DBDEBUG_CONSOLE
2086     cout << sqlStmt.c_str() << endl;
2087 #endif
2088
2089     return(ExecSql(sqlStmt));
2090
2091 }  // wxDb::CreateView()
2092
2093
2094 /********** wxDb::DropView()  **********/
2095 bool wxDb::DropView(const wxString &viewName)
2096 {
2097 /*
2098  * NOTE: This function returns true if the View does not exist, but
2099  *       only for identified databases.  Code will need to be added
2100  *            below for any other databases when those databases are defined
2101  *       to handle this situation consistently
2102  */
2103     wxString sqlStmt;
2104
2105     sqlStmt.Printf(wxT("DROP VIEW %s"), viewName.c_str());
2106
2107     WriteSqlLog(sqlStmt);
2108
2109 #ifdef DBDEBUG_CONSOLE
2110     cout << endl << sqlStmt.c_str() << endl;
2111 #endif
2112
2113     if (SQLExecDirect(hstmt, (SQLTCHAR FAR *) sqlStmt.c_str(), SQL_NTS) != SQL_SUCCESS)
2114     {
2115         // Check for "Base table not found" error and ignore
2116         GetNextError(henv, hdbc, hstmt);
2117         if (wxStrcmp(sqlState,wxT("S0002")))  // "Base table not found"
2118         {
2119             // Check for product specific error codes
2120             if (!((Dbms() == dbmsSYBASE_ASA    && !wxStrcmp(sqlState,wxT("42000")))))  // 5.x (and lower?)
2121             {
2122                 DispNextError();
2123                 DispAllErrors(henv, hdbc, hstmt);
2124                 RollbackTrans();
2125                 return false;
2126             }
2127         }
2128     }
2129
2130     // Commit the transaction
2131     if (!CommitTrans())
2132         return false;
2133
2134     return true;
2135
2136 }  // wxDb::DropView()
2137
2138
2139 /********** wxDb::ExecSql()  **********/
2140 bool wxDb::ExecSql(const wxString &pSqlStmt)
2141 {
2142     RETCODE retcode;
2143
2144     SQLFreeStmt(hstmt, SQL_CLOSE);
2145
2146     retcode = SQLExecDirect(hstmt, (SQLTCHAR FAR *) pSqlStmt.c_str(), SQL_NTS);
2147     if (retcode == SQL_SUCCESS ||
2148         (Dbms() == dbmsDB2 && (retcode == SQL_SUCCESS_WITH_INFO || retcode == SQL_NO_DATA_FOUND)))
2149     {
2150         return true;
2151     }
2152     else
2153     {
2154         DispAllErrors(henv, hdbc, hstmt);
2155         return false;
2156     }
2157
2158 }  // wxDb::ExecSql()
2159
2160
2161 /********** wxDb::GetNext()  **********/
2162 bool wxDb::GetNext(void)
2163 {
2164     if (SQLFetch(hstmt) == SQL_SUCCESS)
2165         return true;
2166     else
2167     {
2168         DispAllErrors(henv, hdbc, hstmt);
2169         return false;
2170     }
2171
2172 }  // wxDb::GetNext()
2173
2174
2175 /********** wxDb::GetData()  **********/
2176 bool wxDb::GetData(UWORD colNo, SWORD cType, PTR pData, SDWORD maxLen, SDWORD FAR *cbReturned)
2177 {
2178     wxASSERT(pData);
2179     wxASSERT(cbReturned);
2180
2181     if (SQLGetData(hstmt, colNo, cType, pData, maxLen, cbReturned) == SQL_SUCCESS)
2182         return true;
2183     else
2184     {
2185         DispAllErrors(henv, hdbc, hstmt);
2186         return false;
2187     }
2188
2189 }  // wxDb::GetData()
2190
2191
2192 /********** wxDb::GetKeyFields() **********/
2193 int wxDb::GetKeyFields(const wxString &tableName, wxDbColInf* colInf, UWORD noCols)
2194 {
2195     wxChar       szPkTable[DB_MAX_TABLE_NAME_LEN+1];  /* Primary key table name */
2196     wxChar       szFkTable[DB_MAX_TABLE_NAME_LEN+1];  /* Foreign key table name */
2197     SWORD        iKeySeq;
2198 //    SQLSMALLINT  iKeySeq;
2199     wxChar       szPkCol[DB_MAX_COLUMN_NAME_LEN+1];   /* Primary key column     */
2200     wxChar       szFkCol[DB_MAX_COLUMN_NAME_LEN+1];   /* Foreign key column     */
2201     SQLRETURN    retcode;
2202     SDWORD       cb;
2203     SWORD        i;
2204     wxString     tempStr;
2205     /*
2206      * -----------------------------------------------------------------------
2207      * -- 19991224 : mj10777 : Create                                   ------
2208      * --          : Three things are done and stored here :            ------
2209      * --          : 1) which Column(s) is/are Primary Key(s)           ------
2210      * --          : 2) which tables use this Key as a Foreign Key      ------
2211      * --          : 3) which columns are Foreign Key and the name      ------
2212      * --          :     of the Table where the Key is the Primary Key  -----
2213      * --          : Called from GetColumns(const wxString &tableName,  ------
2214      * --                           int *numCols,const wxChar *userID ) ------
2215      * -----------------------------------------------------------------------
2216      */
2217
2218     /*---------------------------------------------------------------------*/
2219     /* Get the names of the columns in the primary key.                    */
2220     /*---------------------------------------------------------------------*/
2221     retcode = SQLPrimaryKeys(hstmt,
2222                              NULL, 0,                               /* Catalog name  */
2223                              NULL, 0,                               /* Schema name   */
2224                              (SQLTCHAR FAR *) tableName.c_str(), SQL_NTS); /* Table name    */
2225
2226     /*---------------------------------------------------------------------*/
2227     /* Fetch and display the result set. This will be a list of the        */
2228     /* columns in the primary key of the tableName table.                  */
2229     /*---------------------------------------------------------------------*/
2230     while ((retcode == SQL_SUCCESS) || (retcode == SQL_SUCCESS_WITH_INFO))
2231     {
2232         retcode = SQLFetch(hstmt);
2233         if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO)
2234         {
2235             GetData( 4, SQL_C_CHAR,   szPkCol,     DB_MAX_COLUMN_NAME_LEN+1, &cb);
2236             GetData( 5, SQL_C_SSHORT, &iKeySeq,    0,                        &cb);
2237             //-------
2238             for (i=0;i<noCols;i++)                          // Find the Column name
2239                 if (!wxStrcmp(colInf[i].colName,szPkCol))   // We have found the Column
2240                     colInf[i].PkCol = iKeySeq;              // Which Primary Key is this (first, second usw.) ?
2241         }  // if
2242     }  // while
2243     SQLFreeStmt(hstmt, SQL_CLOSE);  /* Close the cursor (the hstmt is still allocated).      */
2244
2245     /*---------------------------------------------------------------------*/
2246     /* Get all the foreign keys that refer to tableName primary key.       */
2247     /*---------------------------------------------------------------------*/
2248     retcode = SQLForeignKeys(hstmt,
2249                              NULL, 0,                            /* Primary catalog */
2250                              NULL, 0,                            /* Primary schema  */
2251                              (SQLTCHAR FAR *)tableName.c_str(), SQL_NTS,/* Primary table   */
2252                              NULL, 0,                            /* Foreign catalog */
2253                              NULL, 0,                            /* Foreign schema  */
2254                              NULL, 0);                           /* Foreign table   */
2255
2256     /*---------------------------------------------------------------------*/
2257     /* Fetch and display the result set. This will be all of the foreign   */
2258     /* keys in other tables that refer to the tableName  primary key.      */
2259     /*---------------------------------------------------------------------*/
2260     tempStr.Empty();
2261     szPkCol[0] = 0;
2262     while ((retcode == SQL_SUCCESS) || (retcode == SQL_SUCCESS_WITH_INFO))
2263     {
2264         retcode = SQLFetch(hstmt);
2265         if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO)
2266         {
2267             GetData( 3, SQL_C_CHAR,   szPkTable,   DB_MAX_TABLE_NAME_LEN+1,  &cb);
2268             GetData( 4, SQL_C_CHAR,   szPkCol,     DB_MAX_COLUMN_NAME_LEN+1, &cb);
2269             GetData( 5, SQL_C_SSHORT, &iKeySeq,    0,                        &cb);
2270             GetData( 7, SQL_C_CHAR,   szFkTable,   DB_MAX_TABLE_NAME_LEN+1,  &cb);
2271             GetData( 8, SQL_C_CHAR,   szFkCol,     DB_MAX_COLUMN_NAME_LEN+1, &cb);
2272             tempStr.Printf(wxT("%s[%s] "),tempStr.c_str(),szFkTable);  // [ ] in case there is a blank in the Table name
2273         }  // if
2274     }  // while
2275
2276     tempStr.Trim();     // Get rid of any unneeded blanks
2277     if (!tempStr.IsEmpty())
2278     {
2279         for (i=0; i<noCols; i++)
2280         {   // Find the Column name
2281             if (!wxStrcmp(colInf[i].colName, szPkCol))           // We have found the Column, store the Information
2282                 wxStrcpy(colInf[i].PkTableName, tempStr.c_str());  // Name of the Tables where this Primary Key is used as a Foreign Key
2283         }
2284     }  // if
2285
2286     SQLFreeStmt(hstmt, SQL_CLOSE);  /* Close the cursor (the hstmt is still allocated). */
2287
2288     /*---------------------------------------------------------------------*/
2289     /* Get all the foreign keys in the tablename table.                    */
2290     /*---------------------------------------------------------------------*/
2291     retcode = SQLForeignKeys(hstmt,
2292                              NULL, 0,                             /* Primary catalog   */
2293                              NULL, 0,                             /* Primary schema    */
2294                              NULL, 0,                             /* Primary table     */
2295                              NULL, 0,                             /* Foreign catalog   */
2296                              NULL, 0,                             /* Foreign schema    */
2297                              (SQLTCHAR *)tableName.c_str(), SQL_NTS);/* Foreign table     */
2298
2299     /*---------------------------------------------------------------------*/
2300     /*  Fetch and display the result set. This will be all of the          */
2301     /*  primary keys in other tables that are referred to by foreign       */
2302     /*  keys in the tableName table.                                       */
2303     /*---------------------------------------------------------------------*/
2304     while ((retcode == SQL_SUCCESS) || (retcode == SQL_SUCCESS_WITH_INFO))
2305     {
2306         retcode = SQLFetch(hstmt);
2307         if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO)
2308         {
2309             GetData( 3, SQL_C_CHAR,   szPkTable,   DB_MAX_TABLE_NAME_LEN+1,  &cb);
2310             GetData( 5, SQL_C_SSHORT, &iKeySeq,    0,                        &cb);
2311             GetData( 8, SQL_C_CHAR,   szFkCol,     DB_MAX_COLUMN_NAME_LEN+1, &cb);
2312             //-------
2313             for (i=0; i<noCols; i++)                            // Find the Column name
2314             {
2315                 if (!wxStrcmp(colInf[i].colName,szFkCol))       // We have found the (Foreign Key) Column
2316                 {
2317                     colInf[i].FkCol = iKeySeq;                  // Which Foreign Key is this (first, second usw.) ?
2318                     wxStrcpy(colInf[i].FkTableName,szPkTable);  // Name of the Table where this Foriegn is the Primary Key
2319                 } // if
2320             }  // for
2321         }  // if
2322     }  // while
2323     SQLFreeStmt(hstmt, SQL_CLOSE);  /* Close the cursor (the hstmt is still allocated). */
2324
2325     return TRUE;
2326
2327 }  // wxDb::GetKeyFields()
2328
2329
2330 #if OLD_GETCOLUMNS
2331 /********** wxDb::GetColumns() **********/
2332 wxDbColInf *wxDb::GetColumns(wxChar *tableName[], const wxChar *userID)
2333 /*
2334  *        1) The last array element of the tableName[] argument must be zero (null).
2335  *            This is how the end of the array is detected.
2336  *        2) This function returns an array of wxDbColInf structures.  If no columns
2337  *            were found, or an error occured, this pointer will be zero (null).  THE
2338  *            CALLING FUNCTION IS RESPONSIBLE FOR DELETING THE MEMORY RETURNED WHEN IT
2339  *            IS FINISHED WITH IT.  i.e.
2340  *
2341  *            wxDbColInf *colInf = pDb->GetColumns(tableList, userID);
2342  *            if (colInf)
2343  *            {
2344  *                // Use the column inf
2345  *                .......
2346  *                // Destroy the memory
2347  *                delete [] colInf;
2348  *            }
2349  *
2350  * userID is evaluated in the following manner:
2351  *        userID == NULL  ... UserID is ignored
2352  *        userID == ""    ... UserID set equal to 'this->uid'
2353  *        userID != ""    ... UserID set equal to 'userID'
2354  *
2355  * NOTE: ALL column bindings associated with this wxDb instance are unbound
2356  *       by this function.  This function should use its own wxDb instance
2357  *       to avoid undesired unbinding of columns.
2358  */
2359 {
2360     UWORD       noCols = 0;
2361     UWORD       colNo  = 0;
2362     wxDbColInf *colInf = 0;
2363
2364     RETCODE  retcode;
2365     SDWORD   cb;
2366
2367     wxString TableName;
2368
2369     wxString UserID;
2370     convertUserID(userID,UserID);
2371
2372     // Pass 1 - Determine how many columns there are.
2373     // Pass 2 - Allocate the wxDbColInf array and fill in
2374     //                the array with the column information.
2375     int pass;
2376     for (pass = 1; pass <= 2; pass++)
2377     {
2378         if (pass == 2)
2379         {
2380             if (noCols == 0)  // Probably a bogus table name(s)
2381                 break;
2382             // Allocate n wxDbColInf objects to hold the column information
2383             colInf = new wxDbColInf[noCols+1];
2384             if (!colInf)
2385                 break;
2386             // Mark the end of the array
2387             wxStrcpy(colInf[noCols].tableName,wxEmptyString);
2388             wxStrcpy(colInf[noCols].colName,wxEmptyString);
2389             colInf[noCols].sqlDataType = 0;
2390         }
2391         // Loop through each table name
2392         int tbl;
2393         for (tbl = 0; tableName[tbl]; tbl++)
2394         {
2395             TableName = tableName[tbl];
2396             // Oracle and Interbase table names are uppercase only, so force
2397             // the name to uppercase just in case programmer forgot to do this
2398             if ((Dbms() == dbmsORACLE) ||
2399                 (Dbms() == dbmsINTERBASE))
2400                 TableName = TableName.Upper();
2401
2402             SQLFreeStmt(hstmt, SQL_CLOSE);
2403
2404             // MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
2405             // use the call below that leaves out the user name
2406             if (!UserID.IsEmpty() &&
2407                 Dbms() != dbmsMY_SQL &&
2408                 Dbms() != dbmsACCESS &&
2409                 Dbms() != dbmsMS_SQL_SERVER)
2410             {
2411                 retcode = SQLColumns(hstmt,
2412                                      NULL, 0,                                // All qualifiers
2413                                      (SQLTCHAR *) UserID.c_str(), SQL_NTS,      // Owner
2414                                      (SQLTCHAR *) TableName.c_str(), SQL_NTS,
2415                                      NULL, 0);                               // All columns
2416             }
2417             else
2418             {
2419                 retcode = SQLColumns(hstmt,
2420                                      NULL, 0,                                // All qualifiers
2421                                      NULL, 0,                                // Owner
2422                                      (SQLTCHAR *) TableName.c_str(), SQL_NTS,
2423                                      NULL, 0);                               // All columns
2424             }
2425             if (retcode != SQL_SUCCESS)
2426             {  // Error occured, abort
2427                 DispAllErrors(henv, hdbc, hstmt);
2428                 if (colInf)
2429                     delete [] colInf;
2430                 SQLFreeStmt(hstmt, SQL_CLOSE);
2431                 return(0);
2432             }
2433
2434             while ((retcode = SQLFetch(hstmt)) == SQL_SUCCESS)
2435             {
2436                 if (pass == 1)  // First pass, just add up the number of columns
2437                     noCols++;
2438                 else  // Pass 2; Fill in the array of structures
2439                 {
2440                     if (colNo < noCols)  // Some extra error checking to prevent memory overwrites
2441                     {
2442                         // NOTE: Only the ODBC 1.x fields are retrieved
2443                         GetData( 1, SQL_C_CHAR,   (UCHAR*)  colInf[colNo].catalog,      128+1,                    &cb);
2444                         GetData( 2, SQL_C_CHAR,   (UCHAR*)  colInf[colNo].schema,       128+1,                    &cb);
2445                         GetData( 3, SQL_C_CHAR,   (UCHAR*)  colInf[colNo].tableName,    DB_MAX_TABLE_NAME_LEN+1,  &cb);
2446                         GetData( 4, SQL_C_CHAR,   (UCHAR*)  colInf[colNo].colName,      DB_MAX_COLUMN_NAME_LEN+1, &cb);
2447                         GetData( 5, SQL_C_SSHORT, (UCHAR*) &colInf[colNo].sqlDataType,  0,                        &cb);
2448                         GetData( 6, SQL_C_CHAR,   (UCHAR*)  colInf[colNo].typeName,     128+1,                    &cb);
2449                         GetData( 7, SQL_C_SLONG,  (UCHAR*) &colInf[colNo].columnSize,   0,                        &cb);
2450                         GetData( 8, SQL_C_SLONG,  (UCHAR*) &colInf[colNo].bufferLength, 0,                        &cb);
2451                         GetData( 9, SQL_C_SSHORT, (UCHAR*) &colInf[colNo].decimalDigits,0,                        &cb);
2452                         GetData(10, SQL_C_SSHORT, (UCHAR*) &colInf[colNo].numPrecRadix, 0,                        &cb);
2453                         GetData(11, SQL_C_SSHORT, (UCHAR*) &colInf[colNo].nullable,     0,                        &cb);
2454                         GetData(12, SQL_C_CHAR,   (UCHAR*)  colInf[colNo].remarks,      254+1,                    &cb);
2455
2456                         // Determine the wxDb data type that is used to represent the native data type of this data source
2457                         colInf[colNo].dbDataType = 0;
2458                         if (!wxStricmp(typeInfVarchar.TypeName,colInf[colNo].typeName))
2459                         {
2460 #ifdef _IODBC_
2461                             // IODBC does not return a correct columnSize, so we set
2462                             // columnSize = bufferLength if no column size was returned
2463                             // IODBC returns the columnSize in bufferLength.. (bug)
2464                             if (colInf[colNo].columnSize < 1)
2465                             {
2466                                colInf[colNo].columnSize = colInf[colNo].bufferLength;
2467                             }
2468 #endif
2469                             colInf[colNo].dbDataType = DB_DATA_TYPE_VARCHAR;
2470                         }
2471                         else if (!wxStricmp(typeInfInteger.TypeName, colInf[colNo].typeName))
2472                             colInf[colNo].dbDataType = DB_DATA_TYPE_INTEGER;
2473                         else if (!wxStricmp(typeInfFloat.TypeName, colInf[colNo].typeName))
2474                             colInf[colNo].dbDataType = DB_DATA_TYPE_FLOAT;
2475                         else if (!wxStricmp(typeInfDate.TypeName, colInf[colNo].typeName))
2476                             colInf[colNo].dbDataType = DB_DATA_TYPE_DATE;
2477                         else if (!wxStricmp(typeInfBlob.TypeName, colInf[colNo].typeName))
2478                             colInf[colNo].dbDataType = DB_DATA_TYPE_BLOB;
2479                         colNo++;
2480                     }
2481                 }
2482             }
2483             if (retcode != SQL_NO_DATA_FOUND)
2484             {  // Error occured, abort
2485                 DispAllErrors(henv, hdbc, hstmt);
2486                 if (colInf)
2487                     delete [] colInf;
2488                 SQLFreeStmt(hstmt, SQL_CLOSE);
2489                 return(0);
2490             }
2491         }
2492     }
2493
2494     SQLFreeStmt(hstmt, SQL_CLOSE);
2495     return colInf;
2496
2497 }  // wxDb::GetColumns()
2498
2499
2500 /********** wxDb::GetColumns() **********/
2501
2502 wxDbColInf *wxDb::GetColumns(const wxString &tableName, UWORD *numCols, const wxChar *userID)
2503 //
2504 // Same as the above GetColumns() function except this one gets columns
2505 // only for a single table, and if 'numCols' is not NULL, the number of
2506 // columns stored in the returned wxDbColInf is set in '*numCols'
2507 //
2508 // userID is evaluated in the following manner:
2509 //        userID == NULL  ... UserID is ignored
2510 //        userID == ""    ... UserID set equal to 'this->uid'
2511 //        userID != ""    ... UserID set equal to 'userID'
2512 //
2513 // NOTE: ALL column bindings associated with this wxDb instance are unbound
2514 //       by this function.  This function should use its own wxDb instance
2515 //       to avoid undesired unbinding of columns.
2516
2517 {
2518     UWORD       noCols = 0;
2519     UWORD       colNo  = 0;
2520     wxDbColInf *colInf = 0;
2521
2522     RETCODE  retcode;
2523     SDWORD   cb;
2524
2525     wxString TableName;
2526
2527     wxString UserID;
2528     convertUserID(userID,UserID);
2529
2530     // Pass 1 - Determine how many columns there are.
2531     // Pass 2 - Allocate the wxDbColInf array and fill in
2532     //                the array with the column information.
2533     int pass;
2534     for (pass = 1; pass <= 2; pass++)
2535     {
2536         if (pass == 2)
2537         {
2538             if (noCols == 0)  // Probably a bogus table name(s)
2539                 break;
2540             // Allocate n wxDbColInf objects to hold the column information
2541             colInf = new wxDbColInf[noCols+1];
2542             if (!colInf)
2543                 break;
2544             // Mark the end of the array
2545             wxStrcpy(colInf[noCols].tableName, wxEmptyString);
2546             wxStrcpy(colInf[noCols].colName, wxEmptyString);
2547             colInf[noCols].sqlDataType  = 0;
2548         }
2549
2550         TableName = tableName;
2551         // Oracle and Interbase table names are uppercase only, so force
2552         // the name to uppercase just in case programmer forgot to do this
2553         if ((Dbms() == dbmsORACLE) ||
2554             (Dbms() == dbmsINTERBASE))
2555             TableName = TableName.Upper();
2556
2557         SQLFreeStmt(hstmt, SQL_CLOSE);
2558
2559         // MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
2560         // use the call below that leaves out the user name
2561         if (!UserID.IsEmpty() &&
2562             Dbms() != dbmsMY_SQL &&
2563             Dbms() != dbmsACCESS &&
2564             Dbms() != dbmsMS_SQL_SERVER)
2565         {
2566             retcode = SQLColumns(hstmt,
2567                                  NULL, 0,                                // All qualifiers
2568                                  (SQLTCHAR *) UserID.c_str(), SQL_NTS,    // Owner
2569                                  (SQLTCHAR *) TableName.c_str(), SQL_NTS,
2570                                  NULL, 0);                               // All columns
2571         }
2572         else
2573         {
2574             retcode = SQLColumns(hstmt,
2575                                  NULL, 0,                                 // All qualifiers
2576                                  NULL, 0,                                 // Owner
2577                                  (SQLTCHAR *) TableName.c_str(), SQL_NTS,
2578                                  NULL, 0);                                // All columns
2579         }
2580         if (retcode != SQL_SUCCESS)
2581         {  // Error occured, abort
2582             DispAllErrors(henv, hdbc, hstmt);
2583             if (colInf)
2584                 delete [] colInf;
2585             SQLFreeStmt(hstmt, SQL_CLOSE);
2586             if (numCols)
2587                 *numCols = 0;
2588             return(0);
2589         }
2590
2591         while ((retcode = SQLFetch(hstmt)) == SQL_SUCCESS)
2592         {
2593             if (pass == 1)  // First pass, just add up the number of columns
2594                 noCols++;
2595             else  // Pass 2; Fill in the array of structures
2596             {
2597                 if (colNo < noCols)  // Some extra error checking to prevent memory overwrites
2598                 {
2599                     // NOTE: Only the ODBC 1.x fields are retrieved
2600                     GetData( 1, SQL_C_CHAR,   (UCHAR*)  colInf[colNo].catalog,      128+1,                    &cb);
2601                     GetData( 2, SQL_C_CHAR,   (UCHAR*)  colInf[colNo].schema,       128+1,                    &cb);
2602                     GetData( 3, SQL_C_CHAR,   (UCHAR*)  colInf[colNo].tableName,    DB_MAX_TABLE_NAME_LEN+1,  &cb);
2603                     GetData( 4, SQL_C_CHAR,   (UCHAR*)  colInf[colNo].colName,      DB_MAX_COLUMN_NAME_LEN+1, &cb);
2604                     GetData( 5, SQL_C_SSHORT, (UCHAR*) &colInf[colNo].sqlDataType,  0,                        &cb);
2605                     GetData( 6, SQL_C_CHAR,   (UCHAR*)  colInf[colNo].typeName,     128+1,                    &cb);
2606                     GetData( 7, SQL_C_SLONG,  (UCHAR*) &colInf[colNo].columnSize,   0,                        &cb);
2607                     // BJO 991214 : SQL_C_SSHORT instead of SQL_C_SLONG, otherwise fails on Sparc (probably all 64 bit architectures)
2608                     GetData( 8, SQL_C_SSHORT, (UCHAR*) &colInf[colNo].bufferLength, 0,                        &cb);
2609                     GetData( 9, SQL_C_SSHORT, (UCHAR*) &colInf[colNo].decimalDigits,0,                        &cb);
2610                     GetData(10, SQL_C_SSHORT, (UCHAR*) &colInf[colNo].numPrecRadix, 0,                        &cb);
2611                     GetData(11, SQL_C_SSHORT, (UCHAR*) &colInf[colNo].nullable,     0,                        &cb);
2612                     GetData(12, SQL_C_CHAR,   (UCHAR*)  colInf[colNo].remarks,      254+1,                    &cb);
2613                     // Start Values for Primary/Foriegn Key (=No)
2614                     colInf[colNo].PkCol = 0;           // Primary key column   0=No; 1= First Key, 2 = Second Key etc.
2615                     colInf[colNo].PkTableName[0] = 0;  // Tablenames where Primary Key is used as a Foreign Key
2616                     colInf[colNo].FkCol = 0;           // Foreign key column   0=No; 1= First Key, 2 = Second Key etc.
2617                     colInf[colNo].FkTableName[0] = 0;  // Foreign key table name
2618
2619                     // BJO 20000428 : Virtuoso returns type names with upper cases!
2620                     if (Dbms() == dbmsVIRTUOSO)
2621                     {
2622                         wxString s = colInf[colNo].typeName;
2623                         s = s.MakeLower();
2624                         wxStrcmp(colInf[colNo].typeName, s.c_str());
2625                     }
2626
2627                     // Determine the wxDb data type that is used to represent the native data type of this data source
2628                     colInf[colNo].dbDataType = 0;
2629                     if (!wxStricmp(typeInfVarchar.TypeName, colInf[colNo].typeName))
2630                     {
2631 #ifdef _IODBC_
2632                         // IODBC does not return a correct columnSize, so we set
2633                         // columnSize = bufferLength if no column size was returned
2634                         // IODBC returns the columnSize in bufferLength.. (bug)
2635                         if (colInf[colNo].columnSize < 1)
2636                         {
2637                            colInf[colNo].columnSize = colInf[colNo].bufferLength;
2638                         }
2639 #endif
2640
2641                         colInf[colNo].dbDataType = DB_DATA_TYPE_VARCHAR;
2642                     }
2643                     else if (!wxStricmp(typeInfInteger.TypeName, colInf[colNo].typeName))
2644                         colInf[colNo].dbDataType = DB_DATA_TYPE_INTEGER;
2645                     else if (!wxStricmp(typeInfFloat.TypeName, colInf[colNo].typeName))
2646                         colInf[colNo].dbDataType = DB_DATA_TYPE_FLOAT;
2647                     else if (!wxStricmp(typeInfDate.TypeName, colInf[colNo].typeName))
2648                         colInf[colNo].dbDataType = DB_DATA_TYPE_DATE;
2649                     else if (!wxStricmp(typeInfBlob.TypeName, colInf[colNo].typeName))
2650                         colInf[colNo].dbDataType = DB_DATA_TYPE_BLOB;
2651
2652                     colNo++;
2653                 }
2654             }
2655         }
2656         if (retcode != SQL_NO_DATA_FOUND)
2657         {  // Error occured, abort
2658             DispAllErrors(henv, hdbc, hstmt);
2659             if (colInf)
2660                 delete [] colInf;
2661             SQLFreeStmt(hstmt, SQL_CLOSE);
2662             if (numCols)
2663                 *numCols = 0;
2664             return(0);
2665         }
2666     }
2667
2668     SQLFreeStmt(hstmt, SQL_CLOSE);
2669
2670     // Store Primary and Foriegn Keys
2671     GetKeyFields(tableName,colInf,noCols);
2672
2673     if (numCols)
2674         *numCols = noCols;
2675     return colInf;
2676
2677 }  // wxDb::GetColumns()
2678
2679
2680 #else  // New GetColumns
2681
2682
2683 /*
2684     BJO 20000503
2685     These are tentative new GetColumns members which should be more database
2686     independant and which always returns the columns in the order they were
2687     created.
2688
2689     - The first one (wxDbColInf *wxDb::GetColumns(wxChar *tableName[], const
2690       wxChar* userID)) calls the second implementation for each separate table
2691       before merging the results. This makes the code easier to maintain as
2692       only one member (the second) makes the real work
2693     - wxDbColInf *wxDb::GetColumns(const wxString &tableName, int *numCols, const
2694       wxChar *userID) is a little bit improved
2695     - It doesn't anymore rely on the type-name to find out which database-type
2696       each column has
2697     - It ends by sorting the columns, so that they are returned in the same
2698       order they were created
2699 */
2700
2701 typedef struct
2702 {
2703     UWORD noCols;
2704     wxDbColInf *colInf;
2705 } _TableColumns;
2706
2707
2708 wxDbColInf *wxDb::GetColumns(wxChar *tableName[], const wxChar *userID)
2709 {
2710     int i, j;
2711     // The last array element of the tableName[] argument must be zero (null).
2712     // This is how the end of the array is detected.
2713
2714     UWORD noCols = 0;
2715
2716     // How many tables ?
2717     int tbl;
2718     for (tbl = 0 ; tableName[tbl]; tbl++);
2719
2720     // Create a table to maintain the columns for each separate table
2721     _TableColumns *TableColumns = new _TableColumns[tbl];
2722
2723     // Fill the table
2724     for (i = 0 ; i < tbl ; i++)
2725
2726     {
2727         TableColumns[i].colInf = GetColumns(tableName[i], &TableColumns[i].noCols, userID);
2728         if (TableColumns[i].colInf == NULL)
2729             return NULL;
2730         noCols += TableColumns[i].noCols;
2731     }
2732
2733     // Now merge all the separate table infos
2734     wxDbColInf *colInf = new wxDbColInf[noCols+1];
2735
2736     // Mark the end of the array
2737     wxStrcpy(colInf[noCols].tableName, wxEmptyString);
2738     wxStrcpy(colInf[noCols].colName, wxEmptyString);
2739     colInf[noCols].sqlDataType  = 0;
2740
2741     // Merge ...
2742     int offset = 0;
2743
2744     for (i = 0 ; i < tbl ; i++)
2745     {
2746         for (j = 0 ; j < TableColumns[i].noCols ; j++)
2747         {
2748             colInf[offset++] = TableColumns[i].colInf[j];
2749         }
2750     }
2751
2752     delete [] TableColumns;
2753
2754     return colInf;
2755 }  // wxDb::GetColumns()  -- NEW
2756
2757
2758 wxDbColInf *wxDb::GetColumns(const wxString &tableName, int *numCols, const wxChar *userID)
2759 //
2760 // Same as the above GetColumns() function except this one gets columns
2761 // only for a single table, and if 'numCols' is not NULL, the number of
2762 // columns stored in the returned wxDbColInf is set in '*numCols'
2763 //
2764 // userID is evaluated in the following manner:
2765 //        userID == NULL  ... UserID is ignored
2766 //        userID == ""    ... UserID set equal to 'this->uid'
2767 //        userID != ""    ... UserID set equal to 'userID'
2768 //
2769 // NOTE: ALL column bindings associated with this wxDb instance are unbound
2770 //       by this function.  This function should use its own wxDb instance
2771 //       to avoid undesired unbinding of columns.
2772 {
2773     UWORD       noCols = 0;
2774     UWORD       colNo  = 0;
2775     wxDbColInf *colInf = 0;
2776
2777     RETCODE  retcode;
2778     SDWORD   cb;
2779
2780     wxString TableName;
2781
2782     wxString UserID;
2783     convertUserID(userID,UserID);
2784
2785     // Pass 1 - Determine how many columns there are.
2786     // Pass 2 - Allocate the wxDbColInf array and fill in
2787     //                the array with the column information.
2788     int pass;
2789     for (pass = 1; pass <= 2; pass++)
2790     {
2791         if (pass == 2)
2792         {
2793             if (noCols == 0)  // Probably a bogus table name(s)
2794                 break;
2795             // Allocate n wxDbColInf objects to hold the column information
2796             colInf = new wxDbColInf[noCols+1];
2797             if (!colInf)
2798                 break;
2799             // Mark the end of the array
2800             wxStrcpy(colInf[noCols].tableName, wxEmptyString);
2801             wxStrcpy(colInf[noCols].colName, wxEmptyString);
2802             colInf[noCols].sqlDataType = 0;
2803         }
2804
2805         TableName = tableName;
2806         // Oracle and Interbase table names are uppercase only, so force
2807         // the name to uppercase just in case programmer forgot to do this
2808         if ((Dbms() == dbmsORACLE) ||
2809             (Dbms() == dbmsINTERBASE))
2810             TableName = TableName.Upper();
2811
2812         SQLFreeStmt(hstmt, SQL_CLOSE);
2813
2814         // MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
2815         // use the call below that leaves out the user name
2816         if (!UserID.IsEmpty() &&
2817             Dbms() != dbmsMY_SQL &&
2818             Dbms() != dbmsACCESS &&
2819             Dbms() != dbmsMS_SQL_SERVER)
2820         {
2821             retcode = SQLColumns(hstmt,
2822                                  NULL, 0,                              // All qualifiers
2823                                  (UCHAR *) UserID.c_str(), SQL_NTS,    // Owner
2824                                  (UCHAR *) TableName.c_str(), SQL_NTS,
2825                                  NULL, 0);                             // All columns
2826         }
2827         else
2828         {
2829             retcode = SQLColumns(hstmt,
2830                                  NULL, 0,                              // All qualifiers
2831                                  NULL, 0,                              // Owner
2832                                  (UCHAR *) TableName.c_str(), SQL_NTS,
2833                                  NULL, 0);                             // All columns
2834         }
2835         if (retcode != SQL_SUCCESS)
2836         {  // Error occured, abort
2837             DispAllErrors(henv, hdbc, hstmt);
2838             if (colInf)
2839                 delete [] colInf;
2840             SQLFreeStmt(hstmt, SQL_CLOSE);
2841             if (numCols)
2842                 *numCols = 0;
2843             return(0);
2844         }
2845
2846         while ((retcode = SQLFetch(hstmt)) == SQL_SUCCESS)
2847         {
2848             if (pass == 1)  // First pass, just add up the number of columns
2849                 noCols++;
2850             else  // Pass 2; Fill in the array of structures
2851             {
2852                 if (colNo < noCols)  // Some extra error checking to prevent memory overwrites
2853                 {
2854                     // NOTE: Only the ODBC 1.x fields are retrieved
2855                     GetData( 1, SQL_C_CHAR,   (UCHAR*)  colInf[colNo].catalog,      128+1,                    &cb);
2856                     GetData( 2, SQL_C_CHAR,   (UCHAR*)  colInf[colNo].schema,       128+1,                    &cb);
2857                     GetData( 3, SQL_C_CHAR,   (UCHAR*)  colInf[colNo].tableName,    DB_MAX_TABLE_NAME_LEN+1,  &cb);
2858                     GetData( 4, SQL_C_CHAR,   (UCHAR*)  colInf[colNo].colName,      DB_MAX_COLUMN_NAME_LEN+1, &cb);
2859                     GetData( 5, SQL_C_SSHORT, (UCHAR*) &colInf[colNo].sqlDataType,  0,                        &cb);
2860                     GetData( 6, SQL_C_CHAR,   (UCHAR*)  colInf[colNo].typeName,     128+1,                    &cb);
2861                     GetData( 7, SQL_C_SLONG,  (UCHAR*) &colInf[colNo].columnSize,   0,                        &cb);
2862                     GetData( 8, SQL_C_SSHORT, (UCHAR*) &colInf[colNo].bufferLength, 0,                        &cb);
2863                     GetData( 9, SQL_C_SSHORT, (UCHAR*) &colInf[colNo].decimalDigits,0,                        &cb);
2864                     GetData(10, SQL_C_SSHORT, (UCHAR*) &colInf[colNo].numPrecRadix, 0,                        &cb);
2865                     GetData(11, SQL_C_SSHORT, (UCHAR*) &colInf[colNo].nullable,     0,                        &cb);
2866                     GetData(12, SQL_C_CHAR,   (UCHAR*)  colInf[colNo].remarks,      254+1,                    &cb);
2867                     // Start Values for Primary/Foriegn Key (=No)
2868                     colInf[colNo].PkCol = 0;           // Primary key column   0=No; 1= First Key, 2 = Second Key etc.
2869                     colInf[colNo].PkTableName[0] = 0;  // Tablenames where Primary Key is used as a Foreign Key
2870                     colInf[colNo].FkCol = 0;           // Foreign key column   0=No; 1= First Key, 2 = Second Key etc.
2871                     colInf[colNo].FkTableName[0] = 0;  // Foreign key table name
2872
2873 #ifdef _IODBC_
2874                     // IODBC does not return a correct columnSize, so we set
2875                     // columnSize = bufferLength if no column size was returned
2876                     // IODBC returns the columnSize in bufferLength.. (bug)
2877                     if (colInf[colNo].columnSize < 1)
2878                     {
2879                        colInf[colNo].columnSize = colInf[colNo].bufferLength;
2880                     }
2881 #endif
2882
2883                     // Determine the wxDb data type that is used to represent the native data type of this data source
2884                     colInf[colNo].dbDataType = 0;
2885                     // Get the intern datatype
2886                     switch (colInf[colNo].sqlDataType)
2887                     {
2888                         case SQL_VARCHAR:
2889                         case SQL_CHAR:
2890                             colInf[colNo].dbDataType = DB_DATA_TYPE_VARCHAR;
2891                         break;
2892
2893                         case SQL_TINYINT:
2894                         case SQL_SMALLINT:
2895                         case SQL_INTEGER:
2896                             colInf[colNo].dbDataType = DB_DATA_TYPE_INTEGER;
2897                             break;
2898                         case SQL_DOUBLE:
2899                         case SQL_DECIMAL:
2900                         case SQL_NUMERIC:
2901                         case SQL_FLOAT:
2902                         case SQL_REAL:
2903                             colInf[colNo].dbDataType = DB_DATA_TYPE_FLOAT;
2904                             break;
2905                         case SQL_DATE:
2906                             colInf[colNo].dbDataType = DB_DATA_TYPE_DATE;
2907                             break;
2908                         case SQL_BINARY:
2909                             colInf[colNo].dbDataType = DB_DATA_TYPE_BLOB;
2910                             break;
2911 #ifdef __WXDEBUG__
2912                         default:
2913                             wxString errMsg;
2914                             errMsg.Printf(wxT("SQL Data type %d currently not supported by wxWidgets"), colInf[colNo].sqlDataType);
2915                             wxLogDebug(errMsg,wxT("ODBC DEBUG MESSAGE"));
2916 #endif
2917                     }
2918                     colNo++;
2919                 }
2920             }
2921         }
2922         if (retcode != SQL_NO_DATA_FOUND)
2923         {  // Error occured, abort
2924             DispAllErrors(henv, hdbc, hstmt);
2925             if (colInf)
2926                 delete [] colInf;
2927             SQLFreeStmt(hstmt, SQL_CLOSE);
2928             if (numCols)
2929                 *numCols = 0;
2930             return(0);
2931         }
2932     }
2933
2934     SQLFreeStmt(hstmt, SQL_CLOSE);
2935
2936     // Store Primary and Foreign Keys
2937     GetKeyFields(tableName,colInf,noCols);
2938
2939     ///////////////////////////////////////////////////////////////////////////
2940     // Now sort the the columns in order to make them appear in the right order
2941     ///////////////////////////////////////////////////////////////////////////
2942
2943     // Build a generic SELECT statement which returns 0 rows
2944     wxString Stmt;
2945
2946     Stmt.Printf(wxT("select * from \"%s\" where 0=1"), tableName);
2947
2948     // Execute query
2949     if (SQLExecDirect(hstmt, (UCHAR FAR *) Stmt.c_str(), SQL_NTS) != SQL_SUCCESS)
2950     {
2951         DispAllErrors(henv, hdbc, hstmt);
2952         return NULL;
2953     }
2954
2955     // Get the number of result columns
2956     if (SQLNumResultCols (hstmt, &noCols) != SQL_SUCCESS)
2957     {
2958         DispAllErrors(henv, hdbc, hstmt);
2959         return NULL;
2960     }
2961
2962     if (noCols == 0) // Probably a bogus table name
2963         return NULL;
2964
2965     //  Get the name
2966     int i;
2967     short colNum;
2968     UCHAR name[100];
2969     SWORD Sword;
2970     SDWORD Sdword;
2971     for (colNum = 0; colNum < noCols; colNum++)
2972     {
2973         if (SQLColAttributes(hstmt,colNum+1, SQL_COLUMN_NAME,
2974             name, sizeof(name),
2975             &Sword, &Sdword) != SQL_SUCCESS)
2976         {
2977             DispAllErrors(henv, hdbc, hstmt);
2978             return NULL;
2979         }
2980
2981         wxString Name1 = name;
2982         Name1 = Name1.Upper();
2983
2984         // Where is this name in the array ?
2985         for (i = colNum ; i < noCols ; i++)
2986         {
2987             wxString Name2 =  colInf[i].colName;
2988             Name2 = Name2.Upper();
2989             if (Name2 == Name1)
2990             {
2991                 if (colNum != i) // swap to sort
2992                 {
2993                     wxDbColInf tmpColInf = colInf[colNum];
2994                     colInf[colNum] =  colInf[i];
2995                     colInf[i] = tmpColInf;
2996                 }
2997                 break;
2998             }
2999         }
3000     }
3001     SQLFreeStmt(hstmt, SQL_CLOSE);
3002
3003     ///////////////////////////////////////////////////////////////////////////
3004     // End sorting
3005     ///////////////////////////////////////////////////////////////////////////
3006
3007     if (numCols)
3008         *numCols = noCols;
3009     return colInf;
3010
3011 }  // wxDb::GetColumns()
3012
3013
3014 #endif  // #else OLD_GETCOLUMNS
3015
3016
3017 /********** wxDb::GetColumnCount() **********/
3018 int wxDb::GetColumnCount(const wxString &tableName, const wxChar *userID)
3019 /*
3020  * Returns a count of how many columns are in a table.
3021  * If an error occurs in computing the number of columns
3022  * this function will return a -1 for the count
3023  *
3024  * userID is evaluated in the following manner:
3025  *        userID == NULL  ... UserID is ignored
3026  *        userID == ""    ... UserID set equal to 'this->uid'
3027  *        userID != ""    ... UserID set equal to 'userID'
3028  *
3029  * NOTE: ALL column bindings associated with this wxDb instance are unbound
3030  *       by this function.  This function should use its own wxDb instance
3031  *       to avoid undesired unbinding of columns.
3032  */
3033 {
3034     UWORD    noCols = 0;
3035
3036     RETCODE  retcode;
3037
3038     wxString TableName;
3039
3040     wxString UserID;
3041     convertUserID(userID,UserID);
3042
3043     TableName = tableName;
3044     // Oracle and Interbase table names are uppercase only, so force
3045     // the name to uppercase just in case programmer forgot to do this
3046     if ((Dbms() == dbmsORACLE) ||
3047         (Dbms() == dbmsINTERBASE))
3048         TableName = TableName.Upper();
3049
3050     SQLFreeStmt(hstmt, SQL_CLOSE);
3051
3052     // MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
3053     // use the call below that leaves out the user name
3054     if (!UserID.IsEmpty() &&
3055         Dbms() != dbmsMY_SQL &&
3056         Dbms() != dbmsACCESS &&
3057         Dbms() != dbmsMS_SQL_SERVER)
3058     {
3059         retcode = SQLColumns(hstmt,
3060                              NULL, 0,                                // All qualifiers
3061                              (SQLTCHAR *) UserID.c_str(), SQL_NTS,      // Owner
3062                              (SQLTCHAR *) TableName.c_str(), SQL_NTS,
3063                              NULL, 0);                               // All columns
3064     }
3065     else
3066     {
3067         retcode = SQLColumns(hstmt,
3068                              NULL, 0,                                // All qualifiers
3069                              NULL, 0,                                // Owner
3070                              (SQLTCHAR *) TableName.c_str(), SQL_NTS,
3071                              NULL, 0);                               // All columns
3072     }
3073     if (retcode != SQL_SUCCESS)
3074     {  // Error occured, abort
3075         DispAllErrors(henv, hdbc, hstmt);
3076         SQLFreeStmt(hstmt, SQL_CLOSE);
3077         return(-1);
3078     }
3079
3080     // Count the columns
3081     while ((retcode = SQLFetch(hstmt)) == SQL_SUCCESS)
3082         noCols++;
3083
3084     if (retcode != SQL_NO_DATA_FOUND)
3085     {  // Error occured, abort
3086         DispAllErrors(henv, hdbc, hstmt);
3087         SQLFreeStmt(hstmt, SQL_CLOSE);
3088         return(-1);
3089     }
3090
3091     SQLFreeStmt(hstmt, SQL_CLOSE);
3092     return noCols;
3093
3094 }  // wxDb::GetColumnCount()
3095
3096
3097 /********** wxDb::GetCatalog() *******/
3098 wxDbInf *wxDb::GetCatalog(const wxChar *userID)
3099 /*
3100  * ---------------------------------------------------------------------
3101  * -- 19991203 : mj10777 : Create                                 ------
3102  * --          : Creates a wxDbInf with Tables / Cols Array       ------
3103  * --          : uses SQLTables and fills pTableInf;              ------
3104  * --          : pColInf is set to NULL and numCols to 0;         ------
3105  * --          : returns pDbInf (wxDbInf)                         ------
3106  * --            - if unsuccesfull (pDbInf == NULL)               ------
3107  * --          : pColInf can be filled with GetColumns(..);       ------
3108  * --          : numCols   can be filled with GetColumnCount(..); ------
3109  * ---------------------------------------------------------------------
3110  *
3111  * userID is evaluated in the following manner:
3112  *        userID == NULL  ... UserID is ignored
3113  *        userID == ""    ... UserID set equal to 'this->uid'
3114  *        userID != ""    ... UserID set equal to 'userID'
3115  *
3116  * NOTE: ALL column bindings associated with this wxDb instance are unbound
3117  *       by this function.  This function should use its own wxDb instance
3118  *       to avoid undesired unbinding of columns.
3119  */
3120 {
3121     int      noTab = 0;     // Counter while filling table entries
3122     int      pass;
3123     RETCODE  retcode;
3124     SDWORD   cb;
3125     wxString tblNameSave;
3126
3127     wxString UserID;
3128     convertUserID(userID,UserID);
3129
3130     //-------------------------------------------------------------
3131     // Create the Database Array of catalog entries
3132
3133     wxDbInf *pDbInf = new wxDbInf;
3134
3135     //-------------------------------------------------------------
3136     // Table Information
3137     // Pass 1 - Determine how many Tables there are.
3138     // Pass 2 - Create the Table array and fill it
3139     //        - Create the Cols array = NULL
3140     //-------------------------------------------------------------
3141
3142     for (pass = 1; pass <= 2; pass++)
3143     {
3144         SQLFreeStmt(hstmt, SQL_CLOSE);   // Close if Open
3145         tblNameSave.Empty();
3146
3147         if (!UserID.IsEmpty() &&
3148             Dbms() != dbmsMY_SQL &&
3149             Dbms() != dbmsACCESS &&
3150             Dbms() != dbmsMS_SQL_SERVER)
3151         {
3152             retcode = SQLTables(hstmt,
3153                                 NULL, 0,                             // All qualifiers
3154                                 (SQLTCHAR *) UserID.c_str(), SQL_NTS,   // User specified
3155                                 NULL, 0,                             // All tables
3156                                 NULL, 0);                            // All columns
3157         }
3158         else
3159         {
3160             retcode = SQLTables(hstmt,
3161                                 NULL, 0,           // All qualifiers
3162                                 NULL, 0,           // User specified
3163                                 NULL, 0,           // All tables
3164                                 NULL, 0);          // All columns
3165         }
3166
3167         if (retcode != SQL_SUCCESS)
3168         {
3169             DispAllErrors(henv, hdbc, hstmt);
3170             pDbInf = NULL;
3171             SQLFreeStmt(hstmt, SQL_CLOSE);
3172             return pDbInf;
3173         }
3174
3175         while ((retcode = SQLFetch(hstmt)) == SQL_SUCCESS)   // Table Information
3176         {
3177             if (pass == 1)  // First pass, just count the Tables
3178             {
3179                 if (pDbInf->numTables == 0)
3180                 {
3181                     GetData( 1, SQL_C_CHAR,   (UCHAR*)  pDbInf->catalog,  128+1, &cb);
3182                     GetData( 2, SQL_C_CHAR,   (UCHAR*)  pDbInf->schema,   128+1, &cb);
3183                  }
3184                  pDbInf->numTables++;      // Counter for Tables
3185             }  // if (pass == 1)
3186             if (pass == 2) // Create and fill the Table entries
3187             {
3188                 if (pDbInf->pTableInf == NULL)   // Has the Table Array been created
3189                 {  // no, then create the Array
3190                     pDbInf->pTableInf = new wxDbTableInf[pDbInf->numTables];
3191                     noTab = 0;
3192                 } // if (pDbInf->pTableInf == NULL)   // Has the Table Array been created
3193
3194                 GetData( 3, SQL_C_CHAR,   (UCHAR*)  (pDbInf->pTableInf+noTab)->tableName,    DB_MAX_TABLE_NAME_LEN+1, &cb);
3195                 GetData( 4, SQL_C_CHAR,   (UCHAR*)  (pDbInf->pTableInf+noTab)->tableType,    30+1,                    &cb);
3196                 GetData( 5, SQL_C_CHAR,   (UCHAR*)  (pDbInf->pTableInf+noTab)->tableRemarks, 254+1,                   &cb);
3197
3198                 noTab++;
3199             }  // if
3200         }  // while
3201     }  // for
3202     SQLFreeStmt(hstmt, SQL_CLOSE);
3203
3204     // Query how many columns are in each table
3205     for (noTab=0;noTab<pDbInf->numTables;noTab++)
3206     {
3207         (pDbInf->pTableInf+noTab)->numCols = (UWORD)GetColumnCount((pDbInf->pTableInf+noTab)->tableName,UserID);
3208     }
3209
3210     return pDbInf;
3211
3212 }  // wxDb::GetCatalog()
3213
3214
3215 /********** wxDb::Catalog() **********/
3216 bool wxDb::Catalog(const wxChar *userID, const wxString &fileName)
3217 /*
3218  * Creates the text file specified in 'filename' which will contain
3219  * a minimal data dictionary of all tables accessible by the user specified
3220  * in 'userID'
3221  *
3222  * userID is evaluated in the following manner:
3223  *        userID == NULL  ... UserID is ignored
3224  *        userID == ""    ... UserID set equal to 'this->uid'
3225  *        userID != ""    ... UserID set equal to 'userID'
3226  *
3227  * NOTE: ALL column bindings associated with this wxDb instance are unbound
3228  *       by this function.  This function should use its own wxDb instance
3229  *       to avoid undesired unbinding of columns.
3230  */
3231 {
3232     wxASSERT(fileName.Length());
3233
3234     RETCODE   retcode;
3235     SDWORD    cb;
3236     wxChar    tblName[DB_MAX_TABLE_NAME_LEN+1];
3237     wxString  tblNameSave;
3238     wxChar    colName[DB_MAX_COLUMN_NAME_LEN+1];
3239     SWORD     sqlDataType;
3240     wxChar    typeName[30+1];
3241     SDWORD    precision, length;
3242
3243     FILE *fp = wxFopen(fileName.c_str(),wxT("wt"));
3244     if (fp == NULL)
3245         return false;
3246
3247     SQLFreeStmt(hstmt, SQL_CLOSE);
3248
3249     wxString UserID;
3250     convertUserID(userID,UserID);
3251
3252     if (!UserID.IsEmpty() &&
3253         Dbms() != dbmsMY_SQL &&
3254         Dbms() != dbmsACCESS &&
3255         Dbms() != dbmsINTERBASE &&
3256         Dbms() != dbmsMS_SQL_SERVER)
3257     {
3258         retcode = SQLColumns(hstmt,
3259                              NULL, 0,                                // All qualifiers
3260                              (SQLTCHAR *) UserID.c_str(), SQL_NTS,      // User specified
3261                              NULL, 0,                                // All tables
3262                              NULL, 0);                               // All columns
3263     }
3264     else
3265     {
3266         retcode = SQLColumns(hstmt,
3267                              NULL, 0,    // All qualifiers
3268                              NULL, 0,    // User specified
3269                              NULL, 0,    // All tables
3270                              NULL, 0);   // All columns
3271     }
3272     if (retcode != SQL_SUCCESS)
3273     {
3274         DispAllErrors(henv, hdbc, hstmt);
3275         fclose(fp);
3276         return false;
3277     }
3278
3279     wxString outStr;
3280     tblNameSave.Empty();
3281     int cnt = 0;
3282
3283     while (true)
3284     {
3285         retcode = SQLFetch(hstmt);
3286         if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
3287             break;
3288
3289         GetData(3,SQL_C_CHAR,  (UCHAR *) tblName,     DB_MAX_TABLE_NAME_LEN+1, &cb);
3290         GetData(4,SQL_C_CHAR,  (UCHAR *) colName,     DB_MAX_COLUMN_NAME_LEN+1,&cb);
3291         GetData(5,SQL_C_SSHORT,(UCHAR *)&sqlDataType, 0,                       &cb);
3292         GetData(6,SQL_C_CHAR,  (UCHAR *) typeName,    sizeof(typeName),        &cb);
3293         GetData(7,SQL_C_SLONG, (UCHAR *)&precision,   0,                       &cb);
3294         GetData(8,SQL_C_SLONG, (UCHAR *)&length,      0,                       &cb);
3295
3296         if (wxStrcmp(tblName, tblNameSave.c_str()))
3297         {
3298             if (cnt)
3299                 wxFputs(wxT("\n"), fp);
3300             wxFputs(wxT("================================ "), fp);
3301             wxFputs(wxT("================================ "), fp);
3302             wxFputs(wxT("===================== "), fp);
3303             wxFputs(wxT("========= "), fp);
3304             wxFputs(wxT("=========\n"), fp);
3305             outStr.Printf(wxT("%-32s %-32s %-21s %9s %9s\n"),
3306                 wxT("TABLE NAME"), wxT("COLUMN NAME"), wxT("DATA TYPE"), wxT("PRECISION"), wxT("LENGTH"));
3307             wxFputs(outStr.c_str(), fp);
3308             wxFputs(wxT("================================ "), fp);
3309             wxFputs(wxT("================================ "), fp);
3310             wxFputs(wxT("===================== "), fp);
3311             wxFputs(wxT("========= "), fp);
3312             wxFputs(wxT("=========\n"), fp);
3313             tblNameSave = tblName;
3314         }
3315
3316         outStr.Printf(wxT("%-32s %-32s (%04d)%-15s %9ld %9ld\n"),
3317             tblName, colName, sqlDataType, typeName, precision, length);
3318         if (wxFputs(outStr.c_str(), fp) == EOF)
3319         {
3320             SQLFreeStmt(hstmt, SQL_CLOSE);
3321             fclose(fp);
3322             return false;
3323         }
3324         cnt++;
3325     }
3326
3327     if (retcode != SQL_NO_DATA_FOUND)
3328         DispAllErrors(henv, hdbc, hstmt);
3329
3330     SQLFreeStmt(hstmt, SQL_CLOSE);
3331
3332     fclose(fp);
3333     return(retcode == SQL_NO_DATA_FOUND);
3334
3335 }  // wxDb::Catalog()
3336
3337
3338 bool wxDb::TableExists(const wxString &tableName, const wxChar *userID, const wxString &tablePath)
3339 /*
3340  * Table name can refer to a table, view, alias or synonym.  Returns true
3341  * if the object exists in the database.  This function does not indicate
3342  * whether or not the user has privleges to query or perform other functions
3343  * on the table.
3344  *
3345  * userID is evaluated in the following manner:
3346  *        userID == NULL  ... UserID is ignored
3347  *        userID == ""    ... UserID set equal to 'this->uid'
3348  *        userID != ""    ... UserID set equal to 'userID'
3349  */
3350 {
3351     wxASSERT(tableName.Length());
3352
3353     wxString TableName;
3354
3355     if (Dbms() == dbmsDBASE)
3356     {
3357         wxString dbName;
3358         if (tablePath.Length())
3359             dbName.Printf(wxT("%s/%s.dbf"), tablePath.c_str(), tableName.c_str());
3360         else
3361             dbName.Printf(wxT("%s.dbf"), tableName.c_str());
3362
3363         bool exists;
3364         exists = wxFileExists(dbName);
3365         return exists;
3366     }
3367
3368     wxString UserID;
3369     convertUserID(userID,UserID);
3370
3371     TableName = tableName;
3372     // Oracle and Interbase table names are uppercase only, so force
3373     // the name to uppercase just in case programmer forgot to do this
3374     if ((Dbms() == dbmsORACLE) ||
3375         (Dbms() == dbmsINTERBASE))
3376         TableName = TableName.Upper();
3377
3378     SQLFreeStmt(hstmt, SQL_CLOSE);
3379     RETCODE retcode;
3380
3381     // Some databases cannot accept a user name when looking up table names,
3382     // so we use the call below that leaves out the user name
3383     if (!UserID.IsEmpty() &&
3384         Dbms() != dbmsMY_SQL &&
3385         Dbms() != dbmsACCESS &&
3386         Dbms() != dbmsMS_SQL_SERVER &&
3387         Dbms() != dbmsDB2 &&
3388         Dbms() != dbmsINTERBASE &&
3389         Dbms() != dbmsPERVASIVE_SQL)
3390     {
3391         retcode = SQLTables(hstmt,
3392                             NULL, 0,                                  // All qualifiers
3393                             (SQLTCHAR *) UserID.c_str(), SQL_NTS,        // Only tables owned by this user
3394                             (SQLTCHAR FAR *)TableName.c_str(), SQL_NTS,
3395                             NULL, 0);                                 // All table types
3396     }
3397     else
3398     {
3399         retcode = SQLTables(hstmt,
3400                             NULL, 0,                                  // All qualifiers
3401                             NULL, 0,                                  // All owners
3402                             (SQLTCHAR FAR *)TableName.c_str(), SQL_NTS,
3403                             NULL, 0);                                 // All table types
3404     }
3405     if (retcode != SQL_SUCCESS)
3406         return(DispAllErrors(henv, hdbc, hstmt));
3407
3408     retcode = SQLFetch(hstmt);
3409     if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
3410     {
3411         SQLFreeStmt(hstmt, SQL_CLOSE);
3412         return(DispAllErrors(henv, hdbc, hstmt));
3413     }
3414
3415     SQLFreeStmt(hstmt, SQL_CLOSE);
3416
3417     return true;
3418
3419 }  // wxDb::TableExists()
3420
3421
3422 /********** wxDb::TablePrivileges() **********/
3423 bool wxDb::TablePrivileges(const wxString &tableName, const wxString &priv, const wxChar *userID,
3424                             const wxChar *schema, const wxString &WXUNUSED(tablePath))
3425 {
3426     wxASSERT(tableName.Length());
3427
3428     wxDbTablePrivilegeInfo  result;
3429     SDWORD  cbRetVal;
3430     RETCODE retcode;
3431
3432     // We probably need to be able to dynamically set this based on
3433     // the driver type, and state.
3434     wxChar curRole[]=wxT("public");
3435
3436     wxString TableName;
3437
3438     wxString UserID,Schema;
3439     convertUserID(userID,UserID);
3440     convertUserID(schema,Schema);
3441
3442     TableName = tableName;
3443     // Oracle and Interbase table names are uppercase only, so force
3444     // the name to uppercase just in case programmer forgot to do this
3445     if ((Dbms() == dbmsORACLE) ||
3446         (Dbms() == dbmsINTERBASE))
3447         TableName = TableName.Upper();
3448
3449     SQLFreeStmt(hstmt, SQL_CLOSE);
3450
3451     // Some databases cannot accept a user name when looking up table names,
3452     // so we use the call below that leaves out the user name
3453     if (!Schema.IsEmpty() &&
3454         Dbms() != dbmsMY_SQL &&
3455         Dbms() != dbmsACCESS &&
3456         Dbms() != dbmsMS_SQL_SERVER)
3457     {
3458         retcode = SQLTablePrivileges(hstmt,
3459                                      NULL, 0,                                    // Catalog
3460                                      (SQLTCHAR FAR *)Schema.c_str(), SQL_NTS,               // Schema
3461                                      (SQLTCHAR FAR *)TableName.c_str(), SQL_NTS);
3462     }
3463     else
3464     {
3465         retcode = SQLTablePrivileges(hstmt,
3466                                      NULL, 0,                                    // Catalog
3467                                      NULL, 0,                                    // Schema
3468                                      (SQLTCHAR FAR *)TableName.c_str(), SQL_NTS);
3469     }
3470
3471 #ifdef DBDEBUG_CONSOLE
3472     wxFprintf(stderr ,wxT("SQLTablePrivileges() returned %i \n"),retcode);
3473 #endif
3474
3475     if ((retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO))
3476         return(DispAllErrors(henv, hdbc, hstmt));
3477
3478     bool failed = false;
3479     retcode = SQLFetch(hstmt);
3480     while (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO)
3481     {
3482         if (SQLGetData(hstmt, 1, SQL_C_CHAR, (UCHAR*) result.tableQual, sizeof(result.tableQual), &cbRetVal) != SQL_SUCCESS)
3483             failed = true;
3484
3485         if (!failed && SQLGetData(hstmt, 2, SQL_C_CHAR, (UCHAR*) result.tableOwner, sizeof(result.tableOwner), &cbRetVal) != SQL_SUCCESS)
3486             failed = true;
3487
3488         if (!failed && SQLGetData(hstmt, 3, SQL_C_CHAR, (UCHAR*) result.tableName, sizeof(result.tableName), &cbRetVal) != SQL_SUCCESS)
3489             failed = true;
3490
3491         if (!failed && SQLGetData(hstmt, 4, SQL_C_CHAR, (UCHAR*) result.grantor, sizeof(result.grantor), &cbRetVal) != SQL_SUCCESS)
3492             failed = true;
3493
3494         if (!failed && SQLGetData(hstmt, 5, SQL_C_CHAR, (UCHAR*) result.grantee, sizeof(result.grantee), &cbRetVal) != SQL_SUCCESS)
3495             failed = true;
3496
3497         if (!failed && SQLGetData(hstmt, 6, SQL_C_CHAR, (UCHAR*) result.privilege, sizeof(result.privilege), &cbRetVal) != SQL_SUCCESS)
3498             failed = true;
3499
3500         if (!failed && SQLGetData(hstmt, 7, SQL_C_CHAR, (UCHAR*) result.grantable, sizeof(result.grantable), &cbRetVal) != SQL_SUCCESS)
3501             failed = true;
3502
3503         if (failed)
3504         {
3505             return(DispAllErrors(henv, hdbc, hstmt));
3506         }
3507 #ifdef DBDEBUG_CONSOLE
3508         wxFprintf(stderr,wxT("Scanning %s privilege on table %s.%s granted by %s to %s\n"),
3509                 result.privilege,result.tableOwner,result.tableName,
3510                 result.grantor, result.grantee);
3511 #endif
3512
3513         if (UserID.IsSameAs(result.tableOwner,false))
3514         {
3515             SQLFreeStmt(hstmt, SQL_CLOSE);
3516             return true;
3517         }
3518
3519         if (UserID.IsSameAs(result.grantee,false) &&
3520             !wxStrcmp(result.privilege,priv))
3521         {
3522             SQLFreeStmt(hstmt, SQL_CLOSE);
3523             return true;
3524         }
3525
3526         if (!wxStrcmp(result.grantee,curRole) &&
3527             !wxStrcmp(result.privilege,priv))
3528         {
3529             SQLFreeStmt(hstmt, SQL_CLOSE);
3530             return true;
3531         }
3532
3533         retcode = SQLFetch(hstmt);
3534     }
3535
3536     SQLFreeStmt(hstmt, SQL_CLOSE);
3537     return false;
3538
3539 }  // wxDb::TablePrivileges
3540
3541
3542 const wxString wxDb::SQLTableName(const wxChar *tableName)
3543 {
3544     wxString TableName;
3545
3546     if (Dbms() == dbmsACCESS)
3547         TableName = _T("\"");
3548     TableName += tableName;
3549     if (Dbms() == dbmsACCESS)
3550         TableName += _T("\"");
3551
3552     return TableName;
3553 }  // wxDb::SQLTableName()
3554
3555
3556 const wxString wxDb::SQLColumnName(const wxChar *colName)
3557 {
3558     wxString ColName;
3559
3560     if (Dbms() == dbmsACCESS)
3561         ColName = _T("\"");
3562     ColName += colName;
3563     if (Dbms() == dbmsACCESS)
3564         ColName += _T("\"");
3565
3566     return ColName;
3567 }  // wxDb::SQLColumnName()
3568
3569
3570 /********** wxDb::SetSqlLogging() **********/
3571 bool wxDb::SetSqlLogging(wxDbSqlLogState state, const wxString &filename, bool append)
3572 {
3573     wxASSERT(state == sqlLogON  || state == sqlLogOFF);
3574     wxASSERT(state == sqlLogOFF || filename.Length());
3575
3576     if (state == sqlLogON)
3577     {
3578         if (fpSqlLog == 0)
3579         {
3580             fpSqlLog = wxFopen(filename, (append ? wxT("at") : wxT("wt")));
3581             if (fpSqlLog == NULL)
3582                 return false;
3583         }
3584     }
3585     else  // sqlLogOFF
3586     {
3587         if (fpSqlLog)
3588         {
3589             if (fclose(fpSqlLog))
3590                 return false;
3591             fpSqlLog = 0;
3592         }
3593     }
3594
3595     sqlLogState = state;
3596     return true;
3597
3598 }  // wxDb::SetSqlLogging()
3599
3600
3601 /********** wxDb::WriteSqlLog() **********/
3602 bool wxDb::WriteSqlLog(const wxString &logMsg)
3603 {
3604     wxASSERT(logMsg.Length());
3605
3606     if (fpSqlLog == 0 || sqlLogState == sqlLogOFF)
3607         return false;
3608
3609     if (wxFputs(wxT("\n"),   fpSqlLog) == EOF)
3610         return false;
3611     if (wxFputs(logMsg, fpSqlLog) == EOF)
3612         return false;
3613     if (wxFputs(wxT("\n"),   fpSqlLog) == EOF)
3614         return false;
3615
3616     return true;
3617
3618 }  // wxDb::WriteSqlLog()
3619
3620
3621 /********** wxDb::Dbms() **********/
3622 wxDBMS wxDb::Dbms(void)
3623 /*
3624  * Be aware that not all database engines use the exact same syntax, and not
3625  * every ODBC compliant database is compliant to the same level of compliancy.
3626  * Some manufacturers support the minimum Level 1 compliancy, and others up
3627  * through Level 3.  Others support subsets of features for levels above 1.
3628  *
3629  * If you find an inconsistency between the wxDb class and a specific database
3630  * engine, and an identifier to this section, and special handle the database in
3631  * the area where behavior is non-conforming with the other databases.
3632  *
3633  *
3634  * NOTES ABOUT ISSUES SPECIFIC TO EACH DATABASE ENGINE
3635  * ---------------------------------------------------
3636  *
3637  * ORACLE
3638  *        - Currently the only database supported by the class to support VIEWS
3639  *
3640  * DBASE
3641  *        - Does not support the SQL_TIMESTAMP structure
3642  *        - Supports only one cursor and one connect (apparently? with Microsoft driver only?)
3643  *        - Does not automatically create the primary index if the 'keyField' param of SetColDef
3644  *            is true.  The user must create ALL indexes from their program.
3645  *        - Table names can only be 8 characters long
3646  *        - Column names can only be 10 characters long
3647  *
3648  * SYBASE (all)
3649  *        - To lock a record during QUERY functions, the reserved word 'HOLDLOCK' must be added
3650  *            after every table name involved in the query/join if that tables matching record(s)
3651  *            are to be locked
3652  *        - Ignores the keywords 'FOR UPDATE'.  Use the HOLDLOCK functionality described above
3653  *
3654  * SYBASE (Enterprise)
3655  *        - If a column is part of the Primary Key, the column cannot be NULL
3656  *        - Maximum row size is somewhere in the neighborhood of 1920 bytes
3657  *
3658  * MY_SQL
3659  *        - If a column is part of the Primary Key, the column cannot be NULL
3660  *        - Cannot support selecting for update [::CanSelectForUpdate()].  Always returns FALSE
3661  *        - Columns that are part of primary or secondary keys must be defined as being NOT NULL
3662  *            when they are created.  Some code is added in ::CreateIndex to try to adjust the
3663  *            column definition if it is not defined correctly, but it is experimental
3664  *        - Does not support sub-queries in SQL statements
3665  *
3666  * POSTGRES
3667  *        - Does not support the keywords 'ASC' or 'DESC' as of release v6.5.0
3668  *        - Does not support sub-queries in SQL statements
3669  *
3670  * DB2
3671  *        - Primary keys must be declared as NOT NULL
3672  *        - Table and index names must not be longer than 13 characters in length (technically
3673  *          table names can be up to 18 characters, but the primary index is created using the
3674  *          base table name plus "_PIDX", so the limit if the table has a primary index is 13.
3675  *
3676  * PERVASIVE SQL
3677  *
3678  * INTERBASE
3679  *        - Columns that are part of primary keys must be defined as being NOT NULL
3680  *          when they are created.  Some code is added in ::CreateIndex to try to adjust the
3681  *          column definition if it is not defined correctly, but it is experimental
3682  */
3683 {
3684     // Should only need to do this once for each new database connection
3685     // so return the value we already determined it to be to save time
3686     // and lots of string comparisons
3687     if (dbmsType != dbmsUNIDENTIFIED)
3688         return(dbmsType);
3689
3690     wxChar baseName[25+1];
3691     wxStrncpy(baseName,dbInf.dbmsName,25);
3692     baseName[25] = 0;
3693
3694     // RGG 20001025 : add support for Interbase
3695     // GT : Integrated to base classes on 20001121
3696     if (!wxStricmp(dbInf.dbmsName,wxT("Interbase")))
3697         return((wxDBMS)(dbmsType = dbmsINTERBASE));
3698
3699     // BJO 20000428 : add support for Virtuoso
3700     if (!wxStricmp(dbInf.dbmsName,wxT("OpenLink Virtuoso VDBMS")))
3701       return((wxDBMS)(dbmsType = dbmsVIRTUOSO));
3702
3703     if (!wxStricmp(dbInf.dbmsName,wxT("Adaptive Server Anywhere")))
3704         return((wxDBMS)(dbmsType = dbmsSYBASE_ASA));
3705
3706     // BJO 20000427 : The "SQL Server" string is also returned by SQLServer when
3707     // connected through an OpenLink driver.
3708     // Is it also returned by Sybase Adapatitve server?
3709     // OpenLink driver name is OLOD3032.DLL for msw and oplodbc.so for unix
3710     if (!wxStricmp(dbInf.dbmsName,wxT("SQL Server")))
3711     {
3712       if (!wxStrncmp(dbInf.driverName, wxT("oplodbc"), 7) ||
3713           !wxStrncmp(dbInf.driverName, wxT("OLOD"), 4))
3714             return ((wxDBMS)(dbmsMS_SQL_SERVER));
3715         else
3716             return ((wxDBMS)(dbmsType = dbmsSYBASE_ASE));
3717     }
3718
3719     if (!wxStricmp(dbInf.dbmsName,wxT("Microsoft SQL Server")))
3720         return((wxDBMS)(dbmsType = dbmsMS_SQL_SERVER));
3721
3722     baseName[10] = 0;
3723     if (!wxStricmp(baseName,wxT("PostgreSQL")))  // v6.5.0
3724         return((wxDBMS)(dbmsType = dbmsPOSTGRES));
3725
3726     baseName[9] = 0;
3727     if (!wxStricmp(baseName,wxT("Pervasive")))
3728         return((wxDBMS)(dbmsType = dbmsPERVASIVE_SQL));
3729
3730     baseName[8] = 0;
3731     if (!wxStricmp(baseName,wxT("Informix")))
3732         return((wxDBMS)(dbmsType = dbmsINFORMIX));
3733
3734     baseName[6] = 0;
3735     if (!wxStricmp(baseName,wxT("Oracle")))
3736         return((wxDBMS)(dbmsType = dbmsORACLE));
3737     if (!wxStricmp(baseName,wxT("ACCESS")))
3738         return((wxDBMS)(dbmsType = dbmsACCESS));
3739     if (!wxStricmp(baseName,wxT("Sybase")))
3740       return((wxDBMS)(dbmsType = dbmsSYBASE_ASE));
3741
3742     baseName[5] = 0;
3743     if (!wxStricmp(baseName,wxT("DBASE")))
3744         return((wxDBMS)(dbmsType = dbmsDBASE));
3745     if (!wxStricmp(baseName,wxT("xBase")))
3746         return((wxDBMS)(dbmsType = dbmsXBASE_SEQUITER));
3747     if (!wxStricmp(baseName,wxT("MySQL")))
3748         return((wxDBMS)(dbmsType = dbmsMY_SQL));
3749
3750     baseName[3] = 0;
3751     if (!wxStricmp(baseName,wxT("DB2")))
3752         return((wxDBMS)(dbmsType = dbmsDBASE));
3753
3754     return((wxDBMS)(dbmsType = dbmsUNIDENTIFIED));
3755
3756 }  // wxDb::Dbms()
3757
3758
3759 bool wxDb::ModifyColumn(const wxString &tableName, const wxString &columnName,
3760                         int dataType, ULONG columnLength,
3761                         const wxString &optionalParam)
3762 {
3763     wxASSERT(tableName.Length());
3764     wxASSERT(columnName.Length());
3765     wxASSERT((dataType == DB_DATA_TYPE_VARCHAR && columnLength > 0) ||
3766              dataType != DB_DATA_TYPE_VARCHAR);
3767
3768     // Must specify a columnLength if modifying a VARCHAR type column
3769     if (dataType == DB_DATA_TYPE_VARCHAR && !columnLength)
3770         return false;
3771
3772     wxString dataTypeName;
3773     wxString sqlStmt;
3774     wxString alterSlashModify;
3775
3776     switch(dataType)
3777     {
3778         case DB_DATA_TYPE_VARCHAR :
3779             dataTypeName = typeInfVarchar.TypeName;
3780             break;
3781         case DB_DATA_TYPE_INTEGER :
3782             dataTypeName = typeInfInteger.TypeName;
3783             break;
3784         case DB_DATA_TYPE_FLOAT :
3785             dataTypeName = typeInfFloat.TypeName;
3786             break;
3787         case DB_DATA_TYPE_DATE :
3788             dataTypeName = typeInfDate.TypeName;
3789             break;
3790         case DB_DATA_TYPE_BLOB :
3791             dataTypeName = typeInfBlob.TypeName;
3792             break;
3793         default:
3794             return false;
3795     }
3796
3797     // Set the modify or alter syntax depending on the type of database connected to
3798     switch (Dbms())
3799     {
3800         case dbmsORACLE :
3801             alterSlashModify = _T("MODIFY");
3802             break;
3803         case dbmsMS_SQL_SERVER :
3804             alterSlashModify = _T("ALTER COLUMN");
3805             break;
3806         case dbmsUNIDENTIFIED :
3807             return false;
3808         case dbmsSYBASE_ASA :
3809         case dbmsSYBASE_ASE :
3810         case dbmsMY_SQL :
3811         case dbmsPOSTGRES :
3812         case dbmsACCESS :
3813         case dbmsDBASE :
3814         case dbmsXBASE_SEQUITER :
3815         default :
3816             alterSlashModify = _T("MODIFY");
3817             break;
3818     }
3819
3820     // create the SQL statement
3821     if ( Dbms() == dbmsMY_SQL )
3822     {
3823         sqlStmt.Printf(wxT("ALTER TABLE %s %s %s %s"), tableName.c_str(), alterSlashModify.c_str(),
3824               columnName.c_str(), dataTypeName.c_str());
3825     }
3826     else
3827     {
3828         sqlStmt.Printf(wxT("ALTER TABLE \"%s\" \"%s\" \"%s\" %s"), tableName.c_str(), alterSlashModify.c_str(),
3829               columnName.c_str(), dataTypeName.c_str());
3830     }
3831
3832     // For varchars only, append the size of the column
3833     if (dataType == DB_DATA_TYPE_VARCHAR &&
3834         (Dbms() != dbmsMY_SQL || dataTypeName != _T("text")))
3835     {
3836         wxString s;
3837         s.Printf(wxT("(%lu)"), columnLength);
3838         sqlStmt += s;
3839     }
3840
3841     // for passing things like "NOT NULL"
3842     if (optionalParam.Length())
3843     {
3844         sqlStmt += wxT(" ");
3845         sqlStmt += optionalParam;
3846     }
3847
3848     return ExecSql(sqlStmt);
3849
3850 } // wxDb::ModifyColumn()
3851
3852
3853 /********** wxDbGetConnection() **********/
3854 wxDb WXDLLIMPEXP_ODBC *wxDbGetConnection(wxDbConnectInf *pDbConfig, bool FwdOnlyCursors)
3855 {
3856     wxDbList *pList;
3857
3858     // Used to keep a pointer to a DB connection that matches the requested
3859     // DSN and FwdOnlyCursors settings, even if it is not FREE, so that the
3860     // data types can be copied from it (using the wxDb::Open(wxDb *) function)
3861     // rather than having to re-query the datasource to get all the values
3862     // using the wxDb::Open(Dsn,Uid,AuthStr) function
3863     wxDb *matchingDbConnection = NULL;
3864
3865     // Scan the linked list searching for an available database connection
3866     // that's already been opened but is currently not in use.
3867     for (pList = PtrBegDbList; pList; pList = pList->PtrNext)
3868     {
3869         // The database connection must be for the same datasource
3870         // name and must currently not be in use.
3871         if (pList->Free &&
3872             (pList->PtrDb->FwdOnlyCursors() == FwdOnlyCursors))
3873         {
3874             if (pDbConfig->UseConnectionStr())
3875             {
3876                 if (pList->PtrDb->OpenedWithConnectionString() &&
3877                      (!wxStrcmp(pDbConfig->GetConnectionStr(), pList->ConnectionStr)))
3878                 {
3879                     // Found a free connection
3880                     pList->Free = false;
3881                     return(pList->PtrDb);
3882                 }
3883             }
3884             else
3885             {
3886                 if (!pList->PtrDb->OpenedWithConnectionString() &&
3887                      (!wxStrcmp(pDbConfig->GetDsn(), pList->Dsn)))
3888                 {
3889                     // Found a free connection
3890                     pList->Free = false;
3891                     return(pList->PtrDb);
3892                 }
3893             }
3894         }
3895
3896         if (pDbConfig->UseConnectionStr())
3897         {
3898             if (!wxStrcmp(pDbConfig->GetConnectionStr(), pList->ConnectionStr))
3899                 matchingDbConnection = pList->PtrDb;
3900         }
3901         else
3902         {
3903             if (!wxStrcmp(pDbConfig->GetDsn(), pList->Dsn) &&
3904                 !wxStrcmp(pDbConfig->GetUserID(), pList->Uid) &&
3905                 !wxStrcmp(pDbConfig->GetPassword(), pList->AuthStr))
3906                 matchingDbConnection = pList->PtrDb;
3907         }
3908     }
3909
3910     // No available connections.  A new connection must be made and
3911     // appended to the end of the linked list.
3912     if (PtrBegDbList)
3913     {
3914         // Find the end of the list
3915         for (pList = PtrBegDbList; pList->PtrNext; pList = pList->PtrNext);
3916         // Append a new list item
3917         pList->PtrNext = new wxDbList;
3918         pList->PtrNext->PtrPrev = pList;
3919         pList = pList->PtrNext;
3920     }
3921     else  // Empty list
3922     {
3923         // Create the first node on the list
3924         pList = PtrBegDbList = new wxDbList;
3925         pList->PtrPrev = 0;
3926     }
3927
3928     // Initialize new node in the linked list
3929     pList->PtrNext          = 0;
3930     pList->Free             = false;
3931     pList->Dsn              = pDbConfig->GetDsn();
3932     pList->Uid              = pDbConfig->GetUserID();
3933     pList->AuthStr          = pDbConfig->GetPassword();
3934     pList->ConnectionStr    = pDbConfig->GetConnectionStr();
3935
3936     pList->PtrDb = new wxDb(pDbConfig->GetHenv(), FwdOnlyCursors);
3937
3938     bool opened;
3939
3940     if (!matchingDbConnection)
3941     {
3942         if (pDbConfig->UseConnectionStr())
3943         {
3944             opened = pList->PtrDb->Open(pDbConfig->GetConnectionStr());
3945         }
3946         else
3947         {
3948             opened = pList->PtrDb->Open(pDbConfig->GetDsn(), pDbConfig->GetUserID(), pDbConfig->GetPassword());
3949         }
3950     }
3951     else
3952         opened = pList->PtrDb->Open(matchingDbConnection);
3953
3954     // Connect to the datasource
3955     if (opened)
3956     {
3957         pList->PtrDb->setCached(true);  // Prevent a user from deleting a cached connection
3958         pList->PtrDb->SetSqlLogging(SQLLOGstate, SQLLOGfn, true);
3959         return(pList->PtrDb);
3960     }
3961     else  // Unable to connect, destroy list item
3962     {
3963         if (pList->PtrPrev)
3964             pList->PtrPrev->PtrNext = 0;
3965         else
3966             PtrBegDbList = 0;        // Empty list again
3967
3968         pList->PtrDb->CommitTrans(); // Commit any open transactions on wxDb object
3969         pList->PtrDb->Close();       // Close the wxDb object
3970         delete pList->PtrDb;         // Deletes the wxDb object
3971         delete pList;                // Deletes the linked list object
3972         return(0);
3973     }
3974
3975 }  // wxDbGetConnection()
3976
3977
3978 /********** wxDbFreeConnection() **********/
3979 bool WXDLLIMPEXP_ODBC wxDbFreeConnection(wxDb *pDb)
3980 {
3981     wxDbList *pList;
3982
3983     // Scan the linked list searching for the database connection
3984     for (pList = PtrBegDbList; pList; pList = pList->PtrNext)
3985     {
3986         if (pList->PtrDb == pDb)  // Found it, now free it!!!
3987             return (pList->Free = true);
3988     }
3989
3990     // Never found the database object, return failure
3991     return false;
3992
3993 }  // wxDbFreeConnection()
3994
3995
3996 /********** wxDbCloseConnections() **********/
3997 void WXDLLIMPEXP_ODBC wxDbCloseConnections(void)
3998 {
3999     wxDbList *pList, *pNext;
4000
4001     // Traverse the linked list closing database connections and freeing memory as I go.
4002     for (pList = PtrBegDbList; pList; pList = pNext)
4003     {
4004         pNext = pList->PtrNext;       // Save the pointer to next
4005         pList->PtrDb->CommitTrans();  // Commit any open transactions on wxDb object
4006         pList->PtrDb->Close();        // Close the wxDb object
4007         pList->PtrDb->setCached(false);  // Allows deletion of the wxDb instance
4008         delete pList->PtrDb;          // Deletes the wxDb object
4009         delete pList;                 // Deletes the linked list object
4010     }
4011
4012     // Mark the list as empty
4013     PtrBegDbList = 0;
4014
4015 }  // wxDbCloseConnections()
4016
4017
4018 /********** wxDbConnectionsInUse() **********/
4019 int WXDLLIMPEXP_ODBC wxDbConnectionsInUse(void)
4020 {
4021     wxDbList *pList;
4022     int cnt = 0;
4023
4024     // Scan the linked list counting db connections that are currently in use
4025     for (pList = PtrBegDbList; pList; pList = pList->PtrNext)
4026     {
4027         if (pList->Free == false)
4028             cnt++;
4029     }
4030
4031     return(cnt);
4032
4033 }  // wxDbConnectionsInUse()
4034
4035
4036
4037 /********** wxDbLogExtendedErrorMsg() **********/
4038 // DEBUG ONLY function
4039 const wxChar WXDLLIMPEXP_ODBC *wxDbLogExtendedErrorMsg(const wxChar *userText,
4040                                                   wxDb *pDb,
4041                                                   const wxChar *ErrFile,
4042                                                   int ErrLine)
4043 {
4044     static wxString msg;
4045     msg = userText;
4046
4047     wxString tStr;
4048
4049     if (ErrFile || ErrLine)
4050     {
4051         msg += wxT("File: ");
4052         msg += ErrFile;
4053         msg += wxT("   Line: ");
4054         tStr.Printf(wxT("%d"),ErrLine);
4055         msg += tStr.c_str();
4056         msg += wxT("\n");
4057     }
4058
4059     msg.Append (wxT("\nODBC errors:\n"));
4060     msg += wxT("\n");
4061
4062     // Display errors for this connection
4063     int i;
4064     for (i = 0; i < DB_MAX_ERROR_HISTORY; i++)
4065     {
4066         if (pDb->errorList[i])
4067         {
4068             msg.Append(pDb->errorList[i]);
4069             if (wxStrcmp(pDb->errorList[i],wxT("")) != 0)
4070                 msg.Append(wxT("\n"));
4071             // Clear the errmsg buffer so the next error will not
4072             // end up showing the previous error that have occurred
4073             wxStrcpy(pDb->errorList[i],wxT(""));
4074         }
4075     }
4076     msg += wxT("\n");
4077
4078     wxLogDebug(msg.c_str());
4079
4080     return msg.c_str();
4081 }  // wxDbLogExtendedErrorMsg()
4082
4083
4084 /********** wxDbSqlLog() **********/
4085 bool wxDbSqlLog(wxDbSqlLogState state, const wxChar *filename)
4086 {
4087     bool append = false;
4088     wxDbList *pList;
4089
4090     for (pList = PtrBegDbList; pList; pList = pList->PtrNext)
4091     {
4092         if (!pList->PtrDb->SetSqlLogging(state,filename,append))
4093             return false;
4094         append = true;
4095     }
4096
4097     SQLLOGstate = state;
4098     SQLLOGfn = filename;
4099
4100     return true;
4101
4102 }  // wxDbSqlLog()
4103
4104
4105 #if 0
4106 /********** wxDbCreateDataSource() **********/
4107 int wxDbCreateDataSource(const wxString &driverName, const wxString &dsn, const wxString &description,
4108                          bool sysDSN, const wxString &defDir, wxWindow *parent)
4109 /*
4110  * !!!! ONLY FUNCTIONAL UNDER MSW with VC6 !!!!
4111  * Very rudimentary creation of an ODBC data source.
4112  *
4113  * ODBC driver must be ODBC 3.0 compliant to use this function
4114  */
4115 {
4116     int result = FALSE;
4117
4118 //!!!! ONLY FUNCTIONAL UNDER MSW with VC6 !!!!
4119 #ifdef __VISUALC__
4120     int       dsnLocation;
4121     wxString  setupStr;
4122
4123     if (sysDSN)
4124         dsnLocation = ODBC_ADD_SYS_DSN;
4125     else
4126         dsnLocation = ODBC_ADD_DSN;
4127
4128     // NOTE: The decimal 2 is an invalid character in all keyword pairs
4129     // so that is why I used it, as wxString does not deal well with
4130     // embedded nulls in strings
4131     setupStr.Printf(wxT("DSN=%s%cDescription=%s%cDefaultDir=%s%c"),dsn,2,description,2,defDir,2);
4132
4133     // Replace the separator from above with the '\0' seperator needed
4134     // by the SQLConfigDataSource() function
4135     int k;
4136     do
4137     {
4138         k = setupStr.Find((wxChar)2,true);
4139         if (k != wxNOT_FOUND)
4140             setupStr[(UINT)k] = wxT('\0');
4141     }
4142     while (k != wxNOT_FOUND);
4143
4144     result = SQLConfigDataSource((HWND)parent->GetHWND(), dsnLocation,
4145                                  driverName, setupStr.c_str());
4146
4147     if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
4148     {
4149         // check for errors caused by ConfigDSN based functions
4150         DWORD retcode = 0;
4151         WORD cb;
4152         wxChar errMsg[SQL_MAX_MESSAGE_LENGTH];
4153         errMsg[0] = wxT('\0');
4154
4155         // This function is only supported in ODBC drivers v3.0 compliant and above
4156         SQLInstallerError(1,&retcode,errMsg,SQL_MAX_MESSAGE_LENGTH-1,&cb);
4157         if (retcode)
4158         {
4159 #ifdef DBDEBUG_CONSOLE
4160                // When run in console mode, use standard out to display errors.
4161                cout << errMsg << endl;
4162                cout << wxT("Press any key to continue...") << endl;
4163                getchar();
4164 #endif  // DBDEBUG_CONSOLE
4165
4166 #ifdef __WXDEBUG__
4167                wxLogDebug(errMsg,wxT("ODBC DEBUG MESSAGE"));
4168 #endif  // __WXDEBUG__
4169         }
4170     }
4171     else
4172        result = TRUE;
4173 #else
4174     // Using iODBC/unixODBC or some other compiler which does not support the APIs
4175     // necessary to use this function, so this function is not supported
4176 #ifdef __WXDEBUG__
4177     wxLogDebug(wxT("wxDbCreateDataSource() not available except under VC++/MSW"),wxT("ODBC DEBUG MESSAGE"));
4178 #endif
4179     result = FALSE;
4180 #endif  // __VISUALC__
4181
4182     return result;
4183
4184 }  // wxDbCreateDataSource()
4185 #endif
4186
4187
4188 /********** wxDbGetDataSource() **********/
4189 bool wxDbGetDataSource(HENV henv, wxChar *Dsn, SWORD DsnMax, wxChar *DsDesc,
4190                        SWORD DsDescMax, UWORD direction)
4191 /*
4192  * Dsn and DsDesc will contain the data source name and data source
4193  * description upon return
4194  */
4195 {
4196     SWORD cb1,cb2;
4197
4198     if (SQLDataSources(henv, direction, (SQLTCHAR FAR *) Dsn, DsnMax, &cb1,
4199                              (SQLTCHAR FAR *) DsDesc, DsDescMax, &cb2) == SQL_SUCCESS)
4200         return true;
4201     else
4202         return false;
4203
4204 }  // wxDbGetDataSource()
4205
4206
4207 // Change this to 0 to remove use of all deprecated functions
4208 #if wxODBC_BACKWARD_COMPATABILITY
4209 /********************************************************************
4210  ********************************************************************
4211  *
4212  * The following functions are all DEPRECATED and are included for
4213  * backward compatability reasons only
4214  *
4215  ********************************************************************
4216  ********************************************************************/
4217 bool SqlLog(sqlLog state, const wxChar *filename)
4218 {
4219     return wxDbSqlLog((enum wxDbSqlLogState)state, filename);
4220 }
4221 /***** DEPRECATED: use wxGetDataSource() *****/
4222 bool GetDataSource(HENV henv, char *Dsn, SWORD DsnMax, char *DsDesc, SWORD DsDescMax,
4223                          UWORD direction)
4224 {
4225     return wxDbGetDataSource(henv, Dsn, DsnMax, DsDesc, DsDescMax, direction);
4226 }
4227 /***** DEPRECATED: use wxDbGetConnection() *****/
4228 wxDb WXDLLIMPEXP_ODBC *GetDbConnection(DbStuff *pDbStuff, bool FwdOnlyCursors)
4229 {
4230     return wxDbGetConnection((wxDbConnectInf *)pDbStuff, FwdOnlyCursors);
4231 }
4232 /***** DEPRECATED: use wxDbFreeConnection() *****/
4233 bool WXDLLIMPEXP_ODBC FreeDbConnection(wxDb *pDb)
4234 {
4235     return wxDbFreeConnection(pDb);
4236 }
4237 /***** DEPRECATED: use wxDbCloseConnections() *****/
4238 void WXDLLIMPEXP_ODBC CloseDbConnections(void)
4239 {
4240     wxDbCloseConnections();
4241 }
4242 /***** DEPRECATED: use wxDbConnectionsInUse() *****/
4243 int WXDLLIMPEXP_ODBC NumberDbConnectionsInUse(void)
4244 {
4245     return wxDbConnectionsInUse();
4246 }
4247 #endif
4248
4249
4250 #endif
4251  // wxUSE_ODBC