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