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, plus:
22 // Notice: This class library and its intellectual design are free of charge for use,
23 // modification, enhancement, debugging under the following conditions:
24 // 1) These classes may only be used as part of the implementation of a
25 // wxWindows-based application
26 // 2) All enhancements and bug fixes are to be submitted back to the wxWindows
27 // user groups free of all charges for use with the wxWindows library.
28 // 3) These classes may not be distributed as part of any other class library,
29 // DLL, text (written or electronic), other than a complete distribution of
30 // the wxWindows GUI development toolkit.
31 ///////////////////////////////////////////////////////////////////////////////
38 #include "wx/wxprec.h"
41 // Use this line for wxWindows v1.x
43 // Use this line for wxWindows v2.x
44 #include "wx/version.h"
46 #if wxMAJOR_VERSION == 2
48 #pragma implementation "db.h"
52 #ifdef DBDEBUG_CONSOLE
53 #include "wx/ioswrap.h"
60 #if wxMAJOR_VERSION == 2
62 #include "wx/string.h"
63 #include "wx/object.h"
66 #include "wx/msgdlg.h"
69 #include "wx/filefn.h"
70 #include "wx/wxchar.h"
74 #if wxMAJOR_VERSION == 1
75 # if defined(wx_msw) || defined(wx_x)
93 #if wxMAJOR_VERSION == 1
95 #elif wxMAJOR_VERSION == 2
99 WXDLLEXPORT_DATA(wxDbList
*) PtrBegDbList
= 0;
102 wxChar
const *SQL_LOG_FILENAME
= wxT("sqllog.txt");
103 wxChar
const *SQL_CATALOG_FILENAME
= wxT("catalog.txt");
106 extern wxList TablesInUse
;
109 // SQL Log defaults to be used by GetDbConnection
110 wxDbSqlLogState SQLLOGstate
= sqlLogOFF
;
112 static wxString SQLLOGfn
= SQL_LOG_FILENAME
;
114 // The wxDb::errorList is copied to this variable when the wxDb object
115 // is closed. This way, the error list is still available after the
116 // database object is closed. This is necessary if the database
117 // connection fails so the calling application can show the operator
118 // why the connection failed. Note: as each wxDb object is closed, it
119 // will overwrite the errors of the previously destroyed wxDb object in
120 // this variable. NOTE: This occurs during a CLOSE, not a FREEing of the
122 wxChar DBerrorList
[DB_MAX_ERROR_HISTORY
][DB_MAX_ERROR_MSG_LEN
];
124 // This type defines the return row-struct form
125 // SQLTablePrivileges, and is used by wxDB::TablePrivileges.
128 wxChar tableQual
[128+1];
129 wxChar tableOwner
[128+1];
130 wxChar tableName
[128+1];
131 wxChar grantor
[128+1];
132 wxChar grantee
[128+1];
133 wxChar privilege
[128+1];
134 wxChar grantable
[3+1];
135 } wxDbTablePrivilegeInfo
;
138 /********** wxDbColFor Constructor **********/
139 wxDbColFor::wxDbColFor()
149 i_Nation
= 0; // 0=EU, 1=UK, 2=International, 3=US
152 Format(1,DB_DATA_TYPE_VARCHAR
,0,0,0); // the Function that does the work
153 } // wxDbColFor::wxDbColFor()
156 wxDbColFor::~wxDbColFor()
158 } // wxDbColFor::~wxDbColFor()
161 /********** wxDbColInf Con / Destructor **********/
162 wxDbColInf::wxDbColInf()
182 } // wxDbColInf::wxDbColFor()
185 wxDbColInf::~wxDbColInf()
190 } // wxDbColInf::~wxDbColInf()
193 /********** wxDbTableInf Constructor ********/
194 wxDbTableInf::wxDbTableInf()
201 } // wxDbTableInf::wxDbTableFor()
204 /********** wxDbTableInf Constructor ********/
205 wxDbTableInf::~wxDbTableInf()
210 } // wxDbTableInf::~wxDbTableInf()
213 /********** wxDbInf Constructor *************/
220 } // wxDbInf::wxDbFor()
223 /********** wxDbInf Destructor *************/
229 } // wxDbInf::~wxDbInf()
232 int wxDbColFor::Format(int Nation
, int dbDataType
, SWORD sqlDataType
,
233 short columnSize
, short decimalDigits
)
235 // ----------------------------------------------------------------------------------------
236 // -- 19991224 : mj10777 : Create
237 // There is still a lot of work to do here, but it is a start
238 // It handles all the basic data-types that I have run into up to now
239 // The main work will have be with Dates and float Formatting
240 // (US 1,000.00 ; EU 1.000,00)
241 // There are wxWindow plans for locale support and the new wxDateTime. If
242 // they define some constants (wxEUROPEAN) that can be gloably used,
243 // they should be used here.
244 // ----------------------------------------------------------------------------------------
245 // There should also be a function to scan in a string to fill the variable
246 // ----------------------------------------------------------------------------------------
248 i_Nation
= Nation
; // 0 = timestamp , 1=EU, 2=UK, 3=International, 4=US
249 i_dbDataType
= dbDataType
;
250 i_sqlDataType
= sqlDataType
;
251 s_Field
.Printf(wxT("%s%d"),s_Amount
[1].c_str(),i_Amount
[1]); // OK for VARCHAR, INTEGER and FLOAT
253 if (i_dbDataType
== 0) // Filter unsupported dbDataTypes
255 if ((i_sqlDataType
== SQL_VARCHAR
) || (i_sqlDataType
== SQL_LONGVARCHAR
))
256 i_dbDataType
= DB_DATA_TYPE_VARCHAR
;
257 if ((i_sqlDataType
== SQL_C_DATE
) || (i_sqlDataType
== SQL_C_TIMESTAMP
))
258 i_dbDataType
= DB_DATA_TYPE_DATE
;
259 if (i_sqlDataType
== SQL_C_BIT
)
260 i_dbDataType
= DB_DATA_TYPE_INTEGER
;
261 if (i_sqlDataType
== SQL_NUMERIC
)
262 i_dbDataType
= DB_DATA_TYPE_VARCHAR
;
263 if (i_sqlDataType
== SQL_REAL
)
264 i_dbDataType
= DB_DATA_TYPE_FLOAT
;
267 if ((i_dbDataType
== DB_DATA_TYPE_INTEGER
) && (i_sqlDataType
== SQL_C_DOUBLE
))
269 i_dbDataType
= DB_DATA_TYPE_FLOAT
;
272 switch(i_dbDataType
) // TBD: Still a lot of proper formatting to do
274 case DB_DATA_TYPE_VARCHAR
:
277 case DB_DATA_TYPE_INTEGER
:
280 case DB_DATA_TYPE_FLOAT
:
281 if (decimalDigits
== 0)
284 tempStr
.Printf(wxT("%s%d.%d"),tempStr
.c_str(),columnSize
,decimalDigits
);
285 s_Field
.Printf(wxT("%sf"),tempStr
.c_str());
287 case DB_DATA_TYPE_DATE
:
288 if (i_Nation
== 0) // timestamp YYYY-MM-DD HH:MM:SS.SSS (tested for SYBASE)
290 s_Field
= wxT("%04d-%02d-%02d %02d:%02d:%02d.%03d");
292 if (i_Nation
== 1) // European DD.MM.YYYY HH:MM:SS.SSS
294 s_Field
= wxT("%02d.%02d.%04d %02d:%02d:%02d.%03d");
296 if (i_Nation
== 2) // UK DD/MM/YYYY HH:MM:SS.SSS
298 s_Field
= wxT("%02d/%02d/%04d %02d:%02d:%02d.%03d");
300 if (i_Nation
== 3) // International YYYY-MM-DD HH:MM:SS.SSS
302 s_Field
= wxT("%04d-%02d-%02d %02d:%02d:%02d.%03d");
304 if (i_Nation
== 4) // US MM/DD/YYYY HH:MM:SS.SSS
306 s_Field
= wxT("%02d/%02d/%04d %02d:%02d:%02d.%03d");
310 s_Field
.Printf(wxT("Unknown Format(%d)-SQL(%d)"),dbDataType
,sqlDataType
); //
314 } // wxDbColFor::Format()
317 /********** wxDb Constructors **********/
318 wxDb::wxDb(HENV
&aHenv
, bool FwdOnlyCursors
)
320 // Copy the HENV into the db class
322 fwdOnlyCursors
= FwdOnlyCursors
;
327 /********** PRIVATE! wxDb::initialize PRIVATE! **********/
328 void wxDb::initialize()
330 * Private member function that sets all wxDb member variables to
331 * known values at creation of the wxDb
336 fpSqlLog
= 0; // Sql Log file pointer
337 sqlLogState
= sqlLogOFF
; // By default, logging is turned off
339 dbmsType
= dbmsUNIDENTIFIED
;
341 wxStrcpy(sqlState
,wxT(""));
342 wxStrcpy(errorMsg
,wxT(""));
343 nativeError
= cbErrorMsg
= 0;
344 for (i
= 0; i
< DB_MAX_ERROR_HISTORY
; i
++)
345 wxStrcpy(errorList
[i
], wxT(""));
347 // Init typeInf structures
348 typeInfVarchar
.TypeName
.Empty();
349 typeInfVarchar
.FsqlType
= 0;
350 typeInfVarchar
.Precision
= 0;
351 typeInfVarchar
.CaseSensitive
= 0;
352 typeInfVarchar
.MaximumScale
= 0;
354 typeInfInteger
.TypeName
.Empty();
355 typeInfInteger
.FsqlType
= 0;
356 typeInfInteger
.Precision
= 0;
357 typeInfInteger
.CaseSensitive
= 0;
358 typeInfInteger
.MaximumScale
= 0;
360 typeInfFloat
.TypeName
.Empty();
361 typeInfFloat
.FsqlType
= 0;
362 typeInfFloat
.Precision
= 0;
363 typeInfFloat
.CaseSensitive
= 0;
364 typeInfFloat
.MaximumScale
= 0;
366 typeInfDate
.TypeName
.Empty();
367 typeInfDate
.FsqlType
= 0;
368 typeInfDate
.Precision
= 0;
369 typeInfDate
.CaseSensitive
= 0;
370 typeInfDate
.MaximumScale
= 0;
372 // Error reporting is turned OFF by default
375 // Allocate a data source connection handle
376 if (SQLAllocConnect(henv
, &hdbc
) != SQL_SUCCESS
)
379 // Initialize the db status flag
382 // Mark database as not open as of yet
384 } // wxDb::initialize()
387 /********** PRIVATE! wxDb::initialize PRIVATE! **********/
389 // NOTE: Return value from this function MUST be copied
390 // immediately, as the value is not good after
391 // this function has left scope.
393 const wxChar
*wxDb::convertUserID(const wxChar
*userID
, wxString
&UserID
)
397 if (!wxStrlen(userID
))
405 // dBase does not use user names, and some drivers fail if you try to pass one
406 if (Dbms() == dbmsDBASE
)
409 // Oracle user names may only be in uppercase, so force
410 // the name to uppercase
411 if (Dbms() == dbmsORACLE
)
412 UserID
= UserID
.Upper();
414 return UserID
.c_str();
415 } // wxDb::convertUserID()
418 /********** wxDb::Open() **********/
419 bool wxDb::Open(const wxString
&Dsn
, const wxString
&Uid
, const wxString
&AuthStr
)
421 wxASSERT(Dsn
.Length());
428 if (!FwdOnlyCursors())
430 // Specify that the ODBC cursor library be used, if needed. This must be
431 // specified before the connection is made.
432 retcode
= SQLSetConnectOption(hdbc
, SQL_ODBC_CURSORS
, SQL_CUR_USE_IF_NEEDED
);
434 #ifdef DBDEBUG_CONSOLE
435 if (retcode
== SQL_SUCCESS
)
436 cout
<< wxT("SQLSetConnectOption(CURSOR_LIB) successful") << endl
;
438 cout
<< wxT("SQLSetConnectOption(CURSOR_LIB) failed") << endl
;
442 // Connect to the data source
443 retcode
= SQLConnect(hdbc
, (UCHAR FAR
*) dsn
.c_str(), SQL_NTS
,
444 (UCHAR FAR
*) uid
.c_str(), SQL_NTS
,
445 (UCHAR FAR
*) authStr
.c_str(), SQL_NTS
);
448 if (retcode == SQL_SUCCESS_WITH_INFO)
449 DispAllErrors(henv, hdbc);
450 else if (retcode != SQL_SUCCESS)
451 return(DispAllErrors(henv, hdbc));
453 if (retcode == SQL_ERROR)
454 return(DispAllErrors(henv, hdbc));
456 if ((retcode
!= SQL_SUCCESS
) &&
457 (retcode
!= SQL_SUCCESS_WITH_INFO
))
458 return(DispAllErrors(henv
, hdbc
));
461 If using Intersolv branded ODBC drivers, this is the place where you would substitute
462 your branded driver license information
464 SQLSetConnectOption(hdbc, 1041, (UDWORD) wxT(""));
465 SQLSetConnectOption(hdbc, 1042, (UDWORD) wxT(""));
468 // Mark database as open
471 // Allocate a statement handle for the database connection
472 if (SQLAllocStmt(hdbc
, &hstmt
) != SQL_SUCCESS
)
473 return(DispAllErrors(henv
, hdbc
));
475 // Set Connection Options
476 if (!setConnectionOptions())
479 // Query the data source for inf. about itself
483 // Query the data source regarding data type information
486 // The way I determined which SQL data types to use was by calling SQLGetInfo
487 // for all of the possible SQL data types to see which ones were supported. If
488 // a type is not supported, the SQLFetch() that's called from getDataTypeInfo()
489 // fails with SQL_NO_DATA_FOUND. This is ugly because I'm sure the three SQL data
490 // types I've selected below will not alway's be what we want. These are just
491 // what happened to work against an Oracle 7/Intersolv combination. The following is
492 // a complete list of the results I got back against the Oracle 7 database:
494 // SQL_BIGINT SQL_NO_DATA_FOUND
495 // SQL_BINARY SQL_NO_DATA_FOUND
496 // SQL_BIT SQL_NO_DATA_FOUND
497 // SQL_CHAR type name = 'CHAR', Precision = 255
498 // SQL_DATE SQL_NO_DATA_FOUND
499 // SQL_DECIMAL type name = 'NUMBER', Precision = 38
500 // SQL_DOUBLE type name = 'NUMBER', Precision = 15
501 // SQL_FLOAT SQL_NO_DATA_FOUND
502 // SQL_INTEGER SQL_NO_DATA_FOUND
503 // SQL_LONGVARBINARY type name = 'LONG RAW', Precision = 2 billion
504 // SQL_LONGVARCHAR type name = 'LONG', Precision = 2 billion
505 // SQL_NUMERIC SQL_NO_DATA_FOUND
506 // SQL_REAL SQL_NO_DATA_FOUND
507 // SQL_SMALLINT SQL_NO_DATA_FOUND
508 // SQL_TIME SQL_NO_DATA_FOUND
509 // SQL_TIMESTAMP type name = 'DATE', Precision = 19
510 // SQL_VARBINARY type name = 'RAW', Precision = 255
511 // SQL_VARCHAR type name = 'VARCHAR2', Precision = 2000
512 // =====================================================================
513 // Results from a Microsoft Access 7.0 db, using a driver from Microsoft
515 // SQL_VARCHAR type name = 'TEXT', Precision = 255
516 // SQL_TIMESTAMP type name = 'DATETIME'
517 // SQL_DECIMAL SQL_NO_DATA_FOUND
518 // SQL_NUMERIC type name = 'CURRENCY', Precision = 19
519 // SQL_FLOAT SQL_NO_DATA_FOUND
520 // SQL_REAL type name = 'SINGLE', Precision = 7
521 // SQL_DOUBLE type name = 'DOUBLE', Precision = 15
522 // SQL_INTEGER type name = 'LONG', Precision = 10
524 // VARCHAR = Variable length character string
525 if (!getDataTypeInfo(SQL_VARCHAR
, typeInfVarchar
))
526 if (!getDataTypeInfo(SQL_CHAR
, typeInfVarchar
))
529 typeInfVarchar
.FsqlType
= SQL_CHAR
;
531 typeInfVarchar
.FsqlType
= SQL_VARCHAR
;
534 if (!getDataTypeInfo(SQL_DOUBLE
,typeInfFloat
))
536 if (!getDataTypeInfo(SQL_REAL
,typeInfFloat
))
537 if (!getDataTypeInfo(SQL_FLOAT
,typeInfFloat
))
538 if (!getDataTypeInfo(SQL_DECIMAL
,typeInfFloat
))
539 if (!getDataTypeInfo(SQL_NUMERIC
,typeInfFloat
))
542 typeInfFloat
.FsqlType
= SQL_NUMERIC
;
544 typeInfFloat
.FsqlType
= SQL_DECIMAL
;
546 typeInfFloat
.FsqlType
= SQL_FLOAT
;
548 typeInfFloat
.FsqlType
= SQL_REAL
;
550 typeInfFloat
.FsqlType
= SQL_DOUBLE
;
553 if (!getDataTypeInfo(SQL_INTEGER
, typeInfInteger
))
555 // If SQL_INTEGER is not supported, use the floating point
556 // data type to store integers as well as floats
557 if (!getDataTypeInfo(typeInfFloat
.FsqlType
, typeInfInteger
))
560 typeInfInteger
.FsqlType
= typeInfFloat
.FsqlType
;
563 typeInfInteger
.FsqlType
= SQL_INTEGER
;
566 if (Dbms() != dbmsDBASE
)
568 if (! getDataTypeInfo(SQL_TIMESTAMP
,typeInfDate
))
571 typeInfDate
.FsqlType
= SQL_TIMESTAMP
;
575 if (!getDataTypeInfo(SQL_DATE
,typeInfDate
))
578 typeInfDate
.FsqlType
= SQL_DATE
;
581 #ifdef DBDEBUG_CONSOLE
582 cout
<< wxT("VARCHAR DATA TYPE: ") << typeInfVarchar
.TypeName
<< endl
;
583 cout
<< wxT("INTEGER DATA TYPE: ") << typeInfInteger
.TypeName
<< endl
;
584 cout
<< wxT("FLOAT DATA TYPE: ") << typeInfFloat
.TypeName
<< endl
;
585 cout
<< wxT("DATE DATA TYPE: ") << typeInfDate
.TypeName
<< endl
;
589 // Completed Successfully
595 bool wxDb::Open(wxDb
*copyDb
)
597 dsn
= copyDb
->GetDatasourceName();
598 uid
= copyDb
->GetUsername();
599 authStr
= copyDb
->GetPassword();
603 if (!FwdOnlyCursors())
605 // Specify that the ODBC cursor library be used, if needed. This must be
606 // specified before the connection is made.
607 retcode
= SQLSetConnectOption(hdbc
, SQL_ODBC_CURSORS
, SQL_CUR_USE_IF_NEEDED
);
609 #ifdef DBDEBUG_CONSOLE
610 if (retcode
== SQL_SUCCESS
)
611 cout
<< wxT("SQLSetConnectOption(CURSOR_LIB) successful") << endl
;
613 cout
<< wxT("SQLSetConnectOption(CURSOR_LIB) failed") << endl
;
617 // Connect to the data source
618 retcode
= SQLConnect(hdbc
, (UCHAR FAR
*) dsn
.c_str(), SQL_NTS
,
619 (UCHAR FAR
*) uid
.c_str(), SQL_NTS
,
620 (UCHAR FAR
*) authStr
.c_str(), SQL_NTS
);
622 if (retcode
== SQL_ERROR
)
623 return(DispAllErrors(henv
, hdbc
));
626 If using Intersolv branded ODBC drivers, this is the place where you would substitute
627 your branded driver license information
629 SQLSetConnectOption(hdbc, 1041, (UDWORD) wxT(""));
630 SQLSetConnectOption(hdbc, 1042, (UDWORD) wxT(""));
633 // Mark database as open
636 // Allocate a statement handle for the database connection
637 if (SQLAllocStmt(hdbc
, &hstmt
) != SQL_SUCCESS
)
638 return(DispAllErrors(henv
, hdbc
));
640 // Set Connection Options
641 if (!setConnectionOptions())
644 // Instead of Querying the data source for info about itself, it can just be copied
645 // from the wxDb instance that was passed in (copyDb).
646 wxStrcpy(dbInf
.serverName
,copyDb
->dbInf
.serverName
);
647 wxStrcpy(dbInf
.databaseName
,copyDb
->dbInf
.databaseName
);
648 wxStrcpy(dbInf
.dbmsName
,copyDb
->dbInf
.dbmsName
);
649 wxStrcpy(dbInf
.dbmsVer
,copyDb
->dbInf
.dbmsVer
);
650 dbInf
.maxConnections
= copyDb
->dbInf
.maxConnections
;
651 dbInf
.maxStmts
= copyDb
->dbInf
.maxStmts
;
652 wxStrcpy(dbInf
.driverName
,copyDb
->dbInf
.driverName
);
653 wxStrcpy(dbInf
.odbcVer
,copyDb
->dbInf
.odbcVer
);
654 wxStrcpy(dbInf
.drvMgrOdbcVer
,copyDb
->dbInf
.drvMgrOdbcVer
);
655 wxStrcpy(dbInf
.driverVer
,copyDb
->dbInf
.driverVer
);
656 dbInf
.apiConfLvl
= copyDb
->dbInf
.apiConfLvl
;
657 dbInf
.cliConfLvl
= copyDb
->dbInf
.cliConfLvl
;
658 dbInf
.sqlConfLvl
= copyDb
->dbInf
.sqlConfLvl
;
659 wxStrcpy(dbInf
.outerJoins
,copyDb
->dbInf
.outerJoins
);
660 wxStrcpy(dbInf
.procedureSupport
,copyDb
->dbInf
.procedureSupport
);
661 wxStrcpy(dbInf
.accessibleTables
,copyDb
->dbInf
.accessibleTables
);
662 dbInf
.cursorCommitBehavior
= copyDb
->dbInf
.cursorCommitBehavior
;
663 dbInf
.cursorRollbackBehavior
= copyDb
->dbInf
.cursorRollbackBehavior
;
664 dbInf
.supportNotNullClause
= copyDb
->dbInf
.supportNotNullClause
;
665 wxStrcpy(dbInf
.supportIEF
,copyDb
->dbInf
.supportIEF
);
666 dbInf
.txnIsolation
= copyDb
->dbInf
.txnIsolation
;
667 dbInf
.txnIsolationOptions
= copyDb
->dbInf
.txnIsolationOptions
;
668 dbInf
.fetchDirections
= copyDb
->dbInf
.fetchDirections
;
669 dbInf
.lockTypes
= copyDb
->dbInf
.lockTypes
;
670 dbInf
.posOperations
= copyDb
->dbInf
.posOperations
;
671 dbInf
.posStmts
= copyDb
->dbInf
.posStmts
;
672 dbInf
.scrollConcurrency
= copyDb
->dbInf
.scrollConcurrency
;
673 dbInf
.scrollOptions
= copyDb
->dbInf
.scrollOptions
;
674 dbInf
.staticSensitivity
= copyDb
->dbInf
.staticSensitivity
;
675 dbInf
.txnCapable
= copyDb
->dbInf
.txnCapable
;
676 dbInf
.loginTimeout
= copyDb
->dbInf
.loginTimeout
;
678 // VARCHAR = Variable length character string
679 typeInfVarchar
.FsqlType
= copyDb
->typeInfVarchar
.FsqlType
;
680 typeInfVarchar
.TypeName
= copyDb
->typeInfVarchar
.TypeName
;
681 typeInfVarchar
.Precision
= copyDb
->typeInfVarchar
.Precision
;
682 typeInfVarchar
.CaseSensitive
= copyDb
->typeInfVarchar
.CaseSensitive
;
683 typeInfVarchar
.MaximumScale
= copyDb
->typeInfVarchar
.MaximumScale
;
686 typeInfFloat
.FsqlType
= copyDb
->typeInfFloat
.FsqlType
;
687 typeInfFloat
.TypeName
= copyDb
->typeInfFloat
.TypeName
;
688 typeInfFloat
.Precision
= copyDb
->typeInfFloat
.Precision
;
689 typeInfFloat
.CaseSensitive
= copyDb
->typeInfFloat
.CaseSensitive
;
690 typeInfFloat
.MaximumScale
= copyDb
->typeInfFloat
.MaximumScale
;
693 typeInfInteger
.FsqlType
= copyDb
->typeInfInteger
.FsqlType
;
694 typeInfInteger
.TypeName
= copyDb
->typeInfInteger
.TypeName
;
695 typeInfInteger
.Precision
= copyDb
->typeInfInteger
.Precision
;
696 typeInfInteger
.CaseSensitive
= copyDb
->typeInfInteger
.CaseSensitive
;
697 typeInfInteger
.MaximumScale
= copyDb
->typeInfInteger
.MaximumScale
;
700 typeInfDate
.FsqlType
= copyDb
->typeInfDate
.FsqlType
;
701 typeInfDate
.TypeName
= copyDb
->typeInfDate
.TypeName
;
702 typeInfDate
.Precision
= copyDb
->typeInfDate
.Precision
;
703 typeInfDate
.CaseSensitive
= copyDb
->typeInfDate
.CaseSensitive
;
704 typeInfDate
.MaximumScale
= copyDb
->typeInfDate
.MaximumScale
;
706 #ifdef DBDEBUG_CONSOLE
707 cout
<< wxT("VARCHAR DATA TYPE: ") << typeInfVarchar
.TypeName
<< endl
;
708 cout
<< wxT("INTEGER DATA TYPE: ") << typeInfInteger
.TypeName
<< endl
;
709 cout
<< wxT("FLOAT DATA TYPE: ") << typeInfFloat
.TypeName
<< endl
;
710 cout
<< wxT("DATE DATA TYPE: ") << typeInfDate
.TypeName
<< endl
;
714 // Completed Successfully
719 /********** wxDb::setConnectionOptions() **********/
720 bool wxDb::setConnectionOptions(void)
722 * NOTE: The Intersolv/Oracle 7 driver was "Not Capable" of setting the login timeout.
727 // I need to get the DBMS name here, because some of the connection options
728 // are database specific and need to call the Dbms() function.
729 if (SQLGetInfo(hdbc
, SQL_DBMS_NAME
, (UCHAR
*) dbInf
.dbmsName
, 40, &cb
) != SQL_SUCCESS
)
730 return(DispAllErrors(henv
, hdbc
));
732 SQLSetConnectOption(hdbc
, SQL_AUTOCOMMIT
, SQL_AUTOCOMMIT_OFF
);
733 SQLSetConnectOption(hdbc
, SQL_OPT_TRACE
, SQL_OPT_TRACE_OFF
);
734 // SQLSetConnectOption(hdbc, SQL_TXN_ISOLATION, SQL_TXN_READ_COMMITTED); // No dirty reads
736 // By default, MS Sql Server closes cursors on commit and rollback. The following
737 // call to SQLSetConnectOption() is needed to force SQL Server to preserve cursors
738 // after a transaction. This is a driver specific option and is not part of the
739 // ODBC standard. Note: this behavior is specific to the ODBC interface to SQL Server.
740 // The database settings don't have any effect one way or the other.
741 if (Dbms() == dbmsMS_SQL_SERVER
)
743 const long SQL_PRESERVE_CURSORS
= 1204L;
744 const long SQL_PC_ON
= 1L;
745 SQLSetConnectOption(hdbc
, SQL_PRESERVE_CURSORS
, SQL_PC_ON
);
748 // Display the connection options to verify them
749 #ifdef DBDEBUG_CONSOLE
751 cout
<< wxT("****** CONNECTION OPTIONS ******") << endl
;
753 if (SQLGetConnectOption(hdbc
, SQL_AUTOCOMMIT
, &l
) != SQL_SUCCESS
)
754 return(DispAllErrors(henv
, hdbc
));
755 cout
<< wxT("AUTOCOMMIT: ") << (l
== SQL_AUTOCOMMIT_OFF
? "OFF" : "ON") << endl
;
757 if (SQLGetConnectOption(hdbc
, SQL_ODBC_CURSORS
, &l
) != SQL_SUCCESS
)
758 return(DispAllErrors(henv
, hdbc
));
759 cout
<< wxT("ODBC CURSORS: ");
762 case(SQL_CUR_USE_IF_NEEDED
):
763 cout
<< wxT("SQL_CUR_USE_IF_NEEDED");
765 case(SQL_CUR_USE_ODBC
):
766 cout
<< wxT("SQL_CUR_USE_ODBC");
768 case(SQL_CUR_USE_DRIVER
):
769 cout
<< wxT("SQL_CUR_USE_DRIVER");
774 if (SQLGetConnectOption(hdbc
, SQL_OPT_TRACE
, &l
) != SQL_SUCCESS
)
775 return(DispAllErrors(henv
, hdbc
));
776 cout
<< wxT("TRACING: ") << (l
== SQL_OPT_TRACE_OFF
? wxT("OFF") : wxT("ON")) << endl
;
781 // Completed Successfully
784 } // wxDb::setConnectionOptions()
787 /********** wxDb::getDbInfo() **********/
788 bool wxDb::getDbInfo(void)
793 if (SQLGetInfo(hdbc
, SQL_SERVER_NAME
, (UCHAR
*) dbInf
.serverName
, 80, &cb
) != SQL_SUCCESS
)
794 return(DispAllErrors(henv
, hdbc
));
796 if (SQLGetInfo(hdbc
, SQL_DATABASE_NAME
, (UCHAR
*) dbInf
.databaseName
, 128, &cb
) != SQL_SUCCESS
)
797 return(DispAllErrors(henv
, hdbc
));
799 if (SQLGetInfo(hdbc
, SQL_DBMS_NAME
, (UCHAR
*) dbInf
.dbmsName
, 40, &cb
) != SQL_SUCCESS
)
800 return(DispAllErrors(henv
, hdbc
));
803 // After upgrading to MSVC6, the original 20 char buffer below was insufficient,
804 // causing database connectivity to fail in some cases.
805 retcode
= SQLGetInfo(hdbc
, SQL_DBMS_VER
, (UCHAR
*) dbInf
.dbmsVer
, 64, &cb
);
807 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
808 return(DispAllErrors(henv
, hdbc
));
810 if (SQLGetInfo(hdbc
, SQL_ACTIVE_CONNECTIONS
, (UCHAR
*) &dbInf
.maxConnections
, sizeof(dbInf
.maxConnections
), &cb
) != SQL_SUCCESS
)
811 return(DispAllErrors(henv
, hdbc
));
813 if (SQLGetInfo(hdbc
, SQL_ACTIVE_STATEMENTS
, (UCHAR
*) &dbInf
.maxStmts
, sizeof(dbInf
.maxStmts
), &cb
) != SQL_SUCCESS
)
814 return(DispAllErrors(henv
, hdbc
));
816 if (SQLGetInfo(hdbc
, SQL_DRIVER_NAME
, (UCHAR
*) dbInf
.driverName
, 40, &cb
) != SQL_SUCCESS
)
817 return(DispAllErrors(henv
, hdbc
));
819 if (SQLGetInfo(hdbc
, SQL_DRIVER_ODBC_VER
, (UCHAR
*) dbInf
.odbcVer
, 60, &cb
) == SQL_ERROR
)
820 return(DispAllErrors(henv
, hdbc
));
822 retcode
= SQLGetInfo(hdbc
, SQL_ODBC_VER
, (UCHAR
*) dbInf
.drvMgrOdbcVer
, 60, &cb
);
823 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
824 return(DispAllErrors(henv
, hdbc
));
826 if (SQLGetInfo(hdbc
, SQL_DRIVER_VER
, (UCHAR
*) dbInf
.driverVer
, 60, &cb
) == SQL_ERROR
)
827 return(DispAllErrors(henv
, hdbc
));
829 if (SQLGetInfo(hdbc
, SQL_ODBC_API_CONFORMANCE
, (UCHAR
*) &dbInf
.apiConfLvl
, sizeof(dbInf
.apiConfLvl
), &cb
) != SQL_SUCCESS
)
830 return(DispAllErrors(henv
, hdbc
));
832 if (SQLGetInfo(hdbc
, SQL_ODBC_SAG_CLI_CONFORMANCE
, (UCHAR
*) &dbInf
.cliConfLvl
, sizeof(dbInf
.cliConfLvl
), &cb
) != SQL_SUCCESS
)
833 // return(DispAllErrors(henv, hdbc));
835 // Not all drivers support this call - Nick Gorham(unixODBC)
836 dbInf
.cliConfLvl
= 0;
839 if (SQLGetInfo(hdbc
, SQL_ODBC_SQL_CONFORMANCE
, (UCHAR
*) &dbInf
.sqlConfLvl
, sizeof(dbInf
.sqlConfLvl
), &cb
) != SQL_SUCCESS
)
840 return(DispAllErrors(henv
, hdbc
));
842 if (SQLGetInfo(hdbc
, SQL_OUTER_JOINS
, (UCHAR
*) dbInf
.outerJoins
, 2, &cb
) != SQL_SUCCESS
)
843 return(DispAllErrors(henv
, hdbc
));
845 if (SQLGetInfo(hdbc
, SQL_PROCEDURES
, (UCHAR
*) dbInf
.procedureSupport
, 2, &cb
) != SQL_SUCCESS
)
846 return(DispAllErrors(henv
, hdbc
));
848 if (SQLGetInfo(hdbc
, SQL_ACCESSIBLE_TABLES
, (UCHAR
*) dbInf
.accessibleTables
, 2, &cb
) != SQL_SUCCESS
)
849 return(DispAllErrors(henv
, hdbc
));
851 if (SQLGetInfo(hdbc
, SQL_CURSOR_COMMIT_BEHAVIOR
, (UCHAR
*) &dbInf
.cursorCommitBehavior
, sizeof(dbInf
.cursorCommitBehavior
), &cb
) != SQL_SUCCESS
)
852 return(DispAllErrors(henv
, hdbc
));
854 if (SQLGetInfo(hdbc
, SQL_CURSOR_ROLLBACK_BEHAVIOR
, (UCHAR
*) &dbInf
.cursorRollbackBehavior
, sizeof(dbInf
.cursorRollbackBehavior
), &cb
) != SQL_SUCCESS
)
855 return(DispAllErrors(henv
, hdbc
));
857 if (SQLGetInfo(hdbc
, SQL_NON_NULLABLE_COLUMNS
, (UCHAR
*) &dbInf
.supportNotNullClause
, sizeof(dbInf
.supportNotNullClause
), &cb
) != SQL_SUCCESS
)
858 return(DispAllErrors(henv
, hdbc
));
860 if (SQLGetInfo(hdbc
, SQL_ODBC_SQL_OPT_IEF
, (UCHAR
*) dbInf
.supportIEF
, 2, &cb
) != SQL_SUCCESS
)
861 return(DispAllErrors(henv
, hdbc
));
863 if (SQLGetInfo(hdbc
, SQL_DEFAULT_TXN_ISOLATION
, (UCHAR
*) &dbInf
.txnIsolation
, sizeof(dbInf
.txnIsolation
), &cb
) != SQL_SUCCESS
)
864 return(DispAllErrors(henv
, hdbc
));
866 if (SQLGetInfo(hdbc
, SQL_TXN_ISOLATION_OPTION
, (UCHAR
*) &dbInf
.txnIsolationOptions
, sizeof(dbInf
.txnIsolationOptions
), &cb
) != SQL_SUCCESS
)
867 return(DispAllErrors(henv
, hdbc
));
869 if (SQLGetInfo(hdbc
, SQL_FETCH_DIRECTION
, (UCHAR
*) &dbInf
.fetchDirections
, sizeof(dbInf
.fetchDirections
), &cb
) != SQL_SUCCESS
)
870 return(DispAllErrors(henv
, hdbc
));
872 if (SQLGetInfo(hdbc
, SQL_LOCK_TYPES
, (UCHAR
*) &dbInf
.lockTypes
, sizeof(dbInf
.lockTypes
), &cb
) != SQL_SUCCESS
)
873 return(DispAllErrors(henv
, hdbc
));
875 if (SQLGetInfo(hdbc
, SQL_POS_OPERATIONS
, (UCHAR
*) &dbInf
.posOperations
, sizeof(dbInf
.posOperations
), &cb
) != SQL_SUCCESS
)
876 return(DispAllErrors(henv
, hdbc
));
878 if (SQLGetInfo(hdbc
, SQL_POSITIONED_STATEMENTS
, (UCHAR
*) &dbInf
.posStmts
, sizeof(dbInf
.posStmts
), &cb
) != SQL_SUCCESS
)
879 return(DispAllErrors(henv
, hdbc
));
881 if (SQLGetInfo(hdbc
, SQL_SCROLL_CONCURRENCY
, (UCHAR
*) &dbInf
.scrollConcurrency
, sizeof(dbInf
.scrollConcurrency
), &cb
) != SQL_SUCCESS
)
882 return(DispAllErrors(henv
, hdbc
));
884 if (SQLGetInfo(hdbc
, SQL_SCROLL_OPTIONS
, (UCHAR
*) &dbInf
.scrollOptions
, sizeof(dbInf
.scrollOptions
), &cb
) != SQL_SUCCESS
)
885 return(DispAllErrors(henv
, hdbc
));
887 if (SQLGetInfo(hdbc
, SQL_STATIC_SENSITIVITY
, (UCHAR
*) &dbInf
.staticSensitivity
, sizeof(dbInf
.staticSensitivity
), &cb
) != SQL_SUCCESS
)
888 return(DispAllErrors(henv
, hdbc
));
890 if (SQLGetInfo(hdbc
, SQL_TXN_CAPABLE
, (UCHAR
*) &dbInf
.txnCapable
, sizeof(dbInf
.txnCapable
), &cb
) != SQL_SUCCESS
)
891 return(DispAllErrors(henv
, hdbc
));
893 if (SQLGetInfo(hdbc
, SQL_LOGIN_TIMEOUT
, (UCHAR
*) &dbInf
.loginTimeout
, sizeof(dbInf
.loginTimeout
), &cb
) != SQL_SUCCESS
)
894 return(DispAllErrors(henv
, hdbc
));
896 #ifdef DBDEBUG_CONSOLE
897 cout
<< wxT("***** DATA SOURCE INFORMATION *****") << endl
;
898 cout
<< wxT(wxT("SERVER Name: ") << dbInf
.serverName
<< endl
;
899 cout
<< wxT("DBMS Name: ") << dbInf
.dbmsName
<< wxT("; DBMS Version: ") << dbInf
.dbmsVer
<< endl
;
900 cout
<< wxT("ODBC Version: ") << dbInf
.odbcVer
<< wxT("; Driver Version: ") << dbInf
.driverVer
<< endl
;
902 cout
<< wxT("API Conf. Level: ");
903 switch(dbInf
.apiConfLvl
)
905 case SQL_OAC_NONE
: cout
<< wxT("None"); break;
906 case SQL_OAC_LEVEL1
: cout
<< wxT("Level 1"); break;
907 case SQL_OAC_LEVEL2
: cout
<< wxT("Level 2"); break;
911 cout
<< wxT("SAG CLI Conf. Level: ");
912 switch(dbInf
.cliConfLvl
)
914 case SQL_OSCC_NOT_COMPLIANT
: cout
<< wxT("Not Compliant"); break;
915 case SQL_OSCC_COMPLIANT
: cout
<< wxT("Compliant"); break;
919 cout
<< wxT("SQL Conf. Level: ");
920 switch(dbInf
.sqlConfLvl
)
922 case SQL_OSC_MINIMUM
: cout
<< wxT("Minimum Grammar"); break;
923 case SQL_OSC_CORE
: cout
<< wxT("Core Grammar"); break;
924 case SQL_OSC_EXTENDED
: cout
<< wxT("Extended Grammar"); break;
928 cout
<< wxT("Max. Connections: ") << dbInf
.maxConnections
<< endl
;
929 cout
<< wxT("Outer Joins: ") << dbInf
.outerJoins
<< endl
;
930 cout
<< wxT("Support for Procedures: ") << dbInf
.procedureSupport
<< endl
;
931 cout
<< wxT("All tables accessible : ") << dbInf
.accessibleTables
<< endl
;
932 cout
<< wxT("Cursor COMMIT Behavior: ");
933 switch(dbInf
.cursorCommitBehavior
)
935 case SQL_CB_DELETE
: cout
<< wxT("Delete cursors"); break;
936 case SQL_CB_CLOSE
: cout
<< wxT("Close cursors"); break;
937 case SQL_CB_PRESERVE
: cout
<< wxT("Preserve cursors"); break;
941 cout
<< wxT("Cursor ROLLBACK Behavior: ");
942 switch(dbInf
.cursorRollbackBehavior
)
944 case SQL_CB_DELETE
: cout
<< wxT("Delete cursors"); break;
945 case SQL_CB_CLOSE
: cout
<< wxT("Close cursors"); break;
946 case SQL_CB_PRESERVE
: cout
<< wxT("Preserve cursors"); break;
950 cout
<< wxT("Support NOT NULL clause: ");
951 switch(dbInf
.supportNotNullClause
)
953 case SQL_NNC_NULL
: cout
<< wxT("No"); break;
954 case SQL_NNC_NON_NULL
: cout
<< wxT("Yes"); break;
958 cout
<< wxT("Support IEF (Ref. Integrity): ") << dbInf
.supportIEF
<< endl
;
959 cout
<< wxT("Login Timeout: ") << dbInf
.loginTimeout
<< endl
;
961 cout
<< endl
<< endl
<< wxT("more ...") << endl
;
964 cout
<< wxT("Default Transaction Isolation: ";
965 switch(dbInf
.txnIsolation
)
967 case SQL_TXN_READ_UNCOMMITTED
: cout
<< wxT("Read Uncommitted"); break;
968 case SQL_TXN_READ_COMMITTED
: cout
<< wxT("Read Committed"); break;
969 case SQL_TXN_REPEATABLE_READ
: cout
<< wxT("Repeatable Read"); break;
970 case SQL_TXN_SERIALIZABLE
: cout
<< wxT("Serializable"); break;
972 case SQL_TXN_VERSIONING
: cout
<< wxT("Versioning"); break;
977 cout
<< wxT("Transaction Isolation Options: ");
978 if (dbInf
.txnIsolationOptions
& SQL_TXN_READ_UNCOMMITTED
)
979 cout
<< wxT("Read Uncommitted, ");
980 if (dbInf
.txnIsolationOptions
& SQL_TXN_READ_COMMITTED
)
981 cout
<< wxT("Read Committed, ");
982 if (dbInf
.txnIsolationOptions
& SQL_TXN_REPEATABLE_READ
)
983 cout
<< wxT("Repeatable Read, ");
984 if (dbInf
.txnIsolationOptions
& SQL_TXN_SERIALIZABLE
)
985 cout
<< wxT("Serializable, ");
987 if (dbInf
.txnIsolationOptions
& SQL_TXN_VERSIONING
)
988 cout
<< wxT("Versioning");
992 cout
<< wxT("Fetch Directions Supported:") << endl
<< wxT(" ");
993 if (dbInf
.fetchDirections
& SQL_FD_FETCH_NEXT
)
994 cout
<< wxT("Next, ");
995 if (dbInf
.fetchDirections
& SQL_FD_FETCH_PRIOR
)
996 cout
<< wxT("Prev, ");
997 if (dbInf
.fetchDirections
& SQL_FD_FETCH_FIRST
)
998 cout
<< wxT("First, ");
999 if (dbInf
.fetchDirections
& SQL_FD_FETCH_LAST
)
1000 cout
<< wxT("Last, ");
1001 if (dbInf
.fetchDirections
& SQL_FD_FETCH_ABSOLUTE
)
1002 cout
<< wxT("Absolute, ");
1003 if (dbInf
.fetchDirections
& SQL_FD_FETCH_RELATIVE
)
1004 cout
<< wxT("Relative, ");
1006 if (dbInf
.fetchDirections
& SQL_FD_FETCH_RESUME
)
1007 cout
<< wxT("Resume, ");
1009 if (dbInf
.fetchDirections
& SQL_FD_FETCH_BOOKMARK
)
1010 cout
<< wxT("Bookmark");
1013 cout
<< wxT("Lock Types Supported (SQLSetPos): ");
1014 if (dbInf
.lockTypes
& SQL_LCK_NO_CHANGE
)
1015 cout
<< wxT("No Change, ");
1016 if (dbInf
.lockTypes
& SQL_LCK_EXCLUSIVE
)
1017 cout
<< wxT("Exclusive, ");
1018 if (dbInf
.lockTypes
& SQL_LCK_UNLOCK
)
1019 cout
<< wxT("UnLock");
1022 cout
<< wxT("Position Operations Supported (SQLSetPos): ");
1023 if (dbInf
.posOperations
& SQL_POS_POSITION
)
1024 cout
<< wxT("Position, ");
1025 if (dbInf
.posOperations
& SQL_POS_REFRESH
)
1026 cout
<< wxT("Refresh, ");
1027 if (dbInf
.posOperations
& SQL_POS_UPDATE
)
1028 cout
<< wxT("Upd, "));
1029 if (dbInf
.posOperations
& SQL_POS_DELETE
)
1030 cout
<< wxT("Del, ");
1031 if (dbInf
.posOperations
& SQL_POS_ADD
)
1035 cout
<< wxT("Positioned Statements Supported: ");
1036 if (dbInf
.posStmts
& SQL_PS_POSITIONED_DELETE
)
1037 cout
<< wxT("Pos delete, ");
1038 if (dbInf
.posStmts
& SQL_PS_POSITIONED_UPDATE
)
1039 cout
<< wxT("Pos update, ");
1040 if (dbInf
.posStmts
& SQL_PS_SELECT_FOR_UPDATE
)
1041 cout
<< wxT("Select for update");
1044 cout
<< wxT("Scroll Concurrency: ");
1045 if (dbInf
.scrollConcurrency
& SQL_SCCO_READ_ONLY
)
1046 cout
<< wxT("Read Only, ");
1047 if (dbInf
.scrollConcurrency
& SQL_SCCO_LOCK
)
1048 cout
<< wxT("Lock, ");
1049 if (dbInf
.scrollConcurrency
& SQL_SCCO_OPT_ROWVER
)
1050 cout
<< wxT("Opt. Rowver, ");
1051 if (dbInf
.scrollConcurrency
& SQL_SCCO_OPT_VALUES
)
1052 cout
<< wxT("Opt. Values");
1055 cout
<< wxT("Scroll Options: ");
1056 if (dbInf
.scrollOptions
& SQL_SO_FORWARD_ONLY
)
1057 cout
<< wxT("Fwd Only, ");
1058 if (dbInf
.scrollOptions
& SQL_SO_STATIC
)
1059 cout
<< wxT("Static, ");
1060 if (dbInf
.scrollOptions
& SQL_SO_KEYSET_DRIVEN
)
1061 cout
<< wxT("Keyset Driven, ");
1062 if (dbInf
.scrollOptions
& SQL_SO_DYNAMIC
)
1063 cout
<< wxT("Dynamic, ");
1064 if (dbInf
.scrollOptions
& SQL_SO_MIXED
)
1065 cout
<< wxT("Mixed");
1068 cout
<< wxT("Static Sensitivity: ");
1069 if (dbInf
.staticSensitivity
& SQL_SS_ADDITIONS
)
1070 cout
<< wxT("Additions, ");
1071 if (dbInf
.staticSensitivity
& SQL_SS_DELETIONS
)
1072 cout
<< wxT("Deletions, ");
1073 if (dbInf
.staticSensitivity
& SQL_SS_UPDATES
)
1074 cout
<< wxT("Updates");
1077 cout
<< wxT("Transaction Capable?: ");
1078 switch(dbInf
.txnCapable
)
1080 case SQL_TC_NONE
: cout
<< wxT("No"); break;
1081 case SQL_TC_DML
: cout
<< wxT("DML Only"); break;
1082 case SQL_TC_DDL_COMMIT
: cout
<< wxT("DDL Commit"); break;
1083 case SQL_TC_DDL_IGNORE
: cout
<< wxT("DDL Ignore"); break;
1084 case SQL_TC_ALL
: cout
<< wxT("DDL & DML"); break;
1091 // Completed Successfully
1094 } // wxDb::getDbInfo()
1097 /********** wxDb::getDataTypeInfo() **********/
1098 bool wxDb::getDataTypeInfo(SWORD fSqlType
, wxDbSqlTypeInfo
&structSQLTypeInfo
)
1101 * fSqlType will be something like SQL_VARCHAR. This parameter determines
1102 * the data type inf. is gathered for.
1104 * wxDbSqlTypeInfo is a structure that is filled in with data type information,
1109 // Get information about the data type specified
1110 if (SQLGetTypeInfo(hstmt
, fSqlType
) != SQL_SUCCESS
)
1111 return(DispAllErrors(henv
, hdbc
, hstmt
));
1113 if ((retcode
= SQLFetch(hstmt
)) != SQL_SUCCESS
)
1115 #ifdef DBDEBUG_CONSOLE
1116 if (retcode
== SQL_NO_DATA_FOUND
)
1117 cout
<< wxT("SQL_NO_DATA_FOUND fetching inf. about data type.") << endl
;
1119 DispAllErrors(henv
, hdbc
, hstmt
);
1120 SQLFreeStmt(hstmt
, SQL_CLOSE
);
1124 wxChar typeName
[DB_TYPE_NAME_LEN
+1];
1125 // Obtain columns from the record
1126 if (SQLGetData(hstmt
, 1, SQL_C_CHAR
, (UCHAR
*) typeName
, DB_TYPE_NAME_LEN
, &cbRet
) != SQL_SUCCESS
)
1127 return(DispAllErrors(henv
, hdbc
, hstmt
));
1129 structSQLTypeInfo
.TypeName
= typeName
;
1131 // BJO 20000503: no more needed with new GetColumns...
1134 if (Dbms() == dbmsMY_SQL
)
1136 if (structSQLTypeInfo
.TypeName
== wxT("middleint"))
1137 structSQLTypeInfo
.TypeName
= wxT("mediumint");
1138 else if (structSQLTypeInfo
.TypeName
== wxT("middleint unsigned"))
1139 structSQLTypeInfo
.TypeName
= wxT("mediumint unsigned");
1140 else if (structSQLTypeInfo
.TypeName
== wxT("integer"))
1141 structSQLTypeInfo
.TypeName
= wxT("int");
1142 else if (structSQLTypeInfo
.TypeName
== wxT("integer unsigned"))
1143 structSQLTypeInfo
.TypeName
= wxT("int unsigned");
1144 else if (structSQLTypeInfo
.TypeName
== wxT("middleint"))
1145 structSQLTypeInfo
.TypeName
= wxT("mediumint");
1146 else if (structSQLTypeInfo
.TypeName
== wxT("varchar"))
1147 structSQLTypeInfo
.TypeName
= wxT("char");
1150 // BJO 20000427 : OpenLink driver
1151 if (!wxStrncmp(dbInf
.driverName
, wxT("oplodbc"), 7) ||
1152 !wxStrncmp(dbInf
.driverName
, wxT("OLOD"), 4))
1154 if (structSQLTypeInfo
.TypeName
== wxT("double precision"))
1155 structSQLTypeInfo
.TypeName
= wxT("real");
1159 if (SQLGetData(hstmt
, 3, SQL_C_LONG
, (UCHAR
*) &structSQLTypeInfo
.Precision
, 0, &cbRet
) != SQL_SUCCESS
)
1160 return(DispAllErrors(henv
, hdbc
, hstmt
));
1161 if (SQLGetData(hstmt
, 8, SQL_C_SHORT
, (UCHAR
*) &structSQLTypeInfo
.CaseSensitive
, 0, &cbRet
) != SQL_SUCCESS
)
1162 return(DispAllErrors(henv
, hdbc
, hstmt
));
1163 // if (SQLGetData(hstmt, 14, SQL_C_SHORT, (UCHAR*) &structSQLTypeInfo.MinimumScale, 0, &cbRet) != SQL_SUCCESS)
1164 // return(DispAllErrors(henv, hdbc, hstmt));
1166 if (SQLGetData(hstmt
, 15, SQL_C_SHORT
,(UCHAR
*) &structSQLTypeInfo
.MaximumScale
, 0, &cbRet
) != SQL_SUCCESS
)
1167 return(DispAllErrors(henv
, hdbc
, hstmt
));
1169 if (structSQLTypeInfo
.MaximumScale
< 0)
1170 structSQLTypeInfo
.MaximumScale
= 0;
1172 // Close the statement handle which closes open cursors
1173 if (SQLFreeStmt(hstmt
, SQL_CLOSE
) != SQL_SUCCESS
)
1174 return(DispAllErrors(henv
, hdbc
, hstmt
));
1176 // Completed Successfully
1179 } // wxDb::getDataTypeInfo()
1182 /********** wxDb::Close() **********/
1183 void wxDb::Close(void)
1185 // Close the Sql Log file
1192 // Free statement handle
1195 if (SQLFreeStmt(hstmt
, SQL_DROP
) != SQL_SUCCESS
)
1196 DispAllErrors(henv
, hdbc
);
1199 // Disconnect from the datasource
1200 if (SQLDisconnect(hdbc
) != SQL_SUCCESS
)
1201 DispAllErrors(henv
, hdbc
);
1203 // Free the connection to the datasource
1204 if (SQLFreeConnect(hdbc
) != SQL_SUCCESS
)
1205 DispAllErrors(henv
, hdbc
);
1207 // There should be zero Ctable objects still connected to this db object
1208 wxASSERT(nTables
== 0);
1213 pNode
= TablesInUse
.First();
1217 tiu
= (wxTablesInUse
*)pNode
->Data();
1218 if (tiu
->pDb
== this)
1220 s
.Printf(wxT("(%-20s) tableID:[%6lu] pDb:[%p]"), tiu
->tableName
,tiu
->tableID
,tiu
->pDb
);
1221 s2
.Printf(wxT("Orphaned found using pDb:[%p]"),this);
1224 pNode
= pNode
->Next();
1228 // Copy the error messages to a global variable
1230 for (i
= 0; i
< DB_MAX_ERROR_HISTORY
; i
++)
1231 wxStrcpy(DBerrorList
[i
],errorList
[i
]);
1233 dbmsType
= dbmsUNIDENTIFIED
;
1239 /********** wxDb::CommitTrans() **********/
1240 bool wxDb::CommitTrans(void)
1244 // Commit the transaction
1245 if (SQLTransact(henv
, hdbc
, SQL_COMMIT
) != SQL_SUCCESS
)
1246 return(DispAllErrors(henv
, hdbc
));
1249 // Completed successfully
1252 } // wxDb::CommitTrans()
1255 /********** wxDb::RollbackTrans() **********/
1256 bool wxDb::RollbackTrans(void)
1258 // Rollback the transaction
1259 if (SQLTransact(henv
, hdbc
, SQL_ROLLBACK
) != SQL_SUCCESS
)
1260 return(DispAllErrors(henv
, hdbc
));
1262 // Completed successfully
1265 } // wxDb::RollbackTrans()
1268 /********** wxDb::DispAllErrors() **********/
1269 bool wxDb::DispAllErrors(HENV aHenv
, HDBC aHdbc
, HSTMT aHstmt
)
1271 * This function is called internally whenever an error condition prevents the user's
1272 * request from being executed. This function will query the datasource as to the
1273 * actual error(s) that just occured on the previous request of the datasource.
1275 * The function will retrieve each error condition from the datasource and
1276 * Printf the codes/text values into a string which it then logs via logError().
1277 * If in DBDEBUG_CONSOLE mode, the constructed string will be displayed in the console
1278 * window and program execution will be paused until the user presses a key.
1280 * This function always returns a FALSE, so that functions which call this function
1281 * can have a line like "return (DispAllErrors(henv, hdbc));" to indicate the failure
1282 * of the users request, so that the calling code can then process the error msg log
1285 wxString odbcErrMsg
;
1287 while (SQLError(aHenv
, aHdbc
, aHstmt
, (UCHAR FAR
*) sqlState
, &nativeError
, (UCHAR FAR
*) errorMsg
, SQL_MAX_MESSAGE_LENGTH
- 1, &cbErrorMsg
) == SQL_SUCCESS
)
1289 odbcErrMsg
.Printf(wxT("SQL State = %s\nNative Error Code = %li\nError Message = %s\n"), sqlState
, nativeError
, errorMsg
);
1290 logError(odbcErrMsg
, sqlState
);
1293 #ifdef DBDEBUG_CONSOLE
1294 // When run in console mode, use standard out to display errors.
1295 cout
<< odbcErrMsg
.c_str() << endl
;
1296 cout
<< wxT("Press any key to continue...") << endl
;
1301 wxLogDebug(odbcErrMsg
,wxT("ODBC DEBUG MESSAGE from DispAllErrors()"));
1306 return(FALSE
); // This function always returns false.
1308 } // wxDb::DispAllErrors()
1311 /********** wxDb::GetNextError() **********/
1312 bool wxDb::GetNextError(HENV aHenv
, HDBC aHdbc
, HSTMT aHstmt
)
1314 if (SQLError(aHenv
, aHdbc
, aHstmt
, (UCHAR FAR
*) sqlState
, &nativeError
, (UCHAR FAR
*) errorMsg
, SQL_MAX_MESSAGE_LENGTH
- 1, &cbErrorMsg
) == SQL_SUCCESS
)
1319 } // wxDb::GetNextError()
1322 /********** wxDb::DispNextError() **********/
1323 void wxDb::DispNextError(void)
1325 wxString odbcErrMsg
;
1327 odbcErrMsg
.Printf(wxT("SQL State = %s\nNative Error Code = %li\nError Message = %s\n"), sqlState
, nativeError
, errorMsg
);
1328 logError(odbcErrMsg
, sqlState
);
1333 #ifdef DBDEBUG_CONSOLE
1334 // When run in console mode, use standard out to display errors.
1335 cout
<< odbcErrMsg
.c_str() << endl
;
1336 cout
<< wxT("Press any key to continue...") << endl
;
1341 wxLogDebug(odbcErrMsg
,wxT("ODBC DEBUG MESSAGE"));
1342 #endif // __WXDEBUG__
1344 } // wxDb::DispNextError()
1347 /********** wxDb::logError() **********/
1348 void wxDb::logError(const wxString
&errMsg
, const wxString
&SQLState
)
1350 wxASSERT(errMsg
.Length());
1352 static int pLast
= -1;
1355 if (++pLast
== DB_MAX_ERROR_HISTORY
)
1358 for (i
= 0; i
< DB_MAX_ERROR_HISTORY
; i
++)
1359 wxStrcpy(errorList
[i
], errorList
[i
+1]);
1363 wxStrcpy(errorList
[pLast
], errMsg
);
1365 if (SQLState
.Length())
1366 if ((dbStatus
= TranslateSqlState(SQLState
)) != DB_ERR_FUNCTION_SEQUENCE_ERROR
)
1367 DB_STATUS
= dbStatus
;
1369 // Add the errmsg to the sql log
1370 WriteSqlLog(errMsg
);
1372 } // wxDb::logError()
1375 /**********wxDb::TranslateSqlState() **********/
1376 int wxDb::TranslateSqlState(const wxString
&SQLState
)
1378 if (!wxStrcmp(SQLState
, wxT("01000")))
1379 return(DB_ERR_GENERAL_WARNING
);
1380 if (!wxStrcmp(SQLState
, wxT("01002")))
1381 return(DB_ERR_DISCONNECT_ERROR
);
1382 if (!wxStrcmp(SQLState
, wxT("01004")))
1383 return(DB_ERR_DATA_TRUNCATED
);
1384 if (!wxStrcmp(SQLState
, wxT("01006")))
1385 return(DB_ERR_PRIV_NOT_REVOKED
);
1386 if (!wxStrcmp(SQLState
, wxT("01S00")))
1387 return(DB_ERR_INVALID_CONN_STR_ATTR
);
1388 if (!wxStrcmp(SQLState
, wxT("01S01")))
1389 return(DB_ERR_ERROR_IN_ROW
);
1390 if (!wxStrcmp(SQLState
, wxT("01S02")))
1391 return(DB_ERR_OPTION_VALUE_CHANGED
);
1392 if (!wxStrcmp(SQLState
, wxT("01S03")))
1393 return(DB_ERR_NO_ROWS_UPD_OR_DEL
);
1394 if (!wxStrcmp(SQLState
, wxT("01S04")))
1395 return(DB_ERR_MULTI_ROWS_UPD_OR_DEL
);
1396 if (!wxStrcmp(SQLState
, wxT("07001")))
1397 return(DB_ERR_WRONG_NO_OF_PARAMS
);
1398 if (!wxStrcmp(SQLState
, wxT("07006")))
1399 return(DB_ERR_DATA_TYPE_ATTR_VIOL
);
1400 if (!wxStrcmp(SQLState
, wxT("08001")))
1401 return(DB_ERR_UNABLE_TO_CONNECT
);
1402 if (!wxStrcmp(SQLState
, wxT("08002")))
1403 return(DB_ERR_CONNECTION_IN_USE
);
1404 if (!wxStrcmp(SQLState
, wxT("08003")))
1405 return(DB_ERR_CONNECTION_NOT_OPEN
);
1406 if (!wxStrcmp(SQLState
, wxT("08004")))
1407 return(DB_ERR_REJECTED_CONNECTION
);
1408 if (!wxStrcmp(SQLState
, wxT("08007")))
1409 return(DB_ERR_CONN_FAIL_IN_TRANS
);
1410 if (!wxStrcmp(SQLState
, wxT("08S01")))
1411 return(DB_ERR_COMM_LINK_FAILURE
);
1412 if (!wxStrcmp(SQLState
, wxT("21S01")))
1413 return(DB_ERR_INSERT_VALUE_LIST_MISMATCH
);
1414 if (!wxStrcmp(SQLState
, wxT("21S02")))
1415 return(DB_ERR_DERIVED_TABLE_MISMATCH
);
1416 if (!wxStrcmp(SQLState
, wxT("22001")))
1417 return(DB_ERR_STRING_RIGHT_TRUNC
);
1418 if (!wxStrcmp(SQLState
, wxT("22003")))
1419 return(DB_ERR_NUMERIC_VALUE_OUT_OF_RNG
);
1420 if (!wxStrcmp(SQLState
, wxT("22005")))
1421 return(DB_ERR_ERROR_IN_ASSIGNMENT
);
1422 if (!wxStrcmp(SQLState
, wxT("22008")))
1423 return(DB_ERR_DATETIME_FLD_OVERFLOW
);
1424 if (!wxStrcmp(SQLState
, wxT("22012")))
1425 return(DB_ERR_DIVIDE_BY_ZERO
);
1426 if (!wxStrcmp(SQLState
, wxT("22026")))
1427 return(DB_ERR_STR_DATA_LENGTH_MISMATCH
);
1428 if (!wxStrcmp(SQLState
, wxT("23000")))
1429 return(DB_ERR_INTEGRITY_CONSTRAINT_VIOL
);
1430 if (!wxStrcmp(SQLState
, wxT("24000")))
1431 return(DB_ERR_INVALID_CURSOR_STATE
);
1432 if (!wxStrcmp(SQLState
, wxT("25000")))
1433 return(DB_ERR_INVALID_TRANS_STATE
);
1434 if (!wxStrcmp(SQLState
, wxT("28000")))
1435 return(DB_ERR_INVALID_AUTH_SPEC
);
1436 if (!wxStrcmp(SQLState
, wxT("34000")))
1437 return(DB_ERR_INVALID_CURSOR_NAME
);
1438 if (!wxStrcmp(SQLState
, wxT("37000")))
1439 return(DB_ERR_SYNTAX_ERROR_OR_ACCESS_VIOL
);
1440 if (!wxStrcmp(SQLState
, wxT("3C000")))
1441 return(DB_ERR_DUPLICATE_CURSOR_NAME
);
1442 if (!wxStrcmp(SQLState
, wxT("40001")))
1443 return(DB_ERR_SERIALIZATION_FAILURE
);
1444 if (!wxStrcmp(SQLState
, wxT("42000")))
1445 return(DB_ERR_SYNTAX_ERROR_OR_ACCESS_VIOL2
);
1446 if (!wxStrcmp(SQLState
, wxT("70100")))
1447 return(DB_ERR_OPERATION_ABORTED
);
1448 if (!wxStrcmp(SQLState
, wxT("IM001")))
1449 return(DB_ERR_UNSUPPORTED_FUNCTION
);
1450 if (!wxStrcmp(SQLState
, wxT("IM002")))
1451 return(DB_ERR_NO_DATA_SOURCE
);
1452 if (!wxStrcmp(SQLState
, wxT("IM003")))
1453 return(DB_ERR_DRIVER_LOAD_ERROR
);
1454 if (!wxStrcmp(SQLState
, wxT("IM004")))
1455 return(DB_ERR_SQLALLOCENV_FAILED
);
1456 if (!wxStrcmp(SQLState
, wxT("IM005")))
1457 return(DB_ERR_SQLALLOCCONNECT_FAILED
);
1458 if (!wxStrcmp(SQLState
, wxT("IM006")))
1459 return(DB_ERR_SQLSETCONNECTOPTION_FAILED
);
1460 if (!wxStrcmp(SQLState
, wxT("IM007")))
1461 return(DB_ERR_NO_DATA_SOURCE_DLG_PROHIB
);
1462 if (!wxStrcmp(SQLState
, wxT("IM008")))
1463 return(DB_ERR_DIALOG_FAILED
);
1464 if (!wxStrcmp(SQLState
, wxT("IM009")))
1465 return(DB_ERR_UNABLE_TO_LOAD_TRANSLATION_DLL
);
1466 if (!wxStrcmp(SQLState
, wxT("IM010")))
1467 return(DB_ERR_DATA_SOURCE_NAME_TOO_LONG
);
1468 if (!wxStrcmp(SQLState
, wxT("IM011")))
1469 return(DB_ERR_DRIVER_NAME_TOO_LONG
);
1470 if (!wxStrcmp(SQLState
, wxT("IM012")))
1471 return(DB_ERR_DRIVER_KEYWORD_SYNTAX_ERROR
);
1472 if (!wxStrcmp(SQLState
, wxT("IM013")))
1473 return(DB_ERR_TRACE_FILE_ERROR
);
1474 if (!wxStrcmp(SQLState
, wxT("S0001")))
1475 return(DB_ERR_TABLE_OR_VIEW_ALREADY_EXISTS
);
1476 if (!wxStrcmp(SQLState
, wxT("S0002")))
1477 return(DB_ERR_TABLE_NOT_FOUND
);
1478 if (!wxStrcmp(SQLState
, wxT("S0011")))
1479 return(DB_ERR_INDEX_ALREADY_EXISTS
);
1480 if (!wxStrcmp(SQLState
, wxT("S0012")))
1481 return(DB_ERR_INDEX_NOT_FOUND
);
1482 if (!wxStrcmp(SQLState
, wxT("S0021")))
1483 return(DB_ERR_COLUMN_ALREADY_EXISTS
);
1484 if (!wxStrcmp(SQLState
, wxT("S0022")))
1485 return(DB_ERR_COLUMN_NOT_FOUND
);
1486 if (!wxStrcmp(SQLState
, wxT("S0023")))
1487 return(DB_ERR_NO_DEFAULT_FOR_COLUMN
);
1488 if (!wxStrcmp(SQLState
, wxT("S1000")))
1489 return(DB_ERR_GENERAL_ERROR
);
1490 if (!wxStrcmp(SQLState
, wxT("S1001")))
1491 return(DB_ERR_MEMORY_ALLOCATION_FAILURE
);
1492 if (!wxStrcmp(SQLState
, wxT("S1002")))
1493 return(DB_ERR_INVALID_COLUMN_NUMBER
);
1494 if (!wxStrcmp(SQLState
, wxT("S1003")))
1495 return(DB_ERR_PROGRAM_TYPE_OUT_OF_RANGE
);
1496 if (!wxStrcmp(SQLState
, wxT("S1004")))
1497 return(DB_ERR_SQL_DATA_TYPE_OUT_OF_RANGE
);
1498 if (!wxStrcmp(SQLState
, wxT("S1008")))
1499 return(DB_ERR_OPERATION_CANCELLED
);
1500 if (!wxStrcmp(SQLState
, wxT("S1009")))
1501 return(DB_ERR_INVALID_ARGUMENT_VALUE
);
1502 if (!wxStrcmp(SQLState
, wxT("S1010")))
1503 return(DB_ERR_FUNCTION_SEQUENCE_ERROR
);
1504 if (!wxStrcmp(SQLState
, wxT("S1011")))
1505 return(DB_ERR_OPERATION_INVALID_AT_THIS_TIME
);
1506 if (!wxStrcmp(SQLState
, wxT("S1012")))
1507 return(DB_ERR_INVALID_TRANS_OPERATION_CODE
);
1508 if (!wxStrcmp(SQLState
, wxT("S1015")))
1509 return(DB_ERR_NO_CURSOR_NAME_AVAIL
);
1510 if (!wxStrcmp(SQLState
, wxT("S1090")))
1511 return(DB_ERR_INVALID_STR_OR_BUF_LEN
);
1512 if (!wxStrcmp(SQLState
, wxT("S1091")))
1513 return(DB_ERR_DESCRIPTOR_TYPE_OUT_OF_RANGE
);
1514 if (!wxStrcmp(SQLState
, wxT("S1092")))
1515 return(DB_ERR_OPTION_TYPE_OUT_OF_RANGE
);
1516 if (!wxStrcmp(SQLState
, wxT("S1093")))
1517 return(DB_ERR_INVALID_PARAM_NO
);
1518 if (!wxStrcmp(SQLState
, wxT("S1094")))
1519 return(DB_ERR_INVALID_SCALE_VALUE
);
1520 if (!wxStrcmp(SQLState
, wxT("S1095")))
1521 return(DB_ERR_FUNCTION_TYPE_OUT_OF_RANGE
);
1522 if (!wxStrcmp(SQLState
, wxT("S1096")))
1523 return(DB_ERR_INF_TYPE_OUT_OF_RANGE
);
1524 if (!wxStrcmp(SQLState
, wxT("S1097")))
1525 return(DB_ERR_COLUMN_TYPE_OUT_OF_RANGE
);
1526 if (!wxStrcmp(SQLState
, wxT("S1098")))
1527 return(DB_ERR_SCOPE_TYPE_OUT_OF_RANGE
);
1528 if (!wxStrcmp(SQLState
, wxT("S1099")))
1529 return(DB_ERR_NULLABLE_TYPE_OUT_OF_RANGE
);
1530 if (!wxStrcmp(SQLState
, wxT("S1100")))
1531 return(DB_ERR_UNIQUENESS_OPTION_TYPE_OUT_OF_RANGE
);
1532 if (!wxStrcmp(SQLState
, wxT("S1101")))
1533 return(DB_ERR_ACCURACY_OPTION_TYPE_OUT_OF_RANGE
);
1534 if (!wxStrcmp(SQLState
, wxT("S1103")))
1535 return(DB_ERR_DIRECTION_OPTION_OUT_OF_RANGE
);
1536 if (!wxStrcmp(SQLState
, wxT("S1104")))
1537 return(DB_ERR_INVALID_PRECISION_VALUE
);
1538 if (!wxStrcmp(SQLState
, wxT("S1105")))
1539 return(DB_ERR_INVALID_PARAM_TYPE
);
1540 if (!wxStrcmp(SQLState
, wxT("S1106")))
1541 return(DB_ERR_FETCH_TYPE_OUT_OF_RANGE
);
1542 if (!wxStrcmp(SQLState
, wxT("S1107")))
1543 return(DB_ERR_ROW_VALUE_OUT_OF_RANGE
);
1544 if (!wxStrcmp(SQLState
, wxT("S1108")))
1545 return(DB_ERR_CONCURRENCY_OPTION_OUT_OF_RANGE
);
1546 if (!wxStrcmp(SQLState
, wxT("S1109")))
1547 return(DB_ERR_INVALID_CURSOR_POSITION
);
1548 if (!wxStrcmp(SQLState
, wxT("S1110")))
1549 return(DB_ERR_INVALID_DRIVER_COMPLETION
);
1550 if (!wxStrcmp(SQLState
, wxT("S1111")))
1551 return(DB_ERR_INVALID_BOOKMARK_VALUE
);
1552 if (!wxStrcmp(SQLState
, wxT("S1C00")))
1553 return(DB_ERR_DRIVER_NOT_CAPABLE
);
1554 if (!wxStrcmp(SQLState
, wxT("S1T00")))
1555 return(DB_ERR_TIMEOUT_EXPIRED
);
1560 } // wxDb::TranslateSqlState()
1563 /********** wxDb::Grant() **********/
1564 bool wxDb::Grant(int privileges
, const wxString
&tableName
, const wxString
&userList
)
1568 // Build the grant statement
1569 sqlStmt
= wxT("GRANT ");
1570 if (privileges
== DB_GRANT_ALL
)
1571 sqlStmt
+= wxT("ALL");
1575 if (privileges
& DB_GRANT_SELECT
)
1577 sqlStmt
+= wxT("SELECT");
1580 if (privileges
& DB_GRANT_INSERT
)
1583 sqlStmt
+= wxT(", ");
1584 sqlStmt
+= wxT("INSERT");
1586 if (privileges
& DB_GRANT_UPDATE
)
1589 sqlStmt
+= wxT(", ");
1590 sqlStmt
+= wxT("UPDATE");
1592 if (privileges
& DB_GRANT_DELETE
)
1595 sqlStmt
+= wxT(", ");
1596 sqlStmt
+= wxT("DELETE");
1600 sqlStmt
+= wxT(" ON ");
1601 sqlStmt
+= tableName
;
1602 sqlStmt
+= wxT(" TO ");
1603 sqlStmt
+= userList
;
1605 #ifdef DBDEBUG_CONSOLE
1606 cout
<< endl
<< sqlStmt
.c_str() << endl
;
1609 WriteSqlLog(sqlStmt
);
1611 return(ExecSql(sqlStmt
));
1616 /********** wxDb::CreateView() **********/
1617 bool wxDb::CreateView(const wxString
&viewName
, const wxString
&colList
,
1618 const wxString
&pSqlStmt
, bool attemptDrop
)
1622 // Drop the view first
1623 if (attemptDrop
&& !DropView(viewName
))
1626 // Build the create view statement
1627 sqlStmt
= wxT("CREATE VIEW ");
1628 sqlStmt
+= viewName
;
1630 if (colList
.Length())
1632 sqlStmt
+= wxT(" (");
1634 sqlStmt
+= wxT(")");
1637 sqlStmt
+= wxT(" AS ");
1638 sqlStmt
+= pSqlStmt
;
1640 WriteSqlLog(sqlStmt
);
1642 #ifdef DBDEBUG_CONSOLE
1643 cout
<< sqlStmt
.c_str() << endl
;
1646 return(ExecSql(sqlStmt
));
1648 } // wxDb::CreateView()
1651 /********** wxDb::DropView() **********/
1652 bool wxDb::DropView(const wxString
&viewName
)
1655 * NOTE: This function returns TRUE if the View does not exist, but
1656 * only for identified databases. Code will need to be added
1657 * below for any other databases when those databases are defined
1658 * to handle this situation consistently
1662 sqlStmt
.Printf(wxT("DROP VIEW %s"), viewName
);
1664 WriteSqlLog(sqlStmt
);
1666 #ifdef DBDEBUG_CONSOLE
1667 cout
<< endl
<< sqlStmt
.c_str() << endl
;
1670 if (SQLExecDirect(hstmt
, (UCHAR FAR
*) sqlStmt
.c_str(), SQL_NTS
) != SQL_SUCCESS
)
1672 // Check for "Base table not found" error and ignore
1673 GetNextError(henv
, hdbc
, hstmt
);
1674 if (wxStrcmp(sqlState
,wxT("S0002"))) // "Base table not found"
1676 // Check for product specific error codes
1677 if (!((Dbms() == dbmsSYBASE_ASA
&& !wxStrcmp(sqlState
,wxT("42000"))))) // 5.x (and lower?)
1680 DispAllErrors(henv
, hdbc
, hstmt
);
1687 // Commit the transaction
1688 if (! CommitTrans())
1693 } // wxDb::DropView()
1696 /********** wxDb::ExecSql() **********/
1697 bool wxDb::ExecSql(const wxString
&pSqlStmt
)
1699 SQLFreeStmt(hstmt
, SQL_CLOSE
);
1700 if (SQLExecDirect(hstmt
, (UCHAR FAR
*) pSqlStmt
.c_str(), SQL_NTS
) == SQL_SUCCESS
)
1704 DispAllErrors(henv
, hdbc
, hstmt
);
1708 } // wxDb::ExecSql()
1711 /********** wxDb::GetNext() **********/
1712 bool wxDb::GetNext(void)
1714 if (SQLFetch(hstmt
) == SQL_SUCCESS
)
1718 DispAllErrors(henv
, hdbc
, hstmt
);
1722 } // wxDb::GetNext()
1725 /********** wxDb::GetData() **********/
1726 bool wxDb::GetData(UWORD colNo
, SWORD cType
, PTR pData
, SDWORD maxLen
, SDWORD FAR
*cbReturned
)
1729 wxASSERT(cbReturned
);
1731 if (SQLGetData(hstmt
, colNo
, cType
, pData
, maxLen
, cbReturned
) == SQL_SUCCESS
)
1735 DispAllErrors(henv
, hdbc
, hstmt
);
1739 } // wxDb::GetData()
1742 /********** wxDb::GetKeyFields() **********/
1743 int wxDb::GetKeyFields(const wxString
&tableName
, wxDbColInf
* colInf
, int noCols
)
1745 wxChar szPkTable
[DB_MAX_TABLE_NAME_LEN
+1]; /* Primary key table name */
1746 wxChar szFkTable
[DB_MAX_TABLE_NAME_LEN
+1]; /* Foreign key table name */
1748 // SQLSMALLINT iKeySeq;
1749 wxChar szPkCol
[DB_MAX_COLUMN_NAME_LEN
+1]; /* Primary key column */
1750 wxChar szFkCol
[DB_MAX_COLUMN_NAME_LEN
+1]; /* Foreign key column */
1756 * -----------------------------------------------------------------------
1757 * -- 19991224 : mj10777 : Create ------
1758 * -- : Three things are done and stored here : ------
1759 * -- : 1) which Column(s) is/are Primary Key(s) ------
1760 * -- : 2) which tables use this Key as a Foreign Key ------
1761 * -- : 3) which columns are Foreign Key and the name ------
1762 * -- : of the Table where the Key is the Primary Key -----
1763 * -- : Called from GetColumns(const wxString &tableName, ------
1764 * -- int *numCols,const wxChar *userID ) ------
1765 * -----------------------------------------------------------------------
1768 /*---------------------------------------------------------------------*/
1769 /* Get the names of the columns in the primary key. */
1770 /*---------------------------------------------------------------------*/
1771 retcode
= SQLPrimaryKeys(hstmt
,
1772 NULL
, 0, /* Catalog name */
1773 NULL
, 0, /* Schema name */
1774 (UCHAR FAR
*) tableName
.c_str(), SQL_NTS
); /* Table name */
1776 /*---------------------------------------------------------------------*/
1777 /* Fetch and display the result set. This will be a list of the */
1778 /* columns in the primary key of the tableName table. */
1779 /*---------------------------------------------------------------------*/
1780 while ((retcode
== SQL_SUCCESS
) || (retcode
== SQL_SUCCESS_WITH_INFO
))
1782 retcode
= SQLFetch(hstmt
);
1783 if (retcode
== SQL_SUCCESS
|| retcode
== SQL_SUCCESS_WITH_INFO
)
1785 GetData( 4, SQL_C_CHAR
, szPkCol
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
1786 GetData( 5, SQL_C_SSHORT
, &iKeySeq
, 0, &cb
);
1788 for (i
=0;i
<noCols
;i
++) // Find the Column name
1789 if (!wxStrcmp(colInf
[i
].colName
,szPkCol
)) // We have found the Column
1790 colInf
[i
].PkCol
= iKeySeq
; // Which Primary Key is this (first, second usw.) ?
1793 SQLFreeStmt(hstmt
, SQL_CLOSE
); /* Close the cursor (the hstmt is still allocated). */
1795 /*---------------------------------------------------------------------*/
1796 /* Get all the foreign keys that refer to tableName primary key. */
1797 /*---------------------------------------------------------------------*/
1798 retcode
= SQLForeignKeys(hstmt
,
1799 NULL
, 0, /* Primary catalog */
1800 NULL
, 0, /* Primary schema */
1801 (UCHAR FAR
*)tableName
.c_str(), SQL_NTS
,/* Primary table */
1802 NULL
, 0, /* Foreign catalog */
1803 NULL
, 0, /* Foreign schema */
1804 NULL
, 0); /* Foreign table */
1806 /*---------------------------------------------------------------------*/
1807 /* Fetch and display the result set. This will be all of the foreign */
1808 /* keys in other tables that refer to the tableName primary key. */
1809 /*---------------------------------------------------------------------*/
1812 while ((retcode
== SQL_SUCCESS
) || (retcode
== SQL_SUCCESS_WITH_INFO
))
1814 retcode
= SQLFetch(hstmt
);
1815 if (retcode
== SQL_SUCCESS
|| retcode
== SQL_SUCCESS_WITH_INFO
)
1817 GetData( 3, SQL_C_CHAR
, szPkTable
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
1818 GetData( 4, SQL_C_CHAR
, szPkCol
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
1819 GetData( 5, SQL_C_SSHORT
, &iKeySeq
, 0, &cb
);
1820 GetData( 7, SQL_C_CHAR
, szFkTable
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
1821 GetData( 8, SQL_C_CHAR
, szFkCol
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
1822 tempStr
.Printf(wxT("%s[%s] "),tempStr
.c_str(),szFkTable
); // [ ] in case there is a blank in the Table name
1826 tempStr
.Trim(); // Get rid of any unneeded blanks
1827 if (!tempStr
.IsEmpty())
1829 for (i
=0; i
<noCols
; i
++)
1830 { // Find the Column name
1831 if (!wxStrcmp(colInf
[i
].colName
, szPkCol
)) // We have found the Column, store the Information
1832 wxStrcpy(colInf
[i
].PkTableName
, tempStr
.c_str()); // Name of the Tables where this Primary Key is used as a Foreign Key
1836 SQLFreeStmt(hstmt
, SQL_CLOSE
); /* Close the cursor (the hstmt is still allocated). */
1838 /*---------------------------------------------------------------------*/
1839 /* Get all the foreign keys in the tablename table. */
1840 /*---------------------------------------------------------------------*/
1841 retcode
= SQLForeignKeys(hstmt
,
1842 NULL
, 0, /* Primary catalog */
1843 NULL
, 0, /* Primary schema */
1844 NULL
, 0, /* Primary table */
1845 NULL
, 0, /* Foreign catalog */
1846 NULL
, 0, /* Foreign schema */
1847 (UCHAR
*)tableName
.c_str(), SQL_NTS
);/* Foreign table */
1849 /*---------------------------------------------------------------------*/
1850 /* Fetch and display the result set. This will be all of the */
1851 /* primary keys in other tables that are referred to by foreign */
1852 /* keys in the tableName table. */
1853 /*---------------------------------------------------------------------*/
1855 while ((retcode
== SQL_SUCCESS
) || (retcode
== SQL_SUCCESS_WITH_INFO
))
1857 retcode
= SQLFetch(hstmt
);
1858 if (retcode
== SQL_SUCCESS
|| retcode
== SQL_SUCCESS_WITH_INFO
)
1860 GetData( 3, SQL_C_CHAR
, szPkTable
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
1861 GetData( 5, SQL_C_SSHORT
, &iKeySeq
, 0, &cb
);
1862 GetData( 8, SQL_C_CHAR
, szFkCol
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
1864 for (i
=0; i
<noCols
; i
++) // Find the Column name
1866 if (!wxStrcmp(colInf
[i
].colName
,szFkCol
)) // We have found the (Foreign Key) Column
1868 colInf
[i
].FkCol
= iKeySeq
; // Which Foreign Key is this (first, second usw.) ?
1869 wxStrcpy(colInf
[i
].FkTableName
,szPkTable
); // Name of the Table where this Foriegn is the Primary Key
1874 SQLFreeStmt(hstmt
, SQL_CLOSE
); /* Close the cursor (the hstmt is still allocated). */
1878 } // wxDb::GetKeyFields()
1882 /********** wxDb::GetColumns() **********/
1883 wxDbColInf
*wxDb::GetColumns(wxChar
*tableName
[], const wxChar
*userID
)
1885 * 1) The last array element of the tableName[] argument must be zero (null).
1886 * This is how the end of the array is detected.
1887 * 2) This function returns an array of wxDbColInf structures. If no columns
1888 * were found, or an error occured, this pointer will be zero (null). THE
1889 * CALLING FUNCTION IS RESPONSIBLE FOR DELETING THE MEMORY RETURNED WHEN IT
1890 * IS FINISHED WITH IT. i.e.
1892 * wxDbColInf *colInf = pDb->GetColumns(tableList, userID);
1895 * // Use the column inf
1897 * // Destroy the memory
1901 * userID is evaluated in the following manner:
1902 * userID == NULL ... UserID is ignored
1903 * userID == "" ... UserID set equal to 'this->uid'
1904 * userID != "" ... UserID set equal to 'userID'
1906 * NOTE: ALL column bindings associated with this wxDb instance are unbound
1907 * by this function. This function should use its own wxDb instance
1908 * to avoid undesired unbinding of columns.
1913 wxDbColInf
*colInf
= 0;
1921 convertUserID(userID
,UserID
);
1923 // Pass 1 - Determine how many columns there are.
1924 // Pass 2 - Allocate the wxDbColInf array and fill in
1925 // the array with the column information.
1927 for (pass
= 1; pass
<= 2; pass
++)
1931 if (noCols
== 0) // Probably a bogus table name(s)
1933 // Allocate n wxDbColInf objects to hold the column information
1934 colInf
= new wxDbColInf
[noCols
+1];
1937 // Mark the end of the array
1938 wxStrcpy(colInf
[noCols
].tableName
,wxT(""));
1939 wxStrcpy(colInf
[noCols
].colName
,wxT(""));
1940 colInf
[noCols
].sqlDataType
= 0;
1942 // Loop through each table name
1944 for (tbl
= 0; tableName
[tbl
]; tbl
++)
1946 TableName
= tableName
[tbl
];
1947 // Oracle and Interbase table names are uppercase only, so force
1948 // the name to uppercase just in case programmer forgot to do this
1949 if ((Dbms() == dbmsORACLE
) ||
1950 (Dbms() == dbmsINTERBASE
))
1951 TableName
= TableName
.Upper();
1953 SQLFreeStmt(hstmt
, SQL_CLOSE
);
1955 // MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
1956 // use the call below that leaves out the user name
1957 if (!UserID
.IsEmpty() &&
1958 Dbms() != dbmsMY_SQL
&&
1959 Dbms() != dbmsACCESS
&&
1960 Dbms() != dbmsMS_SQL_SERVER
)
1962 retcode
= SQLColumns(hstmt
,
1963 NULL
, 0, // All qualifiers
1964 (UCHAR
*) UserID
.c_str(), SQL_NTS
, // Owner
1965 (UCHAR
*) TableName
.c_str(), SQL_NTS
,
1966 NULL
, 0); // All columns
1970 retcode
= SQLColumns(hstmt
,
1971 NULL
, 0, // All qualifiers
1973 (UCHAR
*) TableName
.c_str(), SQL_NTS
,
1974 NULL
, 0); // All columns
1976 if (retcode
!= SQL_SUCCESS
)
1977 { // Error occured, abort
1978 DispAllErrors(henv
, hdbc
, hstmt
);
1981 SQLFreeStmt(hstmt
, SQL_CLOSE
);
1985 while ((retcode
= SQLFetch(hstmt
)) == SQL_SUCCESS
)
1987 if (pass
== 1) // First pass, just add up the number of columns
1989 else // Pass 2; Fill in the array of structures
1991 if (colNo
< noCols
) // Some extra error checking to prevent memory overwrites
1993 // NOTE: Only the ODBC 1.x fields are retrieved
1994 GetData( 1, SQL_C_CHAR
, (UCHAR
*) colInf
[colNo
].catalog
, 128+1, &cb
);
1995 GetData( 2, SQL_C_CHAR
, (UCHAR
*) colInf
[colNo
].schema
, 128+1, &cb
);
1996 GetData( 3, SQL_C_CHAR
, (UCHAR
*) colInf
[colNo
].tableName
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
1997 GetData( 4, SQL_C_CHAR
, (UCHAR
*) colInf
[colNo
].colName
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
1998 GetData( 5, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].sqlDataType
, 0, &cb
);
1999 GetData( 6, SQL_C_CHAR
, (UCHAR
*) colInf
[colNo
].typeName
, 128+1, &cb
);
2000 GetData( 7, SQL_C_SLONG
, (UCHAR
*) &colInf
[colNo
].columnSize
, 0, &cb
);
2001 GetData( 8, SQL_C_SLONG
, (UCHAR
*) &colInf
[colNo
].bufferLength
, 0, &cb
);
2002 GetData( 9, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].decimalDigits
,0, &cb
);
2003 GetData(10, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].numPrecRadix
, 0, &cb
);
2004 GetData(11, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].nullable
, 0, &cb
);
2005 GetData(12, SQL_C_CHAR
, (UCHAR
*) colInf
[colNo
].remarks
, 254+1, &cb
);
2007 // Determine the wxDb data type that is used to represent the native data type of this data source
2008 colInf
[colNo
].dbDataType
= 0;
2009 if (!wxStricmp(typeInfVarchar
.TypeName
,colInf
[colNo
].typeName
))
2012 // IODBC does not return a correct columnSize, so we set
2013 // columnSize = bufferLength if no column size was returned
2014 // IODBC returns the columnSize in bufferLength.. (bug)
2015 if (colInf
[colNo
].columnSize
< 1)
2017 colInf
[colNo
].columnSize
= colInf
[colNo
].bufferLength
;
2020 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_VARCHAR
;
2022 else if (!wxStricmp(typeInfInteger
.TypeName
,colInf
[colNo
].typeName
))
2023 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_INTEGER
;
2024 else if (!wxStricmp(typeInfFloat
.TypeName
,colInf
[colNo
].typeName
))
2025 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_FLOAT
;
2026 else if (!wxStricmp(typeInfDate
.TypeName
,colInf
[colNo
].typeName
))
2027 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_DATE
;
2033 if (retcode
!= SQL_NO_DATA_FOUND
)
2034 { // Error occured, abort
2035 DispAllErrors(henv
, hdbc
, hstmt
);
2038 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2044 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2047 } // wxDb::GetColumns()
2050 /********** wxDb::GetColumns() **********/
2052 wxDbColInf
*wxDb::GetColumns(const wxString
&tableName
, int *numCols
, const wxChar
*userID
)
2054 // Same as the above GetColumns() function except this one gets columns
2055 // only for a single table, and if 'numCols' is not NULL, the number of
2056 // columns stored in the returned wxDbColInf is set in '*numCols'
2058 // userID is evaluated in the following manner:
2059 // userID == NULL ... UserID is ignored
2060 // userID == "" ... UserID set equal to 'this->uid'
2061 // userID != "" ... UserID set equal to 'userID'
2063 // NOTE: ALL column bindings associated with this wxDb instance are unbound
2064 // by this function. This function should use its own wxDb instance
2065 // to avoid undesired unbinding of columns.
2070 wxDbColInf
*colInf
= 0;
2078 convertUserID(userID
,UserID
);
2080 // Pass 1 - Determine how many columns there are.
2081 // Pass 2 - Allocate the wxDbColInf array and fill in
2082 // the array with the column information.
2084 for (pass
= 1; pass
<= 2; pass
++)
2088 if (noCols
== 0) // Probably a bogus table name(s)
2090 // Allocate n wxDbColInf objects to hold the column information
2091 colInf
= new wxDbColInf
[noCols
+1];
2094 // Mark the end of the array
2095 wxStrcpy(colInf
[noCols
].tableName
, wxT(""));
2096 wxStrcpy(colInf
[noCols
].colName
, wxT(""));
2097 colInf
[noCols
].sqlDataType
= 0;
2100 TableName
= tableName
;
2101 // Oracle and Interbase table names are uppercase only, so force
2102 // the name to uppercase just in case programmer forgot to do this
2103 if ((Dbms() == dbmsORACLE
) ||
2104 (Dbms() == dbmsINTERBASE
))
2105 TableName
= TableName
.Upper();
2107 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2109 // MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
2110 // use the call below that leaves out the user name
2111 if (!UserID
.IsEmpty() &&
2112 Dbms() != dbmsMY_SQL
&&
2113 Dbms() != dbmsACCESS
&&
2114 Dbms() != dbmsMS_SQL_SERVER
)
2116 retcode
= SQLColumns(hstmt
,
2117 NULL
, 0, // All qualifiers
2118 (UCHAR
*) UserID
.c_str(), SQL_NTS
, // Owner
2119 (UCHAR
*) TableName
.c_str(), SQL_NTS
,
2120 NULL
, 0); // All columns
2124 retcode
= SQLColumns(hstmt
,
2125 NULL
, 0, // All qualifiers
2127 (UCHAR
*) TableName
.c_str(), SQL_NTS
,
2128 NULL
, 0); // All columns
2130 if (retcode
!= SQL_SUCCESS
)
2131 { // Error occured, abort
2132 DispAllErrors(henv
, hdbc
, hstmt
);
2135 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2141 while ((retcode
= SQLFetch(hstmt
)) == SQL_SUCCESS
)
2143 if (pass
== 1) // First pass, just add up the number of columns
2145 else // Pass 2; Fill in the array of structures
2147 if (colNo
< noCols
) // Some extra error checking to prevent memory overwrites
2149 // NOTE: Only the ODBC 1.x fields are retrieved
2150 GetData( 1, SQL_C_CHAR
, (UCHAR
*) colInf
[colNo
].catalog
, 128+1, &cb
);
2151 GetData( 2, SQL_C_CHAR
, (UCHAR
*) colInf
[colNo
].schema
, 128+1, &cb
);
2152 GetData( 3, SQL_C_CHAR
, (UCHAR
*) colInf
[colNo
].tableName
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
2153 GetData( 4, SQL_C_CHAR
, (UCHAR
*) colInf
[colNo
].colName
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
2154 GetData( 5, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].sqlDataType
, 0, &cb
);
2155 GetData( 6, SQL_C_CHAR
, (UCHAR
*) colInf
[colNo
].typeName
, 128+1, &cb
);
2156 GetData( 7, SQL_C_SLONG
, (UCHAR
*) &colInf
[colNo
].columnSize
, 0, &cb
);
2157 // BJO 991214 : SQL_C_SSHORT instead of SQL_C_SLONG, otherwise fails on Sparc (probably all 64 bit architectures)
2158 GetData( 8, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].bufferLength
, 0, &cb
);
2159 GetData( 9, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].decimalDigits
,0, &cb
);
2160 GetData(10, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].numPrecRadix
, 0, &cb
);
2161 GetData(11, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].nullable
, 0, &cb
);
2162 GetData(12, SQL_C_CHAR
, (UCHAR
*) colInf
[colNo
].remarks
, 254+1, &cb
);
2163 // Start Values for Primary/Foriegn Key (=No)
2164 colInf
[colNo
].PkCol
= 0; // Primary key column 0=No; 1= First Key, 2 = Second Key etc.
2165 colInf
[colNo
].PkTableName
[0] = 0; // Tablenames where Primary Key is used as a Foreign Key
2166 colInf
[colNo
].FkCol
= 0; // Foreign key column 0=No; 1= First Key, 2 = Second Key etc.
2167 colInf
[colNo
].FkTableName
[0] = 0; // Foreign key table name
2169 // BJO 20000428 : Virtuoso returns type names with upper cases!
2170 if (Dbms() == dbmsVIRTUOSO
)
2172 wxString s
= colInf
[colNo
].typeName
;
2174 wxStrcmp(colInf
[colNo
].typeName
, s
.c_str());
2177 // Determine the wxDb data type that is used to represent the native data type of this data source
2178 colInf
[colNo
].dbDataType
= 0;
2179 if (!wxStricmp(typeInfVarchar
.TypeName
,colInf
[colNo
].typeName
))
2182 // IODBC does not return a correct columnSize, so we set
2183 // columnSize = bufferLength if no column size was returned
2184 // IODBC returns the columnSize in bufferLength.. (bug)
2185 if (colInf
[colNo
].columnSize
< 1)
2187 colInf
[colNo
].columnSize
= colInf
[colNo
].bufferLength
;
2191 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_VARCHAR
;
2193 else if (!wxStricmp(typeInfInteger
.TypeName
,colInf
[colNo
].typeName
))
2194 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_INTEGER
;
2195 else if (!wxStricmp(typeInfFloat
.TypeName
,colInf
[colNo
].typeName
))
2196 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_FLOAT
;
2197 else if (!wxStricmp(typeInfDate
.TypeName
,colInf
[colNo
].typeName
))
2198 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_DATE
;
2204 if (retcode
!= SQL_NO_DATA_FOUND
)
2205 { // Error occured, abort
2206 DispAllErrors(henv
, hdbc
, hstmt
);
2209 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2216 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2218 // Store Primary and Foriegn Keys
2219 GetKeyFields(tableName
,colInf
,noCols
);
2225 } // wxDb::GetColumns()
2228 #else // New GetColumns
2233 These are tentative new GetColumns members which should be more database
2234 independant and which always returns the columns in the order they were
2237 - The first one (wxDbColInf *wxDb::GetColumns(wxChar *tableName[], const
2238 wxChar* userID)) calls the second implementation for each separate table
2239 before merging the results. This makes the code easier to maintain as
2240 only one member (the second) makes the real work
2241 - wxDbColInf *wxDb::GetColumns(const wxString &tableName, int *numCols, const
2242 wxChar *userID) is a little bit improved
2243 - It doesn't anymore rely on the type-name to find out which database-type
2245 - It ends by sorting the columns, so that they are returned in the same
2246 order they were created
2256 wxDbColInf
*wxDb::GetColumns(wxChar
*tableName
[], const wxChar
*userID
)
2259 // The last array element of the tableName[] argument must be zero (null).
2260 // This is how the end of the array is detected.
2264 // How many tables ?
2266 for (tbl
= 0 ; tableName
[tbl
]; tbl
++);
2268 // Create a table to maintain the columns for each separate table
2269 _TableColumns
*TableColumns
= new _TableColumns
[tbl
];
2272 for (i
= 0 ; i
< tbl
; i
++)
2275 TableColumns
[i
].colInf
= GetColumns(tableName
[i
], &TableColumns
[i
].noCols
, userID
);
2276 if (TableColumns
[i
].colInf
== NULL
)
2278 noCols
+= TableColumns
[i
].noCols
;
2281 // Now merge all the separate table infos
2282 wxDbColInf
*colInf
= new wxDbColInf
[noCols
+1];
2284 // Mark the end of the array
2285 wxStrcpy(colInf
[noCols
].tableName
, wxT(""));
2286 wxStrcpy(colInf
[noCols
].colName
, wxT(""));
2287 colInf
[noCols
].sqlDataType
= 0;
2292 for (i
= 0 ; i
< tbl
; i
++)
2294 for (j
= 0 ; j
< TableColumns
[i
].noCols
; j
++)
2296 colInf
[offset
++] = TableColumns
[i
].colInf
[j
];
2300 delete [] TableColumns
;
2303 } // wxDb::GetColumns() -- NEW
2306 wxDbColInf
*wxDb::GetColumns(const wxString
&tableName
, int *numCols
, const wxChar
*userID
)
2308 // Same as the above GetColumns() function except this one gets columns
2309 // only for a single table, and if 'numCols' is not NULL, the number of
2310 // columns stored in the returned wxDbColInf is set in '*numCols'
2312 // userID is evaluated in the following manner:
2313 // userID == NULL ... UserID is ignored
2314 // userID == "" ... UserID set equal to 'this->uid'
2315 // userID != "" ... UserID set equal to 'userID'
2317 // NOTE: ALL column bindings associated with this wxDb instance are unbound
2318 // by this function. This function should use its own wxDb instance
2319 // to avoid undesired unbinding of columns.
2323 wxDbColInf
*colInf
= 0;
2331 convertUserID(userID
,UserID
);
2333 // Pass 1 - Determine how many columns there are.
2334 // Pass 2 - Allocate the wxDbColInf array and fill in
2335 // the array with the column information.
2337 for (pass
= 1; pass
<= 2; pass
++)
2341 if (noCols
== 0) // Probably a bogus table name(s)
2343 // Allocate n wxDbColInf objects to hold the column information
2344 colInf
= new wxDbColInf
[noCols
+1];
2347 // Mark the end of the array
2348 wxStrcpy(colInf
[noCols
].tableName
, wxT(""));
2349 wxStrcpy(colInf
[noCols
].colName
, wxT(""));
2350 colInf
[noCols
].sqlDataType
= 0;
2353 TableName
= tableName
;
2354 // Oracle and Interbase table names are uppercase only, so force
2355 // the name to uppercase just in case programmer forgot to do this
2356 if ((Dbms() == dbmsORACLE
) ||
2357 (Dbms() == dbmsINTERBASE
))
2358 TableName
= TableName
.Upper();
2360 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2362 // MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
2363 // use the call below that leaves out the user name
2364 if (!UserID
.IsEmpty() &&
2365 Dbms() != dbmsMY_SQL
&&
2366 Dbms() != dbmsACCESS
&&
2367 Dbms() != dbmsMS_SQL_SERVER
)
2369 retcode
= SQLColumns(hstmt
,
2370 NULL
, 0, // All qualifiers
2371 (UCHAR
*) UserID
.c_str(), SQL_NTS
, // Owner
2372 (UCHAR
*) TableName
.c_str(), SQL_NTS
,
2373 NULL
, 0); // All columns
2377 retcode
= SQLColumns(hstmt
,
2378 NULL
, 0, // All qualifiers
2380 (UCHAR
*) TableName
.c_str(), SQL_NTS
,
2381 NULL
, 0); // All columns
2383 if (retcode
!= SQL_SUCCESS
)
2384 { // Error occured, abort
2385 DispAllErrors(henv
, hdbc
, hstmt
);
2388 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2394 while ((retcode
= SQLFetch(hstmt
)) == SQL_SUCCESS
)
2396 if (pass
== 1) // First pass, just add up the number of columns
2398 else // Pass 2; Fill in the array of structures
2400 if (colNo
< noCols
) // Some extra error checking to prevent memory overwrites
2402 // NOTE: Only the ODBC 1.x fields are retrieved
2403 GetData( 1, SQL_C_CHAR
, (UCHAR
*) colInf
[colNo
].catalog
, 128+1, &cb
);
2404 GetData( 2, SQL_C_CHAR
, (UCHAR
*) colInf
[colNo
].schema
, 128+1, &cb
);
2405 GetData( 3, SQL_C_CHAR
, (UCHAR
*) colInf
[colNo
].tableName
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
2406 GetData( 4, SQL_C_CHAR
, (UCHAR
*) colInf
[colNo
].colName
, DB_MAX_COLUMN_NAME_LEN
+1, &cb
);
2407 GetData( 5, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].sqlDataType
, 0, &cb
);
2408 GetData( 6, SQL_C_CHAR
, (UCHAR
*) colInf
[colNo
].typeName
, 128+1, &cb
);
2409 GetData( 7, SQL_C_SLONG
, (UCHAR
*) &colInf
[colNo
].columnSize
, 0, &cb
);
2410 GetData( 8, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].bufferLength
, 0, &cb
);
2411 GetData( 9, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].decimalDigits
,0, &cb
);
2412 GetData(10, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].numPrecRadix
, 0, &cb
);
2413 GetData(11, SQL_C_SSHORT
, (UCHAR
*) &colInf
[colNo
].nullable
, 0, &cb
);
2414 GetData(12, SQL_C_CHAR
, (UCHAR
*) colInf
[colNo
].remarks
, 254+1, &cb
);
2415 // Start Values for Primary/Foriegn Key (=No)
2416 colInf
[colNo
].PkCol
= 0; // Primary key column 0=No; 1= First Key, 2 = Second Key etc.
2417 colInf
[colNo
].PkTableName
[0] = 0; // Tablenames where Primary Key is used as a Foreign Key
2418 colInf
[colNo
].FkCol
= 0; // Foreign key column 0=No; 1= First Key, 2 = Second Key etc.
2419 colInf
[colNo
].FkTableName
[0] = 0; // Foreign key table name
2422 // IODBC does not return a correct columnSize, so we set
2423 // columnSize = bufferLength if no column size was returned
2424 // IODBC returns the columnSize in bufferLength.. (bug)
2425 if (colInf
[colNo
].columnSize
< 1)
2427 colInf
[colNo
].columnSize
= colInf
[colNo
].bufferLength
;
2431 // Determine the wxDb data type that is used to represent the native data type of this data source
2432 colInf
[colNo
].dbDataType
= 0;
2433 // Get the intern datatype
2434 switch (colInf
[colNo
].sqlDataType
)
2438 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_VARCHAR
;
2444 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_INTEGER
;
2451 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_FLOAT
;
2454 colInf
[colNo
].dbDataType
= DB_DATA_TYPE_DATE
;
2459 errMsg
.Printf(wxT("SQL Data type %d currently not supported by wxWindows"), colInf
[colNo
].sqlDataType
);
2460 wxLogDebug(errMsg
,wxT("ODBC DEBUG MESSAGE"));
2467 if (retcode
!= SQL_NO_DATA_FOUND
)
2468 { // Error occured, abort
2469 DispAllErrors(henv
, hdbc
, hstmt
);
2472 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2479 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2481 // Store Primary and Foreign Keys
2482 GetKeyFields(tableName
,colInf
,noCols
);
2484 ///////////////////////////////////////////////////////////////////////////
2485 // Now sort the the columns in order to make them appear in the right order
2486 ///////////////////////////////////////////////////////////////////////////
2488 // Build a generic SELECT statement which returns 0 rows
2491 Stmt
.Printf(wxT("select * from %s where 0=1"), tableName
);
2494 if (SQLExecDirect(hstmt
, (UCHAR FAR
*) Stmt
.c_str(), SQL_NTS
) != SQL_SUCCESS
)
2496 DispAllErrors(henv
, hdbc
, hstmt
);
2500 // Get the number of result columns
2501 if (SQLNumResultCols (hstmt
, &noCols
) != SQL_SUCCESS
)
2503 DispAllErrors(henv
, hdbc
, hstmt
);
2507 if (noCols
== 0) // Probably a bogus table name
2516 for (colNum
= 0; colNum
< noCols
; colNum
++)
2518 if (SQLColAttributes(hstmt
,colNum
+1, SQL_COLUMN_NAME
,
2520 &Sword
, &Sdword
) != SQL_SUCCESS
)
2522 DispAllErrors(henv
, hdbc
, hstmt
);
2526 wxString Name1
= name
;
2527 Name1
= Name1
.Upper();
2529 // Where is this name in the array ?
2530 for (i
= colNum
; i
< noCols
; i
++)
2532 wxString Name2
= colInf
[i
].colName
;
2533 Name2
= Name2
.Upper();
2536 if (colNum
!= i
) // swap to sort
2538 wxDbColInf tmpColInf
= colInf
[colNum
];
2539 colInf
[colNum
] = colInf
[i
];
2540 colInf
[i
] = tmpColInf
;
2546 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2548 ///////////////////////////////////////////////////////////////////////////
2550 ///////////////////////////////////////////////////////////////////////////
2556 } // wxDb::GetColumns()
2559 #endif // #else OLD_GETCOLUMNS
2562 /********** wxDb::GetColumnCount() **********/
2563 int wxDb::GetColumnCount(const wxString
&tableName
, const wxChar
*userID
)
2565 * Returns a count of how many columns are in a table.
2566 * If an error occurs in computing the number of columns
2567 * this function will return a -1 for the count
2569 * userID is evaluated in the following manner:
2570 * userID == NULL ... UserID is ignored
2571 * userID == "" ... UserID set equal to 'this->uid'
2572 * userID != "" ... UserID set equal to 'userID'
2574 * NOTE: ALL column bindings associated with this wxDb instance are unbound
2575 * by this function. This function should use its own wxDb instance
2576 * to avoid undesired unbinding of columns.
2586 convertUserID(userID
,UserID
);
2588 TableName
= tableName
;
2589 // Oracle and Interbase table names are uppercase only, so force
2590 // the name to uppercase just in case programmer forgot to do this
2591 if ((Dbms() == dbmsORACLE
) ||
2592 (Dbms() == dbmsINTERBASE
))
2593 TableName
= TableName
.Upper();
2595 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2597 // MySQL, SQLServer, and Access cannot accept a user name when looking up column names, so we
2598 // use the call below that leaves out the user name
2599 if (!UserID
.IsEmpty() &&
2600 Dbms() != dbmsMY_SQL
&&
2601 Dbms() != dbmsACCESS
&&
2602 Dbms() != dbmsMS_SQL_SERVER
)
2604 retcode
= SQLColumns(hstmt
,
2605 NULL
, 0, // All qualifiers
2606 (UCHAR
*) UserID
.c_str(), SQL_NTS
, // Owner
2607 (UCHAR
*) TableName
.c_str(), SQL_NTS
,
2608 NULL
, 0); // All columns
2612 retcode
= SQLColumns(hstmt
,
2613 NULL
, 0, // All qualifiers
2615 (UCHAR
*) TableName
.c_str(), SQL_NTS
,
2616 NULL
, 0); // All columns
2618 if (retcode
!= SQL_SUCCESS
)
2619 { // Error occured, abort
2620 DispAllErrors(henv
, hdbc
, hstmt
);
2621 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2625 // Count the columns
2626 while ((retcode
= SQLFetch(hstmt
)) == SQL_SUCCESS
)
2629 if (retcode
!= SQL_NO_DATA_FOUND
)
2630 { // Error occured, abort
2631 DispAllErrors(henv
, hdbc
, hstmt
);
2632 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2636 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2639 } // wxDb::GetColumnCount()
2642 /********** wxDb::GetCatalog() *******/
2643 wxDbInf
*wxDb::GetCatalog(const wxChar
*userID
)
2645 * ---------------------------------------------------------------------
2646 * -- 19991203 : mj10777 : Create ------
2647 * -- : Creates a wxDbInf with Tables / Cols Array ------
2648 * -- : uses SQLTables and fills pTableInf; ------
2649 * -- : pColInf is set to NULL and numCols to 0; ------
2650 * -- : returns pDbInf (wxDbInf) ------
2651 * -- - if unsuccesfull (pDbInf == NULL) ------
2652 * -- : pColInf can be filled with GetColumns(..); ------
2653 * -- : numCols can be filled with GetColumnCount(..); ------
2654 * ---------------------------------------------------------------------
2656 * userID is evaluated in the following manner:
2657 * userID == NULL ... UserID is ignored
2658 * userID == "" ... UserID set equal to 'this->uid'
2659 * userID != "" ... UserID set equal to 'userID'
2661 * NOTE: ALL column bindings associated with this wxDb instance are unbound
2662 * by this function. This function should use its own wxDb instance
2663 * to avoid undesired unbinding of columns.
2666 wxDbInf
*pDbInf
= NULL
; // Array of catalog entries
2667 int noTab
= 0; // Counter while filling table entries
2671 wxString tblNameSave
;
2674 convertUserID(userID
,UserID
);
2676 //-------------------------------------------------------------
2677 pDbInf
= new wxDbInf
; // Create the Database Array
2678 //-------------------------------------------------------------
2679 // Table Information
2680 // Pass 1 - Determine how many Tables there are.
2681 // Pass 2 - Create the Table array and fill it
2682 // - Create the Cols array = NULL
2683 //-------------------------------------------------------------
2685 for (pass
= 1; pass
<= 2; pass
++)
2687 SQLFreeStmt(hstmt
, SQL_CLOSE
); // Close if Open
2688 tblNameSave
.Empty();
2690 if (!UserID
.IsEmpty() &&
2691 Dbms() != dbmsMY_SQL
&&
2692 Dbms() != dbmsACCESS
&&
2693 Dbms() != dbmsMS_SQL_SERVER
)
2695 retcode
= SQLTables(hstmt
,
2696 NULL
, 0, // All qualifiers
2697 (UCHAR
*) UserID
.c_str(), SQL_NTS
, // User specified
2698 NULL
, 0, // All tables
2699 NULL
, 0); // All columns
2703 retcode
= SQLTables(hstmt
,
2704 NULL
, 0, // All qualifiers
2705 NULL
, 0, // User specified
2706 NULL
, 0, // All tables
2707 NULL
, 0); // All columns
2710 if (retcode
!= SQL_SUCCESS
)
2712 DispAllErrors(henv
, hdbc
, hstmt
);
2714 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2718 while ((retcode
= SQLFetch(hstmt
)) == SQL_SUCCESS
) // Table Information
2720 if (pass
== 1) // First pass, just count the Tables
2722 if (pDbInf
->numTables
== 0)
2724 GetData( 1, SQL_C_CHAR
, (UCHAR
*) pDbInf
->catalog
, 128+1, &cb
);
2725 GetData( 2, SQL_C_CHAR
, (UCHAR
*) pDbInf
->schema
, 128+1, &cb
);
2727 pDbInf
->numTables
++; // Counter for Tables
2729 if (pass
== 2) // Create and fill the Table entries
2731 if (pDbInf
->pTableInf
== NULL
) // Has the Table Array been created
2732 { // no, then create the Array
2733 pDbInf
->pTableInf
= new wxDbTableInf
[pDbInf
->numTables
];
2735 } // if (pDbInf->pTableInf == NULL) // Has the Table Array been created
2737 GetData( 3, SQL_C_CHAR
, (UCHAR
*) (pDbInf
->pTableInf
+noTab
)->tableName
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
2738 GetData( 4, SQL_C_CHAR
, (UCHAR
*) (pDbInf
->pTableInf
+noTab
)->tableType
, 30+1, &cb
);
2739 GetData( 5, SQL_C_CHAR
, (UCHAR
*) (pDbInf
->pTableInf
+noTab
)->tableRemarks
, 254+1, &cb
);
2745 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2747 // Query how many columns are in each table
2748 for (noTab
=0;noTab
<pDbInf
->numTables
;noTab
++)
2750 (pDbInf
->pTableInf
+noTab
)->numCols
= GetColumnCount((pDbInf
->pTableInf
+noTab
)->tableName
,UserID
);
2755 } // wxDb::GetCatalog()
2758 /********** wxDb::Catalog() **********/
2759 bool wxDb::Catalog(const wxChar
*userID
, const wxString
&fileName
)
2761 * Creates the text file specified in 'filename' which will contain
2762 * a minimal data dictionary of all tables accessible by the user specified
2765 * userID is evaluated in the following manner:
2766 * userID == NULL ... UserID is ignored
2767 * userID == "" ... UserID set equal to 'this->uid'
2768 * userID != "" ... UserID set equal to 'userID'
2770 * NOTE: ALL column bindings associated with this wxDb instance are unbound
2771 * by this function. This function should use its own wxDb instance
2772 * to avoid undesired unbinding of columns.
2775 wxASSERT(fileName
.Length());
2779 wxChar tblName
[DB_MAX_TABLE_NAME_LEN
+1];
2780 wxString tblNameSave
;
2781 wxChar colName
[DB_MAX_COLUMN_NAME_LEN
+1];
2783 wxChar typeName
[30+1];
2784 SWORD precision
, length
;
2786 FILE *fp
= fopen(fileName
.c_str(),wxT("wt"));
2790 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2793 convertUserID(userID
,UserID
);
2795 if (!UserID
.IsEmpty() &&
2796 Dbms() != dbmsMY_SQL
&&
2797 Dbms() != dbmsACCESS
&&
2798 Dbms() != dbmsMS_SQL_SERVER
)
2800 retcode
= SQLColumns(hstmt
,
2801 NULL
, 0, // All qualifiers
2802 (UCHAR
*) UserID
.c_str(), SQL_NTS
, // User specified
2803 NULL
, 0, // All tables
2804 NULL
, 0); // All columns
2808 retcode
= SQLColumns(hstmt
,
2809 NULL
, 0, // All qualifiers
2810 NULL
, 0, // User specified
2811 NULL
, 0, // All tables
2812 NULL
, 0); // All columns
2814 if (retcode
!= SQL_SUCCESS
)
2816 DispAllErrors(henv
, hdbc
, hstmt
);
2822 tblNameSave
.Empty();
2825 while ((retcode
= SQLFetch(hstmt
)) == SQL_SUCCESS
)
2827 if (wxStrcmp(tblName
, tblNameSave
.c_str()))
2830 fputs(wxT("\n"), fp
);
2831 fputs(wxT("================================ "), fp
);
2832 fputs(wxT("================================ "), fp
);
2833 fputs(wxT("===================== "), fp
);
2834 fputs(wxT("========= "), fp
);
2835 fputs(wxT("=========\n"), fp
);
2836 outStr
.Printf(wxT("%-32s %-32s %-21s %9s %9s\n"),
2837 wxT("TABLE NAME"), wxT("COLUMN NAME"), wxT("DATA TYPE"), wxT("PRECISION"), wxT("LENGTH"));
2838 fputs(outStr
.c_str(), fp
);
2839 fputs(wxT("================================ "), fp
);
2840 fputs(wxT("================================ "), fp
);
2841 fputs(wxT("===================== "), fp
);
2842 fputs(wxT("========= "), fp
);
2843 fputs(wxT("=========\n"), fp
);
2844 tblNameSave
= tblName
;
2847 GetData(3,SQL_C_CHAR
, (UCHAR
*)tblName
, DB_MAX_TABLE_NAME_LEN
+1, &cb
);
2848 GetData(4,SQL_C_CHAR
, (UCHAR
*)colName
, DB_MAX_COLUMN_NAME_LEN
+1,&cb
);
2849 GetData(5,SQL_C_SSHORT
,(UCHAR
*)&sqlDataType
,0, &cb
);
2850 GetData(6,SQL_C_CHAR
, (UCHAR
*)typeName
, sizeof(typeName
), &cb
);
2851 GetData(7,SQL_C_SSHORT
,(UCHAR
*)&precision
, 0, &cb
);
2852 GetData(8,SQL_C_SSHORT
,(UCHAR
*)&length
, 0, &cb
);
2854 outStr
.Printf(wxT("%-32s %-32s (%04d)%-15s %9d %9d\n"),
2855 tblName
, colName
, sqlDataType
, typeName
, precision
, length
);
2856 if (fputs(outStr
.c_str(), fp
) == EOF
)
2858 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2865 if (retcode
!= SQL_NO_DATA_FOUND
)
2866 DispAllErrors(henv
, hdbc
, hstmt
);
2868 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2871 return(retcode
== SQL_NO_DATA_FOUND
);
2873 } // wxDb::Catalog()
2876 bool wxDb::TableExists(const wxString
&tableName
, const wxChar
*userID
, const wxString
&tablePath
)
2878 * Table name can refer to a table, view, alias or synonym. Returns true
2879 * if the object exists in the database. This function does not indicate
2880 * whether or not the user has privleges to query or perform other functions
2883 * userID is evaluated in the following manner:
2884 * userID == NULL ... UserID is ignored
2885 * userID == "" ... UserID set equal to 'this->uid'
2886 * userID != "" ... UserID set equal to 'userID'
2889 wxASSERT(tableName
.Length());
2893 if (Dbms() == dbmsDBASE
)
2896 if (tablePath
.Length())
2897 dbName
.Printf(wxT("%s/%s.dbf"),tablePath
,tableName
);
2899 dbName
.Printf(wxT("%s.dbf"),tableName
);
2902 exists
= wxFileExists(dbName
);
2907 convertUserID(userID
,UserID
);
2909 TableName
= tableName
;
2910 // Oracle and Interbase table names are uppercase only, so force
2911 // the name to uppercase just in case programmer forgot to do this
2912 if ((Dbms() == dbmsORACLE
) ||
2913 (Dbms() == dbmsINTERBASE
))
2914 TableName
= TableName
.Upper();
2916 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2919 // Some databases cannot accept a user name when looking up table names,
2920 // so we use the call below that leaves out the user name
2921 if (!UserID
.IsEmpty() &&
2922 Dbms() != dbmsMY_SQL
&&
2923 Dbms() != dbmsACCESS
&&
2924 Dbms() != dbmsMS_SQL_SERVER
)
2926 retcode
= SQLTables(hstmt
,
2927 NULL
, 0, // All qualifiers
2928 (UCHAR
*) UserID
.c_str(), SQL_NTS
, // Only tables owned by this user
2929 (UCHAR FAR
*)TableName
.c_str(), SQL_NTS
,
2930 NULL
, 0); // All table types
2934 retcode
= SQLTables(hstmt
,
2935 NULL
, 0, // All qualifiers
2936 NULL
, 0, // All owners
2937 (UCHAR FAR
*)TableName
.c_str(), SQL_NTS
,
2938 NULL
, 0); // All table types
2940 if (retcode
!= SQL_SUCCESS
)
2941 return(DispAllErrors(henv
, hdbc
, hstmt
));
2943 retcode
= SQLFetch(hstmt
);
2944 if (retcode
!= SQL_SUCCESS
&& retcode
!= SQL_SUCCESS_WITH_INFO
)
2946 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2947 return(DispAllErrors(henv
, hdbc
, hstmt
));
2950 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2954 } // wxDb::TableExists()
2957 /********** wxDb::TablePrivileges() **********/
2958 bool wxDb::TablePrivileges(const wxString
&tableName
, const wxString
&priv
, const wxChar
*userID
,
2959 const wxChar
*schema
, const wxString
&tablePath
)
2961 wxASSERT(tableName
.Length());
2963 wxDbTablePrivilegeInfo result
;
2967 // We probably need to be able to dynamically set this based on
2968 // the driver type, and state.
2969 wxChar curRole
[]=wxT("public");
2974 convertUserID(userID
,UserID
);
2976 TableName
= tableName
;
2977 // Oracle and Interbase table names are uppercase only, so force
2978 // the name to uppercase just in case programmer forgot to do this
2979 if ((Dbms() == dbmsORACLE
) ||
2980 (Dbms() == dbmsINTERBASE
))
2981 TableName
= TableName
.Upper();
2983 SQLFreeStmt(hstmt
, SQL_CLOSE
);
2987 retcode
= SQLTablePrivileges(hstmt
,
2990 (UCHAR FAR
*)TableName
.c_str(), SQL_NTS
);
2994 retcode
= SQLTablePrivileges(hstmt
,
2996 (UCHAR FAR
*)schema
, SQL_NTS
, // Schema
2997 (UCHAR FAR
*)TableName
.c_str(), SQL_NTS
);
3000 #ifdef DBDEBUG_CONSOLE
3001 fprintf(stderr
,wxT("SQLTablePrivileges() returned %i \n"),retcode
);
3004 if ((retcode
!= SQL_SUCCESS
) && (retcode
!= SQL_SUCCESS_WITH_INFO
))
3005 return(DispAllErrors(henv
, hdbc
, hstmt
));
3007 retcode
= SQLFetch(hstmt
);
3008 while (retcode
== SQL_SUCCESS
|| retcode
== SQL_SUCCESS_WITH_INFO
)
3010 if (SQLGetData(hstmt
, 1, SQL_C_CHAR
, (UCHAR
*) result
.tableQual
, sizeof(result
.tableQual
), &cbRetVal
) != SQL_SUCCESS
)
3011 return(DispAllErrors(henv
, hdbc
, hstmt
));
3013 if (SQLGetData(hstmt
, 2, SQL_C_CHAR
, (UCHAR
*) result
.tableOwner
, sizeof(result
.tableOwner
), &cbRetVal
) != SQL_SUCCESS
)
3014 return(DispAllErrors(henv
, hdbc
, hstmt
));
3016 if (SQLGetData(hstmt
, 3, SQL_C_CHAR
, (UCHAR
*) result
.tableName
, sizeof(result
.tableName
), &cbRetVal
) != SQL_SUCCESS
)
3017 return(DispAllErrors(henv
, hdbc
, hstmt
));
3019 if (SQLGetData(hstmt
, 4, SQL_C_CHAR
, (UCHAR
*) result
.grantor
, sizeof(result
.grantor
), &cbRetVal
) != SQL_SUCCESS
)
3020 return(DispAllErrors(henv
, hdbc
, hstmt
));
3022 if (SQLGetData(hstmt
, 5, SQL_C_CHAR
, (UCHAR
*) result
.grantee
, sizeof(result
.grantee
), &cbRetVal
) != SQL_SUCCESS
)
3023 return(DispAllErrors(henv
, hdbc
, hstmt
));
3025 if (SQLGetData(hstmt
, 6, SQL_C_CHAR
, (UCHAR
*) result
.privilege
, sizeof(result
.privilege
), &cbRetVal
) != SQL_SUCCESS
)
3026 return(DispAllErrors(henv
, hdbc
, hstmt
));
3028 if (SQLGetData(hstmt
, 7, SQL_C_CHAR
, (UCHAR
*) result
.grantable
, sizeof(result
.grantable
), &cbRetVal
) != SQL_SUCCESS
)
3029 return(DispAllErrors(henv
, hdbc
, hstmt
));
3031 #ifdef DBDEBUG_CONSOLE
3032 fprintf(stderr
,wxT("Scanning %s privilege on table %s.%s granted by %s to %s\n"),
3033 result
.privilege
,result
.tableOwner
,result
.tableName
,
3034 result
.grantor
, result
.grantee
);
3037 if (UserID
.IsSameAs(result
.tableOwner
,FALSE
))
3039 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3043 if (UserID
.IsSameAs(result
.grantee
,FALSE
) &&
3044 !wxStrcmp(result
.privilege
,priv
))
3046 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3050 if (!wxStrcmp(result
.grantee
,curRole
) &&
3051 !wxStrcmp(result
.privilege
,priv
))
3053 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3057 retcode
= SQLFetch(hstmt
);
3060 SQLFreeStmt(hstmt
, SQL_CLOSE
);
3063 } // wxDb::TablePrivileges
3066 /********** wxDb::SetSqlLogging() **********/
3067 bool wxDb::SetSqlLogging(wxDbSqlLogState state
, const wxString
&filename
, bool append
)
3069 wxASSERT(state
== sqlLogON
|| state
== sqlLogOFF
);
3070 wxASSERT(state
== sqlLogOFF
|| filename
.Length());
3072 if (state
== sqlLogON
)
3076 fpSqlLog
= fopen(filename
, (append
? wxT("at") : wxT("wt")));
3077 if (fpSqlLog
== NULL
)
3085 if (fclose(fpSqlLog
))
3091 sqlLogState
= state
;
3094 } // wxDb::SetSqlLogging()
3097 /********** wxDb::WriteSqlLog() **********/
3098 bool wxDb::WriteSqlLog(const wxString
&logMsg
)
3100 wxASSERT(logMsg
.Length());
3102 if (fpSqlLog
== 0 || sqlLogState
== sqlLogOFF
)
3105 if (fputs(wxT("\n"), fpSqlLog
) == EOF
)
3107 if (fputs(logMsg
, fpSqlLog
) == EOF
)
3109 if (fputs(wxT("\n"), fpSqlLog
) == EOF
)
3114 } // wxDb::WriteSqlLog()
3117 /********** wxDb::Dbms() **********/
3118 wxDBMS
wxDb::Dbms(void)
3120 * Be aware that not all database engines use the exact same syntax, and not
3121 * every ODBC compliant database is compliant to the same level of compliancy.
3122 * Some manufacturers support the minimum Level 1 compliancy, and others up
3123 * through Level 3. Others support subsets of features for levels above 1.
3125 * If you find an inconsistency between the wxDb class and a specific database
3126 * engine, and an identifier to this section, and special handle the database in
3127 * the area where behavior is non-conforming with the other databases.
3130 * NOTES ABOUT ISSUES SPECIFIC TO EACH DATABASE ENGINE
3131 * ---------------------------------------------------
3134 * - Currently the only database supported by the class to support VIEWS
3137 * - Does not support the SQL_TIMESTAMP structure
3138 * - Supports only one cursor and one connect (apparently? with Microsoft driver only?)
3139 * - Does not automatically create the primary index if the 'keyField' param of SetColDef
3140 * is TRUE. The user must create ALL indexes from their program.
3141 * - Table names can only be 8 characters long
3142 * - Column names can only be 10 characters long
3145 * - To lock a record during QUERY functions, the reserved word 'HOLDLOCK' must be added
3146 * after every table name involved in the query/join if that tables matching record(s)
3148 * - Ignores the keywords 'FOR UPDATE'. Use the HOLDLOCK functionality described above
3150 * SYBASE (Enterprise)
3151 * - If a column is part of the Primary Key, the column cannot be NULL
3152 * - Maximum row size is somewhere in the neighborhood of 1920 bytes
3155 * - If a column is part of the Primary Key, the column cannot be NULL
3156 * - Cannot support selecting for update [::CanSelectForUpdate()]. Always returns FALSE
3157 * - Columns that are part of primary or secondary keys must be defined as being NOT NULL
3158 * when they are created. Some code is added in ::CreateIndex to try to adjust the
3159 * column definition if it is not defined correctly, but it is experimental
3160 * - Does not support sub-queries in SQL statements
3163 * - Does not support the keywords 'ASC' or 'DESC' as of release v6.5.0
3164 * - Does not support sub-queries in SQL statements
3167 * - Primary keys must be declared as NOT NULL
3171 // Should only need to do this once for each new database connection
3172 // so return the value we already determined it to be to save time
3173 // and lots of string comparisons
3174 if (dbmsType
!= dbmsUNIDENTIFIED
)
3177 wxChar baseName
[25+1];
3178 wxStrncpy(baseName
,dbInf
.dbmsName
,25);
3181 // RGG 20001025 : add support for Interbase
3182 // GT : Integrated to base classes on 20001121
3183 if (!wxStricmp(dbInf
.dbmsName
,wxT("Interbase")))
3184 return((wxDBMS
)(dbmsType
= dbmsINTERBASE
));
3186 // BJO 20000428 : add support for Virtuoso
3187 if (!wxStricmp(dbInf
.dbmsName
,wxT("OpenLink Virtuoso VDBMS")))
3188 return((wxDBMS
)(dbmsType
= dbmsVIRTUOSO
));
3190 if (!wxStricmp(dbInf
.dbmsName
,wxT("Adaptive Server Anywhere")))
3191 return((wxDBMS
)(dbmsType
= dbmsSYBASE_ASA
));
3193 // BJO 20000427 : The "SQL Server" string is also returned by SQLServer when
3194 // connected through an OpenLink driver.
3195 // Is it also returned by Sybase Adapatitve server?
3196 // OpenLink driver name is OLOD3032.DLL for msw and oplodbc.so for unix
3197 if (!wxStricmp(dbInf
.dbmsName
,wxT("SQL Server")))
3199 if (!wxStrncmp(dbInf
.driverName
, wxT("oplodbc"), 7) ||
3200 !wxStrncmp(dbInf
.driverName
, wxT("OLOD"), 4))
3201 return ((wxDBMS
)(dbmsMS_SQL_SERVER
));
3203 return ((wxDBMS
)(dbmsType
= dbmsSYBASE_ASE
));
3206 if (!wxStricmp(dbInf
.dbmsName
,wxT("Microsoft SQL Server")))
3207 return((wxDBMS
)(dbmsType
= dbmsMS_SQL_SERVER
));
3208 if (!wxStricmp(dbInf
.dbmsName
,wxT("MySQL")))
3209 return((wxDBMS
)(dbmsType
= dbmsMY_SQL
));
3210 if (!wxStricmp(dbInf
.dbmsName
,wxT("PostgreSQL"))) // v6.5.0
3211 return((wxDBMS
)(dbmsType
= dbmsPOSTGRES
));
3214 if (!wxStricmp(baseName
,wxT("Informix")))
3215 return((wxDBMS
)(dbmsType
= dbmsINFORMIX
));
3218 if (!wxStricmp(baseName
,wxT("Oracle")))
3219 return((wxDBMS
)(dbmsType
= dbmsORACLE
));
3220 if (!wxStricmp(dbInf
.dbmsName
,wxT("ACCESS")))
3221 return((wxDBMS
)(dbmsType
= dbmsACCESS
));
3222 if (!wxStricmp(dbInf
.dbmsName
,wxT("MySQL")))
3223 return((wxDBMS
)(dbmsType
= dbmsMY_SQL
));
3224 if (!wxStricmp(baseName
,wxT("Sybase")))
3225 return((wxDBMS
)(dbmsType
= dbmsSYBASE_ASE
));
3228 if (!wxStricmp(baseName
,wxT("DBASE")))
3229 return((wxDBMS
)(dbmsType
= dbmsDBASE
));
3232 if (!wxStricmp(baseName
,wxT("DB2")))
3233 return((wxDBMS
)(dbmsType
= dbmsDBASE
));
3235 return((wxDBMS
)(dbmsType
= dbmsUNIDENTIFIED
));
3240 bool wxDb::ModifyColumn(const wxString
&tableName
, const wxString
&columnName
,
3241 int dataType
, ULONG columnLength
,
3242 const wxString
&optionalParam
)
3244 wxASSERT(tableName
.Length());
3245 wxASSERT(columnName
.Length());
3246 wxASSERT((dataType
== DB_DATA_TYPE_VARCHAR
&& columnLength
> 0) ||
3247 dataType
!= DB_DATA_TYPE_VARCHAR
);
3249 // Must specify a columnLength if modifying a VARCHAR type column
3250 if (dataType
== DB_DATA_TYPE_VARCHAR
&& !columnLength
)
3253 wxString dataTypeName
;
3255 wxString alterSlashModify
;
3259 case DB_DATA_TYPE_VARCHAR
:
3260 dataTypeName
= typeInfVarchar
.TypeName
;
3262 case DB_DATA_TYPE_INTEGER
:
3263 dataTypeName
= typeInfInteger
.TypeName
;
3265 case DB_DATA_TYPE_FLOAT
:
3266 dataTypeName
= typeInfFloat
.TypeName
;
3268 case DB_DATA_TYPE_DATE
:
3269 dataTypeName
= typeInfDate
.TypeName
;
3275 // Set the modify or alter syntax depending on the type of database connected to
3279 alterSlashModify
= "MODIFY";
3281 case dbmsMS_SQL_SERVER
:
3282 alterSlashModify
= "ALTER COLUMN";
3284 case dbmsUNIDENTIFIED
:
3286 case dbmsSYBASE_ASA
:
3287 case dbmsSYBASE_ASE
:
3293 alterSlashModify
= "MODIFY";
3297 // create the SQL statement
3298 sqlStmt
.Printf(wxT("ALTER TABLE %s %s %s %s"), tableName
, alterSlashModify
,
3299 columnName
, dataTypeName
);
3301 // For varchars only, append the size of the column
3302 if (dataType
== DB_DATA_TYPE_VARCHAR
)
3305 s
.Printf(wxT("(%d)"), columnLength
);
3309 // for passing things like "NOT NULL"
3310 if (optionalParam
.Length())
3312 sqlStmt
+= wxT(" ");
3313 sqlStmt
+= optionalParam
;
3316 return ExecSql(sqlStmt
);
3318 } // wxDb::ModifyColumn()
3321 /********** wxDbGetConnection() **********/
3322 wxDb WXDLLEXPORT
*wxDbGetConnection(wxDbConnectInf
*pDbConfig
, bool FwdOnlyCursors
)
3326 // Used to keep a pointer to a DB connection that matches the requested
3327 // DSN and FwdOnlyCursors settings, even if it is not FREE, so that the
3328 // data types can be copied from it (using the wxDb::Open(wxDb *) function)
3329 // rather than having to re-query the datasource to get all the values
3330 // using the wxDb::Open(Dsn,Uid,AuthStr) function
3331 wxDb
*matchingDbConnection
= NULL
;
3333 // Scan the linked list searching for an available database connection
3334 // that's already been opened but is currently not in use.
3335 for (pList
= PtrBegDbList
; pList
; pList
= pList
->PtrNext
)
3337 // The database connection must be for the same datasource
3338 // name and must currently not be in use.
3340 (pList
->PtrDb
->FwdOnlyCursors() == FwdOnlyCursors
) &&
3341 (!wxStrcmp(pDbConfig
->Dsn
, pList
->Dsn
))) // Found a free connection
3343 pList
->Free
= FALSE
;
3344 return(pList
->PtrDb
);
3347 if (!wxStrcmp(pDbConfig
->Dsn
, pList
->Dsn
) &&
3348 !wxStrcmp(pDbConfig
->Uid
, pList
->Uid
) &&
3349 !wxStrcmp(pDbConfig
->AuthStr
, pList
->AuthStr
))
3350 matchingDbConnection
= pList
->PtrDb
;
3353 // No available connections. A new connection must be made and
3354 // appended to the end of the linked list.
3357 // Find the end of the list
3358 for (pList
= PtrBegDbList
; pList
->PtrNext
; pList
= pList
->PtrNext
);
3359 // Append a new list item
3360 pList
->PtrNext
= new wxDbList
;
3361 pList
->PtrNext
->PtrPrev
= pList
;
3362 pList
= pList
->PtrNext
;
3366 // Create the first node on the list
3367 pList
= PtrBegDbList
= new wxDbList
;
3371 // Initialize new node in the linked list
3373 pList
->Free
= FALSE
;
3374 pList
->Dsn
= pDbConfig
->Dsn
;
3375 pList
->Uid
= pDbConfig
->Uid
;
3376 pList
->AuthStr
= pDbConfig
->AuthStr
;
3378 pList
->PtrDb
= new wxDb(pDbConfig
->Henv
,FwdOnlyCursors
);
3380 bool opened
= FALSE
;
3382 if (!matchingDbConnection
)
3383 opened
= pList
->PtrDb
->Open(pDbConfig
->Dsn
, pDbConfig
->Uid
, pDbConfig
->AuthStr
);
3385 opened
= pList
->PtrDb
->Open(matchingDbConnection
);
3387 // Connect to the datasource
3390 pList
->PtrDb
->SetSqlLogging(SQLLOGstate
,SQLLOGfn
,TRUE
);
3391 return(pList
->PtrDb
);
3393 else // Unable to connect, destroy list item
3396 pList
->PtrPrev
->PtrNext
= 0;
3398 PtrBegDbList
= 0; // Empty list again
3399 pList
->PtrDb
->CommitTrans(); // Commit any open transactions on wxDb object
3400 pList
->PtrDb
->Close(); // Close the wxDb object
3401 delete pList
->PtrDb
; // Deletes the wxDb object
3402 delete pList
; // Deletes the linked list object
3406 } // wxDbGetConnection()
3409 /********** wxDbFreeConnection() **********/
3410 bool WXDLLEXPORT
wxDbFreeConnection(wxDb
*pDb
)
3414 // Scan the linked list searching for the database connection
3415 for (pList
= PtrBegDbList
; pList
; pList
= pList
->PtrNext
)
3417 if (pList
->PtrDb
== pDb
) // Found it, now free it!!!
3418 return (pList
->Free
= TRUE
);
3421 // Never found the database object, return failure
3424 } // wxDbFreeConnection()
3427 /********** wxDbCloseConnections() **********/
3428 void WXDLLEXPORT
wxDbCloseConnections(void)
3430 wxDbList
*pList
, *pNext
;
3432 // Traverse the linked list closing database connections and freeing memory as I go.
3433 for (pList
= PtrBegDbList
; pList
; pList
= pNext
)
3435 pNext
= pList
->PtrNext
; // Save the pointer to next
3436 pList
->PtrDb
->CommitTrans(); // Commit any open transactions on wxDb object
3437 pList
->PtrDb
->Close(); // Close the wxDb object
3438 delete pList
->PtrDb
; // Deletes the wxDb object
3439 delete pList
; // Deletes the linked list object
3442 // Mark the list as empty
3445 } // wxDbCloseConnections()
3448 /********** wxDbConnectionsInUse() **********/
3449 int WXDLLEXPORT
wxDbConnectionsInUse(void)
3454 // Scan the linked list counting db connections that are currently in use
3455 for (pList
= PtrBegDbList
; pList
; pList
= pList
->PtrNext
)
3457 if (pList
->Free
== FALSE
)
3463 } // wxDbConnectionsInUse()
3466 /********** wxDbSqlLog() **********/
3467 bool wxDbSqlLog(wxDbSqlLogState state
, const wxChar
*filename
)
3469 bool append
= FALSE
;
3472 for (pList
= PtrBegDbList
; pList
; pList
= pList
->PtrNext
)
3474 if (!pList
->PtrDb
->SetSqlLogging(state
,filename
,append
))
3479 SQLLOGstate
= state
;
3480 SQLLOGfn
= filename
;
3488 /********** wxDbCreateDataSource() **********/
3489 int wxDbCreateDataSource(const wxString
&driverName
, const wxString
&dsn
, const wxString
&description
,
3490 bool sysDSN
, const wxString
&defDir
, wxWindow
*parent
)
3492 * !!!! ONLY FUNCTIONAL UNDER MSW with VC6 !!!!
3493 * Very rudimentary creation of an ODBC data source.
3495 * ODBC driver must be ODBC 3.0 compliant to use this function
3500 //!!!! ONLY FUNCTIONAL UNDER MSW with VC6 !!!!
3506 dsnLocation
= ODBC_ADD_SYS_DSN
;
3508 dsnLocation
= ODBC_ADD_DSN
;
3510 // NOTE: The decimal 2 is an invalid character in all keyword pairs
3511 // so that is why I used it, as wxString does not deal well with
3512 // embedded nulls in strings
3513 setupStr
.Printf(wxT("DSN=%s%cDescription=%s%cDefaultDir=%s%c"),dsn
,2,description
,2,defDir
,2);
3515 // Replace the separator from above with the '\0' seperator needed
3516 // by the SQLConfigDataSource() function
3520 k
= setupStr
.Find((wxChar
)2,TRUE
);
3521 if (k
!= wxNOT_FOUND
)
3522 setupStr
[(UINT
)k
] = wxT('\0');
3524 while (k
!= wxNOT_FOUND
);
3526 result
= SQLConfigDataSource((HWND
)parent
->GetHWND(), dsnLocation
,
3527 driverName
, setupStr
.c_str());
3529 if ((result
!= SQL_SUCCESS
) && (result
!= SQL_SUCCESS_WITH_INFO
))
3531 // check for errors caused by ConfigDSN based functions
3534 wxChar errMsg
[SQL_MAX_MESSAGE_LENGTH
];
3535 errMsg
[0] = wxT('\0');
3537 // This function is only supported in ODBC drivers v3.0 compliant and above
3538 SQLInstallerError(1,&retcode
,errMsg
,SQL_MAX_MESSAGE_LENGTH
-1,&cb
);
3541 #ifdef DBDEBUG_CONSOLE
3542 // When run in console mode, use standard out to display errors.
3543 cout
<< errMsg
<< endl
;
3544 cout
<< wxT("Press any key to continue...") << endl
;
3546 #endif // DBDEBUG_CONSOLE
3549 wxLogDebug(errMsg
,wxT("ODBC DEBUG MESSAGE"));
3550 #endif // __WXDEBUG__
3556 // Using iODBC/unixODBC or some other compiler which does not support the APIs
3557 // necessary to use this function, so this function is not supported
3559 wxLogDebug(wxT("wxDbCreateDataSource() not available except under VC++/MSW"),wxT("ODBC DEBUG MESSAGE"));
3562 #endif // __VISUALC__
3566 } // wxDbCreateDataSource()
3570 /********** wxDbGetDataSource() **********/
3571 bool wxDbGetDataSource(HENV henv
, wxChar
*Dsn
, SWORD DsnMax
, wxChar
*DsDesc
,
3572 SWORD DsDescMax
, UWORD direction
)
3574 * Dsn and DsDesc will contain the data source name and data source
3575 * description upon return
3580 if (SQLDataSources(henv
, direction
, (UCHAR FAR
*) Dsn
, DsnMax
, &cb1
,
3581 (UCHAR FAR
*) DsDesc
, DsDescMax
, &cb2
) == SQL_SUCCESS
)
3586 } // wxDbGetDataSource()
3589 // Change this to 0 to remove use of all deprecated functions
3590 #if wxODBC_BACKWARD_COMPATABILITY
3591 /********************************************************************
3592 ********************************************************************
3594 * The following functions are all DEPRECATED and are included for
3595 * backward compatability reasons only
3597 ********************************************************************
3598 ********************************************************************/
3599 bool SqlLog(sqlLog state
, const wxChar
*filename
)
3601 return wxDbSqlLog((enum wxDbSqlLogState
)state
, filename
);
3603 /***** DEPRECATED: use wxGetDataSource() *****/
3604 bool GetDataSource(HENV henv
, char *Dsn
, SWORD DsnMax
, char *DsDesc
, SWORD DsDescMax
,
3607 return wxDbGetDataSource(henv
, Dsn
, DsnMax
, DsDesc
, DsDescMax
, direction
);
3609 /***** DEPRECATED: use wxDbGetConnection() *****/
3610 wxDb WXDLLEXPORT
*GetDbConnection(DbStuff
*pDbStuff
, bool FwdOnlyCursors
)
3612 return wxDbGetConnection((wxDbConnectInf
*)pDbStuff
, FwdOnlyCursors
);
3614 /***** DEPRECATED: use wxDbFreeConnection() *****/
3615 bool WXDLLEXPORT
FreeDbConnection(wxDb
*pDb
)
3617 return wxDbFreeConnection(pDb
);
3619 /***** DEPRECATED: use wxDbCloseConnections() *****/
3620 void WXDLLEXPORT
CloseDbConnections(void)
3622 wxDbCloseConnections();
3624 /***** DEPRECATED: use wxDbConnectionsInUse() *****/
3625 int WXDLLEXPORT
NumberDbConnectionsInUse(void)
3627 return wxDbConnectionsInUse();