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