src/common/db.cpp

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