Appendix E. Release Notes
Prev |  | Next

## Appendix E. Release Notes

2.4.3 -- 26 March 2003

- Notable changes

  Bugfixes

  - Included a new version of serp that resolves issues with weak and soft references that can lead to memory leaks. Be sure to copy the new serp jar into your lib dir as well as the new Kodo jars.

  - Fixed a bug in ClassDBSequenceFactory to address potential concurrency issues that could lead to a deadlock while obtaining new ID values.

  - Fixed AbstractDictionary to deal with null Locale objects properly.

2.4.2 -- 26 Feb 2003

- Notable changes

  - The `ProxyManager` now includes capabilities to proxy user-defined mutable field types that are not part of the JDO specification.

  - The SunONE Studio / NetBeans plugin module has moved into release status. Existing module users should un-install and re-install the module.

  - The Eclipse / WSAD plugin has moved into release status. Note that the plugin folder structure has changed to reflect this change. Existing plugin users should remove the old folder, install the new folder, and update the plugin.xml accordingly. Included in this new version are changes in classpath and project resolution.

  Bugfixes

  - Mutating a Date field via deprecated setDate(), setHour(), etc. now properly dirties the owning object.

  - Fixed LocalCache synchronization issue.

2.4.1 -- 26 January 2003

- New features

  - New subclass provider implementation option simplifies using an integer lookup value to store subclass information in the database. Additionally, the source for this implementation is included in the release, so creating a custom subclass provider is simpler.

  - We now set the default transaction isolation level to TRANSACTION_SERIALIZABLE when using DB2. This is necessary in order for datastore (pessimistic) transactions to lock rows correctly.

  - Added a new SequenceFactory: com.solarmetric.kodo.impl.jdbc.schema.ClassDBSequenceFactory which provides class sensitive table-based id sequences. To use the new sequence factory, existing sequence tables need to be dropped to be mapped to the differing table structure.

  - Added a table name option to com.solarmetric.kodo.impl.jdbc.schema.DBSequenceFactory to map sequences to. To set this option, add the option `tableName=yourname` to com.solarmetric.kodo.impl.jdbc.SequenceFactoryProperties property when configuring your PersistenceManagerFactory.

  - Persistent types can once again be enumerated by using the com.solarmetric.kodo.PersistentTypes property. This property is optional, but help to avoid classloader issues when deploying to an application server.

  Bugfixes

  - Fixed data caching plug-in to not enlist objects with can-cache=false when loading existing data from the database.

  - Fixed bug in metadata parsing algorithm that could cause classloader problems in application servers

  - Fixed SQLServerDictionary to work around SQLServer's issues with setting null BLOBs via PreparedStatement.setNull().

  - Datastore locking (i.e., pessimistic locking) is now supported for Sybase. Note that the connection property "BE_AS_JDBC_COMPLIANT_AS_POSSIBLE=true" must be set, either in the ConnectionURL or the ConnectionProperties properties. See the SybaseDictionary.java source file for more details. This requires the Sybase JDBC driver version 4.5 or higher.

  Notable changes

  - Removed the AutoReturnTimeout property. The Kodo pooling DataSource no longer reclaims expired connections.

2.4.0 -- 13 Dec 2002

- New features

  - Pre-release versions of plugins for SunONE Studio, NetBeans, Eclipse, and WebSphere Studio are now available. See the documentation on installation and usage instructions.

  - Kodo JDO Enterprise Edition and the Kodo JDO Performance Pack are now bundled with a cache plug-in that supports Tangosol Coherence cache products. See the datastore cache documentation for details.

  - Added `evictAll(Class)` and `evictAll(Extent)` method calls to `PersistenceManagerImpl`. These methods are useful for clearing often-updated objects in pooled PersistenceManager configurations.

  - Added the capability of loading `ResultSet` objects (or any other stream of data) into `PersistenceCapable` objects associated with a `PersistenceManager` via application-defined logic.

  - Added metadata extensions for specifying custom `ClassMapping` and `FieldMapping` values for particular classes and fields.

  - Added class-level metadata extension to exclude certain classes from the PersistenceManagerFactory cache.

  - Added property for configuring the how long to wait before testing connections that have been put into the pool.

  - Simplified the process of defining custom subclass indicator behavior.

  - When supported by the underlying JDBC driver, Kodo will now use PreparedStatements and batch updates whenever possible for very significant performance benefits. See the documentation for the com.solarmetric.kodo.impl.jdbc.UsePreparedStatements and com.solarmetric.kodo.impl.jdbc.UseBatchedStatements properties.

  - Inverse one-to-one mappings are now supported. The field can now reside on either table corresponding to the related objects. If both sides of an one-to-one are marked as having an inverse, one field should be designated as read-only to indicate to the system the owning class and table for the given relational field.

  - Logging is now done through the Apache commons project, which offers the ability to use an underlying logging mechanism, such as Apache Log4J, JDK 1.4's native logging, or simple file/stdout logging. It is now necessary to include the new `jakarta-commons-logging-1.0.2.jar` jar in the CLASSPATH. See the Logging chapter.

  - Added a pluggable `SQLExecutionManager` architecture, which allows the developer to override the mechanism by which SQL is issued to the database. See the documentation for the com.solarmetric.kodo.impl.jdbc.SQLExecutionManagerClass property.

  - There is now an option to automatically refresh the database schema during runtime, allowing the developer to skip the `schematool` step. See the documentation for the com.solarmetric.kodo.impl.jdbc.SynchronizeSchema property.

  - Properties may be specified for a Driver with the com.solarmetric.kodo.ConnectionProperties property.

  - A `javax.sql.DataSource` may be specified in the javax.jdo.option.ConnectionDriverName property, which will be customizable with bean-like enteries in the com.solarmetric.kodo.ConnectionProperties property.

  - The default transaction isolation for a JDBC connection can be overridden with the com.solarmetric.kodo.impl.jdbc.TransactionIsolation property.

  - Kodo JDO now distributes a single jar for both the enterprise and standard edition, as well as datacache and query extensions.

  - The rd-metadatatool can now be used to generate default JDO metadata for classes.

  - The rd-schemagen tool used for reverse mapping classes from a schema has now been tested with the following databases: Hypersonic SQL 7.1, SQLServer (MS Beta 2 JDBC driver), Sybase, Oracle (9.0.1 JDBC driver), DB2, Postgres (7.3 Beta 3 JDBC driver).

  Bugfixes

  - `default-fetch-group="false"` is now respected for fields that default to `default-fetch-group="true"`.

  - Traversing orphaned relations in data cache now behaves in the same way as traversing orphaned db relations -- the invalid relation is set to null.

  - Changing a field to the same value as it was originally set to no longer constitutes dirtying that field. This means that subsequent flushes to the database will not necessarily re-write the same data.

  - Class loading is performed in accordance with section 12.5 of the JDO specification.

  Notable changes

  - The API for implementing a SequenceFactory has changed. See the API documentation for com.solarmetric.kodo.impl.jdbc.SequenceFactory.

  - Persistent types are no longer enumerated, either in the data store or in a property. Classes are now dynamically added upon class initialization, via the JDOImplHelper class registration process. The `-register` and `-unregister` options to schematool are no longer needed. The `JDO_SCHEMA_METADATA` table is no longer used and can be dropped.

2.3.4

- New features

  - The R&D schema generator can now accept a list of tables to generate.

  - The R&D reverse mapping tool has additional options for using foreign key names to generate relation names, generating primitive wrapper-type fields if a column is nullable, and allowing primary keys on many-to-many join tables.

- Bugfixes

  - Fixed problems with many-to-many relations between tables that use vertical inheritance.

  - Fixed bug in schematool that caused it to not generate primary key columns in subclass tables when using datastore identity + custom names + vertical inheritance.

  - Fixed serp library conflict between reverse mapping tool and main Kodo libraries.

  - Fixed a reverse mapping tool bug in which column names that conflicted with Java keywords would result in the generation of uncompilable Java classes.

  - Fixed problem that caused read-only flag to be ignored in many-to-many relations.

  - Multi-table inheritance deletes are now performed from the leaf table in the inheritance chain up to the base table. Inserts are performed from the base table down to the leaf. This supports the common referential integrity model of establishing a foreign key relation from inherited tables to their parent tables.

2.3.3

- New features

  - The R&D schema generator can now accept a list of tables to generate.

- Bugfixes

  - Fixed `null-value="default"` behavior.

  - Fixed bugs that prevented removal of map elements through the key set, entry set, and values collection.

  - Added more validation on static/final fields to metadata.

  - Fixed memory leak in serp regarding soft and weak collections backed by `HashSet`s.

  - Multi-variable query issues resolved.

  - Fixed bug that could cause optimistic lock version numbers to be incremented before successful transaction commit.

  - The R&D reverse mapping tool now handles Oracle DATE columns correctly.

2.3.2

- New features

  - The new com.solarmetric.kodo.CacheReferenceSize property dictates a number of hard references to cached objects that the PersistenceManager will retain, in addition to its soft cache.

  - Added 'all' option to unregister action of schematool Ant task. This option allows all classes in the current persistent types list to be unregistered, regardless of whether or not those classes are currently in the classpath.

  - Added com.solarmetric.kodo.UseSoftTransactionCache to configure whether or not Kodo should maintain soft references to transactional items that have not been dirtied. This now defaults to false; previous versions of Kodo always used soft references for non-dirty transactional items.

- Bugfixes

  - The jdodoclet task no longer creates JDO metadata entries for final or static fields, or for transient fields that do not have a `jdo:persistence-modifier` tag.

  - The jdoc task no longer attempts to enhance classes that have already been enhannced.

  - Several default property values were being set improperly.

2.3.1

- New features

  - Smart proxies for set and map fields. Smart proxies better optimize database updates when persistent set and map fields are modified.

  - TCP, JMS-based distributed DataCache implementations.

  - All DataCache implementations now use an LRU cache with a configurable maximum size.

  - Customizable tracked instance proxies.

  - Alpha release of upcoming reverse mapping tool for creating persistent class definitions, metadata, and mapping extensions from an existing schema.

  - Cache object com.solarmetric.kodo.runtime.datacache.PMFactoryCache is now named com.solarmetric.kodo.runtime.datacache.plugins.LocalCache.

- Bugfixes

  - A Query with an unspecified filter defaults to a filter of "true", rather than "false".

  - A Query with an unspecified candidate Extent but a specified candidate Class will automatically create an Extent of the appropriate type with subclasses turned on.

  - Various bugs related to compiled queries with null arguments or no parameters have been resolved.

  - Various InstanceCallbacks interface bugs have been resolved.

  - Ant schematool and jdoc tasks deal with the Ant ClassLoader system better.

- Notable changes

  - Made `GenericDicitonary.toSQL()` and `GenericDicitonary.fromSQL()` methods `final`. Subclasses of `GenericDictionary` that must change the behavior of SQL generation or parsing should do so by overriding the appropriate `xxxToSQL()` or `xxxFromSQL()` methods instead. Note that the source for all our dictionary classes is now available in the Kodo JDO distribution.

2.3.0

- New features

  - JDO specification version 1.0 support.

  - Highly flexible multiple-table inheritance model now supported. See the multi-table class mapping documentation for details.

  - Support for large result sets when using any JDBC 2.0+ driver that supports ResultSets of type TYPE_SCROLL_INSENSITIVE. Return values from all Query.executeXXX() methods will be an instance of java.util.List, which can then be used for efficient random access.

  - DataCache API batches distributed updates, facilitating custom processing of distributed cache invalidation.

  - DataCache implementation loads data read from the data store into the cache as well as data being written to the data store.

  - JDBC back-end customizability is improved, allowing for custom field and class mappings and much finer-grained control of generated SQL.

  - Kodo JDO now supports extending JDOQL with custom tags. A number of default extensions, including substring searches and case-insensitive searches, are included by default with Kodo JDO. For more on this feature, see the query extensions documentation.

  - Support for IBM WebSphere, and other application servers that do not provide a TransactionManager though a JNDI lookup.

  - Source code release for various utility classes under the source/ directory.

  - Deprecated the srcDir attribute of jdoc and schematool: the nested fileset no longer needs to be relative to an absolute directory.

  - Added a new method to ExtentImpl that returns a list containing all objects described by the extent.

- Bugfixes

  - Resolved a problem with large (> 5000 bytes) BLOBs being stored in Oracle.

  - Fixed problem with compiled queries and null parameters returning empty result sets. Currently, when null parameters are used, prepared statements are bypassed and custom SQL is generated instead. In a future release, a new prepared statement that uses IS NULL will be generated on-the-fly.

2.2.5 May 6, 2002

- New features

  - The String serialization of ObjectIds.Id now uses a '-' as the delimiter, as the previous choice of the '#' made it difficult to use the serialization in a JSP without re-encoding it.

  - Released ant tasks for JDO enhancement, the SchemaTool, and an XDoclet task for generating .jdo metadata files from java source code comments.

  - Integration features for the upcoming JBuilder 7.

- Bugfixes

  - Fixed issue with managed transaction rollbacks. See bug #157 for details.

  - Fixed problem with prepared statements and in-memory queries. See bug #161 for details.

2.2.4 SP1 April 19, 2002

- Bugfixes

  - Resolved issues when using null parameters and compiled queries.

2.2.4 April 17, 2002

- New features

  - Support for java.math.BigInteger and java.math.BigDecimal

  - Added support for using packagename.jdo as the package's JDO metadata file, where "packagename" is the last section of the resource's package. E.g., a java class named com.solarmetric.mypackage.MyClass can now use a metadata file named mypackage.jdo.

  - Query.compile() will now create and use a PreparedStatement.

  - Kodo JDO now supports both single-JVM and distributed caching of persistent data.

  - It is now possible to extend the PersistenceManagerImpl and the EEPersistenceManager.

  - Added support for serialization/deserialization of an object id to/from a String.

  - Added an example of using Kodo within JSPs in the samples/jsp/ directory.

- Bugfixes

  - Resolved inefficient behavior when executing a query that returns objects that have already been loaded but are hollow (bug 116).

  - Fixed NotSerializableException when trying to bind an instance of EEPersistenceManagerFactory into JNDI (bug 117).

  - Fixed problem where changing any of the configuration values in a PersistenceManagerFactory changed those values for all PersistenceManagerFactory instances on the system (bug 131).

2.2.3 March 4, 2002

- New features

  - New and improved documentation is now available at docs/manual.html. Enjoy!

  - Added code to check parameter count against declared parameter count when executing queries.

  - Partial support for the Java Connector Architecture is now available in the Enterprise Edition. This permits simple configuration of Kodo JDO using an application server's JCA configuration tools.

  - PersistenceManagerFactory instances can now be created from a Properties.

  - Guaranteed that SQL statements corresponding to object modifications (insert, update, delete) occur in the order that the modifications were performed in the PersistenceManager. If an object is modified multiple times, it will remain in the position that it was in after its first modification. When committing, we now traverse this list in order, so it is possible to do things like delete an object and then add a new object with the same id in a single transaction.

  - Added optional '-outfile filename' option to schematool. If specified, the SQL statements necessary to perform the schema modification will be appended to filename. No changes will be made to the database itself. This is useful when database modification is not permitted, or for post-processing the SQL generated by Kodo JDO with an external tool.

  - Changed schematool to print a warning when an array, collection, or map field is implicitly made persistent because of the rules of the spec. This often leads to undesirable behavior, as the default mode of insertion is to serialize the array/collection/map into a BLOB field, which is more often than not the desired behavior.

  - Both 'kodo' and 'tt' are now supported vendor tags. No collision checking is performed, so you should probably use just one.

  - Added support for Hypersonic free file-based JDBC driver

  - Added a new database preference: db/schema-name. If set, this value will be used in calls to DatabaseMetaData.getTables().

- Bugfixes

  - Made queries take into account changes in the current transaction if IgnoreCache == false.

  - Made extents pay attention to changes made in the current transaction

  - Changed methods that are part of javax.jdo interfaces to never throw anything but JDOExceptions. See bug 69.

  - Resolved problem with listing table names when multiple database users should each have their own set of tables. See bug 77.

  - Only invalidate the connection and not return it to the pool if the Connection name contains "postgres". See PostgreSQL bugfix in 2.2.2 section for more details.

  - Fixed a problem where executing 'jdoc' on a package.jdo that contains both app id and datastore id classes causes a failure.

  - Improved error messages.

2.2.2 February 14, 2002

- New features

  - Added a duplicate column check to SQL INSERT and UPDATE query generation methods. If a duplicate column name is encountered and the values are also duplicates, then life proceeds happily along. If duplicates are found and the values differ, a JDOUserException is thrown. This permits using schema mappings in which a column is used both as a primary key and a foreign key.

- Bugfixes

  - Resolved potential deadlocks. See bug 42.

  - Added mechanism for controlling date precision when constructing SQL statements. See bug 6.

  - Fixed schematool strangeness when using table name metadata extensions. See bug 54.

  - improved error-reporting in exceptions thrown when invalid data is added to proxy collections/maps.

  - Fixed bug in which persistent-deleted objects were not containing the correct values on rollback if RetainValues was set. This fix makes persistent-deleted objects transition to hollow instead of performing any rollback.

  - Transaction.commit() and Transaction.rollback() now throw a JDOUserException instead of an IllegalStateException when a transaction is not active. See bug 44.

  - Because of a probable Postgres JDBC driver bug, changed connection pooling to not recycle connections that have been involved in a transaction.

  - Resolved a VerifyError that occurred when a non-primitive, non-String object was used as part of an object's primary key.

  - Resolved a situation in which the number of connections needed to load a single object from the data store was proportional to the depth of persistence-capable fields in the tree of default fetch groups. That is, if A has a relation to B called b, and B has a relation to C called c, and b is in A's default fetch group, and c is in B's default fetch group, then three connections were needed in order to load an A.

  - Fixed bug in which queries on date fields occasionally threw exceptions.

  - Fixed obscure bug in makeDirty(). If using data store transactions and setting a JDO field without first having loaded the field (either implicitly by having the field in the default fetch group, or explicitly), then the field would not be set when InstanceCallbacks.jdoPostLoad() was invoked. Additionally, nontransactionalRead must have been set to true for this problem to occur.

  - Fixed a bug that caused queries to fail in certain Tomcat configurations. See bug 35.

  - Added writeReplace() methods to fix issues with serialization of dates and collection types retrieved from data stores.

  - Fixed bug in which jdoNewInstance(StateManager,Object) method was only being added to base application identity classes.

  - com/solarmetric/kodo/runtime/PersistenceManagerImpl.java: improved error reporting when validating and making persistent objects that are not managed by the current PM.

- Notable changes

  - Made default table type for MySQL be Berkley DB, which has real transactional capabilities

  - Set the default to warn on persistent type failures, rather than throw an exception.

2.2.1 November 1 2001

- New features

  - IBM DB2 UDB 7.2 is now supported.

  - All datastore identity classes now use the com.solarmetric.kodo.util.ObjectIds.Id object ID type rather than individual dynamically loaded classes.

  - Performance enhancements.

- Bugfixes

  - Old versions of MySQL for Windows are now supported.

  - A new algorithm for auto-generation of table/column/index names that is much less likely to generate naming collisions is now available.

  - Fixed PersistenceManager.refreshAll() behavior when no transaction is active.

  - New persistent objects, first class children, etc. are correctly dealt with when created in jdoPreStore().

  - Queries that perform multiple contains(), containsKey(), or containsValue() clauses &&'d together for different values on the same collection/map now work.

  - The PM will throw some subclass of JDOFatalException on commit if and only if the transaction is also automatically rolled back.

- Notable changes

  - One-to-one mappings are dealt with more efficiently, reducing the number of database accesses and therefore improving performance.

  - Changed resource-loading and class-loading to use the current thread's context's class loader, rather than the system class loader. This makes deployment to a web application container much easier.

  - A single class is now used as the ID class for all persistent types managed with data store identity.

2.2.0 October 5, 2001

- New features

  - Application identity is now supported.

  - Preview release of tool to generate a class suitable for use as an application-identity object id class, complete with an appropriate equals() method, a corresponding hashCode() method, and a toString() method. For more information and usage, run 'java com.solarmetric.kodo.tools.appid.ApplicationIDTool'.

  - Improvements have been made to common error messages, and inappropriate exception types have been replaced with more useful ones.

  - New library: kodo-jdo-runtime.jar. This library contains all the class files necessary for run-time use of Kodo JDO.

  - Enhanced mapping customizations for mapping application-identity pk fields (see docs/existing-schema.html)

  - Various minor performance enhancements

- Bugfixes

  - PersistenceManager refresh methods behave correctly when invoked from outside the context of a transaction. Note that the noargs refreshAll () call behaves as designated by the JDO javadoc, not as designated by the 0.95 specification.

  - SQL generation for statements that insert decimals (floats and doubles) now always use United States notation (3.14159 for example).

  - Assorted minor bugfixes.

- Notable changes

  - Major redesign of the refresh mechanism.

beta 2.1 July 15, 2001

- New features

  - The null-value attribute on field metadata is supported.

  - BLOB mappings are supported; any serializable field can now be persisted. (Note: PostgreSQL does not support BLOB mappings)

- Bugfixes

  - jdoPreStore() is no longer called on deleted instances.

  - Fixed a NullPointerException that could occur when softly-cached instances were garbage collected by the JVM.

  - Indexes were not being created on fields marked with the 'column-index' metadata extension.

  - Fixed a bug that prevented retrieving CLOB values with Oracle.

  - Fixed a bug that caused a SQLException with fields set to empty strings or chars with a 0 value on PostgreSQL.

- Notable changes

  - The SQLTypeMap, used in DBDictionaries, changed slightly.

  - The Kodo User Guide chapter on Metadata has been updated to include information on the new 'blob' metadata extension for explicitly marking fields that should be stored in serialized form.

beta 2 July 10, 2001

- New features

  - Maps with user-defined persistent object values can be persisted (n-many relations).

  - Static inner classes can be persisted.

  - Queries support the use of containsKey() and containsValue() for Map fields.

  - Queries support ordering declarations.

  - The SchemaTool's schema migration capabilities have been enhanced.

  - The SchemaTool offers the option of automatically maintaining the list of persistent types for the system.

  - Schema generation can be customized through JDO metadata.

  - The standard javax.sql.DataSource is used to obtain connections.

  - Connection pooling has been enhanced, and new pooling parameters have been added (timeout time, autoreturn time).

  - The ObjectId helper class has been introduced to map opaque JDO OID values to and from primitive long values.

  - PersistenceManagerFactories can be stored in JNDI, including JNDI trees that are replicated over multiple JVMs.

  - PersistenceManagers can transparently synchronize with global J2EE Transactions (Kodo Enterprise Edition beta only).

- Bugfixes

  - Row-level locking is now performed within pessimistic Transactions.

  - Object ID generation is now done using the database by default.

  - Globally unique primary key values are no longer required (per-class only).

  - Inserting new instances of classes mapped to an existing schema without a class indicator column no longer throws a NullPointerException.

  - Numerous minor fixes.

- Notable changes

  - Users of previous beta versions of Kodo should scan the user guide in the docs/ directory for new information included with this release.

  - The schematool can now automatically maintain a list of persistent classes; the persistent-types array in system.prefs is not needed. This is covered in the Database Setup chapter of the user guide.

  - The syntax for using the schematool has changed. This is covered in the Database Setup chapter of the user guide.

  - The syntax for mapping classes to existing database tables has changed. This is covered in the Using Existing Schema chapter of the user guide.

  - The Runtime Use chapter of the user guide covers new runtime options available, such as JNDI storage of the JDBCPersistenceManagerFactory and safe conversion of JDO OID values to and from primitive long values.

Prev | Up | Next
Appendix D. SQL Types | Home | Appendix F. Known Bugs and Limitations