src/common/db.cpp

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