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