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