C++ ResourcePool Changelog
V0.99.29 - 2009-06-22 [ Download ]- Fixed a bug which caused errors not correctly propagated to the client code in certain cases when using a BatchCommand against an oracle database.
- Fixed dependencies on oci.h for client programs which directly use the oracle bindings (in contrast to the runtime-selectable driver).
- The configure script was converted to use the ax_lib_oracle_oci autoconf macro available from the autoconf-archive. The previous --with-oracle configure switch is now --with-oci.
- Prefixed all config.h defines to not clash with same defines of other packages.
- The BindInterface was re-factored to allow easy re-use (similar to bindout in V0.99.26)
- Improved usability of SQLStatement by introducing a default constructor.
- Refactored SQLStatement for performance on copy-construction. Since SQLStatements are passed around like std::strings before, the became a performance issue since they are much more complex.
- Major code-cleanup of the oracle SQLExecute method, resulting in a considerable performance gain.
- The SQLStatement class was introduced as an explicit type for SQL statements. Previously SQL statements were passed around as std::string. All SQL commands expect a SQLStatement instance instead of a std::string from this release on. However, SQLStatement provides constructors which will make implicit conversion to make a temporary for you without any code change.
- Some redundant code for oracle and mysql was centralized in the SQLStatement class. All functionality to process placeholder (?) as well as additional functionality in preparation for named parameters is now in the SQLStatement class.
- Some performance improvements were done.
- Portability was checked again. This release was successfully tested on Solaris, OSX and Linux with various GCC compiler version (3.3 - 4.3) and Intels C++ compiler (v10).
- The BindOutInterface was re-factored to allow easy re-use of SQLFetcher implementations. Please consult the select.cc example for details.
- A noticeable performance improvement was reached by optimizing the memory management of the smart pointer implementation.
- Simplified the BindOut NotNull constraint implementation.
- Further optimized the bind and bindout implementations.
- Added and improved some test-case to allow better performance measurements.
- Cleaned the oracle driver from the old "plain_resource" concept.
- A bug in the example/select.cc was fixed (uninitialized values).
- A possible memory leak was fixed (striking only when failing to connect to oracle)
- Lots of code cleanup. Reduced the library size by about 5% (due to template cleanup), improved performance (a little bit) and made some parts more robust.
- The shortcut to a Pool's commands was renamed from Command to Commands. E.g. RP::Command::SQLExecute becomes RP::Commands::SQLExecute. This change will require (trivial) adoption of client programs.
- Re-Enabled the oracle Statement Cache, but only for SELECT, UPDATE, INSERT and DELETE statements. Others (esp. CREATE/DROP) cause very unpredictable results and are believed to be uncacheable.
- This release was tested against Oracle 11g. As it pointed out there is an oracle bug which causes the test case SQLBatch_complex to fail. Since this is believed to be an Oracle bug (Metalink 7019313) this error is caught and an appropriate information is shown which does not cause the test to fail.
- An event based logging was implemented. An example implementation logs all messages to std::out is available, custom implementations can do whatever they need.
- The log-facility allows filtering for specific events so that only those events of interest are logged. This can either be done programmatic or via the environment variable FATALMIND_DEFAULT_LOGEVENTS.
- The ResourcePool::execute implementation was merged into the ResourcePool source files itself.
- Generally added -O2 to the CXXFLAGS
- Changed the AWK script to support the test cases to be more portable.
- The method getSessionID() was introduced to all SQL Resources to uniquely identify the session in the database.
- Fixed a bug in the select.cc example. The process() method should return a deterministic value!
- Some minor performance improvements.
- The way how data is fetched from a SQLSelect command was changed. A new base class SQLFetcher was introduced to act as basis for the data processing logic. The process() method previously to be overwritten in the SQLSelect command is now in the SQLFetcher. You must supply a SQLFetcher instance to SQLSelect on construction. A new example select.cc was added to the examples section to demonstrate the new interface.
- The process() method (formally part of SQLSelect, now a member of SQLFetcher) gets one argument which is the rownumber of the currently available row.
- The SQLFetcher class supports a done() method which will be called after fetching rows has finished.
- An optimized BatchCommand for oracle SQL was implemented. This command can dynamically identify statements suitable for array execution in a single server round trip. To gain from this, you just need to make sure to use RP::Command::SQLBatch in continuation mode (otherwise the optimization will not take place!) and put your SQLExecute statements into the batch. Identical statements (SQL string needs to match exactly) will then be executed using the oracle array execution feature.
- The BatchCommands continuation mode semantic was changed so that a user is expected to continue execution upon an error until the complete batch was executed. Aborting prior full execution leads to undefined behavior. Users which wish to abort execution upon an error should not use continuation mode OR use other mechanisms to re-gain a defined behavior. For SQL resources it might be useful to wrap the Batch into a Transaction to be able to rollback but still use continuation mode.
- It is no longer allowed to add additional Commands to an already executed BatchCommand. An attempt will cause an exception thrown.
- The operator<<(std::ostream) was implemented for most predefined commands. Commands can be "printed" like std::cout << command for debug purposes.
- Some missing #include directives were added to compile with GCC 4.3.0.
- Fixed a bug which prevented compilation with GCC 3.2 and 3.3.
- Fixed an buffer alignment issue which caused program crashes on SPARC systems due to misaligned indirections.
- Made configure check also /lib32 in case /lib doesn't work. This makes it possible to build 32 bit applications on 64 bit architectures where /lib includes the 64 bit oracle libraries.
- Fixed a bug which caused fetching of LOB values fail on MSB architectures (like SPARC).
- Fixed a bug which could cause an inappropriate exception in case NULL columns are fetched (again).
- Included the flex generated files as well as FlexLexer.h into the distribution so that flex+ is not required anymore to build ResourcePool.
- This release was successfully tested on Solaris 10 running an Oracle 11g client in a 32 bit build.
- Updated to the most recent version of autoconf(2.61), automake(1.10.1) and libtool(2.2)
- Disabled building of static libraries per default. You can still --enables-static manually, if you like.
- NULL handling does work for LOBs now.
- It's now defined that bindout() variables will not be changed in case the column is NULL.
- A bug which could cause "ORA-01000 maximum open cursors exceeded" when using SQLBatch was fixed.
- Fixed a bug which caused inappropriate ORA-01406 if a numeric value was fetched into a string variable.
- Made the MySQL warning 1263 "Data truncated" cause an exception to be thrown. This "warning" indicates that the data added to the database were not correctly stored, reason enough to tell the application about. If this warning is happening, the row was inserted by MySQL but some column value was cut-off, the application must use a transaction if this case shall be rolled-back.
- Added missing template instantiations for bind() and bindout() to the Runtime Selectable database driver (all ISO C++ fundamental types).
- Aborting an oracle operation (ORA-01013) does not cause a failover to happen.
- The oracle driver is now more robust against table definition changes. This is accomplished by invalidating the cache of stored select list definitions upon ORA-01406.
- Added continuation support to BatchCommands. If enabled, reexecution of a already executed BatchCommand will continue after the position where the last execution stoped due to an error (if there was any).
- The clearParameters() method was added to the BindInterface. All Commands which support bind() operations can now be cleared so that binding of new values is possible.
- Removed BatchCommand::back(). Access the elements via the begin() iterator instead.
- The oracle ORA- error messages were cleaned up to not include a newline at the end.
- Introduced the Transaction command (also via RTSQL classes available). The previous versions did already include a oracle transaction command which was not documented. This release refactors this previous approach and supplies also the mysql implementation of transactions.
- Little performance improvements.
- Refactored to no longer have two types of resources (plainresources vs. Resource classes).
- Introduced the BatchCommand which takes care to sequentlually execute several nested Commands.
- Corrected handling of NoFailoverExceptions. Previously it did just not work.
- Fixed a bug which could cause undefined behavior in MultiThreadedModel when a caller had to wait for resources (when the Max limit is reached).
- The argument validation of the bindout() and isnull() methods of SQLSelect(Row) commands has been corrected.
- Fixed a bug in the Cache class which caused an unreasonable exception in case an already cached value is put again.
- The isnull() method has been added to the Runtime selectable SQL driver (fatalmind::ResourceType::SQL).
- The NoFailoverExceptions thrown in the mysql driver do now include the correct message. The messages were lost due to a missing explicit constructor call to the virtual base class.
- The getFactory() method in ResourcePool is now public and returns a const reference.
- Implemented some rudimentary statistics. See ResourcePool.getStats() for details.
- Building improvement: -lrt is used (and not used) more correctly.
- The testing framework has been extended to optionally perform testing in multiple threads. The default behavior has not been changed (make check does not use multiple threads). However when running the test programs manually you can add "-m" as argument. Each "m" does add an additional thread for testing. However, the test programs itself need also to provide such test cases.
- The test cases (used with make check) do now use the complete library. This has the drawback that building must always be done in the top level directory before performing tests. However, the tests use the real library now (and not just a subset) so that the overall testing quality is a little improved.
- This release adds the possibility to choose on configure time to build the complete ResourcePool library in a thread safe manner. Although ResourcePool does support thread safety on class level, this release supports only a library wide selection to build it either with appropriate locking mechanisms of without (which is the default setting).
- Made GCC 4.0.0 aware. There where some minor errors and warnings which have been fixed.
- The (not yet documented) multi threading classes have been cleaned up. Actually ResourcePool is fully thread safe, but nobody knows it ;) One of the next releases will make this officially.
- Made compiling with Intel C++ compiler possible (v8.1).
- Fixed some POSIX issues which caused ResourcePool to not compile on some systems.
- Fixed Makefile so that compiling without any database support is also possible.
- The bind() and bindout() methods are now pre-instantiated for all ISO C++ fundamental types.
- A new ResourceType SQL is available. It supports the SQLExecute, SQLSelect and SQLSelectRow commands and can connect to Oracle or MySQL databases confirureable on at runtime. Previously changing the database type (e.g. from MySQL to Oracle) required changing a typedef and recompiling the application. The "old" way is still possible and has minor performance benefits, since the "new" way is just a wrapper.
- The Doxygen documentation has been improved.
- The Command template has been refactored to take the PoolType as template argument instead of the plainresource_t. This was required to make some private methods really private (previously the required friends clause was not possible).
- Added flex++ to the list of requirements. The configure script will now fail if flex++ is not reachable via $PATH.
- It is now possible to create a MySQL or Oracle factory with a single argument which includes all required data. For Oracle the well known syntax "USER/PASS@SERVICE" is used, for MySQL "USER[/PASS][@DB][;HOST][:PORT]". This is a further step to reduce the differences between the MySQL and Oracle bindings.
- First public release.
