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
];
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
));
210 } // wxDbConnectInf::SetDsn()
213 void wxDbConnectInf::SetUserID(const wxString
&uid
)
215 wxASSERT(uid
.Length() < sizeof(Uid
));
217 } // wxDbConnectInf::SetUserID()
220 void wxDbConnectInf::SetPassword(const wxString
&password
)
222 wxASSERT(password
.Length() < sizeof(AuthStr
));
224 wxStrcpy(AuthStr
, password
);
225 } // wxDbConnectInf::SetPassword()
227 void wxDbConnectInf::SetConnectionStr(const wxString
&connectStr
)
229 wxASSERT(connectStr
.Length() < sizeof(ConnectionStr
));
231 useConnectionStr
= wxStrlen(connectStr
) > 0;
233 wxStrcpy(ConnectionStr
, connectStr
);
234 } // wxDbConnectInf::SetConnectionStr()
237 /********** wxDbColFor Constructor **********/
238 wxDbColFor::wxDbColFor()
241 } // wxDbColFor::wxDbColFor()
244 /********** wxDbColFor::Initialize() **********/
245 void wxDbColFor::Initialize()
255 i_Nation
= 0; // 0=EU, 1=UK, 2=International, 3=US
258 Format(1,DB_DATA_TYPE_VARCHAR
,0,0,0); // the Function that does the work
259 } // wxDbColFor::Initialize()
262 /********** wxDbColFor::Format() **********/
263 int wxDbColFor::Format(int Nation
, int dbDataType
, SWORD sqlDataType
,
264 short columnLength
, short decimalDigits
)
266 // ----------------------------------------------------------------------------------------
267 // -- 19991224 : mj10777 : Create
268 // There is still a lot of work to do here, but it is a start
269 // It handles all the basic data-types that I have run into up to now
270 // The main work will have be with Dates and float Formatting
271 // (US 1,000.00 ; EU 1.000,00)
272 // There are wxWindow plans for locale support and the new wxDateTime. If
273 // they define some constants (wxEUROPEAN) that can be gloably used,
274 // they should be used here.
275 // ----------------------------------------------------------------------------------------
276 // There should also be a function to scan in a string to fill the variable
277 // ----------------------------------------------------------------------------------------
279 i_Nation
= Nation
; // 0 = timestamp , 1=EU, 2=UK, 3=International, 4=US
280 i_dbDataType
= dbDataType
;
281 i_sqlDataType
= sqlDataType
;
282 s_Field
.Printf(wxT("%s%d"),s_Amount
[1].c_str(),i_Amount
[1]); // OK for VARCHAR, INTEGER and FLOAT
284 if (i_dbDataType
== 0) // Filter unsupported dbDataTypes
286 if ((i_sqlDataType
== SQL_VARCHAR
) || (i_sqlDataType
== SQL_LONGVARCHAR
))
287 i_dbDataType
= DB_DATA_TYPE_VARCHAR
;
288 if ((i_sqlDataType
== SQL_C_DATE
) || (i_sqlDataType
== SQL_C_TIMESTAMP
))
289 i_dbDataType
= DB_DATA_TYPE_DATE
;
290 if (i_sqlDataType
== SQL_C_BIT
)
291 i_dbDataType
= DB_DATA_TYPE_INTEGER
;
292 if (i_sqlDataType
== SQL_NUMERIC
)
293 i_dbDataType
= DB_DATA_TYPE_VARCHAR
;
294 if (i_sqlDataType
== SQL_REAL
)
295 i_dbDataType
= DB_DATA_TYPE_FLOAT
;
296 if (i_sqlDataType
== SQL_C_BINARY
)
297 i_dbDataType
= DB_DATA_TYPE_BLOB
;
300 if ((i_dbDataType
== DB_DATA_TYPE_INTEGER
) && (i_sqlDataType
== SQL_C_DOUBLE
))
302 i_dbDataType
= DB_DATA_TYPE_FLOAT
;
305 switch(i_dbDataType
) // TBD: Still a lot of proper formatting to do
307 case DB_DATA_TYPE_VARCHAR
:
310 case DB_DATA_TYPE_INTEGER
:
313 case DB_DATA_TYPE_FLOAT
:
314 if (decimalDigits
== 0)
317 tempStr
.Printf(wxT("%s%d.%d"), tempStr
.c_str(),columnLength
, decimalDigits
);
318 s_Field
.Printf(wxT("%sf"), tempStr
.c_str());
320 case DB_DATA_TYPE_DATE
:
321 if (i_Nation
== 0) // timestamp YYYY-MM-DD HH:MM:SS.SSS (tested for SYBASE)
323 s_Field
= wxT("%04d-%02d-%02d %02d:%02d:%02d.%03d");
325 if (i_Nation
== 1) // European DD.MM.YYYY HH:MM:SS.SSS
327 s_Field
= wxT("%02d.%02d.%04d %02d:%02d:%02d.%03d");
329 if (i_Nation
== 2) // UK DD/MM/YYYY HH:MM:SS.SSS
331 s_Field
= wxT("%02d/%02d/%04d %02d:%02d:%02d.%03d");
333 if (i_Nation
== 3) // International YYYY-MM-DD HH:MM:SS.SSS
335 s_Field
= wxT("%04d-%02d-%02d %02d:%02d:%02d.%03d");
337 if (i_Nation
== 4) // US MM/DD/YYYY HH:MM:SS.SSS
339 s_Field
= wxT("%02d/%02d/%04d %02d:%02d:%02d.%03d");
342 case DB_DATA_TYPE_BLOB
:
343 s_Field
.Printf(wxT("Unable to format(%d)-SQL(%d)"), dbDataType
,sqlDataType
); //
346 s_Field
.Printf(wxT("Unknown Format(%d)-SQL(%d)"), dbDataType
,sqlDataType
); //
350 } // wxDbColFor::Format()
353 /********** wxDbColInf Constructor **********/
354 wxDbColInf::wxDbColInf()
357 } // wxDbColInf::wxDbColInf()
360 /********** wxDbColInf Destructor ********/
361 wxDbColInf::~wxDbColInf()
366 } // wxDbColInf::~wxDbColInf()
369 bool wxDbColInf::Initialize()
391 } // wxDbColInf::Initialize()
394 /********** wxDbTableInf Constructor ********/
395 wxDbTableInf::wxDbTableInf()
398 } // wxDbTableInf::wxDbTableInf()
401 /********** wxDbTableInf Constructor ********/
402 wxDbTableInf::~wxDbTableInf()
407 } // wxDbTableInf::~wxDbTableInf()
410 bool wxDbTableInf::Initialize()
419 } // wxDbTableInf::Initialize()
422 /********** wxDbInf Constructor *************/
426 } // wxDbInf::wxDbInf()
429 /********** wxDbInf Destructor *************/
435 } // wxDbInf::~wxDbInf()
438 /********** wxDbInf::Initialize() *************/
439 bool wxDbInf::Initialize()
447 } // wxDbInf::Initialize()
450 /********** wxDb Constructor **********/
451 wxDb::wxDb(const HENV
&aHenv
, bool FwdOnlyCursors
)
453 // Copy the HENV into the db class
455 fwdOnlyCursors
= FwdOnlyCursors
;
461 /********** wxDb Destructor **********/
464 wxASSERT_MSG(!IsCached(),wxT("Cached connections must not be manually deleted, use\nwxDbFreeConnection() or wxDbCloseConnections()."));
474 /********** PRIVATE! wxDb::initialize PRIVATE! **********/
475 /********** wxDb::initialize() **********/
476 void wxDb::initialize()
478 * Private member function that sets all wxDb member variables to
479 * known values at creation of the wxDb
484 fpSqlLog
= 0; // Sql Log file pointer
485 sqlLogState
= sqlLogOFF
; // By default, logging is turned off
487 dbmsType
= dbmsUNIDENTIFIED
;
489 wxStrcpy(sqlState
,wxEmptyString
);
490 wxStrcpy(errorMsg
,wxEmptyString
);
491 nativeError
= cbErrorMsg
= 0;
492 for (i
= 0; i
< DB_MAX_ERROR_HISTORY
; i
++)
493 wxStrcpy(errorList
[i
], wxEmptyString
);
495 // Init typeInf structures
496 typeInfVarchar
.TypeName
.Empty();
497 typeInfVarchar
.FsqlType
= 0;
498 typeInfVarchar
.Precision
= 0;
499 typeInfVarchar
.CaseSensitive
= 0;
500 typeInfVarchar
.MaximumScale
= 0;
502 typeInfInteger
.TypeName
.Empty();
503 typeInfInteger
.FsqlType
= 0;
504 typeInfInteger
.Precision
= 0;
505 typeInfInteger
.CaseSensitive
= 0;
506 typeInfInteger
.MaximumScale
= 0;
508 typeInfFloat
.TypeName
.Empty();
509 typeInfFloat
.FsqlType
= 0;
510 typeInfFloat
.Precision
= 0;
511 typeInfFloat
.CaseSensitive
= 0;
512 typeInfFloat
.MaximumScale
= 0;
514 typeInfDate
.TypeName
.Empty();
515 typeInfDate
.FsqlType
= 0;
516 typeInfDate
.Precision
= 0;
517 typeInfDate
.CaseSensitive
= 0;
518 typeInfDate
.MaximumScale
= 0;
520 typeInfBlob
.TypeName
.Empty();
521 typeInfBlob
.FsqlType
= 0;
522 typeInfBlob
.Precision
= 0;
523 typeInfBlob
.CaseSensitive
= 0;
524 typeInfBlob
.MaximumScale
= 0;
526 // Error reporting is turned OFF by default
529 // Allocate a data source connection handle
530 if (SQLAllocConnect(henv
, &hdbc
) != SQL_SUCCESS
)
533 // Initialize the db status flag
536 // Mark database as not open as of yet
539 dbOpenedWithConnectionString
= false;
540 } // wxDb::initialize()
543 /********** PRIVATE! wxDb::convertUserID PRIVATE! **********/
545 // NOTE: Return value from this function MUST be copied
546 // immediately, as the value is not good after
547 // this function has left scope.
549 const wxChar
*wxDb::convertUserID(const wxChar
*userID
, wxString
&UserID
)
553 if (!wxStrlen(userID
))
561 // dBase does not use user names, and some drivers fail if you try to pass one
562 if ( Dbms() == dbmsDBASE
563 || Dbms() == dbmsXBASE_SEQUITER
)
566 // Oracle user names may only be in uppercase, so force
567 // the name to uppercase
568 if (Dbms() == dbmsORACLE
)
569 UserID
= UserID
.Upper();
571 return UserID
.c_str();
572 } // wxDb::convertUserID()
575 bool wxDb::open(bool failOnDataTypeUnsupported
)
578 If using Intersolv branded ODBC drivers, this is the place where you would substitute
579 your branded driver license information
581 SQLSetConnectOption(hdbc, 1041, (UDWORD) wxEmptyString);
582 SQLSetConnectOption(hdbc, 1042, (UDWORD) wxEmptyString);
585 // Mark database as open
588 // Allocate a statement handle for the database connection
589 if (SQLAllocStmt(hdbc
, &hstmt
) != SQL_SUCCESS
)
590 return(DispAllErrors(henv
, hdbc
));
592 // Set Connection Options
593 if (!setConnectionOptions())
596 // Query the data source for inf. about itself
597 if (!getDbInfo(failOnDataTypeUnsupported
))
600 // Query the data source regarding data type information
603 // The way it was determined which SQL data types to use was by calling SQLGetInfo
604 // for all of the possible SQL data types to see which ones were supported. If
605 // a type is not supported, the SQLFetch() that's called from getDataTypeInfo()
606 // fails with SQL_NO_DATA_FOUND. This is ugly because I'm sure the three SQL data
607 // types I've selected below will not alway's be what we want. These are just
608 // what happened to work against an Oracle 7/Intersolv combination. The following is
609 // a complete list of the results I got back against the Oracle 7 database:
611 // SQL_BIGINT SQL_NO_DATA_FOUND
612 // SQL_BINARY SQL_NO_DATA_FOUND
613 // SQL_BIT SQL_NO_DATA_FOUND
614 // SQL_CHAR type name = 'CHAR', Precision = 255
615 // SQL_DATE SQL_NO_DATA_FOUND
616 // SQL_DECIMAL type name = 'NUMBER', Precision = 38
617 // SQL_DOUBLE type name = 'NUMBER', Precision = 15
618 // SQL_FLOAT SQL_NO_DATA_FOUND
619 // SQL_INTEGER SQL_NO_DATA_FOUND
620 // SQL_LONGVARBINARY type name = 'LONG RAW', Precision = 2 billion
621 // SQL_LONGVARCHAR type name = 'LONG', Precision = 2 billion
622 // SQL_NUMERIC SQL_NO_DATA_FOUND
623 // SQL_REAL SQL_NO_DATA_FOUND
624 // SQL_SMALLINT SQL_NO_DATA_FOUND
625 // SQL_TIME SQL_NO_DATA_FOUND
626 // SQL_TIMESTAMP type name = 'DATE', Precision = 19
627 // SQL_VARBINARY type name = 'RAW', Precision = 255
628 // SQL_VARCHAR type name = 'VARCHAR2', Precision = 2000
629 // =====================================================================
630 // Results from a Microsoft Access 7.0 db, using a driver from Microsoft
632 // SQL_VARCHAR type name = 'TEXT', Precision = 255
633 // SQL_TIMESTAMP type name = 'DATETIME'
634 // SQL_DECIMAL SQL_NO_DATA_FOUND
635 // SQL_NUMERIC type name = 'CURRENCY', Precision = 19
636 // SQL_FLOAT SQL_NO_DATA_FOUND
637 // SQL_REAL type name = 'SINGLE', Precision = 7
638 // SQL_DOUBLE type name = 'DOUBLE', Precision = 15
639 // SQL_INTEGER type name = 'LONG', Precision = 10
641 // VARCHAR = Variable length character string
642 if (!getDataTypeInfo(SQL_VARCHAR
, typeInfVarchar
))
643 if (!getDataTypeInfo(SQL_CHAR
, typeInfVarchar
))
646 typeInfVarchar
.FsqlType
= SQL_CHAR
;
648 typeInfVarchar
.FsqlType
= SQL_VARCHAR
;
651 if (!getDataTypeInfo(SQL_DOUBLE
,typeInfFloat
))
652 if (!getDataTypeInfo(SQL_REAL
,typeInfFloat
))
653 if (!getDataTypeInfo(SQL_FLOAT
,typeInfFloat
))
654 if (!getDataTypeInfo(SQL_DECIMAL
,typeInfFloat
))
655 if (!getDataTypeInfo(SQL_NUMERIC
,typeInfFloat
))
657 if (failOnDataTypeUnsupported
)
661 typeInfFloat
.FsqlType
= SQL_NUMERIC
;
663 typeInfFloat
.FsqlType
= SQL_DECIMAL
;
665 typeInfFloat
.FsqlType
= SQL_FLOAT
;
667 typeInfFloat
.FsqlType
= SQL_REAL
;
669 typeInfFloat
.FsqlType
= SQL_DOUBLE
;
672 if (!getDataTypeInfo(SQL_INTEGER
, typeInfInteger
))
674 // If SQL_INTEGER is not supported, use the floating point
675 // data type to store integers as well as floats
676 if (!getDataTypeInfo(typeInfFloat
.FsqlType
, typeInfInteger
))
678 if (failOnDataTypeUnsupported
)
682 typeInfInteger
.FsqlType
= typeInfFloat
.FsqlType
;
685 typeInfInteger
.FsqlType
= SQL_INTEGER
;
688 if (!getDataTypeInfo(SQL_TIMESTAMP
,typeInfDate
))
690 if (!getDataTypeInfo(SQL_DATE
,typeInfDate
))
693 if (getDataTypeInfo(SQL_DATETIME
,typeInfDate
))
695 typeInfDate
.FsqlType
= SQL_TIME
;
698 #endif // SQL_DATETIME defined
700 if (failOnDataTypeUnsupported
)
705 typeInfDate
.FsqlType
= SQL_DATE
;
708 typeInfDate
.FsqlType
= SQL_TIMESTAMP
;
711 if (!getDataTypeInfo(SQL_LONGVARBINARY
, typeInfBlob
))
713 if (!getDataTypeInfo(SQL_VARBINARY
,typeInfBlob
))
715 if (failOnDataTypeUnsupported
)
719 typeInfBlob
.FsqlType
= SQL_VARBINARY
;
722 typeInfBlob
.FsqlType
= SQL_LONGVARBINARY
;
725 #ifdef DBDEBUG_CONSOLE
726 cout
<< wxT("VARCHAR DATA TYPE: ") << typeInfVarchar
.TypeName
<< endl
;
727 cout
<< wxT("INTEGER DATA TYPE: ") << typeInfInteger
.TypeName
<< endl
;
728 cout
<< wxT("FLOAT DATA TYPE: ") << typeInfFloat
.TypeName
<< endl
;
729 cout
<< wxT("DATE DATA TYPE: ") << typeInfDate
.TypeName
<< endl
;
730 cout
<< wxT("BLOB DATA TYPE: ") << typeInfBlob
.TypeName
<< endl
;
734 // Completed Successfully
738 bool wxDb::Open(const wxString
& inConnectStr
, bool failOnDataTypeUnsupported
)
740 wxASSERT(inConnectStr
.Length());
747 if (!FwdOnlyCursors())
749 // Specify that the ODBC cursor library be used, if needed. This must be
750 // specified before the connection is made.
751 retcode
= SQLSetConnectOption(hdbc
, SQL_ODBC_CURSORS
, SQL_CUR_USE_IF_NEEDED
);
753 #ifdef DBDEBUG_CONSOLE
754 if (retcode
== SQL_SUCCESS
)
755 cout
<< wxT("SQLSetConnectOption(CURSOR_LIB) successful") << endl
;
757 cout
<< wxT("SQLSetConnectOption(CURSOR_LIB) failed") << endl
;
759 wxUnusedVar(retcode
);
763 // Connect to the data source
764 SQLTCHAR outConnectBuffer
[SQL_MAX_CONNECTSTR_LEN
+1]; // MS recommends at least 1k buffer
765 short outConnectBufferLen
;
767 inConnectionStr
= inConnectStr
;
769 retcode
= SQLDriverConnect(hdbc
, NULL
, (SQLTCHAR FAR
*)inConnectionStr
.c_str(),
770 (SWORD
)inConnectionStr
.Length(), (SQLTCHAR FAR
*)outConnectBuffer
,
771 sizeof(outConnectBuffer
), &outConnectBufferLen
, SQL_DRIVER_COMPLETE
);
773 if ((retcode
!= SQL_SUCCESS
) &&
774 (retcode
!= SQL_SUCCESS_WITH_INFO
))
775 return(DispAllErrors(henv
, hdbc
));
777 outConnectBuffer
[outConnectBufferLen
] = 0;
778 outConnectionStr
= outConnectBuffer
;
779 dbOpenedWithConnectionString
= true;
781 return open(failOnDataTypeUnsupported
);
784 /********** wxDb::Open() **********/
785 bool wxDb::Open(const wxString
&Dsn
, const wxString
&Uid
, const wxString
&AuthStr
, bool failOnDataTypeUnsupported
)
787 wxASSERT(Dsn
.Length());
792 inConnectionStr
= wxT("");
793 outConnectionStr
= wxT("");
797 if (!FwdOnlyCursors())
799 // Specify that the ODBC cursor library be used, if needed. This must be
800 // specified before the connection is made.
801 retcode
= SQLSetConnectOption(hdbc
, SQL_ODBC_CURSORS
, SQL_CUR_USE_IF_NEEDED
);
803 #ifdef DBDEBUG_CONSOLE
804 if (retcode
== SQL_SUCCESS
)
805 cout
<< wxT("SQLSetConnectOption(CURSOR_LIB) successful") << endl
;
807 cout
<< wxT("SQLSetConnectOption(CURSOR_LIB) failed") << endl
;
809 wxUnusedVar( retcode
);
813 // Connect to the data source
814 retcode
= SQLConnect(hdbc
, (SQLTCHAR FAR
*) dsn
.c_str(), SQL_NTS
,
815 (SQLTCHAR FAR
*) uid
.c_str(), SQL_NTS
,
816 (SQLTCHAR FAR
*) authStr
.c_str(), SQL_NTS
);
818 if ((retcode
!= SQL_SUCCESS
) &&
819 (retcode
!= SQL_SUCCESS_WITH_INFO
))
820 return(DispAllErrors(henv
, hdbc
));
822 return open(failOnDataTypeUnsupported
);
827 bool wxDb::Open(wxDbConnectInf
*dbConnectInf
, bool failOnDataTypeUnsupported
)
829 wxASSERT(dbConnectInf
);
831 // Use the connection string if one is present
832 if (dbConnectInf
->UseConnectionStr())
833 return Open(GetConnectionInStr(), failOnDataTypeUnsupported
);
835 return Open(dbConnectInf
->GetDsn(), dbConnectInf
->GetUserID(),
836 dbConnectInf
->GetPassword(), failOnDataTypeUnsupported
);
840 bool wxDb::Open(wxDb
*copyDb
)
842 dsn
= copyDb
->GetDatasourceName();
843 uid
= copyDb
->GetUsername();
844 authStr
= copyDb
->GetPassword();
845 inConnectionStr
= copyDb
->GetConnectionInStr();
846 outConnectionStr
= copyDb
->GetConnectionOutStr();
850 if (!FwdOnlyCursors())
852 // Specify that the ODBC cursor library be used, if needed. This must be
853 // specified before the connection is made.
854 retcode
= SQLSetConnectOption(hdbc
, SQL_ODBC_CURSORS
, SQL_CUR_USE_IF_NEEDED
);
856 #ifdef DBDEBUG_CONSOLE
857 if (retcode
== SQL_SUCCESS
)
858 cout
<< wxT("SQLSetConnectOption(CURSOR_LIB) successful") << endl
;
860 cout
<< wxT("SQLSetConnectOption(CURSOR_LIB) failed") << endl
;
862 wxUnusedVar( retcode
);
866 if (copyDb
->OpenedWithConnectionString())
868 // Connect to the data source
869 SQLTCHAR outConnectBuffer
[SQL_MAX_CONNECTSTR_LEN
+1];
870 short outConnectBufferLen
;
872 inConnectionStr
= copyDb
->GetConnectionInStr();
874 retcode
= SQLDriverConnect(hdbc
, NULL
, (SQLTCHAR FAR
*)inConnectionStr
.c_str(),
875 (SWORD
)inConnectionStr
.Length(), (SQLTCHAR FAR
*)outConnectBuffer
,
876 sizeof(outConnectBuffer
), &outConnectBufferLen
, SQL_DRIVER_COMPLETE
);
878 if ((retcode
!= SQL_SUCCESS
) &&
879 (retcode
!= SQL_SUCCESS_WITH_INFO
))
880 return(DispAllErrors(henv
, hdbc
));
882 outConnectBuffer
[outConnectBufferLen
] = 0;
883 outConnectionStr
= outConnectBuffer
;
884 dbOpenedWithConnectionString
= true;
888 // Connect to the data source
889 retcode
= SQLConnect(hdbc
, (SQLTCHAR FAR
*) dsn
.c_str(), SQL_NTS
,
890 (SQLTCHAR FAR
*) uid
.c_str(), SQL_NTS
,
891 (SQLTCHAR FAR
*) authStr
.c_str(), SQL_NTS
);
894 if ((retcode
!= SQL_SUCCESS
) &&
895 (retcode
!= SQL_SUCCESS_WITH_INFO
))
896 return(DispAllErrors(henv
, hdbc
));
899 If using Intersolv branded ODBC drivers, this is the place where you would substitute
900 your branded driver license information
902 SQLSetConnectOption(hdbc, 1041, (UDWORD) wxEmptyString);
903 SQLSetConnectOption(hdbc, 1042, (UDWORD) wxEmptyString);
906 // Mark database as open
909 // Allocate a statement handle for the database connection
910 if (SQLAllocStmt(hdbc
, &hstmt
) != SQL_SUCCESS
)
911 return(DispAllErrors(henv
, hdbc
));
913 // Set Connection Options
914 if (!setConnectionOptions())
917 // Instead of Querying the data source for info about itself, it can just be copied
918 // from the wxDb instance that was passed in (copyDb).
919 wxStrcpy(dbInf
.serverName
,copyDb
->dbInf
.serverName
);
920 wxStrcpy(dbInf
.databaseName
,copyDb
->dbInf
.databaseName
);
921 wxStrcpy(dbInf
.dbmsName
,copyDb
->dbInf
.dbmsName
);
922 wxStrcpy(dbInf
.dbmsVer
,copyDb
->dbInf
.dbmsVer
);
923 dbInf
.maxConnections
= copyDb
->dbInf
.maxConnections
;
924 dbInf
.maxStmts
= copyDb
->dbInf
.maxStmts
;
925 wxStrcpy(dbInf
.driverName
,copyDb
->dbInf
.driverName
);
926 wxStrcpy(dbInf
.odbcVer
,copyDb
->dbInf
.odbcVer
);
927 wxStrcpy(dbInf
.drvMgrOdbcVer
,copyDb
->dbInf
.drvMgrOdbcVer
);
928 wxStrcpy(dbInf
.driverVer
,copyDb
->dbInf
.driverVer
);
929 dbInf
.apiConfLvl
= copyDb
->dbInf
.apiConfLvl
;
930 dbInf
.cliConfLvl
= copyDb
->dbInf
.cliConfLvl
;
931 dbInf
.sqlConfLvl
= copyDb
->dbInf
.sqlConfLvl
;
932 wxStrcpy(dbInf
.outerJoins
,copyDb
->dbInf
.outerJoins
);
933 wxStrcpy(dbInf
.procedureSupport
,copyDb
->dbInf
.procedureSupport
);
934 wxStrcpy(dbInf
.accessibleTables
,copyDb
->dbInf
.accessibleTables
);
935 dbInf
.cursorCommitBehavior
= copyDb
->dbInf
.cursorCommitBehavior
;
936 dbInf
.cursorRollbackBehavior
= copyDb
->dbInf
.cursorRollbackBehavior
;
937 dbInf
.supportNotNullClause
= copyDb
->dbInf
.supportNotNullClause
;
938 wxStrcpy(dbInf
.supportIEF
,copyDb
->dbInf
.supportIEF
);
939 dbInf
.txnIsolation
= copyDb
->dbInf
.txnIsolation
;
940 dbInf
.txnIsolationOptions
= copyDb
->dbInf
.txnIsolationOptions
;
941 dbInf
.fetchDirections
= copyDb
->dbInf
.fetchDirections
;
942 dbInf
.lockTypes
= copyDb
->dbInf
.lockTypes
;
943 dbInf
.posOperations
= copyDb
->dbInf
.posOperations
;
944 dbInf
.posStmts
= copyDb
->dbInf
.posStmts
;
945 dbInf
.scrollConcurrency
= copyDb
->dbInf
.scrollConcurrency
;
946 dbInf
.scrollOptions
= copyDb
->dbInf
.scrollOptions
;
947 dbInf
.staticSensitivity
= copyDb
->dbInf
.staticSensitivity
;
948 dbInf
.txnCapable
= copyDb
->dbInf
.txnCapable
;
949 dbInf
.loginTimeout
= copyDb
->dbInf
.loginTimeout
;
951 // VARCHAR = Variable length character string
952 typeInfVarchar
.FsqlType
= copyDb
->typeInfVarchar
.FsqlType
;
953 typeInfVarchar
.TypeName
= copyDb
->typeInfVarchar
.TypeName
;
954 typeInfVarchar
.Precision
= copyDb
->typeInfVarchar
.Precision
;
955 typeInfVarchar
.CaseSensitive
= copyDb
->typeInfVarchar
.CaseSensitive
;
956 typeInfVarchar
.MaximumScale
= copyDb
->typeInfVarchar
.MaximumScale
;
959 typeInfFloat
.FsqlType
= copyDb
->typeInfFloat
.FsqlType
;
960 typeInfFloat
.TypeName
= copyDb
->typeInfFloat
.TypeName
;
961 typeInfFloat
.Precision
= copyDb
->typeInfFloat
.Precision
;
962 typeInfFloat
.CaseSensitive
= copyDb
->typeInfFloat
.CaseSensitive
;
963 typeInfFloat
.MaximumScale
= copyDb
->typeInfFloat
.MaximumScale
;
966 typeInfInteger
.FsqlType
= copyDb
->typeInfInteger
.FsqlType
;
967 typeInfInteger
.TypeName
= copyDb
->typeInfInteger
.TypeName
;
968 typeInfInteger
.Precision
= copyDb
->typeInfInteger
.Precision
;
969 typeInfInteger
.CaseSensitive
= copyDb
->typeInfInteger
.CaseSensitive
;
970 typeInfInteger
.MaximumScale
= copyDb
->typeInfInteger
.MaximumScale
;
973 typeInfDate
.FsqlType
= copyDb
->typeInfDate
.FsqlType
;
974 typeInfDate
.TypeName
= copyDb
->typeInfDate
.TypeName
;
975 typeInfDate
.Precision
= copyDb
->typeInfDate
.Precision
;
976 typeInfDate
.CaseSensitive
= copyDb
->typeInfDate
.CaseSensitive
;
977 typeInfDate
.MaximumScale
= copyDb
->typeInfDate
.MaximumScale
;
980 typeInfBlob
.FsqlType
= copyDb
->typeInfBlob
.FsqlType
;
981 typeInfBlob
.TypeName
= copyDb
->typeInfBlob
.TypeName
;
982 typeInfBlob
.Precision
= copyDb
->typeInfBlob
.Precision
;
983 typeInfBlob
.CaseSensitive
= copyDb
->typeInfBlob
.CaseSensitive
;
984 typeInfBlob
.MaximumScale
= copyDb
->typeInfBlob
.MaximumScale
;
986 #ifdef DBDEBUG_CONSOLE
987 cout
<< wxT("VARCHAR DATA TYPE: ") << typeInfVarchar
.TypeName
<< endl
;
988 cout
<< wxT("INTEGER DATA TYPE: ") << typeInfInteger
.TypeName
<< endl
;
989 cout
<< wxT("FLOAT DATA TYPE: ") << typeInfFloat
.TypeName
<< endl
;
990 cout
<< wxT("DATE DATA TYPE: ") << typeInfDate
.TypeName
<< endl
;
991 cout
<< wxT("BLOB DATA TYPE: ") << typeInfBlob
.TypeName
<< endl
;
995 // Completed Successfully
1000 /********** wxDb::setConnectionOptions() **********/
1001 bool wxDb::setConnectionOptions(void)
1003 * NOTE: The Intersolv/Oracle 7 driver was "Not Capable" of setting the login timeout.
1008 // I need to get the DBMS name here, because some of the connection options
1009 // are database specific and need to call the Dbms() function.
1012 retcode
= SQLGetInfo(hdbc
, SQL_DBMS_NAME
, (UCHAR
*) dbInf
.dbmsName
, sizeof(dbInf
.dbmsName
), &cb
);
1013 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1014 return(DispAllErrors(henv
, hdbc
));
1016 retcode
= SQLSetConnectOption(hdbc
, SQL_AUTOCOMMIT
, SQL_AUTOCOMMIT_OFF
);
1017 retcode
= SQLSetConnectOption(hdbc
, SQL_OPT_TRACE
, SQL_OPT_TRACE_OFF
);
1018 // SQLSetConnectOption(hdbc, SQL_TXN_ISOLATION, SQL_TXN_READ_COMMITTED); // No dirty reads
1020 // By default, MS Sql Server closes cursors on commit and rollback. The following
1021 // call to SQLSetConnectOption() is needed to force SQL Server to preserve cursors
1022 // after a transaction. This is a driver specific option and is not part of the
1023 // ODBC standard. Note: this behavior is specific to the ODBC interface to SQL Server.
1024 // The database settings don't have any effect one way or the other.
1025 if (Dbms() == dbmsMS_SQL_SERVER
)
1027 const long SQL_PRESERVE_CURSORS
= 1204L;
1028 const long SQL_PC_ON
= 1L;
1029 retcode
= SQLSetConnectOption(hdbc
, SQL_PRESERVE_CURSORS
, SQL_PC_ON
);
1032 // Display the connection options to verify them
1033 #ifdef DBDEBUG_CONSOLE
1035 cout
<< wxT("****** CONNECTION OPTIONS ******") << endl
;
1037 retcode
= SQLGetConnectOption(hdbc
, SQL_AUTOCOMMIT
, &l
);
1038 if (retcode
!= SQL_SUCCESS
)
1039 return(DispAllErrors(henv
, hdbc
));
1040 cout
<< wxT("AUTOCOMMIT: ") << (l
== SQL_AUTOCOMMIT_OFF
? "OFF" : "ON") << endl
;
1042 retcode
= SQLGetConnectOption(hdbc
, SQL_ODBC_CURSORS
, &l
);
1043 if (retcode
!= SQL_SUCCESS
)
1044 return(DispAllErrors(henv
, hdbc
));
1045 cout
<< wxT("ODBC CURSORS: ");
1048 case(SQL_CUR_USE_IF_NEEDED
):
1049 cout
<< wxT("SQL_CUR_USE_IF_NEEDED");
1051 case(SQL_CUR_USE_ODBC
):
1052 cout
<< wxT("SQL_CUR_USE_ODBC");
1054 case(SQL_CUR_USE_DRIVER
):
1055 cout
<< wxT("SQL_CUR_USE_DRIVER");
1060 retcode
= SQLGetConnectOption(hdbc
, SQL_OPT_TRACE
, &l
)
1061 if (retcode
!= SQL_SUCCESS
)
1062 return(DispAllErrors(henv
, hdbc
));
1063 cout
<< wxT("TRACING: ") << (l
== SQL_OPT_TRACE_OFF
? wxT("OFF") : wxT("ON")) << endl
;
1068 // Completed Successfully
1071 } // wxDb::setConnectionOptions()
1074 /********** wxDb::getDbInfo() **********/
1075 bool wxDb::getDbInfo(bool failOnDataTypeUnsupported
)
1080 retcode
= SQLGetInfo(hdbc
, SQL_SERVER_NAME
, (UCHAR
*) dbInf
.serverName
, sizeof(dbInf
.serverName
), &cb
);
1081 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1083 DispAllErrors(henv
, hdbc
);
1084 if (failOnDataTypeUnsupported
)
1088 retcode
= SQLGetInfo(hdbc
, SQL_DATABASE_NAME
, (UCHAR
*) dbInf
.databaseName
, sizeof(dbInf
.databaseName
), &cb
);
1089 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1091 DispAllErrors(henv
, hdbc
);
1092 if (failOnDataTypeUnsupported
)
1096 retcode
= SQLGetInfo(hdbc
, SQL_DBMS_NAME
, (UCHAR
*) dbInf
.dbmsName
, sizeof(dbInf
.dbmsName
), &cb
);
1097 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1099 DispAllErrors(henv
, hdbc
);
1100 if (failOnDataTypeUnsupported
)
1105 // After upgrading to MSVC6, the original 20 char buffer below was insufficient,
1106 // causing database connectivity to fail in some cases.
1107 retcode
= SQLGetInfo(hdbc
, SQL_DBMS_VER
, (UCHAR
*) dbInf
.dbmsVer
, sizeof(dbInf
.dbmsVer
), &cb
);
1108 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1110 DispAllErrors(henv
, hdbc
);
1111 if (failOnDataTypeUnsupported
)
1115 retcode
= SQLGetInfo(hdbc
, SQL_ACTIVE_CONNECTIONS
, (UCHAR
*) &dbInf
.maxConnections
, sizeof(dbInf
.maxConnections
), &cb
);
1116 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1118 DispAllErrors(henv
, hdbc
);
1119 if (failOnDataTypeUnsupported
)
1123 retcode
= SQLGetInfo(hdbc
, SQL_ACTIVE_STATEMENTS
, (UCHAR
*) &dbInf
.maxStmts
, sizeof(dbInf
.maxStmts
), &cb
);
1124 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1126 DispAllErrors(henv
, hdbc
);
1127 if (failOnDataTypeUnsupported
)
1131 retcode
= SQLGetInfo(hdbc
, SQL_DRIVER_NAME
, (UCHAR
*) dbInf
.driverName
, sizeof(dbInf
.driverName
), &cb
);
1132 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1134 DispAllErrors(henv
, hdbc
);
1135 if (failOnDataTypeUnsupported
)
1139 retcode
= SQLGetInfo(hdbc
, SQL_DRIVER_ODBC_VER
, (UCHAR
*) dbInf
.odbcVer
, sizeof(dbInf
.odbcVer
), &cb
);
1140 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1142 DispAllErrors(henv
, hdbc
);
1143 if (failOnDataTypeUnsupported
)
1147 retcode
= SQLGetInfo(hdbc
, SQL_ODBC_VER
, (UCHAR
*) dbInf
.drvMgrOdbcVer
, sizeof(dbInf
.drvMgrOdbcVer
), &cb
);
1148 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1150 DispAllErrors(henv
, hdbc
);
1151 if (failOnDataTypeUnsupported
)
1155 retcode
= SQLGetInfo(hdbc
, SQL_DRIVER_VER
, (UCHAR
*) dbInf
.driverVer
, sizeof(dbInf
.driverVer
), &cb
);
1156 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1158 DispAllErrors(henv
, hdbc
);
1159 if (failOnDataTypeUnsupported
)
1163 retcode
= SQLGetInfo(hdbc
, SQL_ODBC_API_CONFORMANCE
, (UCHAR
*) &dbInf
.apiConfLvl
, sizeof(dbInf
.apiConfLvl
), &cb
);
1164 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1166 DispAllErrors(henv
, hdbc
);
1167 if (failOnDataTypeUnsupported
)
1171 retcode
= SQLGetInfo(hdbc
, SQL_ODBC_SAG_CLI_CONFORMANCE
, (UCHAR
*) &dbInf
.cliConfLvl
, sizeof(dbInf
.cliConfLvl
), &cb
);
1172 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1174 // Not all drivers support this call - Nick Gorham(unixODBC)
1175 dbInf
.cliConfLvl
= 0;
1176 DispAllErrors(henv
, hdbc
);
1177 if (failOnDataTypeUnsupported
)
1181 retcode
= SQLGetInfo(hdbc
, SQL_ODBC_SQL_CONFORMANCE
, (UCHAR
*) &dbInf
.sqlConfLvl
, sizeof(dbInf
.sqlConfLvl
), &cb
);
1182 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1184 DispAllErrors(henv
, hdbc
);
1185 if (failOnDataTypeUnsupported
)
1189 retcode
= SQLGetInfo(hdbc
, SQL_OUTER_JOINS
, (UCHAR
*) dbInf
.outerJoins
, sizeof(dbInf
.outerJoins
), &cb
);
1190 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1192 DispAllErrors(henv
, hdbc
);
1193 if (failOnDataTypeUnsupported
)
1197 retcode
= SQLGetInfo(hdbc
, SQL_PROCEDURES
, (UCHAR
*) dbInf
.procedureSupport
, sizeof(dbInf
.procedureSupport
), &cb
);
1198 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1200 DispAllErrors(henv
, hdbc
);
1201 if (failOnDataTypeUnsupported
)
1205 retcode
= SQLGetInfo(hdbc
, SQL_ACCESSIBLE_TABLES
, (UCHAR
*) dbInf
.accessibleTables
, sizeof(dbInf
.accessibleTables
), &cb
);
1206 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1208 DispAllErrors(henv
, hdbc
);
1209 if (failOnDataTypeUnsupported
)
1213 retcode
= SQLGetInfo(hdbc
, SQL_CURSOR_COMMIT_BEHAVIOR
, (UCHAR
*) &dbInf
.cursorCommitBehavior
, sizeof(dbInf
.cursorCommitBehavior
), &cb
);
1214 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1216 DispAllErrors(henv
, hdbc
);
1217 if (failOnDataTypeUnsupported
)
1221 retcode
= SQLGetInfo(hdbc
, SQL_CURSOR_ROLLBACK_BEHAVIOR
, (UCHAR
*) &dbInf
.cursorRollbackBehavior
, sizeof(dbInf
.cursorRollbackBehavior
), &cb
);
1222 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1224 DispAllErrors(henv
, hdbc
);
1225 if (failOnDataTypeUnsupported
)
1229 retcode
= SQLGetInfo(hdbc
, SQL_NON_NULLABLE_COLUMNS
, (UCHAR
*) &dbInf
.supportNotNullClause
, sizeof(dbInf
.supportNotNullClause
), &cb
);
1230 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1232 DispAllErrors(henv
, hdbc
);
1233 if (failOnDataTypeUnsupported
)
1237 retcode
= SQLGetInfo(hdbc
, SQL_ODBC_SQL_OPT_IEF
, (UCHAR
*) dbInf
.supportIEF
, sizeof(dbInf
.supportIEF
), &cb
);
1238 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1240 DispAllErrors(henv
, hdbc
);
1241 if (failOnDataTypeUnsupported
)
1245 retcode
= SQLGetInfo(hdbc
, SQL_DEFAULT_TXN_ISOLATION
, (UCHAR
*) &dbInf
.txnIsolation
, sizeof(dbInf
.txnIsolation
), &cb
);
1246 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1248 DispAllErrors(henv
, hdbc
);
1249 if (failOnDataTypeUnsupported
)
1253 retcode
= SQLGetInfo(hdbc
, SQL_TXN_ISOLATION_OPTION
, (UCHAR
*) &dbInf
.txnIsolationOptions
, sizeof(dbInf
.txnIsolationOptions
), &cb
);
1254 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1256 DispAllErrors(henv
, hdbc
);
1257 if (failOnDataTypeUnsupported
)
1261 retcode
= SQLGetInfo(hdbc
, SQL_FETCH_DIRECTION
, (UCHAR
*) &dbInf
.fetchDirections
, sizeof(dbInf
.fetchDirections
), &cb
);
1262 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1264 DispAllErrors(henv
, hdbc
);
1265 if (failOnDataTypeUnsupported
)
1269 retcode
= SQLGetInfo(hdbc
, SQL_LOCK_TYPES
, (UCHAR
*) &dbInf
.lockTypes
, sizeof(dbInf
.lockTypes
), &cb
);
1270 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1272 DispAllErrors(henv
, hdbc
);
1273 if (failOnDataTypeUnsupported
)
1277 retcode
= SQLGetInfo(hdbc
, SQL_POS_OPERATIONS
, (UCHAR
*) &dbInf
.posOperations
, sizeof(dbInf
.posOperations
), &cb
);
1278 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1280 DispAllErrors(henv
, hdbc
);
1281 if (failOnDataTypeUnsupported
)
1285 retcode
= SQLGetInfo(hdbc
, SQL_POSITIONED_STATEMENTS
, (UCHAR
*) &dbInf
.posStmts
, sizeof(dbInf
.posStmts
), &cb
);
1286 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1288 DispAllErrors(henv
, hdbc
);
1289 if (failOnDataTypeUnsupported
)
1293 retcode
= SQLGetInfo(hdbc
, SQL_SCROLL_CONCURRENCY
, (UCHAR
*) &dbInf
.scrollConcurrency
, sizeof(dbInf
.scrollConcurrency
), &cb
);
1294 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1296 DispAllErrors(henv
, hdbc
);
1297 if (failOnDataTypeUnsupported
)
1301 retcode
= SQLGetInfo(hdbc
, SQL_SCROLL_OPTIONS
, (UCHAR
*) &dbInf
.scrollOptions
, sizeof(dbInf
.scrollOptions
), &cb
);
1302 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1304 DispAllErrors(henv
, hdbc
);
1305 if (failOnDataTypeUnsupported
)
1309 retcode
= SQLGetInfo(hdbc
, SQL_STATIC_SENSITIVITY
, (UCHAR
*) &dbInf
.staticSensitivity
, sizeof(dbInf
.staticSensitivity
), &cb
);
1310 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1312 DispAllErrors(henv
, hdbc
);
1313 if (failOnDataTypeUnsupported
)
1317 retcode
= SQLGetInfo(hdbc
, SQL_TXN_CAPABLE
, (UCHAR
*) &dbInf
.txnCapable
, sizeof(dbInf
.txnCapable
), &cb
);
1318 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1320 DispAllErrors(henv
, hdbc
);
1321 if (failOnDataTypeUnsupported
)
1325 retcode
= SQLGetInfo(hdbc
, SQL_LOGIN_TIMEOUT
, (UCHAR
*) &dbInf
.loginTimeout
, sizeof(dbInf
.loginTimeout
), &cb
);
1326 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
1328 DispAllErrors(henv
, hdbc
);
1329 if (failOnDataTypeUnsupported
)
1333 #ifdef DBDEBUG_CONSOLE
1334 cout
<< wxT("***** DATA SOURCE INFORMATION *****") << endl
;
1335 cout
<< wxT(wxT("SERVER Name: ") << dbInf
.serverName
<< endl
;
1336 cout
<< wxT("DBMS Name: ") << dbInf
.dbmsName
<< wxT("; DBMS Version: ") << dbInf
.dbmsVer
<< endl
;
1337 cout
<< wxT("ODBC Version: ") << dbInf
.odbcVer
<< wxT("; Driver Version: ") << dbInf
.driverVer
<< endl
;
1339 cout
<< wxT("API Conf. Level: ");
1340 switch(dbInf
.apiConfLvl
)
1342 case SQL_OAC_NONE
: cout
<< wxT("None"); break;
1343 case SQL_OAC_LEVEL1
: cout
<< wxT("Level 1"); break;
1344 case SQL_OAC_LEVEL2
: cout
<< wxT("Level 2"); break;
1348 cout
<< wxT("SAG CLI Conf. Level: ");
1349 switch(dbInf
.cliConfLvl
)
1351 case SQL_OSCC_NOT_COMPLIANT
: cout
<< wxT("Not Compliant"); break;
1352 case SQL_OSCC_COMPLIANT
: cout
<< wxT("Compliant"); break;
1356 cout
<< wxT("SQL Conf. Level: ");
1357 switch(dbInf
.sqlConfLvl
)
1359 case SQL_OSC_MINIMUM
: cout
<< wxT("Minimum Grammar"); break;
1360 case SQL_OSC_CORE
: cout
<< wxT("Core Grammar"); break;
1361 case SQL_OSC_EXTENDED
: cout
<< wxT("Extended Grammar"); break;
1365 cout
<< wxT("Max. Connections: ") << dbInf
.maxConnections
<< endl
;
1366 cout
<< wxT("Outer Joins: ") << dbInf
.outerJoins
<< endl
;
1367 cout
<< wxT("Support for Procedures: ") << dbInf
.procedureSupport
<< endl
;
1368 cout
<< wxT("All tables accessible : ") << dbInf
.accessibleTables
<< endl
;
1369 cout
<< wxT("Cursor COMMIT Behavior: ");
1370 switch(dbInf
.cursorCommitBehavior
)
1372 case SQL_CB_DELETE
: cout
<< wxT("Delete cursors"); break;
1373 case SQL_CB_CLOSE
: cout
<< wxT("Close cursors"); break;
1374 case SQL_CB_PRESERVE
: cout
<< wxT("Preserve cursors"); break;
1378 cout
<< wxT("Cursor ROLLBACK Behavior: ");
1379 switch(dbInf
.cursorRollbackBehavior
)
1381 case SQL_CB_DELETE
: cout
<< wxT("Delete cursors"); break;
1382 case SQL_CB_CLOSE
: cout
<< wxT("Close cursors"); break;
1383 case SQL_CB_PRESERVE
: cout
<< wxT("Preserve cursors"); break;
1387 cout
<< wxT("Support NOT NULL clause: ");
1388 switch(dbInf
.supportNotNullClause
)
1390 case SQL_NNC_NULL
: cout
<< wxT("No"); break;
1391 case SQL_NNC_NON_NULL
: cout
<< wxT("Yes"); break;
1395 cout
<< wxT("Support IEF (Ref. Integrity): ") << dbInf
.supportIEF
<< endl
;
1396 cout
<< wxT("Login Timeout: ") << dbInf
.loginTimeout
<< endl
;
1398 cout
<< endl
<< endl
<< wxT("more ...") << endl
;
1401 cout
<< wxT("Default Transaction Isolation: ";
1402 switch(dbInf
.txnIsolation
)
1404 case SQL_TXN_READ_UNCOMMITTED
: cout
<< wxT("Read Uncommitted"); break;
1405 case SQL_TXN_READ_COMMITTED
: cout
<< wxT("Read Committed"); break;
1406 case SQL_TXN_REPEATABLE_READ
: cout
<< wxT("Repeatable Read"); break;
1407 case SQL_TXN_SERIALIZABLE
: cout
<< wxT("Serializable"); break;
1409 case SQL_TXN_VERSIONING
: cout
<< wxT("Versioning"); break;
1414 cout
<< wxT("Transaction Isolation Options: ");
1415 if (dbInf
.txnIsolationOptions
& SQL_TXN_READ_UNCOMMITTED
)
1416 cout
<< wxT("Read Uncommitted, ");
1417 if (dbInf
.txnIsolationOptions
& SQL_TXN_READ_COMMITTED
)
1418 cout
<< wxT("Read Committed, ");
1419 if (dbInf
.txnIsolationOptions
& SQL_TXN_REPEATABLE_READ
)
1420 cout
<< wxT("Repeatable Read, ");
1421 if (dbInf
.txnIsolationOptions
& SQL_TXN_SERIALIZABLE
)
1422 cout
<< wxT("Serializable, ");
1424 if (dbInf
.txnIsolationOptions
& SQL_TXN_VERSIONING
)
1425 cout
<< wxT("Versioning");
1429 cout
<< wxT("Fetch Directions Supported:") << endl
<< wxT(" ");
1430 if (dbInf
.fetchDirections
& SQL_FD_FETCH_NEXT
)
1431 cout
<< wxT("Next, ");
1432 if (dbInf
.fetchDirections
& SQL_FD_FETCH_PRIOR
)
1433 cout
<< wxT("Prev, ");
1434 if (dbInf
.fetchDirections
& SQL_FD_FETCH_FIRST
)
1435 cout
<< wxT("First, ");
1436 if (dbInf
.fetchDirections
& SQL_FD_FETCH_LAST
)
1437 cout
<< wxT("Last, ");
1438 if (dbInf
.fetchDirections
& SQL_FD_FETCH_ABSOLUTE
)
1439 cout
<< wxT("Absolute, ");
1440 if (dbInf
.fetchDirections
& SQL_FD_FETCH_RELATIVE
)
1441 cout
<< wxT("Relative, ");
1443 if (dbInf
.fetchDirections
& SQL_FD_FETCH_RESUME
)
1444 cout
<< wxT("Resume, ");
1446 if (dbInf
.fetchDirections
& SQL_FD_FETCH_BOOKMARK
)
1447 cout
<< wxT("Bookmark");
1450 cout
<< wxT("Lock Types Supported (SQLSetPos): ");
1451 if (dbInf
.lockTypes
& SQL_LCK_NO_CHANGE
)
1452 cout
<< wxT("No Change, ");
1453 if (dbInf
.lockTypes
& SQL_LCK_EXCLUSIVE
)
1454 cout
<< wxT("Exclusive, ");
1455 if (dbInf
.lockTypes
& SQL_LCK_UNLOCK
)
1456 cout
<< wxT("UnLock");
1459 cout
<< wxT("Position Operations Supported (SQLSetPos): ");
1460 if (dbInf
.posOperations
& SQL_POS_POSITION
)
1461 cout
<< wxT("Position, ");
1462 if (dbInf
.posOperations
& SQL_POS_REFRESH
)
1463 cout
<< wxT("Refresh, ");
1464 if (dbInf
.posOperations
& SQL_POS_UPDATE
)
1465 cout
<< wxT("Upd, "));
1466 if (dbInf
.posOperations
& SQL_POS_DELETE
)
1467 cout
<< wxT("Del, ");
1468 if (dbInf
.posOperations
& SQL_POS_ADD
)
1472 cout
<< wxT("Positioned Statements Supported: ");
1473 if (dbInf
.posStmts
& SQL_PS_POSITIONED_DELETE
)
1474 cout
<< wxT("Pos delete, ");
1475 if (dbInf
.posStmts
& SQL_PS_POSITIONED_UPDATE
)
1476 cout
<< wxT("Pos update, ");
1477 if (dbInf
.posStmts
& SQL_PS_SELECT_FOR_UPDATE
)
1478 cout
<< wxT("Select for update");
1481 cout
<< wxT("Scroll Concurrency: ");
1482 if (dbInf
.scrollConcurrency
& SQL_SCCO_READ_ONLY
)
1483 cout
<< wxT("Read Only, ");
1484 if (dbInf
.scrollConcurrency
& SQL_SCCO_LOCK
)
1485 cout
<< wxT("Lock, ");
1486 if (dbInf
.scrollConcurrency
& SQL_SCCO_OPT_ROWVER
)
1487 cout
<< wxT("Opt. Rowver, ");
1488 if (dbInf
.scrollConcurrency
& SQL_SCCO_OPT_VALUES
)
1489 cout
<< wxT("Opt. Values");
1492 cout
<< wxT("Scroll Options: ");
1493 if (dbInf
.scrollOptions
& SQL_SO_FORWARD_ONLY
)
1494 cout
<< wxT("Fwd Only, ");
1495 if (dbInf
.scrollOptions
& SQL_SO_STATIC
)
1496 cout
<< wxT("Static, ");
1497 if (dbInf
.scrollOptions
& SQL_SO_KEYSET_DRIVEN
)
1498 cout
<< wxT("Keyset Driven, ");
1499 if (dbInf
.scrollOptions
& SQL_SO_DYNAMIC
)
1500 cout
<< wxT("Dynamic, ");
1501 if (dbInf
.scrollOptions
& SQL_SO_MIXED
)
1502 cout
<< wxT("Mixed");
1505 cout
<< wxT("Static Sensitivity: ");
1506 if (dbInf
.staticSensitivity
& SQL_SS_ADDITIONS
)
1507 cout
<< wxT("Additions, ");
1508 if (dbInf
.staticSensitivity
& SQL_SS_DELETIONS
)
1509 cout
<< wxT("Deletions, ");
1510 if (dbInf
.staticSensitivity
& SQL_SS_UPDATES
)
1511 cout
<< wxT("Updates");
1514 cout
<< wxT("Transaction Capable?: ");
1515 switch(dbInf
.txnCapable
)
1517 case SQL_TC_NONE
: cout
<< wxT("No"); break;
1518 case SQL_TC_DML
: cout
<< wxT("DML Only"); break;
1519 case SQL_TC_DDL_COMMIT
: cout
<< wxT("DDL Commit"); break;
1520 case SQL_TC_DDL_IGNORE
: cout
<< wxT("DDL Ignore"); break;
1521 case SQL_TC_ALL
: cout
<< wxT("DDL & DML"); break;
1528 // Completed Successfully
1531 } // wxDb::getDbInfo()
1534 /********** wxDb::getDataTypeInfo() **********/
1535 bool wxDb::getDataTypeInfo(SWORD fSqlType
, wxDbSqlTypeInfo
&structSQLTypeInfo
)
1538 * fSqlType will be something like SQL_VARCHAR. This parameter determines
1539 * the data type inf. is gathered for.
1541 * wxDbSqlTypeInfo is a structure that is filled in with data type information,
1546 // Get information about the data type specified
1547 if (SQLGetTypeInfo(hstmt
, fSqlType
) != SQL_SUCCESS
)
1548 return(DispAllErrors(henv
, hdbc
, hstmt
));
1551 retcode
= SQLFetch(hstmt
);
1552 if (retcode
!= SQL_SUCCESS
)
1554 #ifdef DBDEBUG_CONSOLE
1555 if (retcode
== SQL_NO_DATA_FOUND
)
1556 cout
<< wxT("SQL_NO_DATA_FOUND fetching inf. about data type.") << endl
;
1558 DispAllErrors(henv
, hdbc
, hstmt
);
1559 SQLFreeStmt(hstmt
, SQL_CLOSE
);
1563 wxChar typeName
[DB_TYPE_NAME_LEN
+1];
1565 // Obtain columns from the record
1566 if (SQLGetData(hstmt
, 1, SQL_C_WXCHAR
, typeName
, sizeof(typeName
), &cbRet
) != SQL_SUCCESS
)
1567 return(DispAllErrors(henv
, hdbc
, hstmt
));
1569 structSQLTypeInfo
.TypeName
= typeName
;
1571 // BJO 20000503: no more needed with new GetColumns...
1574 if (Dbms() == dbmsMY_SQL
)
1576 if (structSQLTypeInfo
.TypeName
== wxT("middleint"))
1577 structSQLTypeInfo
.TypeName
= wxT("mediumint");
1578 else if (structSQLTypeInfo
.TypeName
== wxT("middleint unsigned"))
1579 structSQLTypeInfo
.TypeName
= wxT("mediumint unsigned");
1580 else if (structSQLTypeInfo
.TypeName
== wxT("integer"))
1581 structSQLTypeInfo
.TypeName
= wxT("int");
1582 else if (structSQLTypeInfo
.TypeName
== wxT("integer unsigned"))
1583 structSQLTypeInfo
.TypeName
= wxT("int unsigned");
1584 else if (structSQLTypeInfo
.TypeName
== wxT("middleint"))
1585 structSQLTypeInfo
.TypeName
= wxT("mediumint");
1586 else if (structSQLTypeInfo
.TypeName
== wxT("varchar"))
1587 structSQLTypeInfo
.TypeName
= wxT("char");
1590 // BJO 20000427 : OpenLink driver
1591 if (!wxStrncmp(dbInf
.driverName
, wxT("oplodbc"), 7) ||
1592 !wxStrncmp(dbInf
.driverName
, wxT("OLOD"), 4))
1594 if (structSQLTypeInfo
.TypeName
== wxT("double precision"))
1595 structSQLTypeInfo
.TypeName
= wxT("real");
1599 if (SQLGetData(hstmt
, 3, SQL_C_LONG
, (UCHAR
*) &structSQLTypeInfo
.Precision
, 0, &cbRet
) != SQL_SUCCESS
)
1600 return(DispAllErrors(henv
, hdbc
, hstmt
));
1601 if (SQLGetData(hstmt
, 8, SQL_C_SHORT
, (UCHAR
*) &structSQLTypeInfo
.CaseSensitive
, 0, &cbRet
) != SQL_SUCCESS
)
1602 return(DispAllErrors(henv
, hdbc
, hstmt
));
1603 // if (SQLGetData(hstmt, 14, SQL_C_SHORT, (UCHAR*) &structSQLTypeInfo.MinimumScale, 0, &cbRet) != SQL_SUCCESS)
1604 // return(DispAllErrors(henv, hdbc, hstmt));
1606 if (SQLGetData(hstmt
, 15, SQL_C_SHORT
,(UCHAR
*) &structSQLTypeInfo
.MaximumScale
, 0, &cbRet
) != SQL_SUCCESS
)
1607 return(DispAllErrors(henv
, hdbc
, hstmt
));
1609 if (structSQLTypeInfo
.MaximumScale
< 0)
1610 structSQLTypeInfo
.MaximumScale
= 0;
1612 // Close the statement handle which closes open cursors
1613 if (SQLFreeStmt(hstmt
, SQL_CLOSE
) != SQL_SUCCESS
)
1614 return(DispAllErrors(henv
, hdbc
, hstmt
));
1616 // Completed Successfully
1619 } // wxDb::getDataTypeInfo()
1622 /********** wxDb::Close() **********/
1623 void wxDb::Close(void)
1625 // Close the Sql Log file
1632 // Free statement handle
1635 if (SQLFreeStmt(hstmt
, SQL_DROP
) != SQL_SUCCESS
)
1636 DispAllErrors(henv
, hdbc
);
1639 // Disconnect from the datasource
1640 if (SQLDisconnect(hdbc
) != SQL_SUCCESS
)
1641 DispAllErrors(henv
, hdbc
);
1643 // Free the connection to the datasource
1644 if (SQLFreeConnect(hdbc
) != SQL_SUCCESS
)
1645 DispAllErrors(henv
, hdbc
);
1647 // There should be zero Ctable objects still connected to this db object
1648 wxASSERT(nTables
== 0);
1652 wxList::compatibility_iterator pNode
;
1653 pNode
= TablesInUse
.GetFirst();
1657 tiu
= (wxTablesInUse
*)pNode
->GetData();
1658 if (tiu
->pDb
== this)
1660 s
.Printf(wxT("(%-20s) tableID:[%6lu] pDb:[%p]"), tiu
->tableName
,tiu
->tableID
,tiu
->pDb
);
1661 s2
.Printf(wxT("Orphaned table found using pDb:[%p]"),this);
1662 wxLogDebug(s
.c_str(),s2
.c_str());
1664 pNode
= pNode
->GetNext();
1668 // Copy the error messages to a global variable
1670 for (i
= 0; i
< DB_MAX_ERROR_HISTORY
; i
++)
1671 wxStrcpy(DBerrorList
[i
], errorList
[i
]);
1673 dbmsType
= dbmsUNIDENTIFIED
;
1679 /********** wxDb::CommitTrans() **********/
1680 bool wxDb::CommitTrans(void)
1684 // Commit the transaction
1685 if (SQLTransact(henv
, hdbc
, SQL_COMMIT
) != SQL_SUCCESS
)
1686 return(DispAllErrors(henv
, hdbc
));
1689 // Completed successfully
1692 } // wxDb::CommitTrans()
1695 /********** wxDb::RollbackTrans() **********/
1696 bool wxDb::RollbackTrans(void)
1698 // Rollback the transaction
1699 if (SQLTransact(henv
, hdbc
, SQL_ROLLBACK
) != SQL_SUCCESS
)
1700 return(DispAllErrors(henv
, hdbc
));
1702 // Completed successfully
1705 } // wxDb::RollbackTrans()
1708 /********** wxDb::DispAllErrors() **********/
1709 bool wxDb::DispAllErrors(HENV aHenv
, HDBC aHdbc
, HSTMT aHstmt
)
1711 * This function is called internally whenever an error condition prevents the user's
1712 * request from being executed. This function will query the datasource as to the
1713 * actual error(s) that just occured on the previous request of the datasource.
1715 * The function will retrieve each error condition from the datasource and
1716 * Printf the codes/text values into a string which it then logs via logError().
1717 * If in DBDEBUG_CONSOLE mode, the constructed string will be displayed in the console
1718 * window and program execution will be paused until the user presses a key.
1720 * This function always returns a false, so that functions which call this function
1721 * can have a line like "return (DispAllErrors(henv, hdbc));" to indicate the failure
1722 * of the users request, so that the calling code can then process the error msg log
1725 wxString odbcErrMsg
;
1728 while (SQLError(aHenv
, aHdbc
, aHstmt
, (SQLTCHAR FAR
*) sqlState
, (SQLINTEGER
*) &nativeError
, (SQLTCHAR FAR
*) errorMsg
, SQL_MAX_MESSAGE_LENGTH
- 1, &cbErrorMsg
) == SQL_SUCCESS
)
1730 while (SQLError(aHenv
, aHdbc
, aHstmt
, (SQLTCHAR FAR
*) sqlState
, (long*) &nativeError
, (SQLTCHAR FAR
*) errorMsg
, SQL_MAX_MESSAGE_LENGTH
- 1, &cbErrorMsg
) == SQL_SUCCESS
)
1733 odbcErrMsg
.Printf(wxT("SQL State = %s\nNative Error Code = %li\nError Message = %s\n"), sqlState
, nativeError
, errorMsg
);
1734 logError(odbcErrMsg
, sqlState
);
1737 #ifdef DBDEBUG_CONSOLE
1738 // When run in console mode, use standard out to display errors.
1739 cout
<< odbcErrMsg
.c_str() << endl
;
1740 cout
<< wxT("Press any key to continue...") << endl
;
1745 wxLogDebug(odbcErrMsg
,wxT("ODBC DEBUG MESSAGE from DispAllErrors()"));
1750 return false; // This function always returns false.
1752 } // wxDb::DispAllErrors()
1755 /********** wxDb::GetNextError() **********/
1756 bool wxDb::GetNextError(HENV aHenv
, HDBC aHdbc
, HSTMT aHstmt
)
1759 if (SQLError(aHenv
, aHdbc
, aHstmt
, (SQLTCHAR FAR
*) sqlState
, (SQLINTEGER
*) &nativeError
, (SQLTCHAR FAR
*) errorMsg
, SQL_MAX_MESSAGE_LENGTH
- 1, &cbErrorMsg
) == SQL_SUCCESS
)
1761 if (SQLError(aHenv
, aHdbc
, aHstmt
, (SQLTCHAR FAR
*) sqlState
, (long*) &nativeError
, (SQLTCHAR FAR
*) errorMsg
, SQL_MAX_MESSAGE_LENGTH
- 1, &cbErrorMsg
) == SQL_SUCCESS
)
1767 } // wxDb::GetNextError()
1770 /********** wxDb::DispNextError() **********/
1771 void wxDb::DispNextError(void)
1773 wxString odbcErrMsg
;
1775 odbcErrMsg
.Printf(wxT("SQL State = %s\nNative Error Code = %li\nError Message = %s\n"), sqlState
, nativeError
, errorMsg
);
1776 logError(odbcErrMsg
, sqlState
);
1781 #ifdef DBDEBUG_CONSOLE
1782 // When run in console mode, use standard out to display errors.
1783 cout
<< odbcErrMsg
.c_str() << endl
;
1784 cout
<< wxT("Press any key to continue...") << endl
;
1789 wxLogDebug(odbcErrMsg
,wxT("ODBC DEBUG MESSAGE"));
1790 #endif // __WXDEBUG__
1792 } // wxDb::DispNextError()
1795 /********** wxDb::logError() **********/
1796 void wxDb::logError(const wxString
&errMsg
, const wxString
&SQLState
)
1798 wxASSERT(errMsg
.Length());
1800 static int pLast
= -1;
1803 if (++pLast
== DB_MAX_ERROR_HISTORY
)
1806 for (i
= 0; i
< DB_MAX_ERROR_HISTORY
; i
++)
1807 wxStrcpy(errorList
[i
], errorList
[i
+1]);
1811 wxStrcpy(errorList
[pLast
], errMsg
);
1813 if (SQLState
.Length())
1814 if ((dbStatus
= TranslateSqlState(SQLState
)) != DB_ERR_FUNCTION_SEQUENCE_ERROR
)
1815 DB_STATUS
= dbStatus
;
1817 // Add the errmsg to the sql log
1818 WriteSqlLog(errMsg
);
1820 } // wxDb::logError()
1823 /**********wxDb::TranslateSqlState() **********/
1824 int wxDb::TranslateSqlState(const wxString
&SQLState
)
1826 if (!wxStrcmp(SQLState
, wxT("01000")))
1827 return(DB_ERR_GENERAL_WARNING
);
1828 if (!wxStrcmp(SQLState
, wxT("01002")))
1829 return(DB_ERR_DISCONNECT_ERROR
);
1830 if (!wxStrcmp(SQLState
, wxT("01004")))
1831 return(DB_ERR_DATA_TRUNCATED
);
1832 if (!wxStrcmp(SQLState
, wxT("01006")))
1833 return(DB_ERR_PRIV_NOT_REVOKED
);
1834 if (!wxStrcmp(SQLState
, wxT("01S00")))
1835 return(DB_ERR_INVALID_CONN_STR_ATTR
);
1836 if (!wxStrcmp(SQLState
, wxT("01S01")))
1837 return(DB_ERR_ERROR_IN_ROW
);
1838 if (!wxStrcmp(SQLState
, wxT("01S02")))
1839 return(DB_ERR_OPTION_VALUE_CHANGED
);
1840 if (!wxStrcmp(SQLState
, wxT("01S03")))
1841 return(DB_ERR_NO_ROWS_UPD_OR_DEL
);
1842 if (!wxStrcmp(SQLState
, wxT("01S04")))
1843 return(DB_ERR_MULTI_ROWS_UPD_OR_DEL
);
1844 if (!wxStrcmp(SQLState
, wxT("07001")))
1845 return(DB_ERR_WRONG_NO_OF_PARAMS
);
1846 if (!wxStrcmp(SQLState
, wxT("07006")))
1847 return(DB_ERR_DATA_TYPE_ATTR_VIOL
);
1848 if (!wxStrcmp(SQLState
, wxT("08001")))
1849 return(DB_ERR_UNABLE_TO_CONNECT
);
1850 if (!wxStrcmp(SQLState
, wxT("08002")))
1851 return(DB_ERR_CONNECTION_IN_USE
);
1852 if (!wxStrcmp(SQLState
, wxT("08003")))
1853 return(DB_ERR_CONNECTION_NOT_OPEN
);
1854 if (!wxStrcmp(SQLState
, wxT("08004")))
1855 return(DB_ERR_REJECTED_CONNECTION
);
1856 if (!wxStrcmp(SQLState
, wxT("08007")))
1857 return(DB_ERR_CONN_FAIL_IN_TRANS
);
1858 if (!wxStrcmp(SQLState
, wxT("08S01")))
1859 return(DB_ERR_COMM_LINK_FAILURE
);
1860 if (!wxStrcmp(SQLState
, wxT("21S01")))
1861 return(DB_ERR_INSERT_VALUE_LIST_MISMATCH
);
1862 if (!wxStrcmp(SQLState
, wxT("21S02")))
1863 return(DB_ERR_DERIVED_TABLE_MISMATCH
);
1864 if (!wxStrcmp(SQLState
, wxT("22001")))
1865 return(DB_ERR_STRING_RIGHT_TRUNC
);
1866 if (!wxStrcmp(SQLState
, wxT("22003")))
1867 return(DB_ERR_NUMERIC_VALUE_OUT_OF_RNG
);
1868 if (!wxStrcmp(SQLState
, wxT("22005")))
1869 return(DB_ERR_ERROR_IN_ASSIGNMENT
);
1870 if (!wxStrcmp(SQLState
, wxT("22008")))
1871 return(DB_ERR_DATETIME_FLD_OVERFLOW
);
1872 if (!wxStrcmp(SQLState
, wxT("22012")))
1873 return(DB_ERR_DIVIDE_BY_ZERO
);
1874 if (!wxStrcmp(SQLState
, wxT("22026")))
1875 return(DB_ERR_STR_DATA_LENGTH_MISMATCH
);
1876 if (!wxStrcmp(SQLState
, wxT("23000")))
1877 return(DB_ERR_INTEGRITY_CONSTRAINT_VIOL
);
1878 if (!wxStrcmp(SQLState
, wxT("24000")))
1879 return(DB_ERR_INVALID_CURSOR_STATE
);
1880 if (!wxStrcmp(SQLState
, wxT("25000")))
1881 return(DB_ERR_INVALID_TRANS_STATE
);
1882 if (!wxStrcmp(SQLState
, wxT("28000")))
1883 return(DB_ERR_INVALID_AUTH_SPEC
);
1884 if (!wxStrcmp(SQLState
, wxT("34000")))
1885 return(DB_ERR_INVALID_CURSOR_NAME
);
1886 if (!wxStrcmp(SQLState
, wxT("37000")))
1887 return(DB_ERR_SYNTAX_ERROR_OR_ACCESS_VIOL
);
1888 if (!wxStrcmp(SQLState
, wxT("3C000")))
1889 return(DB_ERR_DUPLICATE_CURSOR_NAME
);
1890 if (!wxStrcmp(SQLState
, wxT("40001")))
1891 return(DB_ERR_SERIALIZATION_FAILURE
);
1892 if (!wxStrcmp(SQLState
, wxT("42000")))
1893 return(DB_ERR_SYNTAX_ERROR_OR_ACCESS_VIOL2
);
1894 if (!wxStrcmp(SQLState
, wxT("70100")))
1895 return(DB_ERR_OPERATION_ABORTED
);
1896 if (!wxStrcmp(SQLState
, wxT("IM001")))
1897 return(DB_ERR_UNSUPPORTED_FUNCTION
);
1898 if (!wxStrcmp(SQLState
, wxT("IM002")))
1899 return(DB_ERR_NO_DATA_SOURCE
);
1900 if (!wxStrcmp(SQLState
, wxT("IM003")))
1901 return(DB_ERR_DRIVER_LOAD_ERROR
);
1902 if (!wxStrcmp(SQLState
, wxT("IM004")))
1903 return(DB_ERR_SQLALLOCENV_FAILED
);
1904 if (!wxStrcmp(SQLState
, wxT("IM005")))
1905 return(DB_ERR_SQLALLOCCONNECT_FAILED
);
1906 if (!wxStrcmp(SQLState
, wxT("IM006")))
1907 return(DB_ERR_SQLSETCONNECTOPTION_FAILED
);
1908 if (!wxStrcmp(SQLState
, wxT("IM007")))
1909 return(DB_ERR_NO_DATA_SOURCE_DLG_PROHIB
);
1910 if (!wxStrcmp(SQLState
, wxT("IM008")))
1911 return(DB_ERR_DIALOG_FAILED
);
1912 if (!wxStrcmp(SQLState
, wxT("IM009")))
1913 return(DB_ERR_UNABLE_TO_LOAD_TRANSLATION_DLL
);
1914 if (!wxStrcmp(SQLState
, wxT("IM010")))
1915 return(DB_ERR_DATA_SOURCE_NAME_TOO_LONG
);
1916 if (!wxStrcmp(SQLState
, wxT("IM011")))
1917 return(DB_ERR_DRIVER_NAME_TOO_LONG
);
1918 if (!wxStrcmp(SQLState
, wxT("IM012")))
1919 return(DB_ERR_DRIVER_KEYWORD_SYNTAX_ERROR
);
1920 if (!wxStrcmp(SQLState
, wxT("IM013")))
1921 return(DB_ERR_TRACE_FILE_ERROR
);
1922 if (!wxStrcmp(SQLState
, wxT("S0001")))
1923 return(DB_ERR_TABLE_OR_VIEW_ALREADY_EXISTS
);
1924 if (!wxStrcmp(SQLState
, wxT("S0002")))
1925 return(DB_ERR_TABLE_NOT_FOUND
);
1926 if (!wxStrcmp(SQLState
, wxT("S0011")))
1927 return(DB_ERR_INDEX_ALREADY_EXISTS
);
1928 if (!wxStrcmp(SQLState
, wxT("S0012")))
1929 return(DB_ERR_INDEX_NOT_FOUND
);
1930 if (!wxStrcmp(SQLState
, wxT("S0021")))
1931 return(DB_ERR_COLUMN_ALREADY_EXISTS
);
1932 if (!wxStrcmp(SQLState
, wxT("S0022")))
1933 return(DB_ERR_COLUMN_NOT_FOUND
);
1934 if (!wxStrcmp(SQLState
, wxT("S0023")))
1935 return(DB_ERR_NO_DEFAULT_FOR_COLUMN
);
1936 if (!wxStrcmp(SQLState
, wxT("S1000")))
1937 return(DB_ERR_GENERAL_ERROR
);
1938 if (!wxStrcmp(SQLState
, wxT("S1001")))
1939 return(DB_ERR_MEMORY_ALLOCATION_FAILURE
);
1940 if (!wxStrcmp(SQLState
, wxT("S1002")))
1941 return(DB_ERR_INVALID_COLUMN_NUMBER
);
1942 if (!wxStrcmp(SQLState
, wxT("S1003")))
1943 return(DB_ERR_PROGRAM_TYPE_OUT_OF_RANGE
);
1944 if (!wxStrcmp(SQLState
, wxT("S1004")))
1945 return(DB_ERR_SQL_DATA_TYPE_OUT_OF_RANGE
);
1946 if (!wxStrcmp(SQLState
, wxT("S1008")))
1947 return(DB_ERR_OPERATION_CANCELLED
);
1948 if (!wxStrcmp(SQLState
, wxT("S1009")))
1949 return(DB_ERR_INVALID_ARGUMENT_VALUE
);
1950 if (!wxStrcmp(SQLState
, wxT("S1010")))
1951 return(DB_ERR_FUNCTION_SEQUENCE_ERROR
);
1952 if (!wxStrcmp(SQLState
, wxT("S1011")))
1953 return(DB_ERR_OPERATION_INVALID_AT_THIS_TIME
);
1954 if (!wxStrcmp(SQLState
, wxT("S1012")))
1955 return(DB_ERR_INVALID_TRANS_OPERATION_CODE
);
1956 if (!wxStrcmp(SQLState
, wxT("S1015")))
1957 return(DB_ERR_NO_CURSOR_NAME_AVAIL
);
1958 if (!wxStrcmp(SQLState
, wxT("S1090")))
1959 return(DB_ERR_INVALID_STR_OR_BUF_LEN
);
1960 if (!wxStrcmp(SQLState
, wxT("S1091")))
1961 return(DB_ERR_DESCRIPTOR_TYPE_OUT_OF_RANGE
);
1962 if (!wxStrcmp(SQLState
, wxT("S1092")))
1963 return(DB_ERR_OPTION_TYPE_OUT_OF_RANGE
);
1964 if (!wxStrcmp(SQLState
, wxT("S1093")))
1965 return(DB_ERR_INVALID_PARAM_NO
);
1966 if (!wxStrcmp(SQLState
, wxT("S1094")))
1967 return(DB_ERR_INVALID_SCALE_VALUE
);
1968 if (!wxStrcmp(SQLState
, wxT("S1095")))
1969 return(DB_ERR_FUNCTION_TYPE_OUT_OF_RANGE
);
1970 if (!wxStrcmp(SQLState
, wxT("S1096")))
1971 return(DB_ERR_INF_TYPE_OUT_OF_RANGE
);
1972 if (!wxStrcmp(SQLState
, wxT("S1097")))
1973 return(DB_ERR_COLUMN_TYPE_OUT_OF_RANGE
);
1974 if (!wxStrcmp(SQLState
, wxT("S1098")))
1975 return(DB_ERR_SCOPE_TYPE_OUT_OF_RANGE
);
1976 if (!wxStrcmp(SQLState
, wxT("S1099")))
1977 return(DB_ERR_NULLABLE_TYPE_OUT_OF_RANGE
);
1978 if (!wxStrcmp(SQLState
, wxT("S1100")))
1979 return(DB_ERR_UNIQUENESS_OPTION_TYPE_OUT_OF_RANGE
);
1980 if (!wxStrcmp(SQLState
, wxT("S1101")))
1981 return(DB_ERR_ACCURACY_OPTION_TYPE_OUT_OF_RANGE
);
1982 if (!wxStrcmp(SQLState
, wxT("S1103")))
1983 return(DB_ERR_DIRECTION_OPTION_OUT_OF_RANGE
);
1984 if (!wxStrcmp(SQLState
, wxT("S1104")))
1985 return(DB_ERR_INVALID_PRECISION_VALUE
);
1986 if (!wxStrcmp(SQLState
, wxT("S1105")))
1987 return(DB_ERR_INVALID_PARAM_TYPE
);
1988 if (!wxStrcmp(SQLState
, wxT("S1106")))
1989 return(DB_ERR_FETCH_TYPE_OUT_OF_RANGE
);
1990 if (!wxStrcmp(SQLState
, wxT("S1107")))
1991 return(DB_ERR_ROW_VALUE_OUT_OF_RANGE
);
1992 if (!wxStrcmp(SQLState
, wxT("S1108")))
1993 return(DB_ERR_CONCURRENCY_OPTION_OUT_OF_RANGE
);
1994 if (!wxStrcmp(SQLState
, wxT("S1109")))
1995 return(DB_ERR_INVALID_CURSOR_POSITION
);
1996 if (!wxStrcmp(SQLState
, wxT("S1110")))
1997 return(DB_ERR_INVALID_DRIVER_COMPLETION
);
1998 if (!wxStrcmp(SQLState
, wxT("S1111")))
1999 return(DB_ERR_INVALID_BOOKMARK_VALUE
);
2000 if (!wxStrcmp(SQLState
, wxT("S1C00")))
2001 return(DB_ERR_DRIVER_NOT_CAPABLE
);
2002 if (!wxStrcmp(SQLState
, wxT("S1T00")))
2003 return(DB_ERR_TIMEOUT_EXPIRED
);
2008 } // wxDb::TranslateSqlState()
2011 /********** wxDb::Grant() **********/
2012 bool wxDb::Grant(int privileges
, const wxString
&tableName
, const wxString
&userList
)
2016 // Build the grant statement
2017 sqlStmt
= wxT("GRANT ");
2018 if (privileges
== DB_GRANT_ALL
)
2019 sqlStmt
+= wxT("ALL");
2023 if (privileges
& DB_GRANT_SELECT
)
2025 sqlStmt
+= wxT("SELECT");
2028 if (privileges
& DB_GRANT_INSERT
)
2031 sqlStmt
+= wxT(", ");
2032 sqlStmt
+= wxT("INSERT");
2034 if (privileges
& DB_GRANT_UPDATE
)
2037 sqlStmt
+= wxT(", ");
2038 sqlStmt
+= wxT("UPDATE");
2040 if (privileges
& DB_GRANT_DELETE
)
2043 sqlStmt
+= wxT(", ");
2044 sqlStmt
+= wxT("DELETE");
2048 sqlStmt
+= wxT(" ON ");
2049 sqlStmt
+= SQLTableName(tableName
);
2050 sqlStmt
+= wxT(" TO ");
2051 sqlStmt
+= userList
;
2053 #ifdef DBDEBUG_CONSOLE
2054 cout
<< endl
<< sqlStmt
.c_str() << endl
;
2057 WriteSqlLog(sqlStmt
);
2059 return(ExecSql(sqlStmt
));
2064 /********** wxDb::CreateView() **********/
2065 bool wxDb::CreateView(const wxString
&viewName
, const wxString
&colList
,
2066 const wxString
&pSqlStmt
, bool attemptDrop
)
2070 // Drop the view first
2071 if (attemptDrop
&& !DropView(viewName
))
2074 // Build the create view statement
2075 sqlStmt
= wxT("CREATE VIEW ");
2076 sqlStmt
+= viewName
;
2078 if (colList
.Length())
2080 sqlStmt
+= wxT(" (");
2082 sqlStmt
+= wxT(")");
2085 sqlStmt
+= wxT(" AS ");
2086 sqlStmt
+= pSqlStmt
;
2088 WriteSqlLog(sqlStmt
);
2090 #ifdef DBDEBUG_CONSOLE
2091 cout
<< sqlStmt
.c_str() << endl
;
2094 return(ExecSql(sqlStmt
));
2096 } // wxDb::CreateView()
2099 /********** wxDb::DropView() **********/
2100 bool wxDb::DropView(const wxString
&viewName
)
2103 * NOTE: This function returns true if the View does not exist, but
2104 * only for identified databases. Code will need to be added
2105 * below for any other databases when those databases are defined
2106 * to handle this situation consistently
2110 sqlStmt
.Printf(wxT("DROP VIEW %s"), viewName
.c_str());
2112 WriteSqlLog(sqlStmt
);
2114 #ifdef DBDEBUG_CONSOLE
2115 cout
<< endl
<< sqlStmt
.c_str() << endl
;
2118 if (SQLExecDirect(hstmt
, (SQLTCHAR FAR
*) sqlStmt
.c_str(), SQL_NTS
) != SQL_SUCCESS
)
2120 // Check for "Base table not found" error and ignore
2121 GetNextError(henv
, hdbc
, hstmt
);
2122 if (wxStrcmp(sqlState
,wxT("S0002"))) // "Base table not found"
2124 // Check for product specific error codes
2125 if (!((Dbms() == dbmsSYBASE_ASA
&& !wxStrcmp(sqlState
,wxT("42000"))))) // 5.x (and lower?)
2128 DispAllErrors(henv
, hdbc
, hstmt
);
2135 // Commit the transaction
2141 } // wxDb::DropView()
2144 /********** wxDb::ExecSql() **********/
2145 bool wxDb::ExecSql(const wxString
&pSqlStmt
)
2149 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2151 retcode
= SQLExecDirect(hstmt
, (SQLTCHAR FAR
*) pSqlStmt
.c_str(), SQL_NTS
);
2152 if (retcode
== SQL_SUCCESS
||
2153 (Dbms() == dbmsDB2
&& (retcode
== SQL_SUCCESS_WITH_INFO
|| retcode
== SQL_NO_DATA_FOUND
)))
2159 DispAllErrors(henv
, hdbc
, hstmt
);
2163 } // wxDb::ExecSql()
2166 /********** wxDb::GetNext() **********/
2167 bool wxDb::GetNext(void)
2169 if (SQLFetch(hstmt
) == SQL_SUCCESS
)
2173 DispAllErrors(henv
, hdbc
, hstmt
);
2177 } // wxDb::GetNext()
2180 /********** wxDb::GetData() **********/
2181 bool wxDb::GetData(UWORD colNo
, SWORD cType
, PTR pData
, SDWORD maxLen
, SDWORD FAR
*cbReturned
)
2184 wxASSERT(cbReturned
);
2186 long bufferSize
= maxLen
;
2188 if (cType
== SQL_C_WXCHAR
)
2189 bufferSize
= maxLen
* sizeof(wxChar
);
2191 if (SQLGetData(hstmt
, colNo
, cType
, pData
, bufferSize
, cbReturned
) == SQL_SUCCESS
)
2195 DispAllErrors(henv
, hdbc
, hstmt
);
2199 } // wxDb::GetData()
2202 /********** wxDb::GetKeyFields() **********/
2203 int wxDb::GetKeyFields(const wxString
&tableName
, wxDbColInf
* colInf
, UWORD noCols
)
2205 wxChar szPkTable
[DB_MAX_TABLE_NAME_LEN
+1]; /* Primary key table name */
2206 wxChar szFkTable
[DB_MAX_TABLE_NAME_LEN
+1]; /* Foreign key table name */
2208 // SQLSMALLINT iKeySeq;
2209 wxChar szPkCol
[DB_MAX_COLUMN_NAME_LEN
+1]; /* Primary key column */
2210 wxChar szFkCol
[DB_MAX_COLUMN_NAME_LEN
+1]; /* Foreign key column */
2216 * -----------------------------------------------------------------------
2217 * -- 19991224 : mj10777 : Create ------
2218 * -- : Three things are done and stored here : ------
2219 * -- : 1) which Column(s) is/are Primary Key(s) ------
2220 * -- : 2) which tables use this Key as a Foreign Key ------
2221 * -- : 3) which columns are Foreign Key and the name ------
2222 * -- : of the Table where the Key is the Primary Key -----
2223 * -- : Called from GetColumns(const wxString &tableName, ------
2224 * -- int *numCols,const wxChar *userID ) ------
2225 * -----------------------------------------------------------------------
2228 /*---------------------------------------------------------------------*/
2229 /* Get the names of the columns in the primary key. */
2230 /*---------------------------------------------------------------------*/
2231 retcode
= SQLPrimaryKeys(hstmt
,
2232 NULL
, 0, /* Catalog name */
2233 NULL
, 0, /* Schema name */
2234 (SQLTCHAR FAR
*) tableName
.c_str(), SQL_NTS
); /* Table name */
2236 /*---------------------------------------------------------------------*/
2237 /* Fetch and display the result set. This will be a list of the */
2238 /* columns in the primary key of the tableName table. */
2239 /*---------------------------------------------------------------------*/
2240 while ((retcode
== SQL_SUCCESS
) || (retcode
== SQL_SUCCESS_WITH_INFO
))
2242 retcode
= SQLFetch(hstmt
);
2243 if (retcode
== SQL_SUCCESS
|| retcode
== SQL_SUCCESS_WITH_INFO
)
2245 GetData( 4, SQL_C_WXCHAR
, szPkCol
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
2246 GetData( 5, SQL_C_SSHORT
, &iKeySeq
, 0, &cb
);
2248 for (i
=0;i
<noCols
;i
++) // Find the Column name
2249 if (!wxStrcmp(colInf
[i
].colName
,szPkCol
)) // We have found the Column
2250 colInf
[i
].PkCol
= iKeySeq
; // Which Primary Key is this (first, second usw.) ?
2253 SQLFreeStmt(hstmt
, SQL_CLOSE
); /* Close the cursor (the hstmt is still allocated). */
2255 /*---------------------------------------------------------------------*/
2256 /* Get all the foreign keys that refer to tableName primary key. */
2257 /*---------------------------------------------------------------------*/
2258 retcode
= SQLForeignKeys(hstmt
,
2259 NULL
, 0, /* Primary catalog */
2260 NULL
, 0, /* Primary schema */
2261 (SQLTCHAR FAR
*)tableName
.c_str(), SQL_NTS
,/* Primary table */
2262 NULL
, 0, /* Foreign catalog */
2263 NULL
, 0, /* Foreign schema */
2264 NULL
, 0); /* Foreign table */
2266 /*---------------------------------------------------------------------*/
2267 /* Fetch and display the result set. This will be all of the foreign */
2268 /* keys in other tables that refer to the tableName primary key. */
2269 /*---------------------------------------------------------------------*/
2272 while ((retcode
== SQL_SUCCESS
) || (retcode
== SQL_SUCCESS_WITH_INFO
))
2274 retcode
= SQLFetch(hstmt
);
2275 if (retcode
== SQL_SUCCESS
|| retcode
== SQL_SUCCESS_WITH_INFO
)
2277 GetData( 3, SQL_C_WXCHAR
, szPkTable
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
2278 GetData( 4, SQL_C_WXCHAR
, szPkCol
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
2279 GetData( 5, SQL_C_SSHORT
, &iKeySeq
, 0, &cb
);
2280 GetData( 7, SQL_C_WXCHAR
, szFkTable
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
2281 GetData( 8, SQL_C_WXCHAR
, szFkCol
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
2282 tempStr
.Printf(wxT("%s[%s] "),tempStr
.c_str(),szFkTable
); // [ ] in case there is a blank in the Table name
2286 tempStr
.Trim(); // Get rid of any unneeded blanks
2287 if (!tempStr
.IsEmpty())
2289 for (i
=0; i
<noCols
; i
++)
2290 { // Find the Column name
2291 if (!wxStrcmp(colInf
[i
].colName
, szPkCol
)) // We have found the Column, store the Information
2292 wxStrcpy(colInf
[i
].PkTableName
, tempStr
.c_str()); // Name of the Tables where this Primary Key is used as a Foreign Key
2296 SQLFreeStmt(hstmt
, SQL_CLOSE
); /* Close the cursor (the hstmt is still allocated). */
2298 /*---------------------------------------------------------------------*/
2299 /* Get all the foreign keys in the tablename table. */
2300 /*---------------------------------------------------------------------*/
2301 retcode
= SQLForeignKeys(hstmt
,
2302 NULL
, 0, /* Primary catalog */
2303 NULL
, 0, /* Primary schema */
2304 NULL
, 0, /* Primary table */
2305 NULL
, 0, /* Foreign catalog */
2306 NULL
, 0, /* Foreign schema */
2307 (SQLTCHAR
*)tableName
.c_str(), SQL_NTS
);/* Foreign table */
2309 /*---------------------------------------------------------------------*/
2310 /* Fetch and display the result set. This will be all of the */
2311 /* primary keys in other tables that are referred to by foreign */
2312 /* keys in the tableName table. */
2313 /*---------------------------------------------------------------------*/
2314 while ((retcode
== SQL_SUCCESS
) || (retcode
== SQL_SUCCESS_WITH_INFO
))
2316 retcode
= SQLFetch(hstmt
);
2317 if (retcode
== SQL_SUCCESS
|| retcode
== SQL_SUCCESS_WITH_INFO
)
2319 GetData( 3, SQL_C_WXCHAR
, szPkTable
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
2320 GetData( 5, SQL_C_SSHORT
, &iKeySeq
, 0, &cb
);
2321 GetData( 8, SQL_C_WXCHAR
, szFkCol
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
2323 for (i
=0; i
<noCols
; i
++) // Find the Column name
2325 if (!wxStrcmp(colInf
[i
].colName
,szFkCol
)) // We have found the (Foreign Key) Column
2327 colInf
[i
].FkCol
= iKeySeq
; // Which Foreign Key is this (first, second usw.) ?
2328 wxStrcpy(colInf
[i
].FkTableName
,szPkTable
); // Name of the Table where this Foriegn is the Primary Key
2333 SQLFreeStmt(hstmt
, SQL_CLOSE
); /* Close the cursor (the hstmt is still allocated). */
2337 } // wxDb::GetKeyFields()
2341 /********** wxDb::GetColumns() **********/
2342 wxDbColInf
*wxDb::GetColumns(wxChar
*tableName
[], const wxChar
*userID
)
2344 * 1) The last array element of the tableName[] argument must be zero (null).
2345 * This is how the end of the array is detected.
2346 * 2) This function returns an array of wxDbColInf structures. If no columns
2347 * were found, or an error occured, this pointer will be zero (null). THE
2348 * CALLING FUNCTION IS RESPONSIBLE FOR DELETING THE MEMORY RETURNED WHEN IT
2349 * IS FINISHED WITH IT. i.e.
2351 * wxDbColInf *colInf = pDb->GetColumns(tableList, userID);
2354 * // Use the column inf
2356 * // Destroy the memory
2360 * userID is evaluated in the following manner:
2361 * userID == NULL ... UserID is ignored
2362 * userID == "" ... UserID set equal to 'this->uid'
2363 * userID != "" ... UserID set equal to 'userID'
2365 * NOTE: ALL column bindings associated with this wxDb instance are unbound
2366 * by this function. This function should use its own wxDb instance
2367 * to avoid undesired unbinding of columns.
2372 wxDbColInf
*colInf
= 0;
2380 convertUserID(userID
,UserID
);
2382 // Pass 1 - Determine how many columns there are.
2383 // Pass 2 - Allocate the wxDbColInf array and fill in
2384 // the array with the column information.
2386 for (pass
= 1; pass
<= 2; pass
++)
2390 if (noCols
== 0) // Probably a bogus table name(s)
2392 // Allocate n wxDbColInf objects to hold the column information
2393 colInf
= new wxDbColInf
[noCols
+1];
2396 // Mark the end of the array
2397 wxStrcpy(colInf
[noCols
].tableName
,wxEmptyString
);
2398 wxStrcpy(colInf
[noCols
].colName
,wxEmptyString
);
2399 colInf
[noCols
].sqlDataType
= 0;
2401 // Loop through each table name
2403 for (tbl
= 0; tableName
[tbl
]; tbl
++)
2405 TableName
= tableName
[tbl
];
2406 // Oracle and Interbase table names are uppercase only, so force
2407 // the name to uppercase just in case programmer forgot to do this
2408 if ((Dbms() == dbmsORACLE
) ||
2409 (Dbms() == dbmsINTERBASE
))
2410 TableName
= TableName
.Upper();
2412 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2414 // MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
2415 // use the call below that leaves out the user name
2416 if (!UserID
.IsEmpty() &&
2417 Dbms() != dbmsMY_SQL
&&
2418 Dbms() != dbmsACCESS
&&
2419 Dbms() != dbmsMS_SQL_SERVER
)
2421 retcode
= SQLColumns(hstmt
,
2422 NULL
, 0, // All qualifiers
2423 (SQLTCHAR
*) UserID
.c_str(), SQL_NTS
, // Owner
2424 (SQLTCHAR
*) TableName
.c_str(), SQL_NTS
,
2425 NULL
, 0); // All columns
2429 retcode
= SQLColumns(hstmt
,
2430 NULL
, 0, // All qualifiers
2432 (SQLTCHAR
*) TableName
.c_str(), SQL_NTS
,
2433 NULL
, 0); // All columns
2435 if (retcode
!= SQL_SUCCESS
)
2436 { // Error occured, abort
2437 DispAllErrors(henv
, hdbc
, hstmt
);
2440 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2444 while ((retcode
= SQLFetch(hstmt
)) == SQL_SUCCESS
)
2446 if (pass
== 1) // First pass, just add up the number of columns
2448 else // Pass 2; Fill in the array of structures
2450 if (colNo
< noCols
) // Some extra error checking to prevent memory overwrites
2452 // NOTE: Only the ODBC 1.x fields are retrieved
2453 GetData( 1, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].catalog
, 128+1, &cb
);
2454 GetData( 2, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].schema
, 128+1, &cb
);
2455 GetData( 3, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].tableName
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
2456 GetData( 4, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].colName
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
2457 GetData( 5, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].sqlDataType
, 0, &cb
);
2458 GetData( 6, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].typeName
, 128+1, &cb
);
2459 GetData( 7, SQL_C_SLONG
, (UCHAR
*) &colInf
[colNo
].columnLength
, 0, &cb
);
2460 GetData( 8, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].bufferSize
, 0, &cb
);
2461 GetData( 9, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].decimalDigits
,0, &cb
);
2462 GetData(10, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].numPrecRadix
, 0, &cb
);
2463 GetData(11, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].nullable
, 0, &cb
);
2464 GetData(12, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].remarks
, 254+1, &cb
);
2466 // Determine the wxDb data type that is used to represent the native data type of this data source
2467 colInf
[colNo
].dbDataType
= 0;
2468 if (!wxStricmp(typeInfVarchar
.TypeName
,colInf
[colNo
].typeName
))
2471 // IODBC does not return a correct columnLength, so we set
2472 // columnLength = bufferSize if no column length was returned
2473 // IODBC returns the columnLength in bufferSize. (bug)
2474 if (colInf
[colNo
].columnLength
< 1)
2476 colInf
[colNo
].columnLength
= colInf
[colNo
].bufferSize
;
2479 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_VARCHAR
;
2481 else if (!wxStricmp(typeInfInteger
.TypeName
, colInf
[colNo
].typeName
))
2482 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_INTEGER
;
2483 else if (!wxStricmp(typeInfFloat
.TypeName
, colInf
[colNo
].typeName
))
2484 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_FLOAT
;
2485 else if (!wxStricmp(typeInfDate
.TypeName
, colInf
[colNo
].typeName
))
2486 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_DATE
;
2487 else if (!wxStricmp(typeInfBlob
.TypeName
, colInf
[colNo
].typeName
))
2488 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_BLOB
;
2493 if (retcode
!= SQL_NO_DATA_FOUND
)
2494 { // Error occured, abort
2495 DispAllErrors(henv
, hdbc
, hstmt
);
2498 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2504 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2507 } // wxDb::GetColumns()
2510 /********** wxDb::GetColumns() **********/
2512 wxDbColInf
*wxDb::GetColumns(const wxString
&tableName
, UWORD
*numCols
, const wxChar
*userID
)
2514 // Same as the above GetColumns() function except this one gets columns
2515 // only for a single table, and if 'numCols' is not NULL, the number of
2516 // columns stored in the returned wxDbColInf is set in '*numCols'
2518 // userID is evaluated in the following manner:
2519 // userID == NULL ... UserID is ignored
2520 // userID == "" ... UserID set equal to 'this->uid'
2521 // userID != "" ... UserID set equal to 'userID'
2523 // NOTE: ALL column bindings associated with this wxDb instance are unbound
2524 // by this function. This function should use its own wxDb instance
2525 // to avoid undesired unbinding of columns.
2530 wxDbColInf
*colInf
= 0;
2538 convertUserID(userID
,UserID
);
2540 // Pass 1 - Determine how many columns there are.
2541 // Pass 2 - Allocate the wxDbColInf array and fill in
2542 // the array with the column information.
2544 for (pass
= 1; pass
<= 2; pass
++)
2548 if (noCols
== 0) // Probably a bogus table name(s)
2550 // Allocate n wxDbColInf objects to hold the column information
2551 colInf
= new wxDbColInf
[noCols
+1];
2554 // Mark the end of the array
2555 wxStrcpy(colInf
[noCols
].tableName
, wxEmptyString
);
2556 wxStrcpy(colInf
[noCols
].colName
, wxEmptyString
);
2557 colInf
[noCols
].sqlDataType
= 0;
2560 TableName
= tableName
;
2561 // Oracle and Interbase table names are uppercase only, so force
2562 // the name to uppercase just in case programmer forgot to do this
2563 if ((Dbms() == dbmsORACLE
) ||
2564 (Dbms() == dbmsINTERBASE
))
2565 TableName
= TableName
.Upper();
2567 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2569 // MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
2570 // use the call below that leaves out the user name
2571 if (!UserID
.IsEmpty() &&
2572 Dbms() != dbmsMY_SQL
&&
2573 Dbms() != dbmsACCESS
&&
2574 Dbms() != dbmsMS_SQL_SERVER
)
2576 retcode
= SQLColumns(hstmt
,
2577 NULL
, 0, // All qualifiers
2578 (SQLTCHAR
*) UserID
.c_str(), SQL_NTS
, // Owner
2579 (SQLTCHAR
*) TableName
.c_str(), SQL_NTS
,
2580 NULL
, 0); // All columns
2584 retcode
= SQLColumns(hstmt
,
2585 NULL
, 0, // All qualifiers
2587 (SQLTCHAR
*) TableName
.c_str(), SQL_NTS
,
2588 NULL
, 0); // All columns
2590 if (retcode
!= SQL_SUCCESS
)
2591 { // Error occured, abort
2592 DispAllErrors(henv
, hdbc
, hstmt
);
2595 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2601 while ((retcode
= SQLFetch(hstmt
)) == SQL_SUCCESS
)
2603 if (pass
== 1) // First pass, just add up the number of columns
2605 else // Pass 2; Fill in the array of structures
2607 if (colNo
< noCols
) // Some extra error checking to prevent memory overwrites
2609 // NOTE: Only the ODBC 1.x fields are retrieved
2610 GetData( 1, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].catalog
, 128+1, &cb
);
2611 GetData( 2, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].schema
, 128+1, &cb
);
2612 GetData( 3, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].tableName
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
2613 GetData( 4, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].colName
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
2614 GetData( 5, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].sqlDataType
, 0, &cb
);
2615 GetData( 6, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].typeName
, 128+1, &cb
);
2616 GetData( 7, SQL_C_SLONG
, (UCHAR
*) &colInf
[colNo
].columnLength
, 0, &cb
);
2617 // BJO 991214 : SQL_C_SSHORT instead of SQL_C_SLONG, otherwise fails on Sparc (probably all 64 bit architectures)
2618 GetData( 8, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].bufferSize
, 0, &cb
);
2619 GetData( 9, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].decimalDigits
,0, &cb
);
2620 GetData(10, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].numPrecRadix
, 0, &cb
);
2621 GetData(11, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].nullable
, 0, &cb
);
2622 GetData(12, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].remarks
, 254+1, &cb
);
2623 // Start Values for Primary/Foriegn Key (=No)
2624 colInf
[colNo
].PkCol
= 0; // Primary key column 0=No; 1= First Key, 2 = Second Key etc.
2625 colInf
[colNo
].PkTableName
[0] = 0; // Tablenames where Primary Key is used as a Foreign Key
2626 colInf
[colNo
].FkCol
= 0; // Foreign key column 0=No; 1= First Key, 2 = Second Key etc.
2627 colInf
[colNo
].FkTableName
[0] = 0; // Foreign key table name
2629 // BJO 20000428 : Virtuoso returns type names with upper cases!
2630 if (Dbms() == dbmsVIRTUOSO
)
2632 wxString s
= colInf
[colNo
].typeName
;
2634 wxStrcmp(colInf
[colNo
].typeName
, s
.c_str());
2637 // Determine the wxDb data type that is used to represent the native data type of this data source
2638 colInf
[colNo
].dbDataType
= 0;
2639 if (!wxStricmp(typeInfVarchar
.TypeName
, colInf
[colNo
].typeName
))
2642 // IODBC does not return a correct columnLength, so we set
2643 // columnLength = bufferSize if no column length was returned
2644 // IODBC returns the columnLength in bufferSize. (bug)
2645 if (colInf
[colNo
].columnLength
< 1)
2647 colInf
[colNo
].columnLength
= colInf
[colNo
].bufferSize
;
2651 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_VARCHAR
;
2653 else if (!wxStricmp(typeInfInteger
.TypeName
, colInf
[colNo
].typeName
))
2654 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_INTEGER
;
2655 else if (!wxStricmp(typeInfFloat
.TypeName
, colInf
[colNo
].typeName
))
2656 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_FLOAT
;
2657 else if (!wxStricmp(typeInfDate
.TypeName
, colInf
[colNo
].typeName
))
2658 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_DATE
;
2659 else if (!wxStricmp(typeInfBlob
.TypeName
, colInf
[colNo
].typeName
))
2660 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_BLOB
;
2666 if (retcode
!= SQL_NO_DATA_FOUND
)
2667 { // Error occured, abort
2668 DispAllErrors(henv
, hdbc
, hstmt
);
2671 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2678 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2680 // Store Primary and Foriegn Keys
2681 GetKeyFields(tableName
,colInf
,noCols
);
2687 } // wxDb::GetColumns()
2690 #else // New GetColumns
2695 These are tentative new GetColumns members which should be more database
2696 independant and which always returns the columns in the order they were
2699 - The first one (wxDbColInf *wxDb::GetColumns(wxChar *tableName[], const
2700 wxChar* userID)) calls the second implementation for each separate table
2701 before merging the results. This makes the code easier to maintain as
2702 only one member (the second) makes the real work
2703 - wxDbColInf *wxDb::GetColumns(const wxString &tableName, int *numCols, const
2704 wxChar *userID) is a little bit improved
2705 - It doesn't anymore rely on the type-name to find out which database-type
2707 - It ends by sorting the columns, so that they are returned in the same
2708 order they were created
2718 wxDbColInf
*wxDb::GetColumns(wxChar
*tableName
[], const wxChar
*userID
)
2721 // The last array element of the tableName[] argument must be zero (null).
2722 // This is how the end of the array is detected.
2726 // How many tables ?
2728 for (tbl
= 0 ; tableName
[tbl
]; tbl
++);
2730 // Create a table to maintain the columns for each separate table
2731 _TableColumns
*TableColumns
= new _TableColumns
[tbl
];
2734 for (i
= 0 ; i
< tbl
; i
++)
2737 TableColumns
[i
].colInf
= GetColumns(tableName
[i
], &TableColumns
[i
].noCols
, userID
);
2738 if (TableColumns
[i
].colInf
== NULL
)
2740 noCols
+= TableColumns
[i
].noCols
;
2743 // Now merge all the separate table infos
2744 wxDbColInf
*colInf
= new wxDbColInf
[noCols
+1];
2746 // Mark the end of the array
2747 wxStrcpy(colInf
[noCols
].tableName
, wxEmptyString
);
2748 wxStrcpy(colInf
[noCols
].colName
, wxEmptyString
);
2749 colInf
[noCols
].sqlDataType
= 0;
2754 for (i
= 0 ; i
< tbl
; i
++)
2756 for (j
= 0 ; j
< TableColumns
[i
].noCols
; j
++)
2758 colInf
[offset
++] = TableColumns
[i
].colInf
[j
];
2762 delete [] TableColumns
;
2765 } // wxDb::GetColumns() -- NEW
2768 wxDbColInf
*wxDb::GetColumns(const wxString
&tableName
, int *numCols
, const wxChar
*userID
)
2770 // Same as the above GetColumns() function except this one gets columns
2771 // only for a single table, and if 'numCols' is not NULL, the number of
2772 // columns stored in the returned wxDbColInf is set in '*numCols'
2774 // userID is evaluated in the following manner:
2775 // userID == NULL ... UserID is ignored
2776 // userID == "" ... UserID set equal to 'this->uid'
2777 // userID != "" ... UserID set equal to 'userID'
2779 // NOTE: ALL column bindings associated with this wxDb instance are unbound
2780 // by this function. This function should use its own wxDb instance
2781 // to avoid undesired unbinding of columns.
2785 wxDbColInf
*colInf
= 0;
2793 convertUserID(userID
,UserID
);
2795 // Pass 1 - Determine how many columns there are.
2796 // Pass 2 - Allocate the wxDbColInf array and fill in
2797 // the array with the column information.
2799 for (pass
= 1; pass
<= 2; pass
++)
2803 if (noCols
== 0) // Probably a bogus table name(s)
2805 // Allocate n wxDbColInf objects to hold the column information
2806 colInf
= new wxDbColInf
[noCols
+1];
2809 // Mark the end of the array
2810 wxStrcpy(colInf
[noCols
].tableName
, wxEmptyString
);
2811 wxStrcpy(colInf
[noCols
].colName
, wxEmptyString
);
2812 colInf
[noCols
].sqlDataType
= 0;
2815 TableName
= tableName
;
2816 // Oracle and Interbase table names are uppercase only, so force
2817 // the name to uppercase just in case programmer forgot to do this
2818 if ((Dbms() == dbmsORACLE
) ||
2819 (Dbms() == dbmsINTERBASE
))
2820 TableName
= TableName
.Upper();
2822 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2824 // MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
2825 // use the call below that leaves out the user name
2826 if (!UserID
.IsEmpty() &&
2827 Dbms() != dbmsMY_SQL
&&
2828 Dbms() != dbmsACCESS
&&
2829 Dbms() != dbmsMS_SQL_SERVER
)
2831 retcode
= SQLColumns(hstmt
,
2832 NULL
, 0, // All qualifiers
2833 (UCHAR
*) UserID
.c_str(), SQL_NTS
, // Owner
2834 (UCHAR
*) TableName
.c_str(), SQL_NTS
,
2835 NULL
, 0); // All columns
2839 retcode
= SQLColumns(hstmt
,
2840 NULL
, 0, // All qualifiers
2842 (UCHAR
*) TableName
.c_str(), SQL_NTS
,
2843 NULL
, 0); // All columns
2845 if (retcode
!= SQL_SUCCESS
)
2846 { // Error occured, abort
2847 DispAllErrors(henv
, hdbc
, hstmt
);
2850 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2856 while ((retcode
= SQLFetch(hstmt
)) == SQL_SUCCESS
)
2858 if (pass
== 1) // First pass, just add up the number of columns
2860 else // Pass 2; Fill in the array of structures
2862 if (colNo
< noCols
) // Some extra error checking to prevent memory overwrites
2864 // NOTE: Only the ODBC 1.x fields are retrieved
2865 GetData( 1, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].catalog
, 128+1, &cb
);
2866 GetData( 2, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].schema
, 128+1, &cb
);
2867 GetData( 3, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].tableName
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
2868 GetData( 4, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].colName
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
2869 GetData( 5, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].sqlDataType
, 0, &cb
);
2870 GetData( 6, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].typeName
, 128+1, &cb
);
2871 GetData( 7, SQL_C_SLONG
, (UCHAR
*) &colInf
[colNo
].columnLength
, 0, &cb
);
2872 GetData( 8, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].bufferSize
, 0, &cb
);
2873 GetData( 9, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].decimalDigits
,0, &cb
);
2874 GetData(10, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].numPrecRadix
, 0, &cb
);
2875 GetData(11, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].nullable
, 0, &cb
);
2876 GetData(12, SQL_C_WXCHAR
, (UCHAR
*) colInf
[colNo
].remarks
, 254+1, &cb
);
2877 // Start Values for Primary/Foriegn Key (=No)
2878 colInf
[colNo
].PkCol
= 0; // Primary key column 0=No; 1= First Key, 2 = Second Key etc.
2879 colInf
[colNo
].PkTableName
[0] = 0; // Tablenames where Primary Key is used as a Foreign Key
2880 colInf
[colNo
].FkCol
= 0; // Foreign key column 0=No; 1= First Key, 2 = Second Key etc.
2881 colInf
[colNo
].FkTableName
[0] = 0; // Foreign key table name
2884 // IODBC does not return a correct columnLength, so we set
2885 // columnLength = bufferSize if no column length was returned
2886 // IODBC returns the columnLength in bufferSize. (bug)
2887 if (colInf
[colNo
].columnLength
< 1)
2889 colInf
[colNo
].columnLength
= colInf
[colNo
].bufferSize
;
2893 // Determine the wxDb data type that is used to represent the native data type of this data source
2894 colInf
[colNo
].dbDataType
= 0;
2895 // Get the intern datatype
2896 switch (colInf
[colNo
].sqlDataType
)
2900 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_VARCHAR
;
2906 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_INTEGER
;
2913 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_FLOAT
;
2916 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_DATE
;
2919 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_BLOB
;
2924 errMsg
.Printf(wxT("SQL Data type %d currently not supported by wxWidgets"), colInf
[colNo
].sqlDataType
);
2925 wxLogDebug(errMsg
,wxT("ODBC DEBUG MESSAGE"));
2932 if (retcode
!= SQL_NO_DATA_FOUND
)
2933 { // Error occured, abort
2934 DispAllErrors(henv
, hdbc
, hstmt
);
2937 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2944 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2946 // Store Primary and Foreign Keys
2947 GetKeyFields(tableName
,colInf
,noCols
);
2949 ///////////////////////////////////////////////////////////////////////////
2950 // Now sort the the columns in order to make them appear in the right order
2951 ///////////////////////////////////////////////////////////////////////////
2953 // Build a generic SELECT statement which returns 0 rows
2956 Stmt
.Printf(wxT("select * from \"%s\" where 0=1"), tableName
);
2959 if (SQLExecDirect(hstmt
, (UCHAR FAR
*) Stmt
.c_str(), SQL_NTS
) != SQL_SUCCESS
)
2961 DispAllErrors(henv
, hdbc
, hstmt
);
2965 // Get the number of result columns
2966 if (SQLNumResultCols (hstmt
, &noCols
) != SQL_SUCCESS
)
2968 DispAllErrors(henv
, hdbc
, hstmt
);
2972 if (noCols
== 0) // Probably a bogus table name
2981 for (colNum
= 0; colNum
< noCols
; colNum
++)
2983 if (SQLColAttributes(hstmt
,colNum
+1, SQL_COLUMN_NAME
,
2985 &Sword
, &Sdword
) != SQL_SUCCESS
)
2987 DispAllErrors(henv
, hdbc
, hstmt
);
2991 wxString Name1
= name
;
2992 Name1
= Name1
.Upper();
2994 // Where is this name in the array ?
2995 for (i
= colNum
; i
< noCols
; i
++)
2997 wxString Name2
= colInf
[i
].colName
;
2998 Name2
= Name2
.Upper();
3001 if (colNum
!= i
) // swap to sort
3003 wxDbColInf tmpColInf
= colInf
[colNum
];
3004 colInf
[colNum
] = colInf
[i
];
3005 colInf
[i
] = tmpColInf
;
3011 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3013 ///////////////////////////////////////////////////////////////////////////
3015 ///////////////////////////////////////////////////////////////////////////
3021 } // wxDb::GetColumns()
3024 #endif // #else OLD_GETCOLUMNS
3027 /********** wxDb::GetColumnCount() **********/
3028 int wxDb::GetColumnCount(const wxString
&tableName
, const wxChar
*userID
)
3030 * Returns a count of how many columns are in a table.
3031 * If an error occurs in computing the number of columns
3032 * this function will return a -1 for the count
3034 * userID is evaluated in the following manner:
3035 * userID == NULL ... UserID is ignored
3036 * userID == "" ... UserID set equal to 'this->uid'
3037 * userID != "" ... UserID set equal to 'userID'
3039 * NOTE: ALL column bindings associated with this wxDb instance are unbound
3040 * by this function. This function should use its own wxDb instance
3041 * to avoid undesired unbinding of columns.
3051 convertUserID(userID
,UserID
);
3053 TableName
= tableName
;
3054 // Oracle and Interbase table names are uppercase only, so force
3055 // the name to uppercase just in case programmer forgot to do this
3056 if ((Dbms() == dbmsORACLE
) ||
3057 (Dbms() == dbmsINTERBASE
))
3058 TableName
= TableName
.Upper();
3060 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3062 // MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
3063 // use the call below that leaves out the user name
3064 if (!UserID
.IsEmpty() &&
3065 Dbms() != dbmsMY_SQL
&&
3066 Dbms() != dbmsACCESS
&&
3067 Dbms() != dbmsMS_SQL_SERVER
)
3069 retcode
= SQLColumns(hstmt
,
3070 NULL
, 0, // All qualifiers
3071 (SQLTCHAR
*) UserID
.c_str(), SQL_NTS
, // Owner
3072 (SQLTCHAR
*) TableName
.c_str(), SQL_NTS
,
3073 NULL
, 0); // All columns
3077 retcode
= SQLColumns(hstmt
,
3078 NULL
, 0, // All qualifiers
3080 (SQLTCHAR
*) TableName
.c_str(), SQL_NTS
,
3081 NULL
, 0); // All columns
3083 if (retcode
!= SQL_SUCCESS
)
3084 { // Error occured, abort
3085 DispAllErrors(henv
, hdbc
, hstmt
);
3086 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3090 // Count the columns
3091 while ((retcode
= SQLFetch(hstmt
)) == SQL_SUCCESS
)
3094 if (retcode
!= SQL_NO_DATA_FOUND
)
3095 { // Error occured, abort
3096 DispAllErrors(henv
, hdbc
, hstmt
);
3097 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3101 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3104 } // wxDb::GetColumnCount()
3107 /********** wxDb::GetCatalog() *******/
3108 wxDbInf
*wxDb::GetCatalog(const wxChar
*userID
)
3110 * ---------------------------------------------------------------------
3111 * -- 19991203 : mj10777 : Create ------
3112 * -- : Creates a wxDbInf with Tables / Cols Array ------
3113 * -- : uses SQLTables and fills pTableInf; ------
3114 * -- : pColInf is set to NULL and numCols to 0; ------
3115 * -- : returns pDbInf (wxDbInf) ------
3116 * -- - if unsuccesfull (pDbInf == NULL) ------
3117 * -- : pColInf can be filled with GetColumns(..); ------
3118 * -- : numCols can be filled with GetColumnCount(..); ------
3119 * ---------------------------------------------------------------------
3121 * userID is evaluated in the following manner:
3122 * userID == NULL ... UserID is ignored
3123 * userID == "" ... UserID set equal to 'this->uid'
3124 * userID != "" ... UserID set equal to 'userID'
3126 * NOTE: ALL column bindings associated with this wxDb instance are unbound
3127 * by this function. This function should use its own wxDb instance
3128 * to avoid undesired unbinding of columns.
3131 int noTab
= 0; // Counter while filling table entries
3135 wxString tblNameSave
;
3138 convertUserID(userID
,UserID
);
3140 //-------------------------------------------------------------
3141 // Create the Database Array of catalog entries
3143 wxDbInf
*pDbInf
= new wxDbInf
;
3145 //-------------------------------------------------------------
3146 // Table Information
3147 // Pass 1 - Determine how many Tables there are.
3148 // Pass 2 - Create the Table array and fill it
3149 // - Create the Cols array = NULL
3150 //-------------------------------------------------------------
3152 for (pass
= 1; pass
<= 2; pass
++)
3154 SQLFreeStmt(hstmt
, SQL_CLOSE
); // Close if Open
3155 tblNameSave
.Empty();
3157 if (!UserID
.IsEmpty() &&
3158 Dbms() != dbmsMY_SQL
&&
3159 Dbms() != dbmsACCESS
&&
3160 Dbms() != dbmsMS_SQL_SERVER
)
3162 retcode
= SQLTables(hstmt
,
3163 NULL
, 0, // All qualifiers
3164 (SQLTCHAR
*) UserID
.c_str(), SQL_NTS
, // User specified
3165 NULL
, 0, // All tables
3166 NULL
, 0); // All columns
3170 retcode
= SQLTables(hstmt
,
3171 NULL
, 0, // All qualifiers
3172 NULL
, 0, // User specified
3173 NULL
, 0, // All tables
3174 NULL
, 0); // All columns
3177 if (retcode
!= SQL_SUCCESS
)
3179 DispAllErrors(henv
, hdbc
, hstmt
);
3181 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3185 while ((retcode
= SQLFetch(hstmt
)) == SQL_SUCCESS
) // Table Information
3187 if (pass
== 1) // First pass, just count the Tables
3189 if (pDbInf
->numTables
== 0)
3191 GetData( 1, SQL_C_WXCHAR
, (UCHAR
*) pDbInf
->catalog
, 128+1, &cb
);
3192 GetData( 2, SQL_C_WXCHAR
, (UCHAR
*) pDbInf
->schema
, 128+1, &cb
);
3194 pDbInf
->numTables
++; // Counter for Tables
3196 if (pass
== 2) // Create and fill the Table entries
3198 if (pDbInf
->pTableInf
== NULL
) // Has the Table Array been created
3199 { // no, then create the Array
3200 pDbInf
->pTableInf
= new wxDbTableInf
[pDbInf
->numTables
];
3202 } // if (pDbInf->pTableInf == NULL) // Has the Table Array been created
3204 GetData( 3, SQL_C_WXCHAR
, (UCHAR
*) (pDbInf
->pTableInf
+noTab
)->tableName
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
3205 GetData( 4, SQL_C_WXCHAR
, (UCHAR
*) (pDbInf
->pTableInf
+noTab
)->tableType
, 30+1, &cb
);
3206 GetData( 5, SQL_C_WXCHAR
, (UCHAR
*) (pDbInf
->pTableInf
+noTab
)->tableRemarks
, 254+1, &cb
);
3212 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3214 // Query how many columns are in each table
3215 for (noTab
=0;noTab
<pDbInf
->numTables
;noTab
++)
3217 (pDbInf
->pTableInf
+noTab
)->numCols
= (UWORD
)GetColumnCount((pDbInf
->pTableInf
+noTab
)->tableName
,UserID
);
3222 } // wxDb::GetCatalog()
3225 /********** wxDb::Catalog() **********/
3226 bool wxDb::Catalog(const wxChar
*userID
, const wxString
&fileName
)
3228 * Creates the text file specified in 'filename' which will contain
3229 * a minimal data dictionary of all tables accessible by the user specified
3232 * userID is evaluated in the following manner:
3233 * userID == NULL ... UserID is ignored
3234 * userID == "" ... UserID set equal to 'this->uid'
3235 * userID != "" ... UserID set equal to 'userID'
3237 * NOTE: ALL column bindings associated with this wxDb instance are unbound
3238 * by this function. This function should use its own wxDb instance
3239 * to avoid undesired unbinding of columns.
3242 wxASSERT(fileName
.Length());
3246 wxChar tblName
[DB_MAX_TABLE_NAME_LEN
+1];
3247 wxString tblNameSave
;
3248 wxChar colName
[DB_MAX_COLUMN_NAME_LEN
+1];
3250 wxChar typeName
[30+1];
3251 SDWORD precision
, length
;
3253 FILE *fp
= wxFopen(fileName
.c_str(),wxT("wt"));
3257 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3260 convertUserID(userID
,UserID
);
3262 if (!UserID
.IsEmpty() &&
3263 Dbms() != dbmsMY_SQL
&&
3264 Dbms() != dbmsACCESS
&&
3265 Dbms() != dbmsINTERBASE
&&
3266 Dbms() != dbmsMS_SQL_SERVER
)
3268 retcode
= SQLColumns(hstmt
,
3269 NULL
, 0, // All qualifiers
3270 (SQLTCHAR
*) UserID
.c_str(), SQL_NTS
, // User specified
3271 NULL
, 0, // All tables
3272 NULL
, 0); // All columns
3276 retcode
= SQLColumns(hstmt
,
3277 NULL
, 0, // All qualifiers
3278 NULL
, 0, // User specified
3279 NULL
, 0, // All tables
3280 NULL
, 0); // All columns
3282 if (retcode
!= SQL_SUCCESS
)
3284 DispAllErrors(henv
, hdbc
, hstmt
);
3290 tblNameSave
.Empty();
3295 retcode
= SQLFetch(hstmt
);
3296 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
3299 GetData(3,SQL_C_WXCHAR
, (UCHAR
*) tblName
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
3300 GetData(4,SQL_C_WXCHAR
, (UCHAR
*) colName
, DB_MAX_COLUMN_NAME_LEN
+1,&cb
);
3301 GetData(5,SQL_C_SSHORT
, (UCHAR
*)&sqlDataType
, 0, &cb
);
3302 GetData(6,SQL_C_WXCHAR
, (UCHAR
*) typeName
, sizeof(typeName
), &cb
);
3303 GetData(7,SQL_C_SLONG
, (UCHAR
*)&precision
, 0, &cb
);
3304 GetData(8,SQL_C_SLONG
, (UCHAR
*)&length
, 0, &cb
);
3306 if (wxStrcmp(tblName
, tblNameSave
.c_str()))
3309 wxFputs(wxT("\n"), fp
);
3310 wxFputs(wxT("================================ "), fp
);
3311 wxFputs(wxT("================================ "), fp
);
3312 wxFputs(wxT("===================== "), fp
);
3313 wxFputs(wxT("========= "), fp
);
3314 wxFputs(wxT("=========\n"), fp
);
3315 outStr
.Printf(wxT("%-32s %-32s %-21s %9s %9s\n"),
3316 wxT("TABLE NAME"), wxT("COLUMN NAME"), wxT("DATA TYPE"), wxT("PRECISION"), wxT("LENGTH"));
3317 wxFputs(outStr
.c_str(), fp
);
3318 wxFputs(wxT("================================ "), fp
);
3319 wxFputs(wxT("================================ "), fp
);
3320 wxFputs(wxT("===================== "), fp
);
3321 wxFputs(wxT("========= "), fp
);
3322 wxFputs(wxT("=========\n"), fp
);
3323 tblNameSave
= tblName
;
3326 outStr
.Printf(wxT("%-32s %-32s (%04d)%-15s %9ld %9ld\n"),
3327 tblName
, colName
, sqlDataType
, typeName
, precision
, length
);
3328 if (wxFputs(outStr
.c_str(), fp
) == EOF
)
3330 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3337 if (retcode
!= SQL_NO_DATA_FOUND
)
3338 DispAllErrors(henv
, hdbc
, hstmt
);
3340 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3343 return(retcode
== SQL_NO_DATA_FOUND
);
3345 } // wxDb::Catalog()
3348 bool wxDb::TableExists(const wxString
&tableName
, const wxChar
*userID
, const wxString
&tablePath
)
3350 * Table name can refer to a table, view, alias or synonym. Returns true
3351 * if the object exists in the database. This function does not indicate
3352 * whether or not the user has privleges to query or perform other functions
3355 * userID is evaluated in the following manner:
3356 * userID == NULL ... UserID is ignored
3357 * userID == "" ... UserID set equal to 'this->uid'
3358 * userID != "" ... UserID set equal to 'userID'
3361 wxASSERT(tableName
.Length());
3365 if (Dbms() == dbmsDBASE
)
3368 if (tablePath
.Length())
3369 dbName
.Printf(wxT("%s/%s.dbf"), tablePath
.c_str(), tableName
.c_str());
3371 dbName
.Printf(wxT("%s.dbf"), tableName
.c_str());
3374 exists
= wxFileExists(dbName
);
3379 convertUserID(userID
,UserID
);
3381 TableName
= tableName
;
3382 // Oracle and Interbase table names are uppercase only, so force
3383 // the name to uppercase just in case programmer forgot to do this
3384 if ((Dbms() == dbmsORACLE
) ||
3385 (Dbms() == dbmsINTERBASE
))
3386 TableName
= TableName
.Upper();
3388 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3391 // Some databases cannot accept a user name when looking up table names,
3392 // so we use the call below that leaves out the user name
3393 if (!UserID
.IsEmpty() &&
3394 Dbms() != dbmsMY_SQL
&&
3395 Dbms() != dbmsACCESS
&&
3396 Dbms() != dbmsMS_SQL_SERVER
&&
3397 Dbms() != dbmsDB2
&&
3398 Dbms() != dbmsINTERBASE
&&
3399 Dbms() != dbmsPERVASIVE_SQL
)
3401 retcode
= SQLTables(hstmt
,
3402 NULL
, 0, // All qualifiers
3403 (SQLTCHAR
*) UserID
.c_str(), SQL_NTS
, // Only tables owned by this user
3404 (SQLTCHAR FAR
*)TableName
.c_str(), SQL_NTS
,
3405 NULL
, 0); // All table types
3409 retcode
= SQLTables(hstmt
,
3410 NULL
, 0, // All qualifiers
3411 NULL
, 0, // All owners
3412 (SQLTCHAR FAR
*)TableName
.c_str(), SQL_NTS
,
3413 NULL
, 0); // All table types
3415 if (retcode
!= SQL_SUCCESS
)
3416 return(DispAllErrors(henv
, hdbc
, hstmt
));
3418 retcode
= SQLFetch(hstmt
);
3419 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
3421 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3422 return(DispAllErrors(henv
, hdbc
, hstmt
));
3425 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3429 } // wxDb::TableExists()
3432 /********** wxDb::TablePrivileges() **********/
3433 bool wxDb::TablePrivileges(const wxString
&tableName
, const wxString
&priv
, const wxChar
*userID
,
3434 const wxChar
*schema
, const wxString
&WXUNUSED(tablePath
))
3436 wxASSERT(tableName
.Length());
3438 wxDbTablePrivilegeInfo result
;
3442 // We probably need to be able to dynamically set this based on
3443 // the driver type, and state.
3444 wxChar curRole
[]=wxT("public");
3448 wxString UserID
,Schema
;
3449 convertUserID(userID
,UserID
);
3450 convertUserID(schema
,Schema
);
3452 TableName
= tableName
;
3453 // Oracle and Interbase table names are uppercase only, so force
3454 // the name to uppercase just in case programmer forgot to do this
3455 if ((Dbms() == dbmsORACLE
) ||
3456 (Dbms() == dbmsINTERBASE
))
3457 TableName
= TableName
.Upper();
3459 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3461 // Some databases cannot accept a user name when looking up table names,
3462 // so we use the call below that leaves out the user name
3463 if (!Schema
.IsEmpty() &&
3464 Dbms() != dbmsMY_SQL
&&
3465 Dbms() != dbmsACCESS
&&
3466 Dbms() != dbmsMS_SQL_SERVER
)
3468 retcode
= SQLTablePrivileges(hstmt
,
3470 (SQLTCHAR FAR
*)Schema
.c_str(), SQL_NTS
, // Schema
3471 (SQLTCHAR FAR
*)TableName
.c_str(), SQL_NTS
);
3475 retcode
= SQLTablePrivileges(hstmt
,
3478 (SQLTCHAR FAR
*)TableName
.c_str(), SQL_NTS
);
3481 #ifdef DBDEBUG_CONSOLE
3482 wxFprintf(stderr
,wxT("SQLTablePrivileges() returned %i \n"),retcode
);
3485 if ((retcode
!= SQL_SUCCESS
) && (retcode
!= SQL_SUCCESS_WITH_INFO
))
3486 return (DispAllErrors(henv
, hdbc
, hstmt
));
3488 bool failed
= false;
3489 retcode
= SQLFetch(hstmt
);
3490 while (retcode
== SQL_SUCCESS
|| retcode
== SQL_SUCCESS_WITH_INFO
)
3492 if (SQLGetData(hstmt
, 1, SQL_C_WXCHAR
, (UCHAR
*) result
.tableQual
, sizeof(result
.tableQual
), &cbRetVal
) != SQL_SUCCESS
)
3495 if (!failed
&& SQLGetData(hstmt
, 2, SQL_C_WXCHAR
, (UCHAR
*) result
.tableOwner
, sizeof(result
.tableOwner
), &cbRetVal
) != SQL_SUCCESS
)
3498 if (!failed
&& SQLGetData(hstmt
, 3, SQL_C_WXCHAR
, (UCHAR
*) result
.tableName
, sizeof(result
.tableName
), &cbRetVal
) != SQL_SUCCESS
)
3501 if (!failed
&& SQLGetData(hstmt
, 4, SQL_C_WXCHAR
, (UCHAR
*) result
.grantor
, sizeof(result
.grantor
), &cbRetVal
) != SQL_SUCCESS
)
3504 if (!failed
&& SQLGetData(hstmt
, 5, SQL_C_WXCHAR
, (UCHAR
*) result
.grantee
, sizeof(result
.grantee
), &cbRetVal
) != SQL_SUCCESS
)
3507 if (!failed
&& SQLGetData(hstmt
, 6, SQL_C_WXCHAR
, (UCHAR
*) result
.privilege
, sizeof(result
.privilege
), &cbRetVal
) != SQL_SUCCESS
)
3510 if (!failed
&& SQLGetData(hstmt
, 7, SQL_C_WXCHAR
, (UCHAR
*) result
.grantable
, sizeof(result
.grantable
), &cbRetVal
) != SQL_SUCCESS
)
3515 return(DispAllErrors(henv
, hdbc
, hstmt
));
3517 #ifdef DBDEBUG_CONSOLE
3518 wxFprintf(stderr
,wxT("Scanning %s privilege on table %s.%s granted by %s to %s\n"),
3519 result
.privilege
,result
.tableOwner
,result
.tableName
,
3520 result
.grantor
, result
.grantee
);
3523 if (UserID
.IsSameAs(result
.tableOwner
,false))
3525 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3529 if (UserID
.IsSameAs(result
.grantee
,false) &&
3530 !wxStrcmp(result
.privilege
,priv
))
3532 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3536 if (!wxStrcmp(result
.grantee
,curRole
) &&
3537 !wxStrcmp(result
.privilege
,priv
))
3539 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3543 retcode
= SQLFetch(hstmt
);
3546 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3549 } // wxDb::TablePrivileges
3552 const wxString
wxDb::SQLTableName(const wxChar
*tableName
)
3556 if (Dbms() == dbmsACCESS
)
3557 TableName
= _T("\"");
3558 TableName
+= tableName
;
3559 if (Dbms() == dbmsACCESS
)
3560 TableName
+= _T("\"");
3563 } // wxDb::SQLTableName()
3566 const wxString
wxDb::SQLColumnName(const wxChar
*colName
)
3570 if (Dbms() == dbmsACCESS
)
3573 if (Dbms() == dbmsACCESS
)
3574 ColName
+= _T("\"");
3577 } // wxDb::SQLColumnName()
3580 /********** wxDb::SetSqlLogging() **********/
3581 bool wxDb::SetSqlLogging(wxDbSqlLogState state
, const wxString
&filename
, bool append
)
3583 wxASSERT(state
== sqlLogON
|| state
== sqlLogOFF
);
3584 wxASSERT(state
== sqlLogOFF
|| filename
.Length());
3586 if (state
== sqlLogON
)
3590 fpSqlLog
= wxFopen(filename
, (append
? wxT("at") : wxT("wt")));
3591 if (fpSqlLog
== NULL
)
3599 if (fclose(fpSqlLog
))
3605 sqlLogState
= state
;
3608 } // wxDb::SetSqlLogging()
3611 /********** wxDb::WriteSqlLog() **********/
3612 bool wxDb::WriteSqlLog(const wxString
&logMsg
)
3614 wxASSERT(logMsg
.Length());
3616 if (fpSqlLog
== 0 || sqlLogState
== sqlLogOFF
)
3619 if (wxFputs(wxT("\n"), fpSqlLog
) == EOF
)
3621 if (wxFputs(logMsg
, fpSqlLog
) == EOF
)
3623 if (wxFputs(wxT("\n"), fpSqlLog
) == EOF
)
3628 } // wxDb::WriteSqlLog()
3631 /********** wxDb::Dbms() **********/
3632 wxDBMS
wxDb::Dbms(void)
3634 * Be aware that not all database engines use the exact same syntax, and not
3635 * every ODBC compliant database is compliant to the same level of compliancy.
3636 * Some manufacturers support the minimum Level 1 compliancy, and others up
3637 * through Level 3. Others support subsets of features for levels above 1.
3639 * If you find an inconsistency between the wxDb class and a specific database
3640 * engine, and an identifier to this section, and special handle the database in
3641 * the area where behavior is non-conforming with the other databases.
3644 * NOTES ABOUT ISSUES SPECIFIC TO EACH DATABASE ENGINE
3645 * ---------------------------------------------------
3648 * - Currently the only database supported by the class to support VIEWS
3651 * - Does not support the SQL_TIMESTAMP structure
3652 * - Supports only one cursor and one connect (apparently? with Microsoft driver only?)
3653 * - Does not automatically create the primary index if the 'keyField' param of SetColDef
3654 * is true. The user must create ALL indexes from their program.
3655 * - Table names can only be 8 characters long
3656 * - Column names can only be 10 characters long
3659 * - To lock a record during QUERY functions, the reserved word 'HOLDLOCK' must be added
3660 * after every table name involved in the query/join if that tables matching record(s)
3662 * - Ignores the keywords 'FOR UPDATE'. Use the HOLDLOCK functionality described above
3664 * SYBASE (Enterprise)
3665 * - If a column is part of the Primary Key, the column cannot be NULL
3666 * - Maximum row size is somewhere in the neighborhood of 1920 bytes
3669 * - If a column is part of the Primary Key, the column cannot be NULL
3670 * - Cannot support selecting for update [::CanSelectForUpdate()]. Always returns FALSE
3671 * - Columns that are part of primary or secondary keys must be defined as being NOT NULL
3672 * when they are created. Some code is added in ::CreateIndex to try to adjust the
3673 * column definition if it is not defined correctly, but it is experimental
3674 * - Does not support sub-queries in SQL statements
3677 * - Does not support the keywords 'ASC' or 'DESC' as of release v6.5.0
3678 * - Does not support sub-queries in SQL statements
3681 * - Primary keys must be declared as NOT NULL
3682 * - Table and index names must not be longer than 13 characters in length (technically
3683 * table names can be up to 18 characters, but the primary index is created using the
3684 * base table name plus "_PIDX", so the limit if the table has a primary index is 13.
3689 * - Columns that are part of primary keys must be defined as being NOT NULL
3690 * when they are created. Some code is added in ::CreateIndex to try to adjust the
3691 * column definition if it is not defined correctly, but it is experimental
3694 // Should only need to do this once for each new database connection
3695 // so return the value we already determined it to be to save time
3696 // and lots of string comparisons
3697 if (dbmsType
!= dbmsUNIDENTIFIED
)
3700 wxChar baseName
[25+1];
3701 wxStrncpy(baseName
,dbInf
.dbmsName
,25);
3704 // RGG 20001025 : add support for Interbase
3705 // GT : Integrated to base classes on 20001121
3706 if (!wxStricmp(dbInf
.dbmsName
,wxT("Interbase")))
3707 return((wxDBMS
)(dbmsType
= dbmsINTERBASE
));
3709 // BJO 20000428 : add support for Virtuoso
3710 if (!wxStricmp(dbInf
.dbmsName
,wxT("OpenLink Virtuoso VDBMS")))
3711 return((wxDBMS
)(dbmsType
= dbmsVIRTUOSO
));
3713 if (!wxStricmp(dbInf
.dbmsName
,wxT("Adaptive Server Anywhere")))
3714 return((wxDBMS
)(dbmsType
= dbmsSYBASE_ASA
));
3716 // BJO 20000427 : The "SQL Server" string is also returned by SQLServer when
3717 // connected through an OpenLink driver.
3718 // Is it also returned by Sybase Adapatitve server?
3719 // OpenLink driver name is OLOD3032.DLL for msw and oplodbc.so for unix
3720 if (!wxStricmp(dbInf
.dbmsName
,wxT("SQL Server")))
3722 if (!wxStrncmp(dbInf
.driverName
, wxT("oplodbc"), 7) ||
3723 !wxStrncmp(dbInf
.driverName
, wxT("OLOD"), 4))
3724 return ((wxDBMS
)(dbmsMS_SQL_SERVER
));
3726 return ((wxDBMS
)(dbmsType
= dbmsSYBASE_ASE
));
3729 if (!wxStricmp(dbInf
.dbmsName
,wxT("Microsoft SQL Server")))
3730 return((wxDBMS
)(dbmsType
= dbmsMS_SQL_SERVER
));
3733 if (!wxStricmp(baseName
,wxT("PostgreSQL"))) // v6.5.0
3734 return((wxDBMS
)(dbmsType
= dbmsPOSTGRES
));
3737 if (!wxStricmp(baseName
,wxT("Pervasive")))
3738 return((wxDBMS
)(dbmsType
= dbmsPERVASIVE_SQL
));
3741 if (!wxStricmp(baseName
,wxT("Informix")))
3742 return((wxDBMS
)(dbmsType
= dbmsINFORMIX
));
3745 if (!wxStricmp(baseName
,wxT("Oracle")))
3746 return((wxDBMS
)(dbmsType
= dbmsORACLE
));
3747 if (!wxStricmp(baseName
,wxT("ACCESS")))
3748 return((wxDBMS
)(dbmsType
= dbmsACCESS
));
3749 if (!wxStricmp(baseName
,wxT("Sybase")))
3750 return((wxDBMS
)(dbmsType
= dbmsSYBASE_ASE
));
3753 if (!wxStricmp(baseName
,wxT("DBASE")))
3754 return((wxDBMS
)(dbmsType
= dbmsDBASE
));
3755 if (!wxStricmp(baseName
,wxT("xBase")))
3756 return((wxDBMS
)(dbmsType
= dbmsXBASE_SEQUITER
));
3757 if (!wxStricmp(baseName
,wxT("MySQL")))
3758 return((wxDBMS
)(dbmsType
= dbmsMY_SQL
));
3761 if (!wxStricmp(baseName
,wxT("DB2")))
3762 return((wxDBMS
)(dbmsType
= dbmsDBASE
));
3764 return((wxDBMS
)(dbmsType
= dbmsUNIDENTIFIED
));
3769 bool wxDb::ModifyColumn(const wxString
&tableName
, const wxString
&columnName
,
3770 int dataType
, ULONG columnLength
,
3771 const wxString
&optionalParam
)
3773 wxASSERT(tableName
.Length());
3774 wxASSERT(columnName
.Length());
3775 wxASSERT((dataType
== DB_DATA_TYPE_VARCHAR
&& columnLength
> 0) ||
3776 dataType
!= DB_DATA_TYPE_VARCHAR
);
3778 // Must specify a columnLength if modifying a VARCHAR type column
3779 if (dataType
== DB_DATA_TYPE_VARCHAR
&& !columnLength
)
3782 wxString dataTypeName
;
3784 wxString alterSlashModify
;
3788 case DB_DATA_TYPE_VARCHAR
:
3789 dataTypeName
= typeInfVarchar
.TypeName
;
3791 case DB_DATA_TYPE_INTEGER
:
3792 dataTypeName
= typeInfInteger
.TypeName
;
3794 case DB_DATA_TYPE_FLOAT
:
3795 dataTypeName
= typeInfFloat
.TypeName
;
3797 case DB_DATA_TYPE_DATE
:
3798 dataTypeName
= typeInfDate
.TypeName
;
3800 case DB_DATA_TYPE_BLOB
:
3801 dataTypeName
= typeInfBlob
.TypeName
;
3807 // Set the modify or alter syntax depending on the type of database connected to
3811 alterSlashModify
= _T("MODIFY");
3813 case dbmsMS_SQL_SERVER
:
3814 alterSlashModify
= _T("ALTER COLUMN");
3816 case dbmsUNIDENTIFIED
:
3818 case dbmsSYBASE_ASA
:
3819 case dbmsSYBASE_ASE
:
3824 case dbmsXBASE_SEQUITER
:
3826 alterSlashModify
= _T("MODIFY");
3830 // create the SQL statement
3831 if ( Dbms() == dbmsMY_SQL
)
3833 sqlStmt
.Printf(wxT("ALTER TABLE %s %s %s %s"), tableName
.c_str(), alterSlashModify
.c_str(),
3834 columnName
.c_str(), dataTypeName
.c_str());
3838 sqlStmt
.Printf(wxT("ALTER TABLE \"%s\" \"%s\" \"%s\" %s"), tableName
.c_str(), alterSlashModify
.c_str(),
3839 columnName
.c_str(), dataTypeName
.c_str());
3842 // For varchars only, append the size of the column
3843 if (dataType
== DB_DATA_TYPE_VARCHAR
&&
3844 (Dbms() != dbmsMY_SQL
|| dataTypeName
!= _T("text")))
3847 s
.Printf(wxT("(%lu)"), columnLength
);
3851 // for passing things like "NOT NULL"
3852 if (optionalParam
.Length())
3854 sqlStmt
+= wxT(" ");
3855 sqlStmt
+= optionalParam
;
3858 return ExecSql(sqlStmt
);
3860 } // wxDb::ModifyColumn()
3863 /********** wxDbGetConnection() **********/
3864 wxDb WXDLLIMPEXP_ODBC
*wxDbGetConnection(wxDbConnectInf
*pDbConfig
, bool FwdOnlyCursors
)
3868 // Used to keep a pointer to a DB connection that matches the requested
3869 // DSN and FwdOnlyCursors settings, even if it is not FREE, so that the
3870 // data types can be copied from it (using the wxDb::Open(wxDb *) function)
3871 // rather than having to re-query the datasource to get all the values
3872 // using the wxDb::Open(Dsn,Uid,AuthStr) function
3873 wxDb
*matchingDbConnection
= NULL
;
3875 // Scan the linked list searching for an available database connection
3876 // that's already been opened but is currently not in use.
3877 for (pList
= PtrBegDbList
; pList
; pList
= pList
->PtrNext
)
3879 // The database connection must be for the same datasource
3880 // name and must currently not be in use.
3882 (pList
->PtrDb
->FwdOnlyCursors() == FwdOnlyCursors
))
3884 if (pDbConfig
->UseConnectionStr())
3886 if (pList
->PtrDb
->OpenedWithConnectionString() &&
3887 (!wxStrcmp(pDbConfig
->GetConnectionStr(), pList
->ConnectionStr
)))
3889 // Found a free connection
3890 pList
->Free
= false;
3891 return(pList
->PtrDb
);
3896 if (!pList
->PtrDb
->OpenedWithConnectionString() &&
3897 (!wxStrcmp(pDbConfig
->GetDsn(), pList
->Dsn
)))
3899 // Found a free connection
3900 pList
->Free
= false;
3901 return(pList
->PtrDb
);
3906 if (pDbConfig
->UseConnectionStr())
3908 if (!wxStrcmp(pDbConfig
->GetConnectionStr(), pList
->ConnectionStr
))
3909 matchingDbConnection
= pList
->PtrDb
;
3913 if (!wxStrcmp(pDbConfig
->GetDsn(), pList
->Dsn
) &&
3914 !wxStrcmp(pDbConfig
->GetUserID(), pList
->Uid
) &&
3915 !wxStrcmp(pDbConfig
->GetPassword(), pList
->AuthStr
))
3916 matchingDbConnection
= pList
->PtrDb
;
3920 // No available connections. A new connection must be made and
3921 // appended to the end of the linked list.
3924 // Find the end of the list
3925 for (pList
= PtrBegDbList
; pList
->PtrNext
; pList
= pList
->PtrNext
);
3926 // Append a new list item
3927 pList
->PtrNext
= new wxDbList
;
3928 pList
->PtrNext
->PtrPrev
= pList
;
3929 pList
= pList
->PtrNext
;
3933 // Create the first node on the list
3934 pList
= PtrBegDbList
= new wxDbList
;
3938 // Initialize new node in the linked list
3940 pList
->Free
= false;
3941 pList
->Dsn
= pDbConfig
->GetDsn();
3942 pList
->Uid
= pDbConfig
->GetUserID();
3943 pList
->AuthStr
= pDbConfig
->GetPassword();
3944 pList
->ConnectionStr
= pDbConfig
->GetConnectionStr();
3946 pList
->PtrDb
= new wxDb(pDbConfig
->GetHenv(), FwdOnlyCursors
);
3950 if (!matchingDbConnection
)
3952 if (pDbConfig
->UseConnectionStr())
3954 opened
= pList
->PtrDb
->Open(pDbConfig
->GetConnectionStr());
3958 opened
= pList
->PtrDb
->Open(pDbConfig
->GetDsn(), pDbConfig
->GetUserID(), pDbConfig
->GetPassword());
3962 opened
= pList
->PtrDb
->Open(matchingDbConnection
);
3964 // Connect to the datasource
3967 pList
->PtrDb
->setCached(true); // Prevent a user from deleting a cached connection
3968 pList
->PtrDb
->SetSqlLogging(SQLLOGstate
, SQLLOGfn
, true);
3969 return(pList
->PtrDb
);
3971 else // Unable to connect, destroy list item
3974 pList
->PtrPrev
->PtrNext
= 0;
3976 PtrBegDbList
= 0; // Empty list again
3978 pList
->PtrDb
->CommitTrans(); // Commit any open transactions on wxDb object
3979 pList
->PtrDb
->Close(); // Close the wxDb object
3980 delete pList
->PtrDb
; // Deletes the wxDb object
3981 delete pList
; // Deletes the linked list object
3985 } // wxDbGetConnection()
3988 /********** wxDbFreeConnection() **********/
3989 bool WXDLLIMPEXP_ODBC
wxDbFreeConnection(wxDb
*pDb
)
3993 // Scan the linked list searching for the database connection
3994 for (pList
= PtrBegDbList
; pList
; pList
= pList
->PtrNext
)
3996 if (pList
->PtrDb
== pDb
) // Found it, now free it!!!
3997 return (pList
->Free
= true);
4000 // Never found the database object, return failure
4003 } // wxDbFreeConnection()
4006 /********** wxDbCloseConnections() **********/
4007 void WXDLLIMPEXP_ODBC
wxDbCloseConnections(void)
4009 wxDbList
*pList
, *pNext
;
4011 // Traverse the linked list closing database connections and freeing memory as I go.
4012 for (pList
= PtrBegDbList
; pList
; pList
= pNext
)
4014 pNext
= pList
->PtrNext
; // Save the pointer to next
4015 pList
->PtrDb
->CommitTrans(); // Commit any open transactions on wxDb object
4016 pList
->PtrDb
->Close(); // Close the wxDb object
4017 pList
->PtrDb
->setCached(false); // Allows deletion of the wxDb instance
4018 delete pList
->PtrDb
; // Deletes the wxDb object
4019 delete pList
; // Deletes the linked list object
4022 // Mark the list as empty
4025 } // wxDbCloseConnections()
4028 /********** wxDbConnectionsInUse() **********/
4029 int WXDLLIMPEXP_ODBC
wxDbConnectionsInUse(void)
4034 // Scan the linked list counting db connections that are currently in use
4035 for (pList
= PtrBegDbList
; pList
; pList
= pList
->PtrNext
)
4037 if (pList
->Free
== false)
4043 } // wxDbConnectionsInUse()
4047 /********** wxDbLogExtendedErrorMsg() **********/
4048 // DEBUG ONLY function
4049 const wxChar WXDLLIMPEXP_ODBC
*wxDbLogExtendedErrorMsg(const wxChar
*userText
,
4051 const wxChar
*ErrFile
,
4054 static wxString msg
;
4059 if (ErrFile
|| ErrLine
)
4061 msg
+= wxT("File: ");
4063 msg
+= wxT(" Line: ");
4064 tStr
.Printf(wxT("%d"),ErrLine
);
4065 msg
+= tStr
.c_str();
4069 msg
.Append (wxT("\nODBC errors:\n"));
4072 // Display errors for this connection
4074 for (i
= 0; i
< DB_MAX_ERROR_HISTORY
; i
++)
4076 if (pDb
->errorList
[i
])
4078 msg
.Append(pDb
->errorList
[i
]);
4079 if (wxStrcmp(pDb
->errorList
[i
],wxT("")) != 0)
4080 msg
.Append(wxT("\n"));
4081 // Clear the errmsg buffer so the next error will not
4082 // end up showing the previous error that have occurred
4083 wxStrcpy(pDb
->errorList
[i
],wxT(""));
4088 wxLogDebug(msg
.c_str());
4091 } // wxDbLogExtendedErrorMsg()
4094 /********** wxDbSqlLog() **********/
4095 bool wxDbSqlLog(wxDbSqlLogState state
, const wxChar
*filename
)
4097 bool append
= false;
4100 for (pList
= PtrBegDbList
; pList
; pList
= pList
->PtrNext
)
4102 if (!pList
->PtrDb
->SetSqlLogging(state
,filename
,append
))
4107 SQLLOGstate
= state
;
4108 SQLLOGfn
= filename
;
4116 /********** wxDbCreateDataSource() **********/
4117 int wxDbCreateDataSource(const wxString
&driverName
, const wxString
&dsn
, const wxString
&description
,
4118 bool sysDSN
, const wxString
&defDir
, wxWindow
*parent
)
4120 * !!!! ONLY FUNCTIONAL UNDER MSW with VC6 !!!!
4121 * Very rudimentary creation of an ODBC data source.
4123 * ODBC driver must be ODBC 3.0 compliant to use this function
4128 //!!!! ONLY FUNCTIONAL UNDER MSW with VC6 !!!!
4134 dsnLocation
= ODBC_ADD_SYS_DSN
;
4136 dsnLocation
= ODBC_ADD_DSN
;
4138 // NOTE: The decimal 2 is an invalid character in all keyword pairs
4139 // so that is why I used it, as wxString does not deal well with
4140 // embedded nulls in strings
4141 setupStr
.Printf(wxT("DSN=%s%cDescription=%s%cDefaultDir=%s%c"),dsn
,2,description
,2,defDir
,2);
4143 // Replace the separator from above with the '\0' seperator needed
4144 // by the SQLConfigDataSource() function
4148 k
= setupStr
.Find((wxChar
)2,true);
4149 if (k
!= wxNOT_FOUND
)
4150 setupStr
[(UINT
)k
] = wxT('\0');
4152 while (k
!= wxNOT_FOUND
);
4154 result
= SQLConfigDataSource((HWND
)parent
->GetHWND(), dsnLocation
,
4155 driverName
, setupStr
.c_str());
4157 if ((result
!= SQL_SUCCESS
) && (result
!= SQL_SUCCESS_WITH_INFO
))
4159 // check for errors caused by ConfigDSN based functions
4162 wxChar errMsg
[SQL_MAX_MESSAGE_LENGTH
];
4163 errMsg
[0] = wxT('\0');
4165 // This function is only supported in ODBC drivers v3.0 compliant and above
4166 SQLInstallerError(1,&retcode
,errMsg
,SQL_MAX_MESSAGE_LENGTH
-1,&cb
);
4169 #ifdef DBDEBUG_CONSOLE
4170 // When run in console mode, use standard out to display errors.
4171 cout
<< errMsg
<< endl
;
4172 cout
<< wxT("Press any key to continue...") << endl
;
4174 #endif // DBDEBUG_CONSOLE
4177 wxLogDebug(errMsg
,wxT("ODBC DEBUG MESSAGE"));
4178 #endif // __WXDEBUG__
4184 // Using iODBC/unixODBC or some other compiler which does not support the APIs
4185 // necessary to use this function, so this function is not supported
4187 wxLogDebug(wxT("wxDbCreateDataSource() not available except under VC++/MSW"),wxT("ODBC DEBUG MESSAGE"));
4190 #endif // __VISUALC__
4194 } // wxDbCreateDataSource()
4198 /********** wxDbGetDataSource() **********/
4199 bool wxDbGetDataSource(HENV henv
, wxChar
*Dsn
, SWORD DsnMaxLength
, wxChar
*DsDesc
,
4200 SWORD DsDescMaxLength
, UWORD direction
)
4202 * Dsn and DsDesc will contain the data source name and data source
4203 * description upon return
4208 if (SQLDataSources(henv
, direction
, (SQLTCHAR FAR
*) Dsn
, DsnMaxLength
*sizeof(wxChar
), &cb1
,
4209 (SQLTCHAR FAR
*) DsDesc
, DsDescMaxLength
*sizeof(wxChar
), &cb2
) == SQL_SUCCESS
)
4214 } // wxDbGetDataSource()
4217 // Change this to 0 to remove use of all deprecated functions
4218 #if wxODBC_BACKWARD_COMPATABILITY
4219 /********************************************************************
4220 ********************************************************************
4222 * The following functions are all DEPRECATED and are included for
4223 * backward compatability reasons only
4225 ********************************************************************
4226 ********************************************************************/
4227 bool SqlLog(sqlLog state
, const wxChar
*filename
)
4229 return wxDbSqlLog((enum wxDbSqlLogState
)state
, filename
);
4231 /***** DEPRECATED: use wxGetDataSource() *****/
4232 bool GetDataSource(HENV henv
, char *Dsn
, SWORD DsnMax
, char *DsDesc
, SWORD DsDescMax
,
4235 return wxDbGetDataSource(henv
, Dsn
, DsnMax
, DsDesc
, DsDescMax
, direction
);
4237 /***** DEPRECATED: use wxDbGetConnection() *****/
4238 wxDb WXDLLIMPEXP_ODBC
*GetDbConnection(DbStuff
*pDbStuff
, bool FwdOnlyCursors
)
4240 return wxDbGetConnection((wxDbConnectInf
*)pDbStuff
, FwdOnlyCursors
);
4242 /***** DEPRECATED: use wxDbFreeConnection() *****/
4243 bool WXDLLIMPEXP_ODBC
FreeDbConnection(wxDb
*pDb
)
4245 return wxDbFreeConnection(pDb
);
4247 /***** DEPRECATED: use wxDbCloseConnections() *****/
4248 void WXDLLIMPEXP_ODBC
CloseDbConnections(void)
4250 wxDbCloseConnections();
4252 /***** DEPRECATED: use wxDbConnectionsInUse() *****/
4253 int WXDLLIMPEXP_ODBC
NumberDbConnectionsInUse(void)
4255 return wxDbConnectionsInUse();