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