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