1 ///////////////////////////////////////////////////////////////////////////////
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.
7 // Modified by: George Tasker
9 // Mark Johnson, wxWindows@mj10777.de
11 // -Added support for SQL statement logging and database cataloging
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
20 // Copyright: (c) 1996 Remstar International, Inc.
21 // Licence: wxWindows licence
22 ///////////////////////////////////////////////////////////////////////////////
28 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
29 #pragma implementation "db.h"
32 #include "wx/wxprec.h"
38 #ifdef DBDEBUG_CONSOLE
39 #include "wx/ioswrap.h"
43 #include "wx/string.h"
44 #include "wx/object.h"
49 #include "wx/filefn.h"
50 #include "wx/wxchar.h"
62 // DLL options compatibility check:
64 WX_CHECK_BUILD_OPTIONS("wxODBC")
66 WXDLLIMPEXP_DATA_ODBC(wxDbList
*) PtrBegDbList
= 0;
68 wxChar
const *SQL_LOG_FILENAME
= wxT("sqllog.txt");
69 wxChar
const *SQL_CATALOG_FILENAME
= wxT("catalog.txt");
72 extern wxList TablesInUse
;
75 // SQL Log defaults to be used by GetDbConnection
76 wxDbSqlLogState SQLLOGstate
= sqlLogOFF
;
78 static wxString SQLLOGfn
= SQL_LOG_FILENAME
;
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
88 wxChar DBerrorList
[DB_MAX_ERROR_HISTORY
][DB_MAX_ERROR_MSG_LEN
+1];
91 // This type defines the return row-struct form
92 // SQLTablePrivileges, and is used by wxDB::TablePrivileges.
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
;
105 /********** wxDbConnectInf Constructor - form 1 **********/
106 wxDbConnectInf::wxDbConnectInf()
109 freeHenvOnDestroy
= false;
115 /********** wxDbConnectInf Constructor - form 2 **********/
116 wxDbConnectInf::wxDbConnectInf(HENV henv
, const wxString
&dsn
, const wxString
&userID
,
117 const wxString
&password
, const wxString
&defaultDir
,
118 const wxString
&fileType
, const wxString
&description
)
121 freeHenvOnDestroy
= false;
132 SetPassword(password
);
133 SetDescription(description
);
134 SetFileType(fileType
);
135 SetDefaultDir(defaultDir
);
136 } // wxDbConnectInf Constructor
139 wxDbConnectInf::~wxDbConnectInf()
141 if (freeHenvOnDestroy
)
145 } // wxDbConnectInf Destructor
149 /********** wxDbConnectInf::Initialize() **********/
150 bool wxDbConnectInf::Initialize()
152 freeHenvOnDestroy
= false;
154 if (freeHenvOnDestroy
&& Henv
)
161 ConnectionStr
[0] = 0;
166 useConnectionStr
= false;
169 } // wxDbConnectInf::Initialize()
172 /********** wxDbConnectInf::AllocHenv() **********/
173 bool wxDbConnectInf::AllocHenv()
175 // This is here to help trap if you are getting a new henv
176 // without releasing an existing henv
179 // Initialize the ODBC Environment for Database Operations
180 if (SQLAllocEnv(&Henv
) != SQL_SUCCESS
)
182 wxLogDebug(wxT("A problem occured while trying to get a connection to the data source"));
186 freeHenvOnDestroy
= true;
189 } // wxDbConnectInf::AllocHenv()
192 void wxDbConnectInf::FreeHenv()
200 freeHenvOnDestroy
= false;
202 } // wxDbConnectInf::FreeHenv()
205 void wxDbConnectInf::SetDsn(const wxString
&dsn
)
207 wxASSERT(dsn
.Length() < sizeof(Dsn
));
209 wxStrncpy(Dsn
, dsn
, sizeof(Dsn
)-1);
210 Dsn
[sizeof(Dsn
)-1] = 0; // Prevent buffer overrun
211 } // wxDbConnectInf::SetDsn()
214 void wxDbConnectInf::SetUserID(const wxString
&uid
)
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()
222 void wxDbConnectInf::SetPassword(const wxString
&password
)
224 wxASSERT(password
.Length() < sizeof(AuthStr
));
226 wxStrncpy(AuthStr
, password
, sizeof(AuthStr
)-1);
227 AuthStr
[sizeof(AuthStr
)-1] = 0; // Prevent buffer overrun
228 } // wxDbConnectInf::SetPassword()
230 void wxDbConnectInf::SetConnectionStr(const wxString
&connectStr
)
232 wxASSERT(connectStr
.Length() < sizeof(ConnectionStr
));
234 useConnectionStr
= wxStrlen(connectStr
) > 0;
236 wxStrncpy(ConnectionStr
, connectStr
, sizeof(ConnectionStr
)-1);
237 ConnectionStr
[sizeof(ConnectionStr
)-1] = 0; // Prevent buffer overrun
238 } // wxDbConnectInf::SetConnectionStr()
241 /********** wxDbColFor Constructor **********/
242 wxDbColFor::wxDbColFor()
245 } // wxDbColFor::wxDbColFor()
248 /********** wxDbColFor::Initialize() **********/
249 void wxDbColFor::Initialize()
259 i_Nation
= 0; // 0=EU, 1=UK, 2=International, 3=US
262 Format(1,DB_DATA_TYPE_VARCHAR
,0,0,0); // the Function that does the work
263 } // wxDbColFor::Initialize()
266 /********** wxDbColFor::Format() **********/
267 int wxDbColFor::Format(int Nation
, int dbDataType
, SWORD sqlDataType
,
268 short columnLength
, short decimalDigits
)
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 // ----------------------------------------------------------------------------------------
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
288 if (i_dbDataType
== 0) // Filter unsupported dbDataTypes
290 if ((i_sqlDataType
== SQL_VARCHAR
)
292 #if defined(SQL_WCHAR)
293 || (i_sqlDataType
== SQL_WCHAR
)
295 #if defined(SQL_WVARCHAR)
296 || (i_sqlDataType
== SQL_WVARCHAR
)
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
;
313 if ((i_dbDataType
== DB_DATA_TYPE_INTEGER
) && (i_sqlDataType
== SQL_C_DOUBLE
))
315 i_dbDataType
= DB_DATA_TYPE_FLOAT
;
318 switch(i_dbDataType
) // TBD: Still a lot of proper formatting to do
320 case DB_DATA_TYPE_VARCHAR
:
323 case DB_DATA_TYPE_INTEGER
:
326 case DB_DATA_TYPE_FLOAT
:
327 if (decimalDigits
== 0)
330 tempStr
.Printf(wxT("%s%d.%d"), tempStr
.c_str(),columnLength
, decimalDigits
);
331 s_Field
.Printf(wxT("%sf"), tempStr
.c_str());
333 case DB_DATA_TYPE_DATE
:
334 if (i_Nation
== 0) // timestamp YYYY-MM-DD HH:MM:SS.SSS (tested for SYBASE)
336 s_Field
= wxT("%04d-%02d-%02d %02d:%02d:%02d.%03d");
338 if (i_Nation
== 1) // European DD.MM.YYYY HH:MM:SS.SSS
340 s_Field
= wxT("%02d.%02d.%04d %02d:%02d:%02d.%03d");
342 if (i_Nation
== 2) // UK DD/MM/YYYY HH:MM:SS.SSS
344 s_Field
= wxT("%02d/%02d/%04d %02d:%02d:%02d.%03d");
346 if (i_Nation
== 3) // International YYYY-MM-DD HH:MM:SS.SSS
348 s_Field
= wxT("%04d-%02d-%02d %02d:%02d:%02d.%03d");
350 if (i_Nation
== 4) // US MM/DD/YYYY HH:MM:SS.SSS
352 s_Field
= wxT("%02d/%02d/%04d %02d:%02d:%02d.%03d");
355 case DB_DATA_TYPE_BLOB
:
356 s_Field
.Printf(wxT("Unable to format(%d)-SQL(%d)"), dbDataType
,sqlDataType
); //
359 s_Field
.Printf(wxT("Unknown Format(%d)-SQL(%d)"), dbDataType
,sqlDataType
); //
363 } // wxDbColFor::Format()
366 /********** wxDbColInf Constructor **********/
367 wxDbColInf::wxDbColInf()
370 } // wxDbColInf::wxDbColInf()
373 /********** wxDbColInf Destructor ********/
374 wxDbColInf::~wxDbColInf()
379 } // wxDbColInf::~wxDbColInf()
382 bool wxDbColInf::Initialize()
404 } // wxDbColInf::Initialize()
407 /********** wxDbTableInf Constructor ********/
408 wxDbTableInf::wxDbTableInf()
411 } // wxDbTableInf::wxDbTableInf()
414 /********** wxDbTableInf Constructor ********/
415 wxDbTableInf::~wxDbTableInf()
420 } // wxDbTableInf::~wxDbTableInf()
423 bool wxDbTableInf::Initialize()
432 } // wxDbTableInf::Initialize()
435 /********** wxDbInf Constructor *************/
439 } // wxDbInf::wxDbInf()
442 /********** wxDbInf Destructor *************/
448 } // wxDbInf::~wxDbInf()
451 /********** wxDbInf::Initialize() *************/
452 bool wxDbInf::Initialize()
460 } // wxDbInf::Initialize()
463 /********** wxDb Constructor **********/
464 wxDb::wxDb(const HENV
&aHenv
, bool FwdOnlyCursors
)
466 // Copy the HENV into the db class
468 fwdOnlyCursors
= FwdOnlyCursors
;
474 /********** wxDb Destructor **********/
477 wxASSERT_MSG(!IsCached(),wxT("Cached connections must not be manually deleted, use\nwxDbFreeConnection() or wxDbCloseConnections()."));
487 /********** PRIVATE! wxDb::initialize PRIVATE! **********/
488 /********** wxDb::initialize() **********/
489 void wxDb::initialize()
491 * Private member function that sets all wxDb member variables to
492 * known values at creation of the wxDb
497 fpSqlLog
= 0; // Sql Log file pointer
498 sqlLogState
= sqlLogOFF
; // By default, logging is turned off
500 dbmsType
= dbmsUNIDENTIFIED
;
502 wxStrcpy(sqlState
,wxEmptyString
);
503 wxStrcpy(errorMsg
,wxEmptyString
);
504 nativeError
= cbErrorMsg
= 0;
505 for (i
= 0; i
< DB_MAX_ERROR_HISTORY
; i
++)
506 wxStrcpy(errorList
[i
], wxEmptyString
);
508 // Init typeInf structures
509 typeInfVarchar
.TypeName
.Empty();
510 typeInfVarchar
.FsqlType
= 0;
511 typeInfVarchar
.Precision
= 0;
512 typeInfVarchar
.CaseSensitive
= 0;
513 typeInfVarchar
.MaximumScale
= 0;
515 typeInfInteger
.TypeName
.Empty();
516 typeInfInteger
.FsqlType
= 0;
517 typeInfInteger
.Precision
= 0;
518 typeInfInteger
.CaseSensitive
= 0;
519 typeInfInteger
.MaximumScale
= 0;
521 typeInfFloat
.TypeName
.Empty();
522 typeInfFloat
.FsqlType
= 0;
523 typeInfFloat
.Precision
= 0;
524 typeInfFloat
.CaseSensitive
= 0;
525 typeInfFloat
.MaximumScale
= 0;
527 typeInfDate
.TypeName
.Empty();
528 typeInfDate
.FsqlType
= 0;
529 typeInfDate
.Precision
= 0;
530 typeInfDate
.CaseSensitive
= 0;
531 typeInfDate
.MaximumScale
= 0;
533 typeInfBlob
.TypeName
.Empty();
534 typeInfBlob
.FsqlType
= 0;
535 typeInfBlob
.Precision
= 0;
536 typeInfBlob
.CaseSensitive
= 0;
537 typeInfBlob
.MaximumScale
= 0;
539 // Error reporting is turned OFF by default
542 // Allocate a data source connection handle
543 if (SQLAllocConnect(henv
, &hdbc
) != SQL_SUCCESS
)
546 // Initialize the db status flag
549 // Mark database as not open as of yet
552 dbOpenedWithConnectionString
= false;
553 } // wxDb::initialize()
556 /********** PRIVATE! wxDb::convertUserID PRIVATE! **********/
558 // NOTE: Return value from this function MUST be copied
559 // immediately, as the value is not good after
560 // this function has left scope.
562 const wxChar
*wxDb::convertUserID(const wxChar
*userID
, wxString
&UserID
)
566 if (!wxStrlen(userID
))
574 // dBase does not use user names, and some drivers fail if you try to pass one
575 if ( Dbms() == dbmsDBASE
576 || Dbms() == dbmsXBASE_SEQUITER
)
579 // Some databases require user names to be specified in uppercase,
580 // so force the name to uppercase
581 if ((Dbms() == dbmsORACLE
) ||
582 (Dbms() == dbmsMAXDB
))
583 UserID
= UserID
.Upper();
585 return UserID
.c_str();
586 } // wxDb::convertUserID()
589 bool wxDb::determineDataTypes(bool failOnDataTypeUnsupported
)
593 // These are the possible SQL types we check for use against the datasource we are connected
594 // to for the purpose of determining which data type to use for the basic character strings
597 // NOTE: The first type in this enumeration that is determined to be supported by the
598 // datasource/driver is the one that will be used.
599 SWORD PossibleSqlCharTypes
[] = {
600 #if wxUSE_UNICODE && defined(SQL_WVARCHAR)
604 #if wxUSE_UNICODE && defined(SQL_WVARCHAR)
610 // These are the possible SQL types we check for use against the datasource we are connected
611 // to for the purpose of determining which data type to use for the basic non-floating point
614 // NOTE: The first type in this enumeration that is determined to be supported by the
615 // datasource/driver is the one that will be used.
616 SWORD PossibleSqlIntegerTypes
[] = {
620 // These are the possible SQL types we check for use against the datasource we are connected
621 // to for the purpose of determining which data type to use for the basic floating point number
624 // NOTE: The first type in this enumeration that is determined to be supported by the
625 // datasource/driver is the one that will be used.
626 SWORD PossibleSqlFloatTypes
[] = {
634 // These are the possible SQL types we check for use agains the datasource we are connected
635 // to for the purpose of determining which data type to use for the date/time column types
637 // NOTE: The first type in this enumeration that is determined to be supported by the
638 // datasource/driver is the one that will be used.
639 SWORD PossibleSqlDateTypes
[] = {
647 // These are the possible SQL types we check for use agains the datasource we are connected
648 // to for the purpose of determining which data type to use for the BLOB column types.
650 // NOTE: The first type in this enumeration that is determined to be supported by the
651 // datasource/driver is the one that will be used.
652 SWORD PossibleSqlBlobTypes
[] = {
658 // Query the data source regarding data type information
661 // The way it was determined which SQL data types to use was by calling SQLGetInfo
662 // for all of the possible SQL data types to see which ones were supported. If
663 // a type is not supported, the SQLFetch() that's called from getDataTypeInfo()
664 // fails with SQL_NO_DATA_FOUND. This is ugly because I'm sure the three SQL data
665 // types I've selected below will not always be what we want. These are just
666 // what happened to work against an Oracle 7/Intersolv combination. The following is
667 // a complete list of the results I got back against the Oracle 7 database:
669 // SQL_BIGINT SQL_NO_DATA_FOUND
670 // SQL_BINARY SQL_NO_DATA_FOUND
671 // SQL_BIT SQL_NO_DATA_FOUND
672 // SQL_CHAR type name = 'CHAR', Precision = 255
673 // SQL_DATE SQL_NO_DATA_FOUND
674 // SQL_DECIMAL type name = 'NUMBER', Precision = 38
675 // SQL_DOUBLE type name = 'NUMBER', Precision = 15
676 // SQL_FLOAT SQL_NO_DATA_FOUND
677 // SQL_INTEGER SQL_NO_DATA_FOUND
678 // SQL_LONGVARBINARY type name = 'LONG RAW', Precision = 2 billion
679 // SQL_LONGVARCHAR type name = 'LONG', Precision = 2 billion
680 // SQL_NUMERIC SQL_NO_DATA_FOUND
681 // SQL_REAL SQL_NO_DATA_FOUND
682 // SQL_SMALLINT SQL_NO_DATA_FOUND
683 // SQL_TIME SQL_NO_DATA_FOUND
684 // SQL_TIMESTAMP type name = 'DATE', Precision = 19
685 // SQL_VARBINARY type name = 'RAW', Precision = 255
686 // SQL_VARCHAR type name = 'VARCHAR2', Precision = 2000
687 // =====================================================================
688 // Results from a Microsoft Access 7.0 db, using a driver from Microsoft
690 // SQL_VARCHAR type name = 'TEXT', Precision = 255
691 // SQL_TIMESTAMP type name = 'DATETIME'
692 // SQL_DECIMAL SQL_NO_DATA_FOUND
693 // SQL_NUMERIC type name = 'CURRENCY', Precision = 19
694 // SQL_FLOAT SQL_NO_DATA_FOUND
695 // SQL_REAL type name = 'SINGLE', Precision = 7
696 // SQL_DOUBLE type name = 'DOUBLE', Precision = 15
697 // SQL_INTEGER type name = 'LONG', Precision = 10
699 // Query the data source for info about itself
700 if (!getDbInfo(failOnDataTypeUnsupported
))
703 // --------------- Varchar - (Variable length character string) ---------------
704 for (iIndex
= 0; iIndex
< WXSIZEOF(PossibleSqlCharTypes
) &&
705 !getDataTypeInfo(PossibleSqlCharTypes
[iIndex
], typeInfVarchar
); ++iIndex
)
708 if (iIndex
< WXSIZEOF(PossibleSqlCharTypes
))
709 typeInfVarchar
.FsqlType
= PossibleSqlCharTypes
[iIndex
];
710 else if (failOnDataTypeUnsupported
)
713 // --------------- Float ---------------
714 for (iIndex
= 0; iIndex
< WXSIZEOF(PossibleSqlFloatTypes
) &&
715 !getDataTypeInfo(PossibleSqlFloatTypes
[iIndex
], typeInfFloat
); ++iIndex
)
718 if (iIndex
< WXSIZEOF(PossibleSqlFloatTypes
))
719 typeInfFloat
.FsqlType
= PossibleSqlFloatTypes
[iIndex
];
720 else if (failOnDataTypeUnsupported
)
723 // --------------- Integer -------------
724 for (iIndex
= 0; iIndex
< WXSIZEOF(PossibleSqlIntegerTypes
) &&
725 !getDataTypeInfo(PossibleSqlIntegerTypes
[iIndex
], typeInfInteger
); ++iIndex
)
728 if (iIndex
< WXSIZEOF(PossibleSqlIntegerTypes
))
729 typeInfInteger
.FsqlType
= PossibleSqlIntegerTypes
[iIndex
];
730 else if (failOnDataTypeUnsupported
)
732 // If no non-floating point data types are supported, we'll
733 // use the type assigned for floats to store integers as well
734 if (!getDataTypeInfo(typeInfFloat
.FsqlType
, typeInfInteger
))
736 if (failOnDataTypeUnsupported
)
740 typeInfInteger
.FsqlType
= typeInfFloat
.FsqlType
;
743 // --------------- Date/Time ---------------
744 for (iIndex
= 0; iIndex
< WXSIZEOF(PossibleSqlDateTypes
) &&
745 !getDataTypeInfo(PossibleSqlDateTypes
[iIndex
], typeInfDate
); ++iIndex
)
748 if (iIndex
< WXSIZEOF(PossibleSqlDateTypes
))
749 typeInfDate
.FsqlType
= PossibleSqlDateTypes
[iIndex
];
750 else if (failOnDataTypeUnsupported
)
753 // --------------- BLOB ---------------
754 for (iIndex
= 0; iIndex
< WXSIZEOF(PossibleSqlBlobTypes
) &&
755 !getDataTypeInfo(PossibleSqlBlobTypes
[iIndex
], typeInfBlob
); ++iIndex
)
758 if (iIndex
< WXSIZEOF(PossibleSqlBlobTypes
))
759 typeInfBlob
.FsqlType
= PossibleSqlBlobTypes
[iIndex
];
760 else if (failOnDataTypeUnsupported
)
764 } // wxDb::determineDataTypes
767 bool wxDb::open(bool failOnDataTypeUnsupported
)
770 If using Intersolv branded ODBC drivers, this is the place where you would substitute
771 your branded driver license information
773 SQLSetConnectOption(hdbc, 1041, (UDWORD) wxEmptyString);
774 SQLSetConnectOption(hdbc, 1042, (UDWORD) wxEmptyString);
777 // Mark database as open
780 // Allocate a statement handle for the database connection
781 if (SQLAllocStmt(hdbc
, &hstmt
) != SQL_SUCCESS
)
782 return(DispAllErrors(henv
, hdbc
));
784 // Set Connection Options
785 if (!setConnectionOptions())
788 if (!determineDataTypes(failOnDataTypeUnsupported
))
791 #ifdef DBDEBUG_CONSOLE
792 cout
<< wxT("VARCHAR DATA TYPE: ") << typeInfVarchar
.TypeName
<< endl
;
793 cout
<< wxT("INTEGER DATA TYPE: ") << typeInfInteger
.TypeName
<< endl
;
794 cout
<< wxT("FLOAT DATA TYPE: ") << typeInfFloat
.TypeName
<< endl
;
795 cout
<< wxT("DATE DATA TYPE: ") << typeInfDate
.TypeName
<< endl
;
796 cout
<< wxT("BLOB DATA TYPE: ") << typeInfBlob
.TypeName
<< endl
;
800 // Completed Successfully
804 bool wxDb::Open(const wxString
& inConnectStr
, bool failOnDataTypeUnsupported
)
806 wxASSERT(inConnectStr
.Length());
807 return Open(inConnectStr
, NULL
, failOnDataTypeUnsupported
);
810 bool wxDb::Open(const wxString
& inConnectStr
, SQLHWND parentWnd
, bool failOnDataTypeUnsupported
)
818 if (!FwdOnlyCursors())
820 // Specify that the ODBC cursor library be used, if needed. This must be
821 // specified before the connection is made.
822 retcode
= SQLSetConnectOption(hdbc
, SQL_ODBC_CURSORS
, SQL_CUR_USE_IF_NEEDED
);
824 #ifdef DBDEBUG_CONSOLE
825 if (retcode
== SQL_SUCCESS
)
826 cout
<< wxT("SQLSetConnectOption(CURSOR_LIB) successful") << endl
;
828 cout
<< wxT("SQLSetConnectOption(CURSOR_LIB) failed") << endl
;
830 wxUnusedVar(retcode
);
834 // Connect to the data source
835 SQLTCHAR outConnectBuffer
[SQL_MAX_CONNECTSTR_LEN
+1]; // MS recommends at least 1k buffer
836 short outConnectBufferLen
;
838 inConnectionStr
= inConnectStr
;
840 retcode
= SQLDriverConnect(hdbc
, parentWnd
, (SQLTCHAR FAR
*)inConnectionStr
.c_str(),
841 (SWORD
)inConnectionStr
.Length(), (SQLTCHAR FAR
*)outConnectBuffer
,
842 sizeof(outConnectBuffer
), &outConnectBufferLen
, SQL_DRIVER_COMPLETE
);
844 if ((retcode
!= SQL_SUCCESS
) &&
845 (retcode
!= SQL_SUCCESS_WITH_INFO
))
846 return(DispAllErrors(henv
, hdbc
));
848 outConnectBuffer
[outConnectBufferLen
] = 0;
849 outConnectionStr
= outConnectBuffer
;
850 dbOpenedWithConnectionString
= true;
852 return open(failOnDataTypeUnsupported
);
855 /********** wxDb::Open() **********/
856 bool wxDb::Open(const wxString
&Dsn
, const wxString
&Uid
, const wxString
&AuthStr
, bool failOnDataTypeUnsupported
)
858 wxASSERT(Dsn
.Length());
863 inConnectionStr
= wxT("");
864 outConnectionStr
= wxT("");
868 if (!FwdOnlyCursors())
870 // Specify that the ODBC cursor library be used, if needed. This must be
871 // specified before the connection is made.
872 retcode
= SQLSetConnectOption(hdbc
, SQL_ODBC_CURSORS
, SQL_CUR_USE_IF_NEEDED
);
874 #ifdef DBDEBUG_CONSOLE
875 if (retcode
== SQL_SUCCESS
)
876 cout
<< wxT("SQLSetConnectOption(CURSOR_LIB) successful") << endl
;
878 cout
<< wxT("SQLSetConnectOption(CURSOR_LIB) failed") << endl
;
880 wxUnusedVar( retcode
);
884 // Connect to the data source
885 retcode
= SQLConnect(hdbc
, (SQLTCHAR FAR
*) dsn
.c_str(), SQL_NTS
,
886 (SQLTCHAR FAR
*) uid
.c_str(), SQL_NTS
,
887 (SQLTCHAR FAR
*) authStr
.c_str(), SQL_NTS
);
889 if ((retcode
!= SQL_SUCCESS
) &&
890 (retcode
!= SQL_SUCCESS_WITH_INFO
))
891 return(DispAllErrors(henv
, hdbc
));
893 return open(failOnDataTypeUnsupported
);
898 bool wxDb::Open(wxDbConnectInf
*dbConnectInf
, bool failOnDataTypeUnsupported
)
900 wxASSERT(dbConnectInf
);
902 // Use the connection string if one is present
903 if (dbConnectInf
->UseConnectionStr())
904 return Open(GetConnectionInStr(), failOnDataTypeUnsupported
);
906 return Open(dbConnectInf
->GetDsn(), dbConnectInf
->GetUserID(),
907 dbConnectInf
->GetPassword(), failOnDataTypeUnsupported
);
911 bool wxDb::Open(wxDb
*copyDb
)
913 dsn
= copyDb
->GetDatasourceName();
914 uid
= copyDb
->GetUsername();
915 authStr
= copyDb
->GetPassword();
916 inConnectionStr
= copyDb
->GetConnectionInStr();
917 outConnectionStr
= copyDb
->GetConnectionOutStr();
921 if (!FwdOnlyCursors())
923 // Specify that the ODBC cursor library be used, if needed. This must be
924 // specified before the connection is made.
925 retcode
= SQLSetConnectOption(hdbc
, SQL_ODBC_CURSORS
, SQL_CUR_USE_IF_NEEDED
);
927 #ifdef DBDEBUG_CONSOLE
928 if (retcode
== SQL_SUCCESS
)
929 cout
<< wxT("SQLSetConnectOption(CURSOR_LIB) successful") << endl
;
931 cout
<< wxT("SQLSetConnectOption(CURSOR_LIB) failed") << endl
;
933 wxUnusedVar( retcode
);
937 if (copyDb
->OpenedWithConnectionString())
939 // Connect to the data source
940 SQLTCHAR outConnectBuffer
[SQL_MAX_CONNECTSTR_LEN
+1];
941 short outConnectBufferLen
;
943 inConnectionStr
= copyDb
->GetConnectionInStr();
945 retcode
= SQLDriverConnect(hdbc
, NULL
, (SQLTCHAR FAR
*)inConnectionStr
.c_str(),
946 (SWORD
)inConnectionStr
.Length(), (SQLTCHAR FAR
*)outConnectBuffer
,
947 sizeof(outConnectBuffer
), &outConnectBufferLen
, SQL_DRIVER_COMPLETE
);
949 if ((retcode
!= SQL_SUCCESS
) &&
950 (retcode
!= SQL_SUCCESS_WITH_INFO
))
951 return(DispAllErrors(henv
, hdbc
));
953 outConnectBuffer
[outConnectBufferLen
] = 0;
954 outConnectionStr
= outConnectBuffer
;
955 dbOpenedWithConnectionString
= true;
959 // Connect to the data source
960 retcode
= SQLConnect(hdbc
, (SQLTCHAR FAR
*) dsn
.c_str(), SQL_NTS
,
961 (SQLTCHAR FAR
*) uid
.c_str(), SQL_NTS
,
962 (SQLTCHAR FAR
*) authStr
.c_str(), SQL_NTS
);
965 if ((retcode
!= SQL_SUCCESS
) &&
966 (retcode
!= SQL_SUCCESS_WITH_INFO
))
967 return(DispAllErrors(henv
, hdbc
));
970 If using Intersolv branded ODBC drivers, this is the place where you would substitute
971 your branded driver license information
973 SQLSetConnectOption(hdbc, 1041, (UDWORD) wxEmptyString);
974 SQLSetConnectOption(hdbc, 1042, (UDWORD) wxEmptyString);
977 // Mark database as open
980 // Allocate a statement handle for the database connection
981 if (SQLAllocStmt(hdbc
, &hstmt
) != SQL_SUCCESS
)
982 return(DispAllErrors(henv
, hdbc
));
984 // Set Connection Options
985 if (!setConnectionOptions())
988 // Instead of Querying the data source for info about itself, it can just be copied
989 // from the wxDb instance that was passed in (copyDb).
990 wxStrcpy(dbInf
.serverName
,copyDb
->dbInf
.serverName
);
991 wxStrcpy(dbInf
.databaseName
,copyDb
->dbInf
.databaseName
);
992 wxStrcpy(dbInf
.dbmsName
,copyDb
->dbInf
.dbmsName
);
993 wxStrcpy(dbInf
.dbmsVer
,copyDb
->dbInf
.dbmsVer
);
994 dbInf
.maxConnections
= copyDb
->dbInf
.maxConnections
;
995 dbInf
.maxStmts
= copyDb
->dbInf
.maxStmts
;
996 wxStrcpy(dbInf
.driverName
,copyDb
->dbInf
.driverName
);
997 wxStrcpy(dbInf
.odbcVer
,copyDb
->dbInf
.odbcVer
);
998 wxStrcpy(dbInf
.drvMgrOdbcVer
,copyDb
->dbInf
.drvMgrOdbcVer
);
999 wxStrcpy(dbInf
.driverVer
,copyDb
->dbInf
.driverVer
);
1000 dbInf
.apiConfLvl
= copyDb
->dbInf
.apiConfLvl
;
1001 dbInf
.cliConfLvl
= copyDb
->dbInf
.cliConfLvl
;
1002 dbInf
.sqlConfLvl
= copyDb
->dbInf
.sqlConfLvl
;
1003 wxStrcpy(dbInf
.outerJoins
,copyDb
->dbInf
.outerJoins
);
1004 wxStrcpy(dbInf
.procedureSupport
,copyDb
->dbInf
.procedureSupport
);
1005 wxStrcpy(dbInf
.accessibleTables
,copyDb
->dbInf
.accessibleTables
);
1006 dbInf
.cursorCommitBehavior
= copyDb
->dbInf
.cursorCommitBehavior
;
1007 dbInf
.cursorRollbackBehavior
= copyDb
->dbInf
.cursorRollbackBehavior
;
1008 dbInf
.supportNotNullClause
= copyDb
->dbInf
.supportNotNullClause
;
1009 wxStrcpy(dbInf
.supportIEF
,copyDb
->dbInf
.supportIEF
);
1010 dbInf
.txnIsolation
= copyDb
->dbInf
.txnIsolation
;
1011 dbInf
.txnIsolationOptions
= copyDb
->dbInf
.txnIsolationOptions
;
1012 dbInf
.fetchDirections
= copyDb
->dbInf
.fetchDirections
;
1013 dbInf
.lockTypes
= copyDb
->dbInf
.lockTypes
;
1014 dbInf
.posOperations
= copyDb
->dbInf
.posOperations
;
1015 dbInf
.posStmts
= copyDb
->dbInf
.posStmts
;
1016 dbInf
.scrollConcurrency
= copyDb
->dbInf
.scrollConcurrency
;
1017 dbInf
.scrollOptions
= copyDb
->dbInf
.scrollOptions
;
1018 dbInf
.staticSensitivity
= copyDb
->dbInf
.staticSensitivity
;
1019 dbInf
.txnCapable
= copyDb
->dbInf
.txnCapable
;
1020 dbInf
.loginTimeout
= copyDb
->dbInf
.loginTimeout
;
1022 // VARCHAR = Variable length character string
1023 typeInfVarchar
.FsqlType
= copyDb
->typeInfVarchar
.FsqlType
;
1024 typeInfVarchar
.TypeName
= copyDb
->typeInfVarchar
.TypeName
;
1025 typeInfVarchar
.Precision
= copyDb
->typeInfVarchar
.Precision
;
1026 typeInfVarchar
.CaseSensitive
= copyDb
->typeInfVarchar
.CaseSensitive
;
1027 typeInfVarchar
.MaximumScale
= copyDb
->typeInfVarchar
.MaximumScale
;
1030 typeInfFloat
.FsqlType
= copyDb
->typeInfFloat
.FsqlType
;
1031 typeInfFloat
.TypeName
= copyDb
->typeInfFloat
.TypeName
;
1032 typeInfFloat
.Precision
= copyDb
->typeInfFloat
.Precision
;
1033 typeInfFloat
.CaseSensitive
= copyDb
->typeInfFloat
.CaseSensitive
;
1034 typeInfFloat
.MaximumScale
= copyDb
->typeInfFloat
.MaximumScale
;
1037 typeInfInteger
.FsqlType
= copyDb
->typeInfInteger
.FsqlType
;
1038 typeInfInteger
.TypeName
= copyDb
->typeInfInteger
.TypeName
;
1039 typeInfInteger
.Precision
= copyDb
->typeInfInteger
.Precision
;
1040 typeInfInteger
.CaseSensitive
= copyDb
->typeInfInteger
.CaseSensitive
;
1041 typeInfInteger
.MaximumScale
= copyDb
->typeInfInteger
.MaximumScale
;
1044 typeInfDate
.FsqlType
= copyDb
->typeInfDate
.FsqlType
;
1045 typeInfDate
.TypeName
= copyDb
->typeInfDate
.TypeName
;
1046 typeInfDate
.Precision
= copyDb
->typeInfDate
.Precision
;
1047 typeInfDate
.CaseSensitive
= copyDb
->typeInfDate
.CaseSensitive
;
1048 typeInfDate
.MaximumScale
= copyDb
->typeInfDate
.MaximumScale
;
1051 typeInfBlob
.FsqlType
= copyDb
->typeInfBlob
.FsqlType
;
1052 typeInfBlob
.TypeName
= copyDb
->typeInfBlob
.TypeName
;
1053 typeInfBlob
.Precision
= copyDb
->typeInfBlob
.Precision
;
1054 typeInfBlob
.CaseSensitive
= copyDb
->typeInfBlob
.CaseSensitive
;
1055 typeInfBlob
.MaximumScale
= copyDb
->typeInfBlob
.MaximumScale
;
1057 #ifdef DBDEBUG_CONSOLE
1058 cout
<< wxT("VARCHAR DATA TYPE: ") << typeInfVarchar
.TypeName
<< endl
;
1059 cout
<< wxT("INTEGER DATA TYPE: ") << typeInfInteger
.TypeName
<< endl
;
1060 cout
<< wxT("FLOAT DATA TYPE: ") << typeInfFloat
.TypeName
<< endl
;
1061 cout
<< wxT("DATE DATA TYPE: ") << typeInfDate
.TypeName
<< endl
;
1062 cout
<< wxT("BLOB DATA TYPE: ") << typeInfBlob
.TypeName
<< endl
;
1066 // Completed Successfully
1071 /********** wxDb::setConnectionOptions() **********/
1072 bool wxDb::setConnectionOptions(void)
1074 * NOTE: The Intersolv/Oracle 7 driver was "Not Capable" of setting the login timeout.
1079 // I need to get the DBMS name here, because some of the connection options
1080 // are database specific and need to call the Dbms() function.
1083 retcode
= SQLGetInfo(hdbc
, SQL_DBMS_NAME
, (UCHAR
*) dbInf
.dbmsName
, sizeof(dbInf
.dbmsName
), &cb
);
1084 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1085 return(DispAllErrors(henv
, hdbc
));
1087 /* retcode = */ SQLSetConnectOption(hdbc
, SQL_AUTOCOMMIT
, SQL_AUTOCOMMIT_OFF
);
1088 /* retcode = */ SQLSetConnectOption(hdbc
, SQL_OPT_TRACE
, SQL_OPT_TRACE_OFF
);
1089 // SQLSetConnectOption(hdbc, SQL_TXN_ISOLATION, SQL_TXN_READ_COMMITTED); // No dirty reads
1091 // By default, MS Sql Server closes cursors on commit and rollback. The following
1092 // call to SQLSetConnectOption() is needed to force SQL Server to preserve cursors
1093 // after a transaction. This is a driver specific option and is not part of the
1094 // ODBC standard. Note: this behavior is specific to the ODBC interface to SQL Server.
1095 // The database settings don't have any effect one way or the other.
1096 if (Dbms() == dbmsMS_SQL_SERVER
)
1098 const long SQL_PRESERVE_CURSORS
= 1204L;
1099 const long SQL_PC_ON
= 1L;
1100 /* retcode = */ SQLSetConnectOption(hdbc
, SQL_PRESERVE_CURSORS
, SQL_PC_ON
);
1103 // Display the connection options to verify them
1104 #ifdef DBDEBUG_CONSOLE
1106 cout
<< wxT("****** CONNECTION OPTIONS ******") << endl
;
1108 retcode
= SQLGetConnectOption(hdbc
, SQL_AUTOCOMMIT
, &l
);
1109 if (retcode
!= SQL_SUCCESS
)
1110 return(DispAllErrors(henv
, hdbc
));
1111 cout
<< wxT("AUTOCOMMIT: ") << (l
== SQL_AUTOCOMMIT_OFF
? "OFF" : "ON") << endl
;
1113 retcode
= SQLGetConnectOption(hdbc
, SQL_ODBC_CURSORS
, &l
);
1114 if (retcode
!= SQL_SUCCESS
)
1115 return(DispAllErrors(henv
, hdbc
));
1116 cout
<< wxT("ODBC CURSORS: ");
1119 case(SQL_CUR_USE_IF_NEEDED
):
1120 cout
<< wxT("SQL_CUR_USE_IF_NEEDED");
1122 case(SQL_CUR_USE_ODBC
):
1123 cout
<< wxT("SQL_CUR_USE_ODBC");
1125 case(SQL_CUR_USE_DRIVER
):
1126 cout
<< wxT("SQL_CUR_USE_DRIVER");
1131 retcode
= SQLGetConnectOption(hdbc
, SQL_OPT_TRACE
, &l
)
1132 if (retcode
!= SQL_SUCCESS
)
1133 return(DispAllErrors(henv
, hdbc
));
1134 cout
<< wxT("TRACING: ") << (l
== SQL_OPT_TRACE_OFF
? wxT("OFF") : wxT("ON")) << endl
;
1139 // Completed Successfully
1142 } // wxDb::setConnectionOptions()
1145 /********** wxDb::getDbInfo() **********/
1146 bool wxDb::getDbInfo(bool failOnDataTypeUnsupported
)
1151 retcode
= SQLGetInfo(hdbc
, SQL_SERVER_NAME
, (UCHAR
*) dbInf
.serverName
, sizeof(dbInf
.serverName
), &cb
);
1152 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1154 DispAllErrors(henv
, hdbc
);
1155 if (failOnDataTypeUnsupported
)
1159 retcode
= SQLGetInfo(hdbc
, SQL_DATABASE_NAME
, (UCHAR
*) dbInf
.databaseName
, sizeof(dbInf
.databaseName
), &cb
);
1160 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1162 DispAllErrors(henv
, hdbc
);
1163 if (failOnDataTypeUnsupported
)
1167 retcode
= SQLGetInfo(hdbc
, SQL_DBMS_NAME
, (UCHAR
*) dbInf
.dbmsName
, sizeof(dbInf
.dbmsName
), &cb
);
1168 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1170 DispAllErrors(henv
, hdbc
);
1171 if (failOnDataTypeUnsupported
)
1176 // After upgrading to MSVC6, the original 20 char buffer below was insufficient,
1177 // causing database connectivity to fail in some cases.
1178 retcode
= SQLGetInfo(hdbc
, SQL_DBMS_VER
, (UCHAR
*) dbInf
.dbmsVer
, sizeof(dbInf
.dbmsVer
), &cb
);
1179 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1181 DispAllErrors(henv
, hdbc
);
1182 if (failOnDataTypeUnsupported
)
1186 retcode
= SQLGetInfo(hdbc
, SQL_ACTIVE_CONNECTIONS
, (UCHAR
*) &dbInf
.maxConnections
, sizeof(dbInf
.maxConnections
), &cb
);
1187 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1189 DispAllErrors(henv
, hdbc
);
1190 if (failOnDataTypeUnsupported
)
1194 retcode
= SQLGetInfo(hdbc
, SQL_ACTIVE_STATEMENTS
, (UCHAR
*) &dbInf
.maxStmts
, sizeof(dbInf
.maxStmts
), &cb
);
1195 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1197 DispAllErrors(henv
, hdbc
);
1198 if (failOnDataTypeUnsupported
)
1202 retcode
= SQLGetInfo(hdbc
, SQL_DRIVER_NAME
, (UCHAR
*) dbInf
.driverName
, sizeof(dbInf
.driverName
), &cb
);
1203 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1205 DispAllErrors(henv
, hdbc
);
1206 if (failOnDataTypeUnsupported
)
1210 retcode
= SQLGetInfo(hdbc
, SQL_DRIVER_ODBC_VER
, (UCHAR
*) dbInf
.odbcVer
, sizeof(dbInf
.odbcVer
), &cb
);
1211 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1213 DispAllErrors(henv
, hdbc
);
1214 if (failOnDataTypeUnsupported
)
1218 retcode
= SQLGetInfo(hdbc
, SQL_ODBC_VER
, (UCHAR
*) dbInf
.drvMgrOdbcVer
, sizeof(dbInf
.drvMgrOdbcVer
), &cb
);
1219 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1221 DispAllErrors(henv
, hdbc
);
1222 if (failOnDataTypeUnsupported
)
1226 retcode
= SQLGetInfo(hdbc
, SQL_DRIVER_VER
, (UCHAR
*) dbInf
.driverVer
, sizeof(dbInf
.driverVer
), &cb
);
1227 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1229 DispAllErrors(henv
, hdbc
);
1230 if (failOnDataTypeUnsupported
)
1234 retcode
= SQLGetInfo(hdbc
, SQL_ODBC_API_CONFORMANCE
, (UCHAR
*) &dbInf
.apiConfLvl
, sizeof(dbInf
.apiConfLvl
), &cb
);
1235 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1237 DispAllErrors(henv
, hdbc
);
1238 if (failOnDataTypeUnsupported
)
1242 retcode
= SQLGetInfo(hdbc
, SQL_ODBC_SAG_CLI_CONFORMANCE
, (UCHAR
*) &dbInf
.cliConfLvl
, sizeof(dbInf
.cliConfLvl
), &cb
);
1243 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1245 // Not all drivers support this call - Nick Gorham(unixODBC)
1246 dbInf
.cliConfLvl
= 0;
1247 DispAllErrors(henv
, hdbc
);
1248 if (failOnDataTypeUnsupported
)
1252 retcode
= SQLGetInfo(hdbc
, SQL_ODBC_SQL_CONFORMANCE
, (UCHAR
*) &dbInf
.sqlConfLvl
, sizeof(dbInf
.sqlConfLvl
), &cb
);
1253 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1255 DispAllErrors(henv
, hdbc
);
1256 if (failOnDataTypeUnsupported
)
1260 retcode
= SQLGetInfo(hdbc
, SQL_OUTER_JOINS
, (UCHAR
*) dbInf
.outerJoins
, sizeof(dbInf
.outerJoins
), &cb
);
1261 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1263 DispAllErrors(henv
, hdbc
);
1264 if (failOnDataTypeUnsupported
)
1268 retcode
= SQLGetInfo(hdbc
, SQL_PROCEDURES
, (UCHAR
*) dbInf
.procedureSupport
, sizeof(dbInf
.procedureSupport
), &cb
);
1269 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1271 DispAllErrors(henv
, hdbc
);
1272 if (failOnDataTypeUnsupported
)
1276 retcode
= SQLGetInfo(hdbc
, SQL_ACCESSIBLE_TABLES
, (UCHAR
*) dbInf
.accessibleTables
, sizeof(dbInf
.accessibleTables
), &cb
);
1277 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1279 DispAllErrors(henv
, hdbc
);
1280 if (failOnDataTypeUnsupported
)
1284 retcode
= SQLGetInfo(hdbc
, SQL_CURSOR_COMMIT_BEHAVIOR
, (UCHAR
*) &dbInf
.cursorCommitBehavior
, sizeof(dbInf
.cursorCommitBehavior
), &cb
);
1285 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1287 DispAllErrors(henv
, hdbc
);
1288 if (failOnDataTypeUnsupported
)
1292 retcode
= SQLGetInfo(hdbc
, SQL_CURSOR_ROLLBACK_BEHAVIOR
, (UCHAR
*) &dbInf
.cursorRollbackBehavior
, sizeof(dbInf
.cursorRollbackBehavior
), &cb
);
1293 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1295 DispAllErrors(henv
, hdbc
);
1296 if (failOnDataTypeUnsupported
)
1300 retcode
= SQLGetInfo(hdbc
, SQL_NON_NULLABLE_COLUMNS
, (UCHAR
*) &dbInf
.supportNotNullClause
, sizeof(dbInf
.supportNotNullClause
), &cb
);
1301 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1303 DispAllErrors(henv
, hdbc
);
1304 if (failOnDataTypeUnsupported
)
1308 retcode
= SQLGetInfo(hdbc
, SQL_ODBC_SQL_OPT_IEF
, (UCHAR
*) dbInf
.supportIEF
, sizeof(dbInf
.supportIEF
), &cb
);
1309 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1311 DispAllErrors(henv
, hdbc
);
1312 if (failOnDataTypeUnsupported
)
1316 retcode
= SQLGetInfo(hdbc
, SQL_DEFAULT_TXN_ISOLATION
, (UCHAR
*) &dbInf
.txnIsolation
, sizeof(dbInf
.txnIsolation
), &cb
);
1317 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1319 DispAllErrors(henv
, hdbc
);
1320 if (failOnDataTypeUnsupported
)
1324 retcode
= SQLGetInfo(hdbc
, SQL_TXN_ISOLATION_OPTION
, (UCHAR
*) &dbInf
.txnIsolationOptions
, sizeof(dbInf
.txnIsolationOptions
), &cb
);
1325 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1327 DispAllErrors(henv
, hdbc
);
1328 if (failOnDataTypeUnsupported
)
1332 retcode
= SQLGetInfo(hdbc
, SQL_FETCH_DIRECTION
, (UCHAR
*) &dbInf
.fetchDirections
, sizeof(dbInf
.fetchDirections
), &cb
);
1333 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1335 DispAllErrors(henv
, hdbc
);
1336 if (failOnDataTypeUnsupported
)
1340 retcode
= SQLGetInfo(hdbc
, SQL_LOCK_TYPES
, (UCHAR
*) &dbInf
.lockTypes
, sizeof(dbInf
.lockTypes
), &cb
);
1341 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1343 DispAllErrors(henv
, hdbc
);
1344 if (failOnDataTypeUnsupported
)
1348 retcode
= SQLGetInfo(hdbc
, SQL_POS_OPERATIONS
, (UCHAR
*) &dbInf
.posOperations
, sizeof(dbInf
.posOperations
), &cb
);
1349 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1351 DispAllErrors(henv
, hdbc
);
1352 if (failOnDataTypeUnsupported
)
1356 retcode
= SQLGetInfo(hdbc
, SQL_POSITIONED_STATEMENTS
, (UCHAR
*) &dbInf
.posStmts
, sizeof(dbInf
.posStmts
), &cb
);
1357 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1359 DispAllErrors(henv
, hdbc
);
1360 if (failOnDataTypeUnsupported
)
1364 retcode
= SQLGetInfo(hdbc
, SQL_SCROLL_CONCURRENCY
, (UCHAR
*) &dbInf
.scrollConcurrency
, sizeof(dbInf
.scrollConcurrency
), &cb
);
1365 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1367 DispAllErrors(henv
, hdbc
);
1368 if (failOnDataTypeUnsupported
)
1372 retcode
= SQLGetInfo(hdbc
, SQL_SCROLL_OPTIONS
, (UCHAR
*) &dbInf
.scrollOptions
, sizeof(dbInf
.scrollOptions
), &cb
);
1373 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1375 DispAllErrors(henv
, hdbc
);
1376 if (failOnDataTypeUnsupported
)
1380 retcode
= SQLGetInfo(hdbc
, SQL_STATIC_SENSITIVITY
, (UCHAR
*) &dbInf
.staticSensitivity
, sizeof(dbInf
.staticSensitivity
), &cb
);
1381 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1383 DispAllErrors(henv
, hdbc
);
1384 if (failOnDataTypeUnsupported
)
1388 retcode
= SQLGetInfo(hdbc
, SQL_TXN_CAPABLE
, (UCHAR
*) &dbInf
.txnCapable
, sizeof(dbInf
.txnCapable
), &cb
);
1389 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1391 DispAllErrors(henv
, hdbc
);
1392 if (failOnDataTypeUnsupported
)
1396 retcode
= SQLGetInfo(hdbc
, SQL_LOGIN_TIMEOUT
, (UCHAR
*) &dbInf
.loginTimeout
, sizeof(dbInf
.loginTimeout
), &cb
);
1397 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1399 DispAllErrors(henv
, hdbc
);
1400 if (failOnDataTypeUnsupported
)
1404 #ifdef DBDEBUG_CONSOLE
1405 cout
<< wxT("***** DATA SOURCE INFORMATION *****") << endl
;
1406 cout
<< wxT(wxT("SERVER Name: ") << dbInf
.serverName
<< endl
;
1407 cout
<< wxT("DBMS Name: ") << dbInf
.dbmsName
<< wxT("; DBMS Version: ") << dbInf
.dbmsVer
<< endl
;
1408 cout
<< wxT("ODBC Version: ") << dbInf
.odbcVer
<< wxT("; Driver Version: ") << dbInf
.driverVer
<< endl
;
1410 cout
<< wxT("API Conf. Level: ");
1411 switch(dbInf
.apiConfLvl
)
1413 case SQL_OAC_NONE
: cout
<< wxT("None"); break;
1414 case SQL_OAC_LEVEL1
: cout
<< wxT("Level 1"); break;
1415 case SQL_OAC_LEVEL2
: cout
<< wxT("Level 2"); break;
1419 cout
<< wxT("SAG CLI Conf. Level: ");
1420 switch(dbInf
.cliConfLvl
)
1422 case SQL_OSCC_NOT_COMPLIANT
: cout
<< wxT("Not Compliant"); break;
1423 case SQL_OSCC_COMPLIANT
: cout
<< wxT("Compliant"); break;
1427 cout
<< wxT("SQL Conf. Level: ");
1428 switch(dbInf
.sqlConfLvl
)
1430 case SQL_OSC_MINIMUM
: cout
<< wxT("Minimum Grammar"); break;
1431 case SQL_OSC_CORE
: cout
<< wxT("Core Grammar"); break;
1432 case SQL_OSC_EXTENDED
: cout
<< wxT("Extended Grammar"); break;
1436 cout
<< wxT("Max. Connections: ") << dbInf
.maxConnections
<< endl
;
1437 cout
<< wxT("Outer Joins: ") << dbInf
.outerJoins
<< endl
;
1438 cout
<< wxT("Support for Procedures: ") << dbInf
.procedureSupport
<< endl
;
1439 cout
<< wxT("All tables accessible : ") << dbInf
.accessibleTables
<< endl
;
1440 cout
<< wxT("Cursor COMMIT Behavior: ");
1441 switch(dbInf
.cursorCommitBehavior
)
1443 case SQL_CB_DELETE
: cout
<< wxT("Delete cursors"); break;
1444 case SQL_CB_CLOSE
: cout
<< wxT("Close cursors"); break;
1445 case SQL_CB_PRESERVE
: cout
<< wxT("Preserve cursors"); break;
1449 cout
<< wxT("Cursor ROLLBACK Behavior: ");
1450 switch(dbInf
.cursorRollbackBehavior
)
1452 case SQL_CB_DELETE
: cout
<< wxT("Delete cursors"); break;
1453 case SQL_CB_CLOSE
: cout
<< wxT("Close cursors"); break;
1454 case SQL_CB_PRESERVE
: cout
<< wxT("Preserve cursors"); break;
1458 cout
<< wxT("Support NOT NULL clause: ");
1459 switch(dbInf
.supportNotNullClause
)
1461 case SQL_NNC_NULL
: cout
<< wxT("No"); break;
1462 case SQL_NNC_NON_NULL
: cout
<< wxT("Yes"); break;
1466 cout
<< wxT("Support IEF (Ref. Integrity): ") << dbInf
.supportIEF
<< endl
;
1467 cout
<< wxT("Login Timeout: ") << dbInf
.loginTimeout
<< endl
;
1469 cout
<< endl
<< endl
<< wxT("more ...") << endl
;
1472 cout
<< wxT("Default Transaction Isolation: ";
1473 switch(dbInf
.txnIsolation
)
1475 case SQL_TXN_READ_UNCOMMITTED
: cout
<< wxT("Read Uncommitted"); break;
1476 case SQL_TXN_READ_COMMITTED
: cout
<< wxT("Read Committed"); break;
1477 case SQL_TXN_REPEATABLE_READ
: cout
<< wxT("Repeatable Read"); break;
1478 case SQL_TXN_SERIALIZABLE
: cout
<< wxT("Serializable"); break;
1480 case SQL_TXN_VERSIONING
: cout
<< wxT("Versioning"); break;
1485 cout
<< wxT("Transaction Isolation Options: ");
1486 if (dbInf
.txnIsolationOptions
& SQL_TXN_READ_UNCOMMITTED
)
1487 cout
<< wxT("Read Uncommitted, ");
1488 if (dbInf
.txnIsolationOptions
& SQL_TXN_READ_COMMITTED
)
1489 cout
<< wxT("Read Committed, ");
1490 if (dbInf
.txnIsolationOptions
& SQL_TXN_REPEATABLE_READ
)
1491 cout
<< wxT("Repeatable Read, ");
1492 if (dbInf
.txnIsolationOptions
& SQL_TXN_SERIALIZABLE
)
1493 cout
<< wxT("Serializable, ");
1495 if (dbInf
.txnIsolationOptions
& SQL_TXN_VERSIONING
)
1496 cout
<< wxT("Versioning");
1500 cout
<< wxT("Fetch Directions Supported:") << endl
<< wxT(" ");
1501 if (dbInf
.fetchDirections
& SQL_FD_FETCH_NEXT
)
1502 cout
<< wxT("Next, ");
1503 if (dbInf
.fetchDirections
& SQL_FD_FETCH_PRIOR
)
1504 cout
<< wxT("Prev, ");
1505 if (dbInf
.fetchDirections
& SQL_FD_FETCH_FIRST
)
1506 cout
<< wxT("First, ");
1507 if (dbInf
.fetchDirections
& SQL_FD_FETCH_LAST
)
1508 cout
<< wxT("Last, ");
1509 if (dbInf
.fetchDirections
& SQL_FD_FETCH_ABSOLUTE
)
1510 cout
<< wxT("Absolute, ");
1511 if (dbInf
.fetchDirections
& SQL_FD_FETCH_RELATIVE
)
1512 cout
<< wxT("Relative, ");
1514 if (dbInf
.fetchDirections
& SQL_FD_FETCH_RESUME
)
1515 cout
<< wxT("Resume, ");
1517 if (dbInf
.fetchDirections
& SQL_FD_FETCH_BOOKMARK
)
1518 cout
<< wxT("Bookmark");
1521 cout
<< wxT("Lock Types Supported (SQLSetPos): ");
1522 if (dbInf
.lockTypes
& SQL_LCK_NO_CHANGE
)
1523 cout
<< wxT("No Change, ");
1524 if (dbInf
.lockTypes
& SQL_LCK_EXCLUSIVE
)
1525 cout
<< wxT("Exclusive, ");
1526 if (dbInf
.lockTypes
& SQL_LCK_UNLOCK
)
1527 cout
<< wxT("UnLock");
1530 cout
<< wxT("Position Operations Supported (SQLSetPos): ");
1531 if (dbInf
.posOperations
& SQL_POS_POSITION
)
1532 cout
<< wxT("Position, ");
1533 if (dbInf
.posOperations
& SQL_POS_REFRESH
)
1534 cout
<< wxT("Refresh, ");
1535 if (dbInf
.posOperations
& SQL_POS_UPDATE
)
1536 cout
<< wxT("Upd, "));
1537 if (dbInf
.posOperations
& SQL_POS_DELETE
)
1538 cout
<< wxT("Del, ");
1539 if (dbInf
.posOperations
& SQL_POS_ADD
)
1543 cout
<< wxT("Positioned Statements Supported: ");
1544 if (dbInf
.posStmts
& SQL_PS_POSITIONED_DELETE
)
1545 cout
<< wxT("Pos delete, ");
1546 if (dbInf
.posStmts
& SQL_PS_POSITIONED_UPDATE
)
1547 cout
<< wxT("Pos update, ");
1548 if (dbInf
.posStmts
& SQL_PS_SELECT_FOR_UPDATE
)
1549 cout
<< wxT("Select for update");
1552 cout
<< wxT("Scroll Concurrency: ");
1553 if (dbInf
.scrollConcurrency
& SQL_SCCO_READ_ONLY
)
1554 cout
<< wxT("Read Only, ");
1555 if (dbInf
.scrollConcurrency
& SQL_SCCO_LOCK
)
1556 cout
<< wxT("Lock, ");
1557 if (dbInf
.scrollConcurrency
& SQL_SCCO_OPT_ROWVER
)
1558 cout
<< wxT("Opt. Rowver, ");
1559 if (dbInf
.scrollConcurrency
& SQL_SCCO_OPT_VALUES
)
1560 cout
<< wxT("Opt. Values");
1563 cout
<< wxT("Scroll Options: ");
1564 if (dbInf
.scrollOptions
& SQL_SO_FORWARD_ONLY
)
1565 cout
<< wxT("Fwd Only, ");
1566 if (dbInf
.scrollOptions
& SQL_SO_STATIC
)
1567 cout
<< wxT("Static, ");
1568 if (dbInf
.scrollOptions
& SQL_SO_KEYSET_DRIVEN
)
1569 cout
<< wxT("Keyset Driven, ");
1570 if (dbInf
.scrollOptions
& SQL_SO_DYNAMIC
)
1571 cout
<< wxT("Dynamic, ");
1572 if (dbInf
.scrollOptions
& SQL_SO_MIXED
)
1573 cout
<< wxT("Mixed");
1576 cout
<< wxT("Static Sensitivity: ");
1577 if (dbInf
.staticSensitivity
& SQL_SS_ADDITIONS
)
1578 cout
<< wxT("Additions, ");
1579 if (dbInf
.staticSensitivity
& SQL_SS_DELETIONS
)
1580 cout
<< wxT("Deletions, ");
1581 if (dbInf
.staticSensitivity
& SQL_SS_UPDATES
)
1582 cout
<< wxT("Updates");
1585 cout
<< wxT("Transaction Capable?: ");
1586 switch(dbInf
.txnCapable
)
1588 case SQL_TC_NONE
: cout
<< wxT("No"); break;
1589 case SQL_TC_DML
: cout
<< wxT("DML Only"); break;
1590 case SQL_TC_DDL_COMMIT
: cout
<< wxT("DDL Commit"); break;
1591 case SQL_TC_DDL_IGNORE
: cout
<< wxT("DDL Ignore"); break;
1592 case SQL_TC_ALL
: cout
<< wxT("DDL & DML"); break;
1599 // Completed Successfully
1602 } // wxDb::getDbInfo()
1605 /********** wxDb::getDataTypeInfo() **********/
1606 bool wxDb::getDataTypeInfo(SWORD fSqlType
, wxDbSqlTypeInfo
&structSQLTypeInfo
)
1609 * fSqlType will be something like SQL_VARCHAR. This parameter determines
1610 * the data type inf. is gathered for.
1612 * wxDbSqlTypeInfo is a structure that is filled in with data type information,
1617 // Get information about the data type specified
1618 if (SQLGetTypeInfo(hstmt
, fSqlType
) != SQL_SUCCESS
)
1619 return(DispAllErrors(henv
, hdbc
, hstmt
));
1622 retcode
= SQLFetch(hstmt
);
1623 if (retcode
!= SQL_SUCCESS
)
1625 #ifdef DBDEBUG_CONSOLE
1626 if (retcode
== SQL_NO_DATA_FOUND
)
1627 cout
<< wxT("SQL_NO_DATA_FOUND fetching information about data type.") << endl
;
1629 DispAllErrors(henv
, hdbc
, hstmt
);
1630 SQLFreeStmt(hstmt
, SQL_CLOSE
);
1634 wxChar typeName
[DB_TYPE_NAME_LEN
+1];
1636 // Obtain columns from the record
1637 if (SQLGetData(hstmt
, 1, SQL_C_WXCHAR
, typeName
, sizeof(typeName
), &cbRet
) != SQL_SUCCESS
)
1638 return(DispAllErrors(henv
, hdbc
, hstmt
));
1640 structSQLTypeInfo
.TypeName
= typeName
;
1642 // BJO 20000503: no more needed with new GetColumns...
1645 if (Dbms() == dbmsMY_SQL
)
1647 if (structSQLTypeInfo
.TypeName
== wxT("middleint"))
1648 structSQLTypeInfo
.TypeName
= wxT("mediumint");
1649 else if (structSQLTypeInfo
.TypeName
== wxT("middleint unsigned"))
1650 structSQLTypeInfo
.TypeName
= wxT("mediumint unsigned");
1651 else if (structSQLTypeInfo
.TypeName
== wxT("integer"))
1652 structSQLTypeInfo
.TypeName
= wxT("int");
1653 else if (structSQLTypeInfo
.TypeName
== wxT("integer unsigned"))
1654 structSQLTypeInfo
.TypeName
= wxT("int unsigned");
1655 else if (structSQLTypeInfo
.TypeName
== wxT("middleint"))
1656 structSQLTypeInfo
.TypeName
= wxT("mediumint");
1657 else if (structSQLTypeInfo
.TypeName
== wxT("varchar"))
1658 structSQLTypeInfo
.TypeName
= wxT("char");
1661 // BJO 20000427 : OpenLink driver
1662 if (!wxStrncmp(dbInf
.driverName
, wxT("oplodbc"), 7) ||
1663 !wxStrncmp(dbInf
.driverName
, wxT("OLOD"), 4))
1665 if (structSQLTypeInfo
.TypeName
== wxT("double precision"))
1666 structSQLTypeInfo
.TypeName
= wxT("real");
1670 if (SQLGetData(hstmt
, 3, SQL_C_LONG
, (UCHAR
*) &structSQLTypeInfo
.Precision
, 0, &cbRet
) != SQL_SUCCESS
)
1671 return(DispAllErrors(henv
, hdbc
, hstmt
));
1672 if (SQLGetData(hstmt
, 8, SQL_C_SHORT
, (UCHAR
*) &structSQLTypeInfo
.CaseSensitive
, 0, &cbRet
) != SQL_SUCCESS
)
1673 return(DispAllErrors(henv
, hdbc
, hstmt
));
1674 // if (SQLGetData(hstmt, 14, SQL_C_SHORT, (UCHAR*) &structSQLTypeInfo.MinimumScale, 0, &cbRet) != SQL_SUCCESS)
1675 // return(DispAllErrors(henv, hdbc, hstmt));
1677 if (SQLGetData(hstmt
, 15, SQL_C_SHORT
,(UCHAR
*) &structSQLTypeInfo
.MaximumScale
, 0, &cbRet
) != SQL_SUCCESS
)
1678 return(DispAllErrors(henv
, hdbc
, hstmt
));
1680 if (structSQLTypeInfo
.MaximumScale
< 0)
1681 structSQLTypeInfo
.MaximumScale
= 0;
1683 // Close the statement handle which closes open cursors
1684 if (SQLFreeStmt(hstmt
, SQL_CLOSE
) != SQL_SUCCESS
)
1685 return(DispAllErrors(henv
, hdbc
, hstmt
));
1687 // Completed Successfully
1690 } // wxDb::getDataTypeInfo()
1693 /********** wxDb::Close() **********/
1694 void wxDb::Close(void)
1696 // Close the Sql Log file
1703 // Free statement handle
1706 if (SQLFreeStmt(hstmt
, SQL_DROP
) != SQL_SUCCESS
)
1707 DispAllErrors(henv
, hdbc
);
1710 // Disconnect from the datasource
1711 if (SQLDisconnect(hdbc
) != SQL_SUCCESS
)
1712 DispAllErrors(henv
, hdbc
);
1714 // Free the connection to the datasource
1715 if (SQLFreeConnect(hdbc
) != SQL_SUCCESS
)
1716 DispAllErrors(henv
, hdbc
);
1718 // There should be zero Ctable objects still connected to this db object
1719 wxASSERT(nTables
== 0);
1723 wxList::compatibility_iterator pNode
;
1724 pNode
= TablesInUse
.GetFirst();
1728 tiu
= (wxTablesInUse
*)pNode
->GetData();
1729 if (tiu
->pDb
== this)
1731 s
.Printf(wxT("(%-20s) tableID:[%6lu] pDb:[%p]"), tiu
->tableName
,tiu
->tableID
,tiu
->pDb
);
1732 s2
.Printf(wxT("Orphaned table found using pDb:[%p]"),this);
1733 wxLogDebug(s
.c_str(),s2
.c_str());
1735 pNode
= pNode
->GetNext();
1739 // Copy the error messages to a global variable
1741 for (i
= 0; i
< DB_MAX_ERROR_HISTORY
; i
++)
1742 wxStrcpy(DBerrorList
[i
], errorList
[i
]);
1744 dbmsType
= dbmsUNIDENTIFIED
;
1750 /********** wxDb::CommitTrans() **********/
1751 bool wxDb::CommitTrans(void)
1755 // Commit the transaction
1756 if (SQLTransact(henv
, hdbc
, SQL_COMMIT
) != SQL_SUCCESS
)
1757 return(DispAllErrors(henv
, hdbc
));
1760 // Completed successfully
1763 } // wxDb::CommitTrans()
1766 /********** wxDb::RollbackTrans() **********/
1767 bool wxDb::RollbackTrans(void)
1769 // Rollback the transaction
1770 if (SQLTransact(henv
, hdbc
, SQL_ROLLBACK
) != SQL_SUCCESS
)
1771 return(DispAllErrors(henv
, hdbc
));
1773 // Completed successfully
1776 } // wxDb::RollbackTrans()
1779 /********** wxDb::DispAllErrors() **********/
1780 bool wxDb::DispAllErrors(HENV aHenv
, HDBC aHdbc
, HSTMT aHstmt
)
1782 * This function is called internally whenever an error condition prevents the user's
1783 * request from being executed. This function will query the datasource as to the
1784 * actual error(s) that just occured on the previous request of the datasource.
1786 * The function will retrieve each error condition from the datasource and
1787 * Printf the codes/text values into a string which it then logs via logError().
1788 * If in DBDEBUG_CONSOLE mode, the constructed string will be displayed in the console
1789 * window and program execution will be paused until the user presses a key.
1791 * This function always returns a false, so that functions which call this function
1792 * can have a line like "return (DispAllErrors(henv, hdbc));" to indicate the failure
1793 * of the users request, so that the calling code can then process the error msg log
1796 wxString odbcErrMsg
;
1798 while (SQLError(aHenv
, aHdbc
, aHstmt
, (SQLTCHAR FAR
*) sqlState
, &nativeError
, (SQLTCHAR FAR
*) errorMsg
, SQL_MAX_MESSAGE_LENGTH
- 1, &cbErrorMsg
) == SQL_SUCCESS
)
1800 odbcErrMsg
.Printf(wxT("SQL State = %s\nNative Error Code = %li\nError Message = %s\n"), sqlState
, nativeError
, errorMsg
);
1801 logError(odbcErrMsg
, sqlState
);
1804 #ifdef DBDEBUG_CONSOLE
1805 // When run in console mode, use standard out to display errors.
1806 cout
<< odbcErrMsg
.c_str() << endl
;
1807 cout
<< wxT("Press any key to continue...") << endl
;
1812 wxLogDebug(odbcErrMsg
,wxT("ODBC DEBUG MESSAGE from DispAllErrors()"));
1817 return false; // This function always returns false.
1819 } // wxDb::DispAllErrors()
1822 /********** wxDb::GetNextError() **********/
1823 bool wxDb::GetNextError(HENV aHenv
, HDBC aHdbc
, HSTMT aHstmt
)
1825 if (SQLError(aHenv
, aHdbc
, aHstmt
, (SQLTCHAR FAR
*) sqlState
, &nativeError
, (SQLTCHAR FAR
*) errorMsg
, SQL_MAX_MESSAGE_LENGTH
- 1, &cbErrorMsg
) == SQL_SUCCESS
)
1830 } // wxDb::GetNextError()
1833 /********** wxDb::DispNextError() **********/
1834 void wxDb::DispNextError(void)
1836 wxString odbcErrMsg
;
1838 odbcErrMsg
.Printf(wxT("SQL State = %s\nNative Error Code = %li\nError Message = %s\n"), sqlState
, nativeError
, errorMsg
);
1839 logError(odbcErrMsg
, sqlState
);
1844 #ifdef DBDEBUG_CONSOLE
1845 // When run in console mode, use standard out to display errors.
1846 cout
<< odbcErrMsg
.c_str() << endl
;
1847 cout
<< wxT("Press any key to continue...") << endl
;
1852 wxLogDebug(odbcErrMsg
,wxT("ODBC DEBUG MESSAGE"));
1853 #endif // __WXDEBUG__
1855 } // wxDb::DispNextError()
1858 /********** wxDb::logError() **********/
1859 void wxDb::logError(const wxString
&errMsg
, const wxString
&SQLState
)
1861 wxASSERT(errMsg
.Length());
1863 static int pLast
= -1;
1866 if (++pLast
== DB_MAX_ERROR_HISTORY
)
1869 for (i
= 0; i
< DB_MAX_ERROR_HISTORY
-1; i
++)
1870 wxStrcpy(errorList
[i
], errorList
[i
+1]);
1874 wxStrncpy(errorList
[pLast
], errMsg
, DB_MAX_ERROR_MSG_LEN
);
1875 errorList
[pLast
][DB_MAX_ERROR_MSG_LEN
] = 0;
1877 if (SQLState
.Length())
1878 if ((dbStatus
= TranslateSqlState(SQLState
)) != DB_ERR_FUNCTION_SEQUENCE_ERROR
)
1879 DB_STATUS
= dbStatus
;
1881 // Add the errmsg to the sql log
1882 WriteSqlLog(errMsg
);
1884 } // wxDb::logError()
1887 /**********wxDb::TranslateSqlState() **********/
1888 int wxDb::TranslateSqlState(const wxString
&SQLState
)
1890 if (!wxStrcmp(SQLState
, wxT("01000")))
1891 return(DB_ERR_GENERAL_WARNING
);
1892 if (!wxStrcmp(SQLState
, wxT("01002")))
1893 return(DB_ERR_DISCONNECT_ERROR
);
1894 if (!wxStrcmp(SQLState
, wxT("01004")))
1895 return(DB_ERR_DATA_TRUNCATED
);
1896 if (!wxStrcmp(SQLState
, wxT("01006")))
1897 return(DB_ERR_PRIV_NOT_REVOKED
);
1898 if (!wxStrcmp(SQLState
, wxT("01S00")))
1899 return(DB_ERR_INVALID_CONN_STR_ATTR
);
1900 if (!wxStrcmp(SQLState
, wxT("01S01")))
1901 return(DB_ERR_ERROR_IN_ROW
);
1902 if (!wxStrcmp(SQLState
, wxT("01S02")))
1903 return(DB_ERR_OPTION_VALUE_CHANGED
);
1904 if (!wxStrcmp(SQLState
, wxT("01S03")))
1905 return(DB_ERR_NO_ROWS_UPD_OR_DEL
);
1906 if (!wxStrcmp(SQLState
, wxT("01S04")))
1907 return(DB_ERR_MULTI_ROWS_UPD_OR_DEL
);
1908 if (!wxStrcmp(SQLState
, wxT("07001")))
1909 return(DB_ERR_WRONG_NO_OF_PARAMS
);
1910 if (!wxStrcmp(SQLState
, wxT("07006")))
1911 return(DB_ERR_DATA_TYPE_ATTR_VIOL
);
1912 if (!wxStrcmp(SQLState
, wxT("08001")))
1913 return(DB_ERR_UNABLE_TO_CONNECT
);
1914 if (!wxStrcmp(SQLState
, wxT("08002")))
1915 return(DB_ERR_CONNECTION_IN_USE
);
1916 if (!wxStrcmp(SQLState
, wxT("08003")))
1917 return(DB_ERR_CONNECTION_NOT_OPEN
);
1918 if (!wxStrcmp(SQLState
, wxT("08004")))
1919 return(DB_ERR_REJECTED_CONNECTION
);
1920 if (!wxStrcmp(SQLState
, wxT("08007")))
1921 return(DB_ERR_CONN_FAIL_IN_TRANS
);
1922 if (!wxStrcmp(SQLState
, wxT("08S01")))
1923 return(DB_ERR_COMM_LINK_FAILURE
);
1924 if (!wxStrcmp(SQLState
, wxT("21S01")))
1925 return(DB_ERR_INSERT_VALUE_LIST_MISMATCH
);
1926 if (!wxStrcmp(SQLState
, wxT("21S02")))
1927 return(DB_ERR_DERIVED_TABLE_MISMATCH
);
1928 if (!wxStrcmp(SQLState
, wxT("22001")))
1929 return(DB_ERR_STRING_RIGHT_TRUNC
);
1930 if (!wxStrcmp(SQLState
, wxT("22003")))
1931 return(DB_ERR_NUMERIC_VALUE_OUT_OF_RNG
);
1932 if (!wxStrcmp(SQLState
, wxT("22005")))
1933 return(DB_ERR_ERROR_IN_ASSIGNMENT
);
1934 if (!wxStrcmp(SQLState
, wxT("22008")))
1935 return(DB_ERR_DATETIME_FLD_OVERFLOW
);
1936 if (!wxStrcmp(SQLState
, wxT("22012")))
1937 return(DB_ERR_DIVIDE_BY_ZERO
);
1938 if (!wxStrcmp(SQLState
, wxT("22026")))
1939 return(DB_ERR_STR_DATA_LENGTH_MISMATCH
);
1940 if (!wxStrcmp(SQLState
, wxT("23000")))
1941 return(DB_ERR_INTEGRITY_CONSTRAINT_VIOL
);
1942 if (!wxStrcmp(SQLState
, wxT("24000")))
1943 return(DB_ERR_INVALID_CURSOR_STATE
);
1944 if (!wxStrcmp(SQLState
, wxT("25000")))
1945 return(DB_ERR_INVALID_TRANS_STATE
);
1946 if (!wxStrcmp(SQLState
, wxT("28000")))
1947 return(DB_ERR_INVALID_AUTH_SPEC
);
1948 if (!wxStrcmp(SQLState
, wxT("34000")))
1949 return(DB_ERR_INVALID_CURSOR_NAME
);
1950 if (!wxStrcmp(SQLState
, wxT("37000")))
1951 return(DB_ERR_SYNTAX_ERROR_OR_ACCESS_VIOL
);
1952 if (!wxStrcmp(SQLState
, wxT("3C000")))
1953 return(DB_ERR_DUPLICATE_CURSOR_NAME
);
1954 if (!wxStrcmp(SQLState
, wxT("40001")))
1955 return(DB_ERR_SERIALIZATION_FAILURE
);
1956 if (!wxStrcmp(SQLState
, wxT("42000")))
1957 return(DB_ERR_SYNTAX_ERROR_OR_ACCESS_VIOL2
);
1958 if (!wxStrcmp(SQLState
, wxT("70100")))
1959 return(DB_ERR_OPERATION_ABORTED
);
1960 if (!wxStrcmp(SQLState
, wxT("IM001")))
1961 return(DB_ERR_UNSUPPORTED_FUNCTION
);
1962 if (!wxStrcmp(SQLState
, wxT("IM002")))
1963 return(DB_ERR_NO_DATA_SOURCE
);
1964 if (!wxStrcmp(SQLState
, wxT("IM003")))
1965 return(DB_ERR_DRIVER_LOAD_ERROR
);
1966 if (!wxStrcmp(SQLState
, wxT("IM004")))
1967 return(DB_ERR_SQLALLOCENV_FAILED
);
1968 if (!wxStrcmp(SQLState
, wxT("IM005")))
1969 return(DB_ERR_SQLALLOCCONNECT_FAILED
);
1970 if (!wxStrcmp(SQLState
, wxT("IM006")))
1971 return(DB_ERR_SQLSETCONNECTOPTION_FAILED
);
1972 if (!wxStrcmp(SQLState
, wxT("IM007")))
1973 return(DB_ERR_NO_DATA_SOURCE_DLG_PROHIB
);
1974 if (!wxStrcmp(SQLState
, wxT("IM008")))
1975 return(DB_ERR_DIALOG_FAILED
);
1976 if (!wxStrcmp(SQLState
, wxT("IM009")))
1977 return(DB_ERR_UNABLE_TO_LOAD_TRANSLATION_DLL
);
1978 if (!wxStrcmp(SQLState
, wxT("IM010")))
1979 return(DB_ERR_DATA_SOURCE_NAME_TOO_LONG
);
1980 if (!wxStrcmp(SQLState
, wxT("IM011")))
1981 return(DB_ERR_DRIVER_NAME_TOO_LONG
);
1982 if (!wxStrcmp(SQLState
, wxT("IM012")))
1983 return(DB_ERR_DRIVER_KEYWORD_SYNTAX_ERROR
);
1984 if (!wxStrcmp(SQLState
, wxT("IM013")))
1985 return(DB_ERR_TRACE_FILE_ERROR
);
1986 if (!wxStrcmp(SQLState
, wxT("S0001")))
1987 return(DB_ERR_TABLE_OR_VIEW_ALREADY_EXISTS
);
1988 if (!wxStrcmp(SQLState
, wxT("S0002")))
1989 return(DB_ERR_TABLE_NOT_FOUND
);
1990 if (!wxStrcmp(SQLState
, wxT("S0011")))
1991 return(DB_ERR_INDEX_ALREADY_EXISTS
);
1992 if (!wxStrcmp(SQLState
, wxT("S0012")))
1993 return(DB_ERR_INDEX_NOT_FOUND
);
1994 if (!wxStrcmp(SQLState
, wxT("S0021")))
1995 return(DB_ERR_COLUMN_ALREADY_EXISTS
);
1996 if (!wxStrcmp(SQLState
, wxT("S0022")))
1997 return(DB_ERR_COLUMN_NOT_FOUND
);
1998 if (!wxStrcmp(SQLState
, wxT("S0023")))
1999 return(DB_ERR_NO_DEFAULT_FOR_COLUMN
);
2000 if (!wxStrcmp(SQLState
, wxT("S1000")))
2001 return(DB_ERR_GENERAL_ERROR
);
2002 if (!wxStrcmp(SQLState
, wxT("S1001")))
2003 return(DB_ERR_MEMORY_ALLOCATION_FAILURE
);
2004 if (!wxStrcmp(SQLState
, wxT("S1002")))
2005 return(DB_ERR_INVALID_COLUMN_NUMBER
);
2006 if (!wxStrcmp(SQLState
, wxT("S1003")))
2007 return(DB_ERR_PROGRAM_TYPE_OUT_OF_RANGE
);
2008 if (!wxStrcmp(SQLState
, wxT("S1004")))
2009 return(DB_ERR_SQL_DATA_TYPE_OUT_OF_RANGE
);
2010 if (!wxStrcmp(SQLState
, wxT("S1008")))
2011 return(DB_ERR_OPERATION_CANCELLED
);
2012 if (!wxStrcmp(SQLState
, wxT("S1009")))
2013 return(DB_ERR_INVALID_ARGUMENT_VALUE
);
2014 if (!wxStrcmp(SQLState
, wxT("S1010")))
2015 return(DB_ERR_FUNCTION_SEQUENCE_ERROR
);
2016 if (!wxStrcmp(SQLState
, wxT("S1011")))
2017 return(DB_ERR_OPERATION_INVALID_AT_THIS_TIME
);
2018 if (!wxStrcmp(SQLState
, wxT("S1012")))
2019 return(DB_ERR_INVALID_TRANS_OPERATION_CODE
);
2020 if (!wxStrcmp(SQLState
, wxT("S1015")))
2021 return(DB_ERR_NO_CURSOR_NAME_AVAIL
);
2022 if (!wxStrcmp(SQLState
, wxT("S1090")))
2023 return(DB_ERR_INVALID_STR_OR_BUF_LEN
);
2024 if (!wxStrcmp(SQLState
, wxT("S1091")))
2025 return(DB_ERR_DESCRIPTOR_TYPE_OUT_OF_RANGE
);
2026 if (!wxStrcmp(SQLState
, wxT("S1092")))
2027 return(DB_ERR_OPTION_TYPE_OUT_OF_RANGE
);
2028 if (!wxStrcmp(SQLState
, wxT("S1093")))
2029 return(DB_ERR_INVALID_PARAM_NO
);
2030 if (!wxStrcmp(SQLState
, wxT("S1094")))
2031 return(DB_ERR_INVALID_SCALE_VALUE
);
2032 if (!wxStrcmp(SQLState
, wxT("S1095")))
2033 return(DB_ERR_FUNCTION_TYPE_OUT_OF_RANGE
);
2034 if (!wxStrcmp(SQLState
, wxT("S1096")))
2035 return(DB_ERR_INF_TYPE_OUT_OF_RANGE
);
2036 if (!wxStrcmp(SQLState
, wxT("S1097")))
2037 return(DB_ERR_COLUMN_TYPE_OUT_OF_RANGE
);
2038 if (!wxStrcmp(SQLState
, wxT("S1098")))
2039 return(DB_ERR_SCOPE_TYPE_OUT_OF_RANGE
);
2040 if (!wxStrcmp(SQLState
, wxT("S1099")))
2041 return(DB_ERR_NULLABLE_TYPE_OUT_OF_RANGE
);
2042 if (!wxStrcmp(SQLState
, wxT("S1100")))
2043 return(DB_ERR_UNIQUENESS_OPTION_TYPE_OUT_OF_RANGE
);
2044 if (!wxStrcmp(SQLState
, wxT("S1101")))
2045 return(DB_ERR_ACCURACY_OPTION_TYPE_OUT_OF_RANGE
);
2046 if (!wxStrcmp(SQLState
, wxT("S1103")))
2047 return(DB_ERR_DIRECTION_OPTION_OUT_OF_RANGE
);
2048 if (!wxStrcmp(SQLState
, wxT("S1104")))
2049 return(DB_ERR_INVALID_PRECISION_VALUE
);
2050 if (!wxStrcmp(SQLState
, wxT("S1105")))
2051 return(DB_ERR_INVALID_PARAM_TYPE
);
2052 if (!wxStrcmp(SQLState
, wxT("S1106")))
2053 return(DB_ERR_FETCH_TYPE_OUT_OF_RANGE
);
2054 if (!wxStrcmp(SQLState
, wxT("S1107")))
2055 return(DB_ERR_ROW_VALUE_OUT_OF_RANGE
);
2056 if (!wxStrcmp(SQLState
, wxT("S1108")))
2057 return(DB_ERR_CONCURRENCY_OPTION_OUT_OF_RANGE
);
2058 if (!wxStrcmp(SQLState
, wxT("S1109")))
2059 return(DB_ERR_INVALID_CURSOR_POSITION
);
2060 if (!wxStrcmp(SQLState
, wxT("S1110")))
2061 return(DB_ERR_INVALID_DRIVER_COMPLETION
);
2062 if (!wxStrcmp(SQLState
, wxT("S1111")))
2063 return(DB_ERR_INVALID_BOOKMARK_VALUE
);
2064 if (!wxStrcmp(SQLState
, wxT("S1C00")))
2065 return(DB_ERR_DRIVER_NOT_CAPABLE
);
2066 if (!wxStrcmp(SQLState
, wxT("S1T00")))
2067 return(DB_ERR_TIMEOUT_EXPIRED
);
2072 } // wxDb::TranslateSqlState()
2075 /********** wxDb::Grant() **********/
2076 bool wxDb::Grant(int privileges
, const wxString
&tableName
, const wxString
&userList
)
2080 // Build the grant statement
2081 sqlStmt
= wxT("GRANT ");
2082 if (privileges
== DB_GRANT_ALL
)
2083 sqlStmt
+= wxT("ALL");
2087 if (privileges
& DB_GRANT_SELECT
)
2089 sqlStmt
+= wxT("SELECT");
2092 if (privileges
& DB_GRANT_INSERT
)
2095 sqlStmt
+= wxT(", ");
2096 sqlStmt
+= wxT("INSERT");
2098 if (privileges
& DB_GRANT_UPDATE
)
2101 sqlStmt
+= wxT(", ");
2102 sqlStmt
+= wxT("UPDATE");
2104 if (privileges
& DB_GRANT_DELETE
)
2107 sqlStmt
+= wxT(", ");
2108 sqlStmt
+= wxT("DELETE");
2112 sqlStmt
+= wxT(" ON ");
2113 sqlStmt
+= SQLTableName(tableName
);
2114 sqlStmt
+= wxT(" TO ");
2115 sqlStmt
+= userList
;
2117 #ifdef DBDEBUG_CONSOLE
2118 cout
<< endl
<< sqlStmt
.c_str() << endl
;
2121 WriteSqlLog(sqlStmt
);
2123 return(ExecSql(sqlStmt
));
2128 /********** wxDb::CreateView() **********/
2129 bool wxDb::CreateView(const wxString
&viewName
, const wxString
&colList
,
2130 const wxString
&pSqlStmt
, bool attemptDrop
)
2134 // Drop the view first
2135 if (attemptDrop
&& !DropView(viewName
))
2138 // Build the create view statement
2139 sqlStmt
= wxT("CREATE VIEW ");
2140 sqlStmt
+= viewName
;
2142 if (colList
.Length())
2144 sqlStmt
+= wxT(" (");
2146 sqlStmt
+= wxT(")");
2149 sqlStmt
+= wxT(" AS ");
2150 sqlStmt
+= pSqlStmt
;
2152 WriteSqlLog(sqlStmt
);
2154 #ifdef DBDEBUG_CONSOLE
2155 cout
<< sqlStmt
.c_str() << endl
;
2158 return(ExecSql(sqlStmt
));
2160 } // wxDb::CreateView()
2163 /********** wxDb::DropView() **********/
2164 bool wxDb::DropView(const wxString
&viewName
)
2167 * NOTE: This function returns true if the View does not exist, but
2168 * only for identified databases. Code will need to be added
2169 * below for any other databases when those databases are defined
2170 * to handle this situation consistently
2174 sqlStmt
.Printf(wxT("DROP VIEW %s"), viewName
.c_str());
2176 WriteSqlLog(sqlStmt
);
2178 #ifdef DBDEBUG_CONSOLE
2179 cout
<< endl
<< sqlStmt
.c_str() << endl
;
2182 if (SQLExecDirect(hstmt
, (SQLTCHAR FAR
*) sqlStmt
.c_str(), SQL_NTS
) != SQL_SUCCESS
)
2184 // Check for "Base table not found" error and ignore
2185 GetNextError(henv
, hdbc
, hstmt
);
2186 if (wxStrcmp(sqlState
,wxT("S0002"))) // "Base table not found"
2188 // Check for product specific error codes
2189 if (!((Dbms() == dbmsSYBASE_ASA
&& !wxStrcmp(sqlState
,wxT("42000"))))) // 5.x (and lower?)
2192 DispAllErrors(henv
, hdbc
, hstmt
);
2199 // Commit the transaction
2205 } // wxDb::DropView()
2208 /********** wxDb::ExecSql() **********/
2209 bool wxDb::ExecSql(const wxString
&pSqlStmt
)
2213 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2215 retcode
= SQLExecDirect(hstmt
, (SQLTCHAR FAR
*) pSqlStmt
.c_str(), SQL_NTS
);
2216 if (retcode
== SQL_SUCCESS
||
2217 (Dbms() == dbmsDB2
&& (retcode
== SQL_SUCCESS_WITH_INFO
|| retcode
== SQL_NO_DATA_FOUND
)))
2223 DispAllErrors(henv
, hdbc
, hstmt
);
2227 } // wxDb::ExecSql()
2230 /********** wxDb::ExecSql() with column info **********/
2231 bool wxDb::ExecSql(const wxString
&pSqlStmt
, wxDbColInf
** columns
, short& numcols
)
2233 //execute the statement first
2234 if (!ExecSql(pSqlStmt
))
2238 if (SQLNumResultCols(hstmt
, &noCols
) != SQL_SUCCESS
)
2240 DispAllErrors(henv
, hdbc
, hstmt
);
2249 // Get column information
2251 wxChar name
[DB_MAX_COLUMN_NAME_LEN
+1];
2254 wxDbColInf
* pColInf
= new wxDbColInf
[noCols
];
2256 // Fill in column information (name, datatype)
2257 for (colNum
= 0; colNum
< noCols
; colNum
++)
2259 if (SQLColAttributes(hstmt
, (UWORD
)(colNum
+1), SQL_COLUMN_NAME
,
2261 &Sword
, &Sdword
) != SQL_SUCCESS
)
2263 DispAllErrors(henv
, hdbc
, hstmt
);
2268 wxStrncpy(pColInf
[colNum
].colName
, name
, DB_MAX_COLUMN_NAME_LEN
);
2269 pColInf
[colNum
].colName
[DB_MAX_COLUMN_NAME_LEN
] = 0; // Prevent buffer overrun
2271 if (SQLColAttributes(hstmt
, (UWORD
)(colNum
+1), SQL_COLUMN_TYPE
,
2272 NULL
, 0, &Sword
, &Sdword
) != SQL_SUCCESS
)
2274 DispAllErrors(henv
, hdbc
, hstmt
);
2282 #if defined(SQL_WCHAR)
2285 #if defined(SQL_WVARCHAR)
2291 pColInf
[colNum
].dbDataType
= DB_DATA_TYPE_VARCHAR
;
2297 pColInf
[colNum
].dbDataType
= DB_DATA_TYPE_INTEGER
;
2304 pColInf
[colNum
].dbDataType
= DB_DATA_TYPE_FLOAT
;
2308 pColInf
[colNum
].dbDataType
= DB_DATA_TYPE_DATE
;
2311 pColInf
[colNum
].dbDataType
= DB_DATA_TYPE_BLOB
;
2316 errMsg
.Printf(wxT("SQL Data type %ld currently not supported by wxWidgets"), (long)Sdword
);
2317 wxLogDebug(errMsg
,wxT("ODBC DEBUG MESSAGE"));
2324 } // wxDb::ExecSql()
2326 /********** wxDb::GetNext() **********/
2327 bool wxDb::GetNext(void)
2329 if (SQLFetch(hstmt
) == SQL_SUCCESS
)
2333 DispAllErrors(henv
, hdbc
, hstmt
);
2337 } // wxDb::GetNext()
2340 /********** wxDb::GetData() **********/
2341 bool wxDb::GetData(UWORD colNo
, SWORD cType
, PTR pData
, SDWORD maxLen
, SDWORD FAR
*cbReturned
)
2344 wxASSERT(cbReturned
);
2346 long bufferSize
= maxLen
;
2348 if (cType
== SQL_C_WXCHAR
)
2349 bufferSize
= maxLen
* sizeof(wxChar
);
2351 if (SQLGetData(hstmt
, colNo
, cType
, pData
, bufferSize
, cbReturned
) == SQL_SUCCESS
)
2355 DispAllErrors(henv
, hdbc
, hstmt
);
2359 } // wxDb::GetData()
2362 /********** wxDb::GetKeyFields() **********/
2363 int wxDb::GetKeyFields(const wxString
&tableName
, wxDbColInf
* colInf
, UWORD noCols
)
2365 wxChar szPkTable
[DB_MAX_TABLE_NAME_LEN
+1]; /* Primary key table name */
2366 wxChar szFkTable
[DB_MAX_TABLE_NAME_LEN
+1]; /* Foreign key table name */
2368 wxChar szPkCol
[DB_MAX_COLUMN_NAME_LEN
+1]; /* Primary key column */
2369 wxChar szFkCol
[DB_MAX_COLUMN_NAME_LEN
+1]; /* Foreign key column */
2375 * -----------------------------------------------------------------------
2376 * -- 19991224 : mj10777 : Create ------
2377 * -- : Three things are done and stored here : ------
2378 * -- : 1) which Column(s) is/are Primary Key(s) ------
2379 * -- : 2) which tables use this Key as a Foreign Key ------
2380 * -- : 3) which columns are Foreign Key and the name ------
2381 * -- : of the Table where the Key is the Primary Key -----
2382 * -- : Called from GetColumns(const wxString &tableName, ------
2383 * -- int *numCols,const wxChar *userID ) ------
2384 * -----------------------------------------------------------------------
2387 /*---------------------------------------------------------------------*/
2388 /* Get the names of the columns in the primary key. */
2389 /*---------------------------------------------------------------------*/
2390 retcode
= SQLPrimaryKeys(hstmt
,
2391 NULL
, 0, /* Catalog name */
2392 NULL
, 0, /* Schema name */
2393 (SQLTCHAR FAR
*) tableName
.c_str(), SQL_NTS
); /* Table name */
2395 /*---------------------------------------------------------------------*/
2396 /* Fetch and display the result set. This will be a list of the */
2397 /* columns in the primary key of the tableName table. */
2398 /*---------------------------------------------------------------------*/
2399 while ((retcode
== SQL_SUCCESS
) || (retcode
== SQL_SUCCESS_WITH_INFO
))
2401 retcode
= SQLFetch(hstmt
);
2402 if (retcode
== SQL_SUCCESS
|| retcode
== SQL_SUCCESS_WITH_INFO
)
2404 GetData( 4, SQL_C_WXCHAR
, szPkCol
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
2405 GetData( 5, SQL_C_SSHORT
, &iKeySeq
, 0, &cb
);
2407 for (i
=0;i
<noCols
;i
++) // Find the Column name
2408 if (!wxStrcmp(colInf
[i
].colName
,szPkCol
)) // We have found the Column
2409 colInf
[i
].PkCol
= iKeySeq
; // Which Primary Key is this (first, second usw.) ?
2412 SQLFreeStmt(hstmt
, SQL_CLOSE
); /* Close the cursor (the hstmt is still allocated). */
2414 /*---------------------------------------------------------------------*/
2415 /* Get all the foreign keys that refer to tableName primary key. */
2416 /*---------------------------------------------------------------------*/
2417 retcode
= SQLForeignKeys(hstmt
,
2418 NULL
, 0, /* Primary catalog */
2419 NULL
, 0, /* Primary schema */
2420 (SQLTCHAR FAR
*)tableName
.c_str(), SQL_NTS
,/* Primary table */
2421 NULL
, 0, /* Foreign catalog */
2422 NULL
, 0, /* Foreign schema */
2423 NULL
, 0); /* Foreign table */
2425 /*---------------------------------------------------------------------*/
2426 /* Fetch and display the result set. This will be all of the foreign */
2427 /* keys in other tables that refer to the tableName primary key. */
2428 /*---------------------------------------------------------------------*/
2431 while ((retcode
== SQL_SUCCESS
) || (retcode
== SQL_SUCCESS_WITH_INFO
))
2433 retcode
= SQLFetch(hstmt
);
2434 if (retcode
== SQL_SUCCESS
|| retcode
== SQL_SUCCESS_WITH_INFO
)
2436 GetData( 3, SQL_C_WXCHAR
, szPkTable
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
2437 GetData( 4, SQL_C_WXCHAR
, szPkCol
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
2438 GetData( 5, SQL_C_SSHORT
, &iKeySeq
, 0, &cb
);
2439 GetData( 7, SQL_C_WXCHAR
, szFkTable
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
2440 GetData( 8, SQL_C_WXCHAR
, szFkCol
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
2441 tempStr
.Printf(wxT("%s[%s] "),tempStr
.c_str(),szFkTable
); // [ ] in case there is a blank in the Table name
2445 tempStr
.Trim(); // Get rid of any unneeded blanks
2446 if (!tempStr
.empty())
2448 for (i
=0; i
<noCols
; i
++)
2449 { // Find the Column name
2450 if (!wxStrcmp(colInf
[i
].colName
, szPkCol
)) // We have found the Column, store the Information
2452 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
2453 colInf
[i
].PkTableName
[DB_MAX_TABLE_NAME_LEN
] = 0; // Prevent buffer overrun
2458 SQLFreeStmt(hstmt
, SQL_CLOSE
); /* Close the cursor (the hstmt is still allocated). */
2460 /*---------------------------------------------------------------------*/
2461 /* Get all the foreign keys in the tablename table. */
2462 /*---------------------------------------------------------------------*/
2463 retcode
= SQLForeignKeys(hstmt
,
2464 NULL
, 0, /* Primary catalog */
2465 NULL
, 0, /* Primary schema */
2466 NULL
, 0, /* Primary table */
2467 NULL
, 0, /* Foreign catalog */
2468 NULL
, 0, /* Foreign schema */
2469 (SQLTCHAR
*)tableName
.c_str(), SQL_NTS
);/* Foreign table */
2471 /*---------------------------------------------------------------------*/
2472 /* Fetch and display the result set. This will be all of the */
2473 /* primary keys in other tables that are referred to by foreign */
2474 /* keys in the tableName table. */
2475 /*---------------------------------------------------------------------*/
2476 while ((retcode
== SQL_SUCCESS
) || (retcode
== SQL_SUCCESS_WITH_INFO
))
2478 retcode
= SQLFetch(hstmt
);
2479 if (retcode
== SQL_SUCCESS
|| retcode
== SQL_SUCCESS_WITH_INFO
)
2481 GetData( 3, SQL_C_WXCHAR
, szPkTable
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
2482 GetData( 5, SQL_C_SSHORT
, &iKeySeq
, 0, &cb
);
2483 GetData( 8, SQL_C_WXCHAR
, szFkCol
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
2485 for (i
=0; i
<noCols
; i
++) // Find the Column name
2487 if (!wxStrcmp(colInf
[i
].colName
,szFkCol
)) // We have found the (Foreign Key) Column
2489 colInf
[i
].FkCol
= iKeySeq
; // Which Foreign Key is this (first, second usw.) ?
2490 wxStrncpy(colInf
[i
].FkTableName
, szFkTable
, DB_MAX_TABLE_NAME_LEN
); // Name of the Table where this Foriegn is the Primary Key
2491 colInf
[i
].FkTableName
[DB_MAX_TABLE_NAME_LEN
] = 0; // Prevent buffer overrun
2496 SQLFreeStmt(hstmt
, SQL_CLOSE
); /* Close the cursor (the hstmt is still allocated). */
2500 } // wxDb::GetKeyFields()
2504 /********** wxDb::GetColumns() **********/
2505 wxDbColInf
*wxDb::GetColumns(wxChar
*tableName
[], const wxChar
*userID
)
2507 * 1) The last array element of the tableName[] argument must be zero (null).
2508 * This is how the end of the array is detected.
2509 * 2) This function returns an array of wxDbColInf structures. If no columns
2510 * were found, or an error occured, this pointer will be zero (null). THE
2511 * CALLING FUNCTION IS RESPONSIBLE FOR DELETING THE MEMORY RETURNED WHEN IT
2512 * IS FINISHED WITH IT. i.e.
2514 * wxDbColInf *colInf = pDb->GetColumns(tableList, userID);
2517 * // Use the column inf
2519 * // Destroy the memory
2523 * userID is evaluated in the following manner:
2524 * userID == NULL ... UserID is ignored
2525 * userID == "" ... UserID set equal to 'this->uid'
2526 * userID != "" ... UserID set equal to 'userID'
2528 * NOTE: ALL column bindings associated with this wxDb instance are unbound
2529 * by this function. This function should use its own wxDb instance
2530 * to avoid undesired unbinding of columns.
2535 wxDbColInf
*colInf
= 0;
2543 convertUserID(userID
,UserID
);
2545 // Pass 1 - Determine how many columns there are.
2546 // Pass 2 - Allocate the wxDbColInf array and fill in
2547 // the array with the column information.
2549 for (pass
= 1; pass
<= 2; pass
++)
2553 if (noCols
== 0) // Probably a bogus table name(s)
2555 // Allocate n wxDbColInf objects to hold the column information
2556 colInf
= new wxDbColInf
[noCols
+1];
2559 // Mark the end of the array
2560 wxStrcpy(colInf
[noCols
].tableName
, wxEmptyString
);
2561 wxStrcpy(colInf
[noCols
].colName
, wxEmptyString
);
2562 colInf
[noCols
].sqlDataType
= 0;
2564 // Loop through each table name
2566 for (tbl
= 0; tableName
[tbl
]; tbl
++)
2568 TableName
= tableName
[tbl
];
2569 // Oracle and Interbase table names are uppercase only, so force
2570 // the name to uppercase just in case programmer forgot to do this
2571 if ((Dbms() == dbmsORACLE
) ||
2572 (Dbms() == dbmsFIREBIRD
) ||
2573 (Dbms() == dbmsINTERBASE
))
2574 TableName
= TableName
.Upper();
2576 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2578 // MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
2579 // use the call below that leaves out the user name
2580 if (!UserID
.empty() &&
2581 Dbms() != dbmsMY_SQL
&&
2582 Dbms() != dbmsACCESS
&&
2583 Dbms() != dbmsMS_SQL_SERVER
)
2585 retcode
= SQLColumns(hstmt
,
2586 NULL
, 0, // All qualifiers
2587 (SQLTCHAR
*) UserID
.c_str(), SQL_NTS
, // Owner
2588 (SQLTCHAR
*) TableName
.c_str(), SQL_NTS
,
2589 NULL
, 0); // All columns
2593 retcode
= SQLColumns(hstmt
,
2594 NULL
, 0, // All qualifiers
2596 (SQLTCHAR
*) TableName
.c_str(), SQL_NTS
,
2597 NULL
, 0); // All columns
2599 if (retcode
!= SQL_SUCCESS
)
2600 { // Error occured, abort
2601 DispAllErrors(henv
, hdbc
, hstmt
);
2604 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2608 while ((retcode
= SQLFetch(hstmt
)) == SQL_SUCCESS
)
2610 if (pass
== 1) // First pass, just add up the number of columns
2612 else // Pass 2; Fill in the array of structures
2614 if (colNo
< noCols
) // Some extra error checking to prevent memory overwrites
2616 // NOTE: Only the ODBC 1.x fields are retrieved
2617 GetData( 1, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].catalog
, 128+1, &cb
);
2618 GetData( 2, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].schema
, 128+1, &cb
);
2619 GetData( 3, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].tableName
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
2620 GetData( 4, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].colName
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
2621 GetData( 5, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].sqlDataType
, 0, &cb
);
2622 GetData( 6, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].typeName
, 128+1, &cb
);
2623 GetData( 7, SQL_C_SLONG
, (UCHAR
*) &colInf
[colNo
].columnLength
, 0, &cb
);
2624 GetData( 8, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].bufferSize
, 0, &cb
);
2625 GetData( 9, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].decimalDigits
,0, &cb
);
2626 GetData(10, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].numPrecRadix
, 0, &cb
);
2627 GetData(11, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].nullable
, 0, &cb
);
2628 GetData(12, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].remarks
, 254+1, &cb
);
2630 // Determine the wxDb data type that is used to represent the native data type of this data source
2631 colInf
[colNo
].dbDataType
= 0;
2632 if (!wxStricmp(typeInfVarchar
.TypeName
,colInf
[colNo
].typeName
))
2635 // IODBC does not return a correct columnLength, so we set
2636 // columnLength = bufferSize if no column length was returned
2637 // IODBC returns the columnLength in bufferSize. (bug)
2638 if (colInf
[colNo
].columnLength
< 1)
2640 colInf
[colNo
].columnLength
= colInf
[colNo
].bufferSize
;
2643 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_VARCHAR
;
2645 else if (!wxStricmp(typeInfInteger
.TypeName
, colInf
[colNo
].typeName
))
2646 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_INTEGER
;
2647 else if (!wxStricmp(typeInfFloat
.TypeName
, colInf
[colNo
].typeName
))
2648 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_FLOAT
;
2649 else if (!wxStricmp(typeInfDate
.TypeName
, colInf
[colNo
].typeName
))
2650 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_DATE
;
2651 else if (!wxStricmp(typeInfBlob
.TypeName
, colInf
[colNo
].typeName
))
2652 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_BLOB
;
2657 if (retcode
!= SQL_NO_DATA_FOUND
)
2658 { // Error occured, abort
2659 DispAllErrors(henv
, hdbc
, hstmt
);
2662 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2668 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2671 } // wxDb::GetColumns()
2674 /********** wxDb::GetColumns() **********/
2676 wxDbColInf
*wxDb::GetColumns(const wxString
&tableName
, UWORD
*numCols
, const wxChar
*userID
)
2678 // Same as the above GetColumns() function except this one gets columns
2679 // only for a single table, and if 'numCols' is not NULL, the number of
2680 // columns stored in the returned wxDbColInf is set in '*numCols'
2682 // userID is evaluated in the following manner:
2683 // userID == NULL ... UserID is ignored
2684 // userID == "" ... UserID set equal to 'this->uid'
2685 // userID != "" ... UserID set equal to 'userID'
2687 // NOTE: ALL column bindings associated with this wxDb instance are unbound
2688 // by this function. This function should use its own wxDb instance
2689 // to avoid undesired unbinding of columns.
2694 wxDbColInf
*colInf
= 0;
2702 convertUserID(userID
,UserID
);
2704 // Pass 1 - Determine how many columns there are.
2705 // Pass 2 - Allocate the wxDbColInf array and fill in
2706 // the array with the column information.
2708 for (pass
= 1; pass
<= 2; pass
++)
2712 if (noCols
== 0) // Probably a bogus table name(s)
2714 // Allocate n wxDbColInf objects to hold the column information
2715 colInf
= new wxDbColInf
[noCols
+1];
2718 // Mark the end of the array
2719 wxStrcpy(colInf
[noCols
].tableName
, wxEmptyString
);
2720 wxStrcpy(colInf
[noCols
].colName
, wxEmptyString
);
2721 colInf
[noCols
].sqlDataType
= 0;
2724 TableName
= tableName
;
2725 // Oracle and Interbase table names are uppercase only, so force
2726 // the name to uppercase just in case programmer forgot to do this
2727 if ((Dbms() == dbmsORACLE
) ||
2728 (Dbms() == dbmsFIREBIRD
) ||
2729 (Dbms() == dbmsINTERBASE
))
2730 TableName
= TableName
.Upper();
2732 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2734 // MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
2735 // use the call below that leaves out the user name
2736 if (!UserID
.empty() &&
2737 Dbms() != dbmsMY_SQL
&&
2738 Dbms() != dbmsACCESS
&&
2739 Dbms() != dbmsMS_SQL_SERVER
)
2741 retcode
= SQLColumns(hstmt
,
2742 NULL
, 0, // All qualifiers
2743 (SQLTCHAR
*) UserID
.c_str(), SQL_NTS
, // Owner
2744 (SQLTCHAR
*) TableName
.c_str(), SQL_NTS
,
2745 NULL
, 0); // All columns
2749 retcode
= SQLColumns(hstmt
,
2750 NULL
, 0, // All qualifiers
2752 (SQLTCHAR
*) TableName
.c_str(), SQL_NTS
,
2753 NULL
, 0); // All columns
2755 if (retcode
!= SQL_SUCCESS
)
2756 { // Error occured, abort
2757 DispAllErrors(henv
, hdbc
, hstmt
);
2760 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2766 while ((retcode
= SQLFetch(hstmt
)) == SQL_SUCCESS
)
2768 if (pass
== 1) // First pass, just add up the number of columns
2770 else // Pass 2; Fill in the array of structures
2772 if (colNo
< noCols
) // Some extra error checking to prevent memory overwrites
2774 // NOTE: Only the ODBC 1.x fields are retrieved
2775 GetData( 1, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].catalog
, 128+1, &cb
);
2776 GetData( 2, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].schema
, 128+1, &cb
);
2777 GetData( 3, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].tableName
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
2778 GetData( 4, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].colName
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
2779 GetData( 5, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].sqlDataType
, 0, &cb
);
2780 GetData( 6, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].typeName
, 128+1, &cb
);
2781 GetData( 7, SQL_C_SLONG
, (UCHAR
*) &colInf
[colNo
].columnLength
, 0, &cb
);
2782 // BJO 991214 : SQL_C_SSHORT instead of SQL_C_SLONG, otherwise fails on Sparc (probably all 64 bit architectures)
2783 GetData( 8, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].bufferSize
, 0, &cb
);
2784 GetData( 9, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].decimalDigits
,0, &cb
);
2785 GetData(10, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].numPrecRadix
, 0, &cb
);
2786 GetData(11, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].nullable
, 0, &cb
);
2787 GetData(12, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].remarks
, 254+1, &cb
);
2788 // Start Values for Primary/Foriegn Key (=No)
2789 colInf
[colNo
].PkCol
= 0; // Primary key column 0=No; 1= First Key, 2 = Second Key etc.
2790 colInf
[colNo
].PkTableName
[0] = 0; // Tablenames where Primary Key is used as a Foreign Key
2791 colInf
[colNo
].FkCol
= 0; // Foreign key column 0=No; 1= First Key, 2 = Second Key etc.
2792 colInf
[colNo
].FkTableName
[0] = 0; // Foreign key table name
2794 // BJO 20000428 : Virtuoso returns type names with upper cases!
2795 if (Dbms() == dbmsVIRTUOSO
)
2797 wxString s
= colInf
[colNo
].typeName
;
2799 wxStrcmp(colInf
[colNo
].typeName
, s
.c_str());
2802 // Determine the wxDb data type that is used to represent the native data type of this data source
2803 colInf
[colNo
].dbDataType
= 0;
2804 if (!wxStricmp(typeInfVarchar
.TypeName
, colInf
[colNo
].typeName
))
2807 // IODBC does not return a correct columnLength, so we set
2808 // columnLength = bufferSize if no column length was returned
2809 // IODBC returns the columnLength in bufferSize. (bug)
2810 if (colInf
[colNo
].columnLength
< 1)
2812 colInf
[colNo
].columnLength
= colInf
[colNo
].bufferSize
;
2816 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_VARCHAR
;
2818 else if (!wxStricmp(typeInfInteger
.TypeName
, colInf
[colNo
].typeName
))
2819 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_INTEGER
;
2820 else if (!wxStricmp(typeInfFloat
.TypeName
, colInf
[colNo
].typeName
))
2821 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_FLOAT
;
2822 else if (!wxStricmp(typeInfDate
.TypeName
, colInf
[colNo
].typeName
))
2823 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_DATE
;
2824 else if (!wxStricmp(typeInfBlob
.TypeName
, colInf
[colNo
].typeName
))
2825 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_BLOB
;
2831 if (retcode
!= SQL_NO_DATA_FOUND
)
2832 { // Error occured, abort
2833 DispAllErrors(henv
, hdbc
, hstmt
);
2836 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2843 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2845 // Store Primary and Foriegn Keys
2846 GetKeyFields(tableName
,colInf
,noCols
);
2852 } // wxDb::GetColumns()
2855 #else // New GetColumns
2860 These are tentative new GetColumns members which should be more database
2861 independent and which always returns the columns in the order they were
2864 - The first one (wxDbColInf *wxDb::GetColumns(wxChar *tableName[], const
2865 wxChar* userID)) calls the second implementation for each separate table
2866 before merging the results. This makes the code easier to maintain as
2867 only one member (the second) makes the real work
2868 - wxDbColInf *wxDb::GetColumns(const wxString &tableName, int *numCols, const
2869 wxChar *userID) is a little bit improved
2870 - It doesn't anymore rely on the type-name to find out which database-type
2872 - It ends by sorting the columns, so that they are returned in the same
2873 order they were created
2883 wxDbColInf
*wxDb::GetColumns(wxChar
*tableName
[], const wxChar
*userID
)
2886 // The last array element of the tableName[] argument must be zero (null).
2887 // This is how the end of the array is detected.
2891 // How many tables ?
2893 for (tbl
= 0 ; tableName
[tbl
]; tbl
++);
2895 // Create a table to maintain the columns for each separate table
2896 _TableColumns
*TableColumns
= new _TableColumns
[tbl
];
2899 for (i
= 0 ; i
< tbl
; i
++)
2902 TableColumns
[i
].colInf
= GetColumns(tableName
[i
], &TableColumns
[i
].noCols
, userID
);
2903 if (TableColumns
[i
].colInf
== NULL
)
2905 noCols
+= TableColumns
[i
].noCols
;
2908 // Now merge all the separate table infos
2909 wxDbColInf
*colInf
= new wxDbColInf
[noCols
+1];
2911 // Mark the end of the array
2912 wxStrcpy(colInf
[noCols
].tableName
, wxEmptyString
);
2913 wxStrcpy(colInf
[noCols
].colName
, wxEmptyString
);
2914 colInf
[noCols
].sqlDataType
= 0;
2919 for (i
= 0 ; i
< tbl
; i
++)
2921 for (j
= 0 ; j
< TableColumns
[i
].noCols
; j
++)
2923 colInf
[offset
++] = TableColumns
[i
].colInf
[j
];
2927 delete [] TableColumns
;
2930 } // wxDb::GetColumns() -- NEW
2933 wxDbColInf
*wxDb::GetColumns(const wxString
&tableName
, int *numCols
, const wxChar
*userID
)
2935 // Same as the above GetColumns() function except this one gets columns
2936 // only for a single table, and if 'numCols' is not NULL, the number of
2937 // columns stored in the returned wxDbColInf is set in '*numCols'
2939 // userID is evaluated in the following manner:
2940 // userID == NULL ... UserID is ignored
2941 // userID == "" ... UserID set equal to 'this->uid'
2942 // userID != "" ... UserID set equal to 'userID'
2944 // NOTE: ALL column bindings associated with this wxDb instance are unbound
2945 // by this function. This function should use its own wxDb instance
2946 // to avoid undesired unbinding of columns.
2950 wxDbColInf
*colInf
= 0;
2958 convertUserID(userID
,UserID
);
2960 // Pass 1 - Determine how many columns there are.
2961 // Pass 2 - Allocate the wxDbColInf array and fill in
2962 // the array with the column information.
2964 for (pass
= 1; pass
<= 2; pass
++)
2968 if (noCols
== 0) // Probably a bogus table name(s)
2970 // Allocate n wxDbColInf objects to hold the column information
2971 colInf
= new wxDbColInf
[noCols
+1];
2974 // Mark the end of the array
2975 wxStrcpy(colInf
[noCols
].tableName
, wxEmptyString
);
2976 wxStrcpy(colInf
[noCols
].colName
, wxEmptyString
);
2977 colInf
[noCols
].sqlDataType
= 0;
2980 TableName
= tableName
;
2981 // Oracle and Interbase table names are uppercase only, so force
2982 // the name to uppercase just in case programmer forgot to do this
2983 if ((Dbms() == dbmsORACLE
) ||
2984 (Dbms() == dbmsFIREBIRD
) ||
2985 (Dbms() == dbmsINTERBASE
))
2986 TableName
= TableName
.Upper();
2988 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2990 // MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
2991 // use the call below that leaves out the user name
2992 if (!UserID
.empty() &&
2993 Dbms() != dbmsMY_SQL
&&
2994 Dbms() != dbmsACCESS
&&
2995 Dbms() != dbmsMS_SQL_SERVER
)
2997 retcode
= SQLColumns(hstmt
,
2998 NULL
, 0, // All qualifiers
2999 (UCHAR
*) UserID
.c_str(), SQL_NTS
, // Owner
3000 (UCHAR
*) TableName
.c_str(), SQL_NTS
,
3001 NULL
, 0); // All columns
3005 retcode
= SQLColumns(hstmt
,
3006 NULL
, 0, // All qualifiers
3008 (UCHAR
*) TableName
.c_str(), SQL_NTS
,
3009 NULL
, 0); // All columns
3011 if (retcode
!= SQL_SUCCESS
)
3012 { // Error occured, abort
3013 DispAllErrors(henv
, hdbc
, hstmt
);
3016 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3022 while ((retcode
= SQLFetch(hstmt
)) == SQL_SUCCESS
)
3024 if (pass
== 1) // First pass, just add up the number of columns
3026 else // Pass 2; Fill in the array of structures
3028 if (colNo
< noCols
) // Some extra error checking to prevent memory overwrites
3030 // NOTE: Only the ODBC 1.x fields are retrieved
3031 GetData( 1, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].catalog
, 128+1, &cb
);
3032 GetData( 2, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].schema
, 128+1, &cb
);
3033 GetData( 3, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].tableName
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
3034 GetData( 4, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].colName
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
3035 GetData( 5, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].sqlDataType
, 0, &cb
);
3036 GetData( 6, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].typeName
, 128+1, &cb
);
3037 GetData( 7, SQL_C_SLONG
, (UCHAR
*) &colInf
[colNo
].columnLength
, 0, &cb
);
3038 GetData( 8, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].bufferSize
, 0, &cb
);
3039 GetData( 9, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].decimalDigits
,0, &cb
);
3040 GetData(10, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].numPrecRadix
, 0, &cb
);
3041 GetData(11, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].nullable
, 0, &cb
);
3042 GetData(12, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].remarks
, 254+1, &cb
);
3043 // Start Values for Primary/Foriegn Key (=No)
3044 colInf
[colNo
].PkCol
= 0; // Primary key column 0=No; 1= First Key, 2 = Second Key etc.
3045 colInf
[colNo
].PkTableName
[0] = 0; // Tablenames where Primary Key is used as a Foreign Key
3046 colInf
[colNo
].FkCol
= 0; // Foreign key column 0=No; 1= First Key, 2 = Second Key etc.
3047 colInf
[colNo
].FkTableName
[0] = 0; // Foreign key table name
3050 // IODBC does not return a correct columnLength, so we set
3051 // columnLength = bufferSize if no column length was returned
3052 // IODBC returns the columnLength in bufferSize. (bug)
3053 if (colInf
[colNo
].columnLength
< 1)
3055 colInf
[colNo
].columnLength
= colInf
[colNo
].bufferSize
;
3059 // Determine the wxDb data type that is used to represent the native data type of this data source
3060 colInf
[colNo
].dbDataType
= 0;
3061 // Get the intern datatype
3062 switch (colInf
[colNo
].sqlDataType
)
3065 #if defined(SQL_WCHAR)
3068 #if defined(SQL_WVARCHAR)
3074 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_VARCHAR
;
3080 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_INTEGER
;
3087 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_FLOAT
;
3091 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_DATE
;
3094 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_BLOB
;
3099 errMsg
.Printf(wxT("SQL Data type %d currently not supported by wxWidgets"), colInf
[colNo
].sqlDataType
);
3100 wxLogDebug(errMsg
,wxT("ODBC DEBUG MESSAGE"));
3107 if (retcode
!= SQL_NO_DATA_FOUND
)
3108 { // Error occured, abort
3109 DispAllErrors(henv
, hdbc
, hstmt
);
3112 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3119 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3121 // Store Primary and Foreign Keys
3122 GetKeyFields(tableName
,colInf
,noCols
);
3124 ///////////////////////////////////////////////////////////////////////////
3125 // Now sort the the columns in order to make them appear in the right order
3126 ///////////////////////////////////////////////////////////////////////////
3128 // Build a generic SELECT statement which returns 0 rows
3131 Stmt
.Printf(wxT("select * from \"%s\" where 0=1"), tableName
);
3134 if (SQLExecDirect(hstmt
, (UCHAR FAR
*) Stmt
.c_str(), SQL_NTS
) != SQL_SUCCESS
)
3136 DispAllErrors(henv
, hdbc
, hstmt
);
3140 // Get the number of result columns
3141 if (SQLNumResultCols (hstmt
, &noCols
) != SQL_SUCCESS
)
3143 DispAllErrors(henv
, hdbc
, hstmt
);
3147 if (noCols
== 0) // Probably a bogus table name
3156 for (colNum
= 0; colNum
< noCols
; colNum
++)
3158 if (SQLColAttributes(hstmt
,colNum
+1, SQL_COLUMN_NAME
,
3160 &Sword
, &Sdword
) != SQL_SUCCESS
)
3162 DispAllErrors(henv
, hdbc
, hstmt
);
3166 wxString Name1
= name
;
3167 Name1
= Name1
.Upper();
3169 // Where is this name in the array ?
3170 for (i
= colNum
; i
< noCols
; i
++)
3172 wxString Name2
= colInf
[i
].colName
;
3173 Name2
= Name2
.Upper();
3176 if (colNum
!= i
) // swap to sort
3178 wxDbColInf tmpColInf
= colInf
[colNum
];
3179 colInf
[colNum
] = colInf
[i
];
3180 colInf
[i
] = tmpColInf
;
3186 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3188 ///////////////////////////////////////////////////////////////////////////
3190 ///////////////////////////////////////////////////////////////////////////
3196 } // wxDb::GetColumns()
3199 #endif // #else OLD_GETCOLUMNS
3202 /********** wxDb::GetColumnCount() **********/
3203 int wxDb::GetColumnCount(const wxString
&tableName
, const wxChar
*userID
)
3205 * Returns a count of how many columns are in a table.
3206 * If an error occurs in computing the number of columns
3207 * this function will return a -1 for the count
3209 * userID is evaluated in the following manner:
3210 * userID == NULL ... UserID is ignored
3211 * userID == "" ... UserID set equal to 'this->uid'
3212 * userID != "" ... UserID set equal to 'userID'
3214 * NOTE: ALL column bindings associated with this wxDb instance are unbound
3215 * by this function. This function should use its own wxDb instance
3216 * to avoid undesired unbinding of columns.
3226 convertUserID(userID
,UserID
);
3228 TableName
= tableName
;
3229 // Oracle and Interbase table names are uppercase only, so force
3230 // the name to uppercase just in case programmer forgot to do this
3231 if ((Dbms() == dbmsORACLE
) ||
3232 (Dbms() == dbmsFIREBIRD
) ||
3233 (Dbms() == dbmsINTERBASE
))
3234 TableName
= TableName
.Upper();
3236 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3238 // MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
3239 // use the call below that leaves out the user name
3240 if (!UserID
.empty() &&
3241 Dbms() != dbmsMY_SQL
&&
3242 Dbms() != dbmsACCESS
&&
3243 Dbms() != dbmsMS_SQL_SERVER
)
3245 retcode
= SQLColumns(hstmt
,
3246 NULL
, 0, // All qualifiers
3247 (SQLTCHAR
*) UserID
.c_str(), SQL_NTS
, // Owner
3248 (SQLTCHAR
*) TableName
.c_str(), SQL_NTS
,
3249 NULL
, 0); // All columns
3253 retcode
= SQLColumns(hstmt
,
3254 NULL
, 0, // All qualifiers
3256 (SQLTCHAR
*) TableName
.c_str(), SQL_NTS
,
3257 NULL
, 0); // All columns
3259 if (retcode
!= SQL_SUCCESS
)
3260 { // Error occured, abort
3261 DispAllErrors(henv
, hdbc
, hstmt
);
3262 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3266 // Count the columns
3267 while ((retcode
= SQLFetch(hstmt
)) == SQL_SUCCESS
)
3270 if (retcode
!= SQL_NO_DATA_FOUND
)
3271 { // Error occured, abort
3272 DispAllErrors(henv
, hdbc
, hstmt
);
3273 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3277 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3280 } // wxDb::GetColumnCount()
3283 /********** wxDb::GetCatalog() *******/
3284 wxDbInf
*wxDb::GetCatalog(const wxChar
*userID
)
3286 * ---------------------------------------------------------------------
3287 * -- 19991203 : mj10777 : Create ------
3288 * -- : Creates a wxDbInf with Tables / Cols Array ------
3289 * -- : uses SQLTables and fills pTableInf; ------
3290 * -- : pColInf is set to NULL and numCols to 0; ------
3291 * -- : returns pDbInf (wxDbInf) ------
3292 * -- - if unsuccesfull (pDbInf == NULL) ------
3293 * -- : pColInf can be filled with GetColumns(..); ------
3294 * -- : numCols can be filled with GetColumnCount(..); ------
3295 * ---------------------------------------------------------------------
3297 * userID is evaluated in the following manner:
3298 * userID == NULL ... UserID is ignored
3299 * userID == "" ... UserID set equal to 'this->uid'
3300 * userID != "" ... UserID set equal to 'userID'
3302 * NOTE: ALL column bindings associated with this wxDb instance are unbound
3303 * by this function. This function should use its own wxDb instance
3304 * to avoid undesired unbinding of columns.
3307 int noTab
= 0; // Counter while filling table entries
3311 wxString tblNameSave
;
3314 convertUserID(userID
,UserID
);
3316 //-------------------------------------------------------------
3317 // Create the Database Array of catalog entries
3319 wxDbInf
*pDbInf
= new wxDbInf
;
3321 //-------------------------------------------------------------
3322 // Table Information
3323 // Pass 1 - Determine how many Tables there are.
3324 // Pass 2 - Create the Table array and fill it
3325 // - Create the Cols array = NULL
3326 //-------------------------------------------------------------
3328 for (pass
= 1; pass
<= 2; pass
++)
3330 SQLFreeStmt(hstmt
, SQL_CLOSE
); // Close if Open
3331 tblNameSave
.Empty();
3333 if (!UserID
.empty() &&
3334 Dbms() != dbmsMY_SQL
&&
3335 Dbms() != dbmsACCESS
&&
3336 Dbms() != dbmsMS_SQL_SERVER
)
3338 retcode
= SQLTables(hstmt
,
3339 NULL
, 0, // All qualifiers
3340 (SQLTCHAR
*) UserID
.c_str(), SQL_NTS
, // User specified
3341 NULL
, 0, // All tables
3342 NULL
, 0); // All columns
3346 retcode
= SQLTables(hstmt
,
3347 NULL
, 0, // All qualifiers
3348 NULL
, 0, // User specified
3349 NULL
, 0, // All tables
3350 NULL
, 0); // All columns
3353 if (retcode
!= SQL_SUCCESS
)
3355 DispAllErrors(henv
, hdbc
, hstmt
);
3357 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3361 while ((retcode
= SQLFetch(hstmt
)) == SQL_SUCCESS
) // Table Information
3363 if (pass
== 1) // First pass, just count the Tables
3365 if (pDbInf
->numTables
== 0)
3367 GetData( 1, SQL_C_WXCHAR
, (UCHAR
*) pDbInf
->catalog
, 128+1, &cb
);
3368 GetData( 2, SQL_C_WXCHAR
, (UCHAR
*) pDbInf
->schema
, 128+1, &cb
);
3370 pDbInf
->numTables
++; // Counter for Tables
3372 if (pass
== 2) // Create and fill the Table entries
3374 if (pDbInf
->pTableInf
== NULL
) // Has the Table Array been created
3375 { // no, then create the Array
3376 pDbInf
->pTableInf
= new wxDbTableInf
[pDbInf
->numTables
];
3378 } // if (pDbInf->pTableInf == NULL) // Has the Table Array been created
3380 GetData( 3, SQL_C_WXCHAR
, (UCHAR
*) (pDbInf
->pTableInf
+noTab
)->tableName
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
3381 GetData( 4, SQL_C_WXCHAR
, (UCHAR
*) (pDbInf
->pTableInf
+noTab
)->tableType
, 30+1, &cb
);
3382 GetData( 5, SQL_C_WXCHAR
, (UCHAR
*) (pDbInf
->pTableInf
+noTab
)->tableRemarks
, 254+1, &cb
);
3388 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3390 // Query how many columns are in each table
3391 for (noTab
=0;noTab
<pDbInf
->numTables
;noTab
++)
3393 (pDbInf
->pTableInf
+noTab
)->numCols
= (UWORD
)GetColumnCount((pDbInf
->pTableInf
+noTab
)->tableName
,UserID
);
3398 } // wxDb::GetCatalog()
3401 /********** wxDb::Catalog() **********/
3402 bool wxDb::Catalog(const wxChar
*userID
, const wxString
&fileName
)
3404 * Creates the text file specified in 'filename' which will contain
3405 * a minimal data dictionary of all tables accessible by the user specified
3408 * userID is evaluated in the following manner:
3409 * userID == NULL ... UserID is ignored
3410 * userID == "" ... UserID set equal to 'this->uid'
3411 * userID != "" ... UserID set equal to 'userID'
3413 * NOTE: ALL column bindings associated with this wxDb instance are unbound
3414 * by this function. This function should use its own wxDb instance
3415 * to avoid undesired unbinding of columns.
3418 wxASSERT(fileName
.Length());
3422 wxChar tblName
[DB_MAX_TABLE_NAME_LEN
+1];
3423 wxString tblNameSave
;
3424 wxChar colName
[DB_MAX_COLUMN_NAME_LEN
+1];
3426 wxChar typeName
[30+1];
3427 SDWORD precision
, length
;
3429 FILE *fp
= wxFopen(fileName
.c_str(),wxT("wt"));
3433 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3436 convertUserID(userID
,UserID
);
3438 if (!UserID
.empty() &&
3439 Dbms() != dbmsMY_SQL
&&
3440 Dbms() != dbmsACCESS
&&
3441 Dbms() != dbmsFIREBIRD
&&
3442 Dbms() != dbmsINTERBASE
&&
3443 Dbms() != dbmsMS_SQL_SERVER
)
3445 retcode
= SQLColumns(hstmt
,
3446 NULL
, 0, // All qualifiers
3447 (SQLTCHAR
*) UserID
.c_str(), SQL_NTS
, // User specified
3448 NULL
, 0, // All tables
3449 NULL
, 0); // All columns
3453 retcode
= SQLColumns(hstmt
,
3454 NULL
, 0, // All qualifiers
3455 NULL
, 0, // User specified
3456 NULL
, 0, // All tables
3457 NULL
, 0); // All columns
3459 if (retcode
!= SQL_SUCCESS
)
3461 DispAllErrors(henv
, hdbc
, hstmt
);
3467 tblNameSave
.Empty();
3472 retcode
= SQLFetch(hstmt
);
3473 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
3476 GetData(3,SQL_C_WXCHAR
, (UCHAR
*) tblName
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
3477 GetData(4,SQL_C_WXCHAR
, (UCHAR
*) colName
, DB_MAX_COLUMN_NAME_LEN
+1,&cb
);
3478 GetData(5,SQL_C_SSHORT
, (UCHAR
*)&sqlDataType
, 0, &cb
);
3479 GetData(6,SQL_C_WXCHAR
, (UCHAR
*) typeName
, sizeof(typeName
), &cb
);
3480 GetData(7,SQL_C_SLONG
, (UCHAR
*)&precision
, 0, &cb
);
3481 GetData(8,SQL_C_SLONG
, (UCHAR
*)&length
, 0, &cb
);
3483 if (wxStrcmp(tblName
, tblNameSave
.c_str()))
3486 wxFputs(wxT("\n"), fp
);
3487 wxFputs(wxT("================================ "), fp
);
3488 wxFputs(wxT("================================ "), fp
);
3489 wxFputs(wxT("===================== "), fp
);
3490 wxFputs(wxT("========= "), fp
);
3491 wxFputs(wxT("=========\n"), fp
);
3492 outStr
.Printf(wxT("%-32s %-32s %-21s %9s %9s\n"),
3493 wxT("TABLE NAME"), wxT("COLUMN NAME"), wxT("DATA TYPE"), wxT("PRECISION"), wxT("LENGTH"));
3494 wxFputs(outStr
.c_str(), fp
);
3495 wxFputs(wxT("================================ "), fp
);
3496 wxFputs(wxT("================================ "), fp
);
3497 wxFputs(wxT("===================== "), fp
);
3498 wxFputs(wxT("========= "), fp
);
3499 wxFputs(wxT("=========\n"), fp
);
3500 tblNameSave
= tblName
;
3503 outStr
.Printf(wxT("%-32s %-32s (%04d)%-15s %9ld %9ld\n"),
3504 tblName
, colName
, sqlDataType
, typeName
, precision
, length
);
3505 if (wxFputs(outStr
.c_str(), fp
) == EOF
)
3507 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3514 if (retcode
!= SQL_NO_DATA_FOUND
)
3515 DispAllErrors(henv
, hdbc
, hstmt
);
3517 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3520 return(retcode
== SQL_NO_DATA_FOUND
);
3522 } // wxDb::Catalog()
3525 bool wxDb::TableExists(const wxString
&tableName
, const wxChar
*userID
, const wxString
&tablePath
)
3527 * Table name can refer to a table, view, alias or synonym. Returns true
3528 * if the object exists in the database. This function does not indicate
3529 * whether or not the user has privleges to query or perform other functions
3532 * userID is evaluated in the following manner:
3533 * userID == NULL ... UserID is ignored
3534 * userID == "" ... UserID set equal to 'this->uid'
3535 * userID != "" ... UserID set equal to 'userID'
3538 wxASSERT(tableName
.Length());
3542 if (Dbms() == dbmsDBASE
)
3545 if (tablePath
.Length())
3546 dbName
.Printf(wxT("%s/%s.dbf"), tablePath
.c_str(), tableName
.c_str());
3548 dbName
.Printf(wxT("%s.dbf"), tableName
.c_str());
3551 exists
= wxFileExists(dbName
);
3556 convertUserID(userID
,UserID
);
3558 TableName
= tableName
;
3559 // Oracle and Interbase table names are uppercase only, so force
3560 // the name to uppercase just in case programmer forgot to do this
3561 if ((Dbms() == dbmsORACLE
) ||
3562 (Dbms() == dbmsFIREBIRD
) ||
3563 (Dbms() == dbmsINTERBASE
))
3564 TableName
= TableName
.Upper();
3566 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3569 // Some databases cannot accept a user name when looking up table names,
3570 // so we use the call below that leaves out the user name
3571 if (!UserID
.empty() &&
3572 Dbms() != dbmsMY_SQL
&&
3573 Dbms() != dbmsACCESS
&&
3574 Dbms() != dbmsMS_SQL_SERVER
&&
3575 Dbms() != dbmsDB2
&&
3576 Dbms() != dbmsFIREBIRD
&&
3577 Dbms() != dbmsINTERBASE
&&
3578 Dbms() != dbmsPERVASIVE_SQL
)
3580 retcode
= SQLTables(hstmt
,
3581 NULL
, 0, // All qualifiers
3582 (SQLTCHAR
*) UserID
.c_str(), SQL_NTS
, // Only tables owned by this user
3583 (SQLTCHAR FAR
*)TableName
.c_str(), SQL_NTS
,
3584 NULL
, 0); // All table types
3588 retcode
= SQLTables(hstmt
,
3589 NULL
, 0, // All qualifiers
3590 NULL
, 0, // All owners
3591 (SQLTCHAR FAR
*)TableName
.c_str(), SQL_NTS
,
3592 NULL
, 0); // All table types
3594 if (retcode
!= SQL_SUCCESS
)
3595 return(DispAllErrors(henv
, hdbc
, hstmt
));
3597 retcode
= SQLFetch(hstmt
);
3598 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
3600 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3601 return(DispAllErrors(henv
, hdbc
, hstmt
));
3604 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3608 } // wxDb::TableExists()
3611 /********** wxDb::TablePrivileges() **********/
3612 bool wxDb::TablePrivileges(const wxString
&tableName
, const wxString
&priv
, const wxChar
*userID
,
3613 const wxChar
*schema
, const wxString
&WXUNUSED(tablePath
))
3615 wxASSERT(tableName
.Length());
3617 wxDbTablePrivilegeInfo result
;
3621 // We probably need to be able to dynamically set this based on
3622 // the driver type, and state.
3623 wxChar curRole
[]=wxT("public");
3627 wxString UserID
,Schema
;
3628 convertUserID(userID
,UserID
);
3629 convertUserID(schema
,Schema
);
3631 TableName
= tableName
;
3632 // Oracle and Interbase table names are uppercase only, so force
3633 // the name to uppercase just in case programmer forgot to do this
3634 if ((Dbms() == dbmsORACLE
) ||
3635 (Dbms() == dbmsFIREBIRD
) ||
3636 (Dbms() == dbmsINTERBASE
))
3637 TableName
= TableName
.Upper();
3639 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3641 // Some databases cannot accept a user name when looking up table names,
3642 // so we use the call below that leaves out the user name
3643 if (!Schema
.empty() &&
3644 Dbms() != dbmsMY_SQL
&&
3645 Dbms() != dbmsACCESS
&&
3646 Dbms() != dbmsMS_SQL_SERVER
)
3648 retcode
= SQLTablePrivileges(hstmt
,
3650 (SQLTCHAR FAR
*)Schema
.c_str(), SQL_NTS
, // Schema
3651 (SQLTCHAR FAR
*)TableName
.c_str(), SQL_NTS
);
3655 retcode
= SQLTablePrivileges(hstmt
,
3658 (SQLTCHAR FAR
*)TableName
.c_str(), SQL_NTS
);
3661 #ifdef DBDEBUG_CONSOLE
3662 wxFprintf(stderr
,wxT("SQLTablePrivileges() returned %i \n"),retcode
);
3665 if ((retcode
!= SQL_SUCCESS
) && (retcode
!= SQL_SUCCESS_WITH_INFO
))
3666 return (DispAllErrors(henv
, hdbc
, hstmt
));
3668 bool failed
= false;
3669 retcode
= SQLFetch(hstmt
);
3670 while (retcode
== SQL_SUCCESS
|| retcode
== SQL_SUCCESS_WITH_INFO
)
3672 if (SQLGetData(hstmt
, 1, SQL_C_WXCHAR
, (UCHAR
*) result
.tableQual
, sizeof(result
.tableQual
), &cbRetVal
) != SQL_SUCCESS
)
3675 if (!failed
&& SQLGetData(hstmt
, 2, SQL_C_WXCHAR
, (UCHAR
*) result
.tableOwner
, sizeof(result
.tableOwner
), &cbRetVal
) != SQL_SUCCESS
)
3678 if (!failed
&& SQLGetData(hstmt
, 3, SQL_C_WXCHAR
, (UCHAR
*) result
.tableName
, sizeof(result
.tableName
), &cbRetVal
) != SQL_SUCCESS
)
3681 if (!failed
&& SQLGetData(hstmt
, 4, SQL_C_WXCHAR
, (UCHAR
*) result
.grantor
, sizeof(result
.grantor
), &cbRetVal
) != SQL_SUCCESS
)
3684 if (!failed
&& SQLGetData(hstmt
, 5, SQL_C_WXCHAR
, (UCHAR
*) result
.grantee
, sizeof(result
.grantee
), &cbRetVal
) != SQL_SUCCESS
)
3687 if (!failed
&& SQLGetData(hstmt
, 6, SQL_C_WXCHAR
, (UCHAR
*) result
.privilege
, sizeof(result
.privilege
), &cbRetVal
) != SQL_SUCCESS
)
3690 if (!failed
&& SQLGetData(hstmt
, 7, SQL_C_WXCHAR
, (UCHAR
*) result
.grantable
, sizeof(result
.grantable
), &cbRetVal
) != SQL_SUCCESS
)
3695 return(DispAllErrors(henv
, hdbc
, hstmt
));
3697 #ifdef DBDEBUG_CONSOLE
3698 wxFprintf(stderr
,wxT("Scanning %s privilege on table %s.%s granted by %s to %s\n"),
3699 result
.privilege
,result
.tableOwner
,result
.tableName
,
3700 result
.grantor
, result
.grantee
);
3703 if (UserID
.IsSameAs(result
.tableOwner
,false))
3705 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3709 if (UserID
.IsSameAs(result
.grantee
,false) &&
3710 !wxStrcmp(result
.privilege
,priv
))
3712 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3716 if (!wxStrcmp(result
.grantee
,curRole
) &&
3717 !wxStrcmp(result
.privilege
,priv
))
3719 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3723 retcode
= SQLFetch(hstmt
);
3726 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3729 } // wxDb::TablePrivileges
3732 const wxString
wxDb::SQLTableName(const wxChar
*tableName
)
3736 if (Dbms() == dbmsACCESS
)
3737 TableName
= _T("\"");
3738 TableName
+= tableName
;
3739 if (Dbms() == dbmsACCESS
)
3740 TableName
+= _T("\"");
3743 } // wxDb::SQLTableName()
3746 const wxString
wxDb::SQLColumnName(const wxChar
*colName
)
3750 if (Dbms() == dbmsACCESS
)
3753 if (Dbms() == dbmsACCESS
)
3754 ColName
+= _T("\"");
3757 } // wxDb::SQLColumnName()
3760 /********** wxDb::SetSqlLogging() **********/
3761 bool wxDb::SetSqlLogging(wxDbSqlLogState state
, const wxString
&filename
, bool append
)
3763 wxASSERT(state
== sqlLogON
|| state
== sqlLogOFF
);
3764 wxASSERT(state
== sqlLogOFF
|| filename
.Length());
3766 if (state
== sqlLogON
)
3770 fpSqlLog
= wxFopen(filename
.c_str(), (append
? wxT("at") : wxT("wt")));
3771 if (fpSqlLog
== NULL
)
3779 if (fclose(fpSqlLog
))
3785 sqlLogState
= state
;
3788 } // wxDb::SetSqlLogging()
3791 /********** wxDb::WriteSqlLog() **********/
3792 bool wxDb::WriteSqlLog(const wxString
&logMsg
)
3794 wxASSERT(logMsg
.Length());
3796 if (fpSqlLog
== 0 || sqlLogState
== sqlLogOFF
)
3799 if (wxFputs(wxT("\n"), fpSqlLog
) == EOF
)
3801 if (wxFputs(logMsg
, fpSqlLog
) == EOF
)
3803 if (wxFputs(wxT("\n"), fpSqlLog
) == EOF
)
3808 } // wxDb::WriteSqlLog()
3811 /********** wxDb::Dbms() **********/
3812 wxDBMS
wxDb::Dbms(void)
3814 * Be aware that not all database engines use the exact same syntax, and not
3815 * every ODBC compliant database is compliant to the same level of compliancy.
3816 * Some manufacturers support the minimum Level 1 compliancy, and others up
3817 * through Level 3. Others support subsets of features for levels above 1.
3819 * If you find an inconsistency between the wxDb class and a specific database
3820 * engine, and an identifier to this section, and special handle the database in
3821 * the area where behavior is non-conforming with the other databases.
3824 * NOTES ABOUT ISSUES SPECIFIC TO EACH DATABASE ENGINE
3825 * ---------------------------------------------------
3828 * - Currently the only database supported by the class to support VIEWS
3831 * - Does not support the SQL_TIMESTAMP structure
3832 * - Supports only one cursor and one connect (apparently? with Microsoft driver only?)
3833 * - Does not automatically create the primary index if the 'keyField' param of SetColDef
3834 * is true. The user must create ALL indexes from their program.
3835 * - Table names can only be 8 characters long
3836 * - Column names can only be 10 characters long
3839 * - To lock a record during QUERY functions, the reserved word 'HOLDLOCK' must be added
3840 * after every table name involved in the query/join if that tables matching record(s)
3842 * - Ignores the keywords 'FOR UPDATE'. Use the HOLDLOCK functionality described above
3844 * SYBASE (Enterprise)
3845 * - If a column is part of the Primary Key, the column cannot be NULL
3846 * - Maximum row size is somewhere in the neighborhood of 1920 bytes
3849 * - If a column is part of the Primary Key, the column cannot be NULL
3850 * - Cannot support selecting for update [::CanSelectForUpdate()]. Always returns FALSE
3851 * - Columns that are part of primary or secondary keys must be defined as being NOT NULL
3852 * when they are created. Some code is added in ::CreateIndex to try to adjust the
3853 * column definition if it is not defined correctly, but it is experimental
3854 * - Does not support sub-queries in SQL statements
3857 * - Does not support the keywords 'ASC' or 'DESC' as of release v6.5.0
3858 * - Does not support sub-queries in SQL statements
3861 * - Primary keys must be declared as NOT NULL
3862 * - Table and index names must not be longer than 13 characters in length (technically
3863 * table names can be up to 18 characters, but the primary index is created using the
3864 * base table name plus "_PIDX", so the limit if the table has a primary index is 13.
3869 * - Columns that are part of primary keys must be defined as being NOT NULL
3870 * when they are created. Some code is added in ::CreateIndex to try to adjust the
3871 * column definition if it is not defined correctly, but it is experimental
3874 // Should only need to do this once for each new database connection
3875 // so return the value we already determined it to be to save time
3876 // and lots of string comparisons
3877 if (dbmsType
!= dbmsUNIDENTIFIED
)
3880 #ifdef DBDEBUG_CONSOLE
3881 // When run in console mode, use standard out to display errors.
3882 cout
<< "Database connecting to: " << dbInf
.dbmsName
<< endl
;
3883 #endif // DBDEBUG_CONSOLE
3885 wxLogDebug(wxT("Database connecting to: "));
3886 wxLogDebug(dbInf
.dbmsName
);
3888 wxChar baseName
[25+1];
3889 wxStrncpy(baseName
, dbInf
.dbmsName
, 25);
3892 // RGG 20001025 : add support for Interbase
3893 // GT : Integrated to base classes on 20001121
3894 if (!wxStricmp(dbInf
.dbmsName
,wxT("Interbase")))
3895 return((wxDBMS
)(dbmsType
= dbmsINTERBASE
));
3897 // BJO 20000428 : add support for Virtuoso
3898 if (!wxStricmp(dbInf
.dbmsName
,wxT("OpenLink Virtuoso VDBMS")))
3899 return((wxDBMS
)(dbmsType
= dbmsVIRTUOSO
));
3901 if (!wxStricmp(dbInf
.dbmsName
,wxT("Adaptive Server Anywhere")))
3902 return((wxDBMS
)(dbmsType
= dbmsSYBASE_ASA
));
3904 // BJO 20000427 : The "SQL Server" string is also returned by SQLServer when
3905 // connected through an OpenLink driver.
3906 // Is it also returned by Sybase Adapatitve server?
3907 // OpenLink driver name is OLOD3032.DLL for msw and oplodbc.so for unix
3908 if (!wxStricmp(dbInf
.dbmsName
,wxT("SQL Server")))
3910 if (!wxStrncmp(dbInf
.driverName
, wxT("oplodbc"), 7) ||
3911 !wxStrncmp(dbInf
.driverName
, wxT("OLOD"), 4))
3912 return ((wxDBMS
)(dbmsMS_SQL_SERVER
));
3914 return ((wxDBMS
)(dbmsType
= dbmsSYBASE_ASE
));
3917 if (!wxStricmp(dbInf
.dbmsName
,wxT("Microsoft SQL Server")))
3918 return((wxDBMS
)(dbmsType
= dbmsMS_SQL_SERVER
));
3921 if (!wxStricmp(baseName
,wxT("PostgreSQL"))) // v6.5.0
3922 return((wxDBMS
)(dbmsType
= dbmsPOSTGRES
));
3925 if (!wxStricmp(baseName
,wxT("Pervasive")))
3926 return((wxDBMS
)(dbmsType
= dbmsPERVASIVE_SQL
));
3929 if (!wxStricmp(baseName
,wxT("Informix")))
3930 return((wxDBMS
)(dbmsType
= dbmsINFORMIX
));
3932 if (!wxStricmp(baseName
,wxT("Firebird")))
3933 return((wxDBMS
)(dbmsType
= dbmsFIREBIRD
));
3936 if (!wxStricmp(baseName
,wxT("Oracle")))
3937 return((wxDBMS
)(dbmsType
= dbmsORACLE
));
3938 if (!wxStricmp(baseName
,wxT("ACCESS")))
3939 return((wxDBMS
)(dbmsType
= dbmsACCESS
));
3940 if (!wxStricmp(baseName
,wxT("Sybase")))
3941 return((wxDBMS
)(dbmsType
= dbmsSYBASE_ASE
));
3944 if (!wxStricmp(baseName
,wxT("DBASE")))
3945 return((wxDBMS
)(dbmsType
= dbmsDBASE
));
3946 if (!wxStricmp(baseName
,wxT("xBase")))
3947 return((wxDBMS
)(dbmsType
= dbmsXBASE_SEQUITER
));
3948 if (!wxStricmp(baseName
,wxT("MySQL")))
3949 return((wxDBMS
)(dbmsType
= dbmsMY_SQL
));
3950 if (!wxStricmp(baseName
,wxT("MaxDB")))
3951 return((wxDBMS
)(dbmsType
= dbmsMAXDB
));
3954 if (!wxStricmp(baseName
,wxT("DB2")))
3955 return((wxDBMS
)(dbmsType
= dbmsDBASE
));
3957 return((wxDBMS
)(dbmsType
= dbmsUNIDENTIFIED
));
3962 bool wxDb::ModifyColumn(const wxString
&tableName
, const wxString
&columnName
,
3963 int dataType
, ULONG columnLength
,
3964 const wxString
&optionalParam
)
3966 wxASSERT(tableName
.Length());
3967 wxASSERT(columnName
.Length());
3968 wxASSERT((dataType
== DB_DATA_TYPE_VARCHAR
&& columnLength
> 0) ||
3969 dataType
!= DB_DATA_TYPE_VARCHAR
);
3971 // Must specify a columnLength if modifying a VARCHAR type column
3972 if (dataType
== DB_DATA_TYPE_VARCHAR
&& !columnLength
)
3975 wxString dataTypeName
;
3977 wxString alterSlashModify
;
3981 case DB_DATA_TYPE_VARCHAR
:
3982 dataTypeName
= typeInfVarchar
.TypeName
;
3984 case DB_DATA_TYPE_INTEGER
:
3985 dataTypeName
= typeInfInteger
.TypeName
;
3987 case DB_DATA_TYPE_FLOAT
:
3988 dataTypeName
= typeInfFloat
.TypeName
;
3990 case DB_DATA_TYPE_DATE
:
3991 dataTypeName
= typeInfDate
.TypeName
;
3993 case DB_DATA_TYPE_BLOB
:
3994 dataTypeName
= typeInfBlob
.TypeName
;
4000 // Set the modify or alter syntax depending on the type of database connected to
4004 alterSlashModify
= _T("MODIFY");
4006 case dbmsMS_SQL_SERVER
:
4007 alterSlashModify
= _T("ALTER COLUMN");
4009 case dbmsUNIDENTIFIED
:
4011 case dbmsSYBASE_ASA
:
4012 case dbmsSYBASE_ASE
:
4017 case dbmsXBASE_SEQUITER
:
4019 alterSlashModify
= _T("MODIFY");
4023 // create the SQL statement
4024 if ( Dbms() == dbmsMY_SQL
)
4026 sqlStmt
.Printf(wxT("ALTER TABLE %s %s %s %s"), tableName
.c_str(), alterSlashModify
.c_str(),
4027 columnName
.c_str(), dataTypeName
.c_str());
4031 sqlStmt
.Printf(wxT("ALTER TABLE \"%s\" \"%s\" \"%s\" %s"), tableName
.c_str(), alterSlashModify
.c_str(),
4032 columnName
.c_str(), dataTypeName
.c_str());
4035 // For varchars only, append the size of the column
4036 if (dataType
== DB_DATA_TYPE_VARCHAR
&&
4037 (Dbms() != dbmsMY_SQL
|| dataTypeName
!= _T("text")))
4040 s
.Printf(wxT("(%lu)"), columnLength
);
4044 // for passing things like "NOT NULL"
4045 if (optionalParam
.Length())
4047 sqlStmt
+= wxT(" ");
4048 sqlStmt
+= optionalParam
;
4051 return ExecSql(sqlStmt
);
4053 } // wxDb::ModifyColumn()
4056 /********** wxDbGetConnection() **********/
4057 wxDb WXDLLIMPEXP_ODBC
*wxDbGetConnection(wxDbConnectInf
*pDbConfig
, bool FwdOnlyCursors
)
4061 // Used to keep a pointer to a DB connection that matches the requested
4062 // DSN and FwdOnlyCursors settings, even if it is not FREE, so that the
4063 // data types can be copied from it (using the wxDb::Open(wxDb *) function)
4064 // rather than having to re-query the datasource to get all the values
4065 // using the wxDb::Open(Dsn,Uid,AuthStr) function
4066 wxDb
*matchingDbConnection
= NULL
;
4068 // Scan the linked list searching for an available database connection
4069 // that's already been opened but is currently not in use.
4070 for (pList
= PtrBegDbList
; pList
; pList
= pList
->PtrNext
)
4072 // The database connection must be for the same datasource
4073 // name and must currently not be in use.
4075 (pList
->PtrDb
->FwdOnlyCursors() == FwdOnlyCursors
))
4077 if (pDbConfig
->UseConnectionStr())
4079 if (pList
->PtrDb
->OpenedWithConnectionString() &&
4080 (!wxStrcmp(pDbConfig
->GetConnectionStr(), pList
->ConnectionStr
)))
4082 // Found a free connection
4083 pList
->Free
= false;
4084 return(pList
->PtrDb
);
4089 if (!pList
->PtrDb
->OpenedWithConnectionString() &&
4090 (!wxStrcmp(pDbConfig
->GetDsn(), pList
->Dsn
)))
4092 // Found a free connection
4093 pList
->Free
= false;
4094 return(pList
->PtrDb
);
4099 if (pDbConfig
->UseConnectionStr())
4101 if (!wxStrcmp(pDbConfig
->GetConnectionStr(), pList
->ConnectionStr
))
4102 matchingDbConnection
= pList
->PtrDb
;
4106 if (!wxStrcmp(pDbConfig
->GetDsn(), pList
->Dsn
) &&
4107 !wxStrcmp(pDbConfig
->GetUserID(), pList
->Uid
) &&
4108 !wxStrcmp(pDbConfig
->GetPassword(), pList
->AuthStr
))
4109 matchingDbConnection
= pList
->PtrDb
;
4113 // No available connections. A new connection must be made and
4114 // appended to the end of the linked list.
4117 // Find the end of the list
4118 for (pList
= PtrBegDbList
; pList
->PtrNext
; pList
= pList
->PtrNext
);
4119 // Append a new list item
4120 pList
->PtrNext
= new wxDbList
;
4121 pList
->PtrNext
->PtrPrev
= pList
;
4122 pList
= pList
->PtrNext
;
4126 // Create the first node on the list
4127 pList
= PtrBegDbList
= new wxDbList
;
4131 // Initialize new node in the linked list
4133 pList
->Free
= false;
4134 pList
->Dsn
= pDbConfig
->GetDsn();
4135 pList
->Uid
= pDbConfig
->GetUserID();
4136 pList
->AuthStr
= pDbConfig
->GetPassword();
4137 pList
->ConnectionStr
= pDbConfig
->GetConnectionStr();
4139 pList
->PtrDb
= new wxDb(pDbConfig
->GetHenv(), FwdOnlyCursors
);
4143 if (!matchingDbConnection
)
4145 if (pDbConfig
->UseConnectionStr())
4147 opened
= pList
->PtrDb
->Open(pDbConfig
->GetConnectionStr());
4151 opened
= pList
->PtrDb
->Open(pDbConfig
->GetDsn(), pDbConfig
->GetUserID(), pDbConfig
->GetPassword());
4155 opened
= pList
->PtrDb
->Open(matchingDbConnection
);
4157 // Connect to the datasource
4160 pList
->PtrDb
->setCached(true); // Prevent a user from deleting a cached connection
4161 pList
->PtrDb
->SetSqlLogging(SQLLOGstate
, SQLLOGfn
, true);
4162 return(pList
->PtrDb
);
4164 else // Unable to connect, destroy list item
4167 pList
->PtrPrev
->PtrNext
= 0;
4169 PtrBegDbList
= 0; // Empty list again
4171 pList
->PtrDb
->CommitTrans(); // Commit any open transactions on wxDb object
4172 pList
->PtrDb
->Close(); // Close the wxDb object
4173 delete pList
->PtrDb
; // Deletes the wxDb object
4174 delete pList
; // Deletes the linked list object
4178 } // wxDbGetConnection()
4181 /********** wxDbFreeConnection() **********/
4182 bool WXDLLIMPEXP_ODBC
wxDbFreeConnection(wxDb
*pDb
)
4186 // Scan the linked list searching for the database connection
4187 for (pList
= PtrBegDbList
; pList
; pList
= pList
->PtrNext
)
4189 if (pList
->PtrDb
== pDb
) // Found it, now free it!!!
4190 return (pList
->Free
= true);
4193 // Never found the database object, return failure
4196 } // wxDbFreeConnection()
4199 /********** wxDbCloseConnections() **********/
4200 void WXDLLIMPEXP_ODBC
wxDbCloseConnections(void)
4202 wxDbList
*pList
, *pNext
;
4204 // Traverse the linked list closing database connections and freeing memory as I go.
4205 for (pList
= PtrBegDbList
; pList
; pList
= pNext
)
4207 pNext
= pList
->PtrNext
; // Save the pointer to next
4208 pList
->PtrDb
->CommitTrans(); // Commit any open transactions on wxDb object
4209 pList
->PtrDb
->Close(); // Close the wxDb object
4210 pList
->PtrDb
->setCached(false); // Allows deletion of the wxDb instance
4211 delete pList
->PtrDb
; // Deletes the wxDb object
4212 delete pList
; // Deletes the linked list object
4215 // Mark the list as empty
4218 } // wxDbCloseConnections()
4221 /********** wxDbConnectionsInUse() **********/
4222 int WXDLLIMPEXP_ODBC
wxDbConnectionsInUse(void)
4227 // Scan the linked list counting db connections that are currently in use
4228 for (pList
= PtrBegDbList
; pList
; pList
= pList
->PtrNext
)
4230 if (pList
->Free
== false)
4236 } // wxDbConnectionsInUse()
4240 /********** wxDbLogExtendedErrorMsg() **********/
4241 // DEBUG ONLY function
4242 const wxChar WXDLLIMPEXP_ODBC
*wxDbLogExtendedErrorMsg(const wxChar
*userText
,
4244 const wxChar
*ErrFile
,
4247 static wxString msg
;
4252 if (ErrFile
|| ErrLine
)
4254 msg
+= wxT("File: ");
4256 msg
+= wxT(" Line: ");
4257 tStr
.Printf(wxT("%d"),ErrLine
);
4258 msg
+= tStr
.c_str();
4262 msg
.Append (wxT("\nODBC errors:\n"));
4265 // Display errors for this connection
4267 for (i
= 0; i
< DB_MAX_ERROR_HISTORY
; i
++)
4269 if (pDb
->errorList
[i
])
4271 msg
.Append(pDb
->errorList
[i
]);
4272 if (wxStrcmp(pDb
->errorList
[i
], wxEmptyString
) != 0)
4273 msg
.Append(wxT("\n"));
4274 // Clear the errmsg buffer so the next error will not
4275 // end up showing the previous error that have occurred
4276 wxStrcpy(pDb
->errorList
[i
], wxEmptyString
);
4281 wxLogDebug(msg
.c_str());
4284 } // wxDbLogExtendedErrorMsg()
4287 /********** wxDbSqlLog() **********/
4288 bool wxDbSqlLog(wxDbSqlLogState state
, const wxChar
*filename
)
4290 bool append
= false;
4293 for (pList
= PtrBegDbList
; pList
; pList
= pList
->PtrNext
)
4295 if (!pList
->PtrDb
->SetSqlLogging(state
,filename
,append
))
4300 SQLLOGstate
= state
;
4301 SQLLOGfn
= filename
;
4309 /********** wxDbCreateDataSource() **********/
4310 int wxDbCreateDataSource(const wxString
&driverName
, const wxString
&dsn
, const wxString
&description
,
4311 bool sysDSN
, const wxString
&defDir
, wxWindow
*parent
)
4313 * !!!! ONLY FUNCTIONAL UNDER MSW with VC6 !!!!
4314 * Very rudimentary creation of an ODBC data source.
4316 * ODBC driver must be ODBC 3.0 compliant to use this function
4321 //!!!! ONLY FUNCTIONAL UNDER MSW with VC6 !!!!
4327 dsnLocation
= ODBC_ADD_SYS_DSN
;
4329 dsnLocation
= ODBC_ADD_DSN
;
4331 // NOTE: The decimal 2 is an invalid character in all keyword pairs
4332 // so that is why I used it, as wxString does not deal well with
4333 // embedded nulls in strings
4334 setupStr
.Printf(wxT("DSN=%s%cDescription=%s%cDefaultDir=%s%c"),dsn
,2,description
,2,defDir
,2);
4336 // Replace the separator from above with the '\0' seperator needed
4337 // by the SQLConfigDataSource() function
4341 k
= setupStr
.Find((wxChar
)2,true);
4342 if (k
!= wxNOT_FOUND
)
4343 setupStr
[(UINT
)k
] = wxT('\0');
4345 while (k
!= wxNOT_FOUND
);
4347 result
= SQLConfigDataSource((HWND
)parent
->GetHWND(), dsnLocation
,
4348 driverName
, setupStr
.c_str());
4350 if ((result
!= SQL_SUCCESS
) && (result
!= SQL_SUCCESS_WITH_INFO
))
4352 // check for errors caused by ConfigDSN based functions
4355 wxChar errMsg
[SQL_MAX_MESSAGE_LENGTH
];
4356 errMsg
[0] = wxT('\0');
4358 // This function is only supported in ODBC drivers v3.0 compliant and above
4359 SQLInstallerError(1,&retcode
,errMsg
,SQL_MAX_MESSAGE_LENGTH
-1,&cb
);
4362 #ifdef DBDEBUG_CONSOLE
4363 // When run in console mode, use standard out to display errors.
4364 cout
<< errMsg
<< endl
;
4365 cout
<< wxT("Press any key to continue...") << endl
;
4367 #endif // DBDEBUG_CONSOLE
4370 wxLogDebug(errMsg
,wxT("ODBC DEBUG MESSAGE"));
4371 #endif // __WXDEBUG__
4377 // Using iODBC/unixODBC or some other compiler which does not support the APIs
4378 // necessary to use this function, so this function is not supported
4380 wxLogDebug(wxT("wxDbCreateDataSource() not available except under VC++/MSW"),wxT("ODBC DEBUG MESSAGE"));
4383 #endif // __VISUALC__
4387 } // wxDbCreateDataSource()
4391 /********** wxDbGetDataSource() **********/
4392 bool wxDbGetDataSource(HENV henv
, wxChar
*Dsn
, SWORD DsnMaxLength
, wxChar
*DsDesc
,
4393 SWORD DsDescMaxLength
, UWORD direction
)
4395 * Dsn and DsDesc will contain the data source name and data source
4396 * description upon return
4400 SWORD lengthDsn
= (SWORD
)(DsnMaxLength
*sizeof(wxChar
));
4401 SWORD lengthDsDesc
= (SWORD
)(DsDescMaxLength
*sizeof(wxChar
));
4403 if (SQLDataSources(henv
, direction
, (SQLTCHAR FAR
*) Dsn
, lengthDsn
, &cb1
,
4404 (SQLTCHAR FAR
*) DsDesc
, lengthDsDesc
, &cb2
) == SQL_SUCCESS
)
4409 } // wxDbGetDataSource()
4412 // Change this to 0 to remove use of all deprecated functions
4413 #if wxODBC_BACKWARD_COMPATABILITY
4414 /********************************************************************
4415 ********************************************************************
4417 * The following functions are all DEPRECATED and are included for
4418 * backward compatability reasons only
4420 ********************************************************************
4421 ********************************************************************/
4422 bool SqlLog(sqlLog state
, const wxChar
*filename
)
4424 return wxDbSqlLog((enum wxDbSqlLogState
)state
, filename
);
4426 /***** DEPRECATED: use wxGetDataSource() *****/
4427 bool GetDataSource(HENV henv
, char *Dsn
, SWORD DsnMax
, char *DsDesc
, SWORD DsDescMax
,
4430 return wxDbGetDataSource(henv
, Dsn
, DsnMax
, DsDesc
, DsDescMax
, direction
);
4432 /***** DEPRECATED: use wxDbGetConnection() *****/
4433 wxDb WXDLLIMPEXP_ODBC
*GetDbConnection(DbStuff
*pDbStuff
, bool FwdOnlyCursors
)
4435 return wxDbGetConnection((wxDbConnectInf
*)pDbStuff
, FwdOnlyCursors
);
4437 /***** DEPRECATED: use wxDbFreeConnection() *****/
4438 bool WXDLLIMPEXP_ODBC
FreeDbConnection(wxDb
*pDb
)
4440 return wxDbFreeConnection(pDb
);
4442 /***** DEPRECATED: use wxDbCloseConnections() *****/
4443 void WXDLLIMPEXP_ODBC
CloseDbConnections(void)
4445 wxDbCloseConnections();
4447 /***** DEPRECATED: use wxDbConnectionsInUse() *****/
4448 int WXDLLIMPEXP_ODBC
NumberDbConnectionsInUse(void)
4450 return wxDbConnectionsInUse();