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