Instructions for using the Database Template Library

  1. Contents
    1. When you unpack dtl.tar.gz it should create the following directories:
    2. \docs: Documentation and examples on how to use the Database Template Library. To read, open the main file called index.htm.
    3. \lib: This is the main code for the DTL.
    4. \example_db: Table definitions and sample data for the code in the "example" and "tests" directories.
    5. \example: Example code for using the DTL.
    6. \tests: Regression tests for the DTL / further examples.
    7. \profile: Simple profiling tests versus raw ODBC calls.

  2. Getting Started:
    1. Take a look at the docs files starting at index.htm. Be sure to read "Introduction to the DTL" as this gives a good overview of the capabilities of the library.
    2. Create the sample database from the example_db directory.
      1. If you have a copy of Access97 there is nothing to do here. We have a sample Access database in the example_db directory.
      2. If you are using Oracle perform the following steps from SQL*PLUS:
        1. >create user example identified by example;
        2. >grant dba to example; -- actually we need less than this, but it's easier to grant dba
        3. >connect example/example;
        4. >@e:\dtl\example_db\tables.sql -- run the tables script to create the example tables
        5. >@e:\dtl\example_db\data.sql -- insert sample data into the example tables
      3. If you are using MySQL perform the following steps:
        1. create a user called "example" with password "example".
        2. >mysql <database_name> -u example < tables_mysql.sql -- run the tables script to create the example tables
        3. >mysql <database_name> -u example < data_mysql.sql -- insert sample data into the example tables
      4. If you are using Microsoft SQL Server:
        1. create a user called "example" with password "example".
        2. Use the data import tool to import the table definitions and data from the Access97 file example.mdb
    3. Create an ODBC data source called "example" from the ODBC Data Source Administrator tool in the control panel:
      1. The example code uses the following ODBC connect string: "UID=example;PWD=example;DSN=example;"; Therefore it connects as user "example", password "example" to the ODBC data source named "example". We assume that the user and password are already set up as explained above & show how to set up the data source name.
      2. Choose the tab labeled "System DSN". Choose "Add --> Microsoft Access Driver (*.mdb)". For the data source name enter "example" and choose the file called example.mdb in the example_db directory. (If you prefer to use Oracle choose the Oracle ODBC driver and enter your SQL*NET connect string etc.)
    4. Build and run the example code.
      1. Go to the directory called \example. Open the file example.dsw and build from VC++ 6.0 to create the example executable. Make sure if you are using Visual Studio 6.0 that you have at least Service Pack 5 installed!!! To compile under UNIX type "sh build.sh" which will run the makefile appropriate to your environment (LINUX, CYGWIN, HP, SOLARIS) and place the result in a ./debug directory. For Linux see ReadMeLinux.htm for details. Also, when compiling under a UNIX environment make sure the ODBC include and link directories are in your path which should be done by default. To compile under Borland (BCC) type "make -f Borland.mak" which will run the "Borland.mak" file in this directory (under Borland you will also need to manually run "make -f Borland.mak" from the /lib directory since our Borland makefile is not smart enough to know it must build the library before the example project). For more details on compling with Borland, see ReadMeBorland.htm.
      2. Run the example.
        	    >example.exe 'DSN=example;UID=example;PWD=example;'
        (If you are running from UNIX you will need to provide the ODBC connection string as an argument to the program in quotes, in VC++ we have already done this via the debug settings).

  3. Using the library in your own code:
    1. To use the library in your own code you will need to do two things:
      1. Include the \lib directory in the include (\I) path for your compiler.
      2. Include the library file (DTL.lib or libDTL.a) in the set of files that you link to in producing your executable.


Release Notes
  1. Version 3.6.5; Released August 23, 2004
    ***Bugfixes***
    1. Fixed bug introduced in 3.6.4 that caused DynamicDBView with parameters to potentially trash memory.

    ***New Features/Improvements/Removed features ***
    1. Upgraded global error handler callback to be able to take a functor as well as a function pointer.

  2. Version 3.6.4; Released July 27, 2004
    ***Bugfixes***
    1. Upgraded sql logging functionality so that sql logs are associated with a DBConnection. This should make logging thread safe for applications that use a separate connection per thread.
    2. Fixed ETIMap initialization to be called from the DBEnvironment constructor. This should avoid a potential multi-threaded bug.
    3. Cleaned up DataObj and ParamObj in dynamic DBView so that fields which are not used in these objects do not get added. (Previously the DataObj and ParamObj would both contain placholders for all parameters and columns).

    ***New Features/Improvements/Removed features ***
    1. Added ability to register global error handler callback.
    2. Upgraded to support gcc 3.4.
    3. Cleaned up installation docs for Redhat Linux. Enabled bulk fetch flag since the MyODBC 3.5.1 driver now supports this.

  3. Version 3.6.3; Released July 12, 2004
    ***Bugfixes***
    1. Renamed MIN to DTL_MIN to avoid possible macro conflicts.
    2. Fixed sql_iterator to point to end() if the executed statement does not return any rows.
    3. Fixed bug with BoundIO::ClearNull() that caused it to not work correctly with insert statements.

    ***New Features/Improvements/Removed features ***
    1. Added ODBCINT64 support to support long integers.
    2. Upgraded writing of strings and blobs to use SQLPutData more efficiently - this should make blobs write slightly faster.
    3. Upgraded sql logging functionality.
      PrintLog(ostream &o) = SQL statements in execution order
      PrintSortedLog(ostream &o) = list of SQL statements in alphabetical order with no duplicates (what PrintLog() used to be).
    4. Minor adjustments to run with Visual C++ 2005 Express.
    5. Added variant_row::tchar_star type to allow the binding of fixed length strings with a variant_row.

  4. Version 3.6.2; Released May 17, 2004
    ***Bugfixes***
    1. Added compiler flag to fix iterator definitions under .NET with STLPort
    2. Added enhancements to support SQL batches under SQL server and to better handle generic sql_iterator queries with dummy column names or repeated column names.
    3. Added workaround for Microsoft Access 2000 bug that was causing memo fields longer than 2000 bytes to be fetched incorrectly.

    ***New Features/Improvements/Removed features ***
    1. Added DBConnection::GetDataSources() to retrieve a list of ODBC data sources.
    2. Added support for calling ODBC catalog functions as SQL statements. Currently supported functions are _SQLTables, _SQLColumns.
    3. Added the ability to log the SQL executed by DTL. See DBStmt for details.
    4. Added the ability to convert from tcstring's of one length to tcstring's of a different length by adding templated conversion constructors and assignment operators to the tcstring class.
    5. Added change by A. Motzkau to improve variant_row performance.
    6. Added draft RPM spec by Ben Martin.

  5. Version 3.6.1; Released February 3, 2004
    ***Bugfixes***
    1. Removed keyword "explicit" in dtl_variant_t constructor when using Visual C++ compiler since this causes Visual C++ 7.0 to choke. Other compilers will continue to use the explicit qualification here.

  6. Version 3.6; Released February 1, 2004
    ***Bugfixes***
    1. Renamed variant_t to dtl_variant_t to avoid a clash with the MFC component BCGControlBar which defines variant_t as a macro.
    2. Added keyword "explicit" to dtl_variant_t constructor to avoid compiler ambiguity that erroneously caused the dtl_variant_t constructor to be called when cout << foo is called for a class with no ostream operator.

    ***New Features/Improvements/Removed features ***
    1. Changed dtl::blob from std::basic_string<unsigned char> to a class which holds a counted pointer to this basic_string. The reason for doing this is that blobs are often quite large so for performance we want to avoid copying these objects whenever possible. Now this class will merely copy the counted pointer on copy construction and assingment which is much faster when working with blobs. One limitation is that we have only forwarded the most common basic_string functions so you may find one is missing that you need. If this happens, the trivial class definition can be found in array_string.h.
    2. Upgraded DynamicDBView so that it will now automatically detect any parameters in a query and bind them to a ParamObj for the view. This extends DynamicDBView so that it can now have both columns and parameters that are not defined until runtime. It also makes the syntax for parameters more intuitive for this case since any parameters can just be assigned to a variant_row parameter object. See SimpleDynamicWhere() or ExecQuery() in example/SimpleDynamicRead.cpp for an example. The downside is that now DynamicDBView no longer allows you to pass in a custom BPA since it automatically detects parameters. Instead, if you want to use a custom BPA with a DynamicDBView you should use a DBView<variant_row> and just pass it a DynamicRowBCA() as is done in DynaDBView.h in the definition of a DynamicDBView.
    3. Upgraded the DBConnection::Connect method so that now it allows users to browse for a connection via ODBC dialogs when DTL_NO_POOLING is set. Also, you can pass a flag to the Connect method telling it not to turn off auto-commit for those drivers that don't support this.
    4. Added new #define called DTL_VARIANT_USE_FIXED_LEN_STRING which causes DynamicDBView to bind strings to a fixed length string buffer instead of using std::string. This can improve performance if you know your strings will be of limited length.

    7.  

  7. Version 3.5.3; Released November 21, 2003
    ***Bugfixes***
    1. Fixed bug that caused InsValidate to be called twice the first time an insert or update iterator is assigned.
    2. Added static_cast labels as needed to remove warnings and clarify code for MSVC 7.1. (Contributed by Paul Greyner. ).
    3. Changed defintions of MAX_JTIME to be less than ULONG_MAX. This was to resolve potential overflow error reported by gcc 3.3.

    ***New Features/Improvements/Removed features ***
    1. Changed default binding for SQL_BLOB so that DynamicDBView now binds this to a C++ data type of dtl::blob rather than std::string.

    8.  

  8. Version 3.5.2; Released September 10, 2003
    ***Bugfixes***
    1. Fixed bug when using STLport with MSVC .NET. This bug caused the code not to use stlport::std::iterator so that the code would not compile.
    2. Empty strings, wstrings were errouneously written with the value of "\0" rather than NULL.
    3. If the database driver does not tell us what quote character to use when quoting table or field names with blanks in them then default to ". Previous versions were supposed to have logic to do this but it was buggy.

    ***New Features/Improvements/Removed features ***
    1. If the database is not of a recognized type and it does not support AutoCommit, then throw an errror, but still allow a connection to be made as indicated by DBConnection.state == CONNECTED.
    2. The dbstmt.MoreResults() method now gives extended error information when the underlying ODBC function indicates an error. This is helpful in debugging stored procedures that may give multiple result sets and error codes.

    9.  

  9. Version 3.5.1; Released May 19, 2003
    ***Bugfixes***
    1. Fixed bug introduced in release 3.5 that broke bulk_fetch for dates. This also affected IndexDBViews which use bulk fetch.
    2. Added flag -DHAVE_LONG_LONG to linux config to let unixODBC know to use the "long long" data type for ODBCINT64.

    ***New Features/Improvements/Removed features ***
    1. None.

    10.  

  10. Version 3.5; Released May 2, 2003
    ***Bugfixes***
    1. Fixed bug where blob type would not fetch the last byte from the database field.

    ***New Features/Improvements/Removed features ***
    1. Added random access container, RandomDBView, to support scrollable static ODBC cursors. (Please note that in our tests we found that this container does not work with the MySQL ODBC driver 3.51 since this ODBC driver does not support a scrollable cursor property we need).
    2. Added support for large integers, ODBCINT64, as defined in sqltypes.h. (Under windows ODBCINT64 generally resolves to "_int64"; under UNIX it generally resolves to "long long").
    3. Upgraded bulk_fetch_helper to support bulk fetches for variant_row objects.
    4. Made changes suggested by R. Kotha to support compilation under FreeBSD using GCC 2.95.4 and STLPort.
    5. Added performance tuning suggested by "bowlbear_aa" to improve speed of reading blob data.

    11.  

  11. Version 3.4.2; Released March 06, 2003
    ***Bugfixes***
    1. Fixed bugs in bulk insert to where one could overflow the buffer.
    2. Added fix for broken ODBC drivers so that now double quote is always assumed as the default quote mark.
    3. Fixed problem with IndexedDBView::erase(). When the underlying vec_multiset became empty, all iterators referring to that container would become invalidated as the sorted flag would be set to false. Fixed by keeping the sorted flag set to true though it means vec_multiset will run a bit slower for this case.
    4. Fixed inconsistencies in GetLastCount() for the different basic DTL iterator types. GetLastCount() now refers to the number of rows processed in the last operation performed on that iterator, regardless of iterator type.

    ***New Features/Improvements/Removed features ***
    1. Provide DTL_TABLE and DTL_STRUCT macros to automatically generate the C++ data objects, DefaultBCA, and DBViews given a table name and the types and names of the columns in the table you wish to process. This feature makes it a lot easier to quickly create a simple structure and bind it directly to a database table.
    2. Added new set of DTL class diagrams from Robert Modolo (these are great!).
    3. Added bulk_insert_helper functions to make it easy to perform bulk operations against any iterator.
    4. More improvements to build script. Now by default unix builds will go to a ./debug directory for debug builds and a ./release directory for release builds.
    5. Added ability to disable printing of ROWIDs for dynamic views through the new DTL_OUTPUT_ROWIDS config flag. If the flag is defined, the ROWIDs will be outputted as in previous versions. Otherwise, a #### ROWID #### marker is printed instead of the actual ROWID.
    6. Improvements in regression test output. By leaving DTL_OUTPUT_ROWIDS undefined and adding ORDER BY clauses to all DBViews that read objects, we get consistent output for all runs of the example and tests projects. If printing of ROWIDs were enabled for the regression tests, we'd get diffs whch mean nothing as the DBMS is free to generate new autokeys on different runs of the code. Our new ORDER BY clauses force a consistent ordering among all fields in the view.

    12.  

  12. Version 3.4.1; Released February 8th, 2003
    ***Bugfixes***
    1. Fixed bug where sql_iterator would not correctly handle stored procedures that take parameters and return result sets.
    2. Added enhancement for SQL Server so that sql_iterator could support statments that return more than one result set (e.g. stored procedures that return values). See the sql_iterator documentation for details.
    3. Fixed bug where IndexedDBView::find() would not work correctly for tcstring classes.

    ***New Features/Improvements/Removed features ***
    1. New compiler/platform support. Visual C++ .Net.
    2. Added bulk_fetch_helper functions to make it easy to perform bulk operations against any iterator.
    3. Improved build script so that we can now build more easily across multiple platforms.

    13.  

  13. Version 3.4.0; Released November 25th, 2002
    ***Bugfixes***
    1. Fixed bug where autokeys in DynamicDBView could go into endless loop.
    2. Upgraded DynamicDBView to use field names as specified by the user when the list of field names is not "*". This allows the use of qualified field names like table.field and also gives support for functions like sum(salary).
    3. Removed broken char binding. Replaced with tcstring<1> binding.

    ***New Features/Improvements/Removed features ***
    1. New compiler/platform support. HP with aCC A.03.35, Solaris with Sun Workshop 6 update 1, Cygwin with gcc 3.2.
    2. Bulk select and bulk insert operation support via the new bulk_copy function.
    3. Upgraded IndexedDBView to automatically use bulk fetch when retrieving records.
    4. Removed support for binding to char, char[N], replaced with tcstring binding for increased portability.

    14.  

  14. Version 3.3.0; Released June 7th, 2002
    ***Bugfixes***
    1. Fixed bug where select_update_iterator wasn't committing to the database on postfix increment. See below for the major change we made in iterator semantics which fixed this problem.

    ***New Features/Improvements/Removed features ***
    1. Major change in iterator semantics:
      • Input iterators (select_iterator, sql_iterator for SELECT/input iterator like ops, select_update_iterator to march to next record) still read from the database on operator++().
      • Output iterators (insert_iterator, update_iterator, delete_iterator, sql_iterator for output iterator like ops, select_update_iterator to update current record) now commit on the proxy assignment operator , as in iterator::operator=(const DataObj &).
      • Note that previous versions of DTL committed all operations to the database on operator++(). Existing code using DTL may break if you make Params() calls between operator*() and operator++(), i. e.: *it = dataObj; it.Params(...); ++it;. You must make the Params() call before the operator*() call as the iterator will write to the database on the proxy assignment call. Thus, you must change your code in the example to read: it.Params(...); *it = dataObj; ++it;.
      • Made necessary changes to the example/tests projects to reflect the new semantics.
      • Changes in IndexedDBView to obey the new semantics and remain exception safe.
    2. User can now specify iterator execution behavior at construction time or through DB_iterator::SetPrepare(bool bPrepare): if bPrepare is true, internally, SQLPrepare() and SQLExecute() will be used to run the query; otherwise, SQLExecDirect() will be called. Default behavior is to set bPrepare to true for all output iterators as they will get executed multiple times normally, but to use bPrepare = false for select_iterators as they will be usually executed only once. Also made changes in IndexedDBView to use bPrepare = false in all cases for the queries used by DBView::iterators inside the routines as those iterators always get thrown away after a single execute call.
    3. Support for field names with spaces added. See "Using Field Names with Spaces in DTL" document for more details.
    4. Widespread changes to run under the Borland 5.5 compiler.
    5. Select_iterator, select_update_iterator, sql_iterator now all return a proxy on postincrement so that future DataObj access can be made within the same expression. Note that now for field access in select_update_iterator and sql_iterator that you must use static_cast<DataObj>(*it).field instead of (*it).field due to these changes. Use it->field where possible for sql_iterator to avoid this syntactic headache.
    6. Performance tweaks: string_util.cpp modifications and added string::reserve() calls throughout.

    15.  

  15. Version 3.2.4; Released March 29th, 2002
    ***Bugfixes***
    1. DBStmt::SetStmtAttr() added to allow user to override stmt. attribute defaults. Added mainly to allow for execution of complex stored procedures in SQL Server. These complex stored procedures caused DBExceptions to be thrown without the ability for the user to set the statement attributes.
    2. Changes in variant_row.h and variant_row.cpp for compatability of DTL on .NET (Peter Schregle's work).
    3. Resolved ambiguity bug for operator<<() for TIMESTAMP_STRUCT to fix variant_t::get_string().
    4. Bugs with unneeded _TEXT() macros in the same operator<<() routines as #4. Changed to use chars for the ostream overload and wchar_ts for the wostream one.
    5. Fixed problems with potential statement handle leaks inside the DBStmt class in the case where the underlying ODBC implementation has an access violation.

    ***New Features/Improvements/Removed features ***
    1. Added four-field find() and equal_range() members to IndexedDBView.
    2. Improved error handling dealing with TIMESTAMP_STRUCT fields in variant_rows. Now, the user must initialize the date field when he tries to insert a record or he will get a VariantException.
  16. Version 3.2.3; Released February 24, 2002.
    ***Bugfixes***
    1. Fixed DBStmt::GetData() and DBStmt::PutData() problems for long strings (strings greater than 255 in length). Most of the changes occurred with BoundIO::MoveRead(), BoundIO::MoveWrite(), and BoundIO::MoveWriteAfterExec().
    2. Fixed typedefs in vec_multiset::iterator and vec_multiset::const_iterator to get rid of GCC compiler warnings.
    3. SelValidate() calls moved from operator*() to operator++() for select_iterator and sql_iterator to get proper for-loop behavior.
    4. Changed default key mode for DynamicDBView and DynamicIndexedDBView to USE_ALL_FIELDS.
    5. Fixed case sensitivity bugs dealing with column names in DBIndex and BoundIO/BoundIOs structures.
    6. Fixed bug to where parameters were getting bound to nonexistent parameter numbers in the case of insert_iterators. In the fix, we don't bind the extra parameters anymore.
    ***New Features/Improvements/Removed features ***
    1. Changed default key mode for DynamicDBView and DynamicIndexedDBView to USE_ALL_FIELDS.
    2. Limited OpenAccess support now provided: DBView and IndexedDBView support all data types in OpenAccess except for string, wstring, and blob.
  17. Version 3.2.2; Released January 31, 2002.
    ***Bugfixes***
    1. SQL_C_BIT is now the mapping for the bool type ... SQL_C_USHORT was buggy.
    2. Fix for single char binding.
    3. Fixed bug in BuildDefaultQry().
    4. Fixed iterator/const_iterator typedefs in IndexedDBView.
    5. Added missing constructor initializers.
    6. Fixed bug in storing of IndexName for key into indexes map. Also more IndexNamesAndFields parsing fun.
    7. Fixed support for char[] binding yet again.
    8. Fixed const problems in comparison operators for select_iterator and sql_iterator and added commutative form of these operators.
    9. Glitches in the docs.
    10. Fixed yet some more missing STD_:: qualifcations.
    11. Moved header guards for IndexedDBView.h and DBIndex.h to proper places.
    12. Bug identified for SQLServer: execution of a bad statement may result in a rollback, regardless of the IOHandler semantics.
    13. Note that unicode is not supported by Oracle 8.x or lower. Oracle only support unicode for version 9.01 and higher, but we haven't tested this yet. We've only tested unicode for SQLServer and MS Access.
    14. Fixed bug in assignment operator for variant_field that caused problem when copying from one DynamicDBView iterator to another.
    15. Changed default SQL binding for float data parameters from SQL_FLOAT to SQL_REAL.
    16. Removed bug that caused wide strings over 255 bytes in length to not be written to the database correctly.

    ***New Features/Improvements/Removed features ***
    1. GetData() and PutData() used to handle "binding" of all basic_string<> types. Now by default binding a string or blob has the capability to fetch a field of an arbitrarily large size.
    2. Added DBView::select_update_iterator.
    3. Changed DEFAULT_IDXCONTAINER to be std::hash_multiset for STLPort. Other configurations default to dtl::vec_multiset. This makes IndexDBView containers run *much* faster. This included downgrading IndexedDBView::iterator from bidirectional iterator to forward iterator if std::hash_multiset is the default index container as it only supports forward iterators.
    4. TCHAR/tstring concept made universal: TCHAR[] and TCHAR bindings used instead of char and char[] being allowed regardless of the UNICODE setting.
    5. star_bidirectional_iterator conversion constructors and comparison operators. Also added star_forward_iterator.
    6. Added DTL_LC and DTL_UC macros to lower-caseify and upper-caseify (respectively) the SQL passed to ODBC.
    7. Added autokey support. Forced some changes in DynamicBCA, DBView, IndexedDBView, DynamicIndexedDBView to properly support this.
    8. Changed MAX_J_DATE. Old max date was incorrect & too small.
    9. Vec_multiset cleanup.
    10. Removed BoundIO::BoundColMode.
    11. Added BoundIO::SetSQLType() so that user may specify a different SQL type to bind to other than the one specified in the ETI Map in bind_basics.cpp.
    12. Added index of code examples.
    13. Added SetParamsFromClass template to make it easier to set parameters when creating IndexedDBViews.
    14. General performance tuning. Replace internal wrappers for BCA, BPA, InsVal and SelVal plus did general performance tuning to improve overall speed of execution.
  18. Version 3.1; Released August 13, 2001.
    ***Bugfixes***
    1. Fixed bug with IndexedDBView so that any changes made by InsVal to the DataObj will be recognized by insert() and replace().
    2. BoundIO::CopyMember() performed only a shallow copy for char[] members. This has now been fixed with the MakeActualCopyOfMember() template.
    3. GenericCmp() incorrectly handled doubles by making epsilon equal to 1 >> 20, yielding an actual value of 0.0000000 due to the fact that this old value operates on integers and thus the fractional part was dropped. The change to make epsilon equal to pow(2, -20) fixed the problem.
    4. Fixed DBException::what() error messages so that multiple database messages can be returned.
    5. Binding for char arrays now uses the size of the array to set the maximum buffer size, this prevents a potential buffer overflow bug.
    6. BYTE typedef now at global scope to avoid potential clash with the typedef from Windows header files.

    ***New Features/Improvements***
    1. Added support for binary data / blob data types.
    2. Variable size buffer for binding basic_string. This allows us to control buffer sizes to bind larger strings and blobs in the BCA without adding unnecessary overhead.
    3. In IndexedDBView, addition of begin_AK(), end_AK() and friends to return iterators to beginning and end of DataObj lists for a given key.
    4. Cleaned up several semantic nits with destructors and also STD_::.
    5. Variant_row::operator[](const string &fieldName) now case insensitive for fieldName.
    6. Return type of DBView::select_iterator::operator++(int) changed to void to improve efficiency and C++ standard compliance. It is now equivalent to its preincrement cousin.
    7. Reimplemented internal comparison function for DBIndex to be more efficient by using raw function objects instead of callbacks in the default implementation. This improves the speed of IndexedDBView containers.
    8. Upgraded to run against gcc 3.0.
    9. Exposed DBConnection::GetDefaultEnvironment() and DBEnvironment::Release() to support manual release of HENV.

  19. Version 3.0; Released July 19, 2001.
    ***Bugfixes***
    1. Fixed IndexedDBView::replace() bug where it threw a DBException when *it == dataObj (replacing object with itself).
    2. Fixed parsing of IndexNamesAndFields string in IndexedDBView constructor. It crapped out on obstacles such as extra whitespace.
    3. Typedef for IndexedDBView::reverse_iterator and its const cousin properly fixed to be std::reverse_bidirectional_iterator.
    4. Fixed bug with DB_iterator copy involving incorrect management of internal buffers for parameter and row data. This bug resulted in incorrect behavior when iterators were copied, most noticeably in standard functions such as std::copy(), which accept their arguments by value.

    ***New Features/Improvements***
    1. Full unicode support. (Not avalable for gcc 2.96 due to lack of wide stream support; still a bit flaky for the Oracle ODBC due to driver bugs from Oracle). Also, we have added a pure unicode example project and converted the tests project converted to a pure unicode format.
    2. "Header Hell" - broke out the implementation of non-template classes into .cpp files to make for faster compile times and give fewer header dependencies.
    3. Changed code to use stringstream instead of deprecated C++ strstream. NOTE FOR LINUX USERS, this new version requires at least gcc 2.96-85 as older versions of libstdc++ that come with gcc do not support stringstream.
    4. DBConnections now may reference already existing connections using the Share() method.
    5. More efficient IndexedDBView::local_insert() implementation. Redundant searches were eliminated by making use of the form of multiset::insert() that takes an iterator hint for where the element should be put into the container.
    6. Facility for passing named arguments to the constructors for DBView, IndexedDBView, DynamicDBView, and DynamicIndexedDBView objects.
    7. DBView and DynamicDBView constructors now accept an initial IOHandler as an argument.
    8. BuildSpecialQry functors now allow the user to customize the SQL query generated for DBView iterators through the use of template specialization. This is primarily useful for custom queries such as "select distinct" etc.
  20. Version 2.5
    1. NOTE: If you are upgrading from a previous version of DTL then the major changes that will affect your old code are: 1. The new signature for InsValidate, which now requires BoundIOs as a parameter. 2. The default error handler for DBView and IndexDBView now throws rather than logging and suppressing errors. This default is user definable -- see DEFAULT_IO_HANDLER below for details.
    2. Added DBView<DataObj, ParamObj>::sql_iterator class (support for general queries). This enables DTL to work with all kinds of SQL queries, including stored procedures.
    3. Changed syntax of binding operator for BCA's and BPA's to indicate directional flow of information while keeping the old syntax around for backwards compatibility.
    4. DBStmt::Execute() now allows SQL_NO_DATA to be returned.
    5. Proper error checking of RETCODE's in DBConnection() and DBEnvironment().
    6. Enhanced facilities for handling null fields in the following classes: BoundIO, BoundIOs, variant_row, variant_field.
    7. Modified implementation of IndexedDBView routines mostly in relation to when validation functions are invoked.
    8. Fixed some bugs with dynamic views.
    9. Moved DataObj() methods from dynamic views and dynamic indexed views to DBView and IndexedDBView under the method name GetDataObj().
    10. Now can create variant_field's on the fly, especially for use in BCA's and BPA's using the variant_row::_typename() syntax.
    11. Support for variant_row's as ParamObj's.
    12. Reentrancy of BCA's and BPA's.
    13. Fixed bugs in parsing of IndexNamesAndFields string passed into constructor for IndexedDBView.
    14. Rationale of example and test projects changed. The examples now also will serve as a preliminary battery of test code for DTL as well as being code meant to clearly show the new user how various things work in the library. Tests contains further code to exercise DTL.
    15. Removed all using-clauses from DTL and explicitly qualified all code which uses the C++ standard namespace. This involved some tricky preprocessor macros to get the right behavior.
    16. Generalized the underlying associative container that DBIndex's use to store DataObj *'s. The underlying associative container now is passed in as a template parameter at the IndexedDBView level and whether it's hashable or not as another template parameter. Added GenericHash() as well as a ContainerFactory function object to help accomplish this purpose.
    17. Added support for null fields in BoundIO, variant_field, GenericCmp() and GenericHash().
    18. Added MoreResults() support to grab more record sets if a statement contains multiple ones.
    19. cb_ptr_fun() and cb_ptr_fun_w_ret() now also accept pointer-to-member methods.
    20. Added DEFAULT_IO_HANDLER macro by which the user can specify the default IOHandler to use. If the user doesn't define this macro, DTL defines AlwaysThrowsHandler to be the default. Previously, the default handler was hardwired to be LoggingHandler.
    21. Added a dtl_config.h file for user-defined macros and other settings into the lib directory.
    22. Added full set of comparison operators to variant_row's so objects of that type can be used in STL constructs that require these operators.
    23. Fixed more typename bugs internally.
    24. Fixed bug in DBIndex::lt() to compare based on the order of fields that the user passed in. The code now properly uses the first field listed as the most significant field to search on and it compares fields in the order specified in that list, through the last field in the list (the least significant), if necessary. In previous versions, this comparison function mistakenly considered the first field name in alphabetical order as the most signficant and proceeded in pure alphabetical order to make necessary comparisons.
    25. Fixed global initialization bug with the SQL_types_to_C ETI_Map. Problem was found when certain global IndexedDBView's were not having the map already built so they could construct themselves as initialization order of globals/class statics is undefined. Fixed by replacing with a global function GetSQL_types_to_C() that returns a reference to a local static ETI_Map that is built properly on the first call to the function, which ensures the proper order of initialization.

  21. Version 2.01
    1. Added support for bool data type.
    2. Successfully ported code to Microsoft SQL Server.
    3. Fixed minor bug with aliased views that did not allow table names to be aliased in queries.
    4. Renamed std_inc.h to std_dtl_inc.h and iterator.h to DB_iterator.h to avoid filename clashes.
    5. Added DBException::GetAllODBCErrors() method.

  22. Version 2.0
    1. Added support for Boris Fomitchev's STLPort implementation of the SGI Standard Template Library.
    2. Successfully ported code to Red Hat Linux 7 under gcc 2.95 running unixODBC and a MySQL 3.23.33 database.
    3. Corrected constness throughout DTL. This fixed some issues that we had in 1.1 which prevented us from running correctly versus some of the standard STL algorithms.
    4. Rewrote the code to make it exception safe.
    5. Added error handling support for all DTL iterator classes, DBView, and IndexedDBView in the form of IOHandler.
    6. Iterator refinements:
      • DB_select_iterator::operator*() now returns a const DataObj & to make that operation truly read-only.
      • All output iterators now use proxies to emulate *it = value to enforce their write-only quality.
      • Also fixed prefix/postix implementation for operator++() on all iterators.
    7. Enhanced DBConnection class to use ODBC connection pooling.
    8. Added Julian date support through the jtime_c class.
    9. Simplified the structure for DBView to need fewer template parameters. In version 1.1 the structure was DBView<DataObj, ParamObj, BCA, BPA> in version 2.0 the structure is simplified to DBView<DataObj, ParamObj> .