Changelog

Contents

Get Started

Help Out

Beta 6 (30 May 2004)

• General:
• Upgraded to JDOM beta 9.
• Upgraded to CGLIB 1.1pre1 dev version.
• Added ASM to distribution as this is what is now used by CGLIB.
• Added open source jta.jar and redistributable jdo.jar -- now no additional packages are required to run XORM.
• Updated to JDO 1.0.1 API. PersistenceManager.getObjectById() will correctly throw JDOObjectNotFoundException if validate=true.
• Changes to better support running some JDO TCK tests.
• Changes to better support standard JDO enhanced objects.
• Hollow state is now used to provide lazy loading where possible.
• java.sql.Time and java.sql.Timestamp are recognized as non-user types.
• Support for indexed properties added to FieldDescriptor utility class.
• More and better error messages and warnings.
• toString() now correctly identifies PERSISTENT_NONTRANSACTIONAL objects.
• Configuration:
• Factory methods on XORM helper class now look for resources in the current thread's ContextClassLoader.
• Added fail-fast logic to detect classes mapped to tables without primary keys.
• Cache:
• Removed SoftReferenceCache. Made LRUCache the default.
• For performance, XORM now tries to avoid clone() operations on Rows wherever possible.
• JDOQL:
• Support "this == parameter" and "this != parameter" expressions.
• Support underscore ('_') characters in identifier names.
• Fix handling of some uncommon whitespace characters.
• Allow ordering statements to use references to objects not explicitly included in the filter condition.
• CodeQuery better supports evaluate() methods with complex parameter types.
• SQL Datastore:
• Added optional "org.xorm.datastore.sql.IdleCheckSQL" property to specify a SQL command to run against the database to test connection integrity.
• Added ability to use JNDI ("javax.jdo.option.ConnectionFactoryName" property) to acquire a DataSource.
• Introduced a default HeapDatastore and HeapConnectionInfo implementation that is aimed at allowing a developer to test an app without a physical datastore.
• PersistenceManagerFactory.close() will cause connections to be released from the connection pool.
• XML Datastore:
• Fixed TypeConverter method that was not properly converting java.util.Date to java.lang.String.

Beta 5 (9 July 2003)

• JDOQL:
• Rewritten JDOQL parser supports much more of the language, including Collection.isEmpty() and parentheses for operator ordering. Fixed support for contains() with variables (improved expression parsing and explicit DISTINCT operator on SQL results). Implemented contains(param).
• As a JDOQL extension, the expression "field.indexOf(str) == -1" is recognized to mean "field contains str" (so is "field.indexOf(str) >= 0"). "strstr" can still be used for this purpose as well.
• Added support for traversal of fields in JDOQL ordering clauses.
• Added support for field traversal from persistence-capable parameters in JDOQL filter expressions.
• JDO:
• Transient instances added to a persistent collection now become persistent automatically, in accordance with the JDO spec.
• Fixed jdoIsDirty() status to include dirtiness of referenced collections.
• Query.close(Object) and Query.closeAll() are implemented.
• Per JDO 1.0.1, closing a PersistenceManager with an active transaction will throw a JDOUserException.
• XORM Extensions:
• Added filtered relationships support. See the User's Guide for details.
• Integrated AppConfig utility classes for easy setup with J2EE environments.
• The CodeQuery mechanism has been fully integrated. Code that can be parsed using BCEL into equivalent JDOQL will generate the relevant SQL queries. Other code will fall back to a brute force method of evaluation.
• Configuration:
• Assume "table" mapping for one-to-many relationships if not specified in JDO extension metadata.
• Added GUI tools for properties file management and several utilities for forward and reverse engineering datastore and classes. New ant tasks provide convenient ways to run these (see User's Guide for details).
• General:
• Enhanced many error messages with explanations of possible causes. Configuration errors are detected earlier.
• Fixed a bug in the LRUCache implementation that could cause runtime errors.
• The default cache utilizes memory more efficiently under high-volume write conditions.
• Better support for datastore configurations that require JDBC autocommit mode.
• Many more minor bug fixes and enhancements.

Beta 4 (8 March 2003)

• JDO metadata files can be bootstrapped for failfast behavior using the "org.xorm.option.BootstrapJDO" property. When this option is used, XORM-enhanced JDO classes are registered with the static JDOImplHelper instance and JDOImplHelper.newInstance() may be used as an alternative to XORM.newInstance().
• Extent.close() and Extent.closeAll() are now implemented.
• SQL queries use variables in prepared statements where possible.
• The JDOQL parser now supports variables (using the contains() operator), floats, doubles, longs, negative numbers, exponents, and the (nonstandard) strstr() operator. A bug that caused errors when using multiple functions in a filter is fixed.
• TypeConverter handles primitive types as targets (e.g. long instead of java.lang.Long).
• Persistent classes are now enhanced with a default implementation of toString() useful for debugging if the application provides no toString() implementation.
• Enhanced classes now implement clone() if it is declared on the interface or abstract class. Clones are shallow and become transient.
• Cleaned up the contract between the InterfaceManagerFactory, ConnectionInfo objects, and DatastoreDrivers. ConnectionInfo is now the top-level configurable entry point, via the "org.xorm.datastore.ConnectionInfoClass" property. The default setting is SQLConnectionInfo.
• An implementation of a least-recently-used cache has been added. See the user's guide for configuration details.
• Changed built-in JDBC driver mapping file to include configurable strings for retrieving the next and last inserted ID. Based on this change, support for MySQL, PostgreSQL, HsqlDB and Oracle is handled through configuration files. Other databases can most likely be configured similarly without code changes. These settings can be manually overridden using "org.xorm.datastore.sql.LastIDStatement" and "org.xorm.datastore.sql.NextIDStatement".
• Added an optional SQL property, "org.xorm.datastore.sql.TransactionIsolationLevel". This can be set to one of the constant names from java.sql.Connection, e.g. "READ_COMMITTED"; it will then apply to all connections in the pool.
• Fixed a bug that allowed iterators over query results to remove() items.
• The SoftReferenceCache is now more proactive about removing the keys for expired objects from its map.
• Upgraded to CGLIB RC 1.0.
• Upgraded to JUnit 3.8.1.
• The "format" attribute is now read from the database schema XML file, and can be used to format dates in the XML datastore driver.
• The XML file datastore driver now supports non-String type conversion.

Beta 3 (26 November 2002)

• Support for setting non-null="true" on a column in the database XML. This information is used in conjunction with default fetch groups to determine whether inner or outer joins should be used. The reverse engineering tool now generates this information.
• Support for default-fetch-group semantics. For reference fields, setting default-fetch-group="true" will turn off lazy loading and instead cause a join or outer join (depending on the null-value treatment of the field) when queried against a SQL datastore. For primitive value fields, setting default-fetch-group="false" will not load these values during the initial lookup; they will instead be loaded on demand if and when accessed.
• In addition, it is possible to implement custom fetch group handling by specifying a value for property "org.xorm.FetchGroupManagerClass" and extending org.xorm.FetchGroupManager.
• Support for setting read-only="true" on a column in the database XML. If specified, no insert or update statements will include the column.
• Generated SQL queries now use table aliases (except when using SQLCondition).
• Generated SQL queries no longer use the DISTINCT keyword (except when using SQLCondition).
• The factory-level cache configuration property has been changed to "org.xorm.cache.DataCacheClass", and the cache interface has been changed to allow greater control.
• Factory-level caching can be turned off by setting "org.xorm.cache.DataCacheClass=none". This may be needed in distributed environments. You can also programmatically clear the factory-level cache by calling XORM.clearCache(factory).
• Fixed a potential race condition when the mappings are being initialized that could cause some queries to fail.
• Upgraded to CGLIB Beta 2 and JDOM Beta 8.
• Database XML file can now specify type="sqlTypeName", where sqlTypeName is the string name of one of the constants in java.sql.Types (e.g. "varchar", "numeric", etc.) If specified, this type will be specified when inserting or updating the column instead of relying on the JDBC driver's default mapping. The reverse engineering utility generates this information.
• Sybase driver no longer fails on update/insertion of VARCHAR columns where the Java String is greater than 255 characters.
• Updated documentation to reflect new configuration options.

Beta 2 (11 October 2002)

• Full support for using abstract classes as well as interfaces for persistent objects.
• The property "org.xorm.datastore.database" is now required to define the resource path to the database XML configuration file. It is not necessary (nor does XORM pay any attention) to reference the database mapping from the .jdo file.
• Better portability across databases that may implement identity columns differently by adding optional datastore-identity-type extension tag to JDO file.
• commons-simplestore enhancer was changed to cglib; changed JARs included with distribution. CGLIB now enhances package-protected and protected methods, which can be used in XORM with abstract classes.
• The "org.xorm.datastore.xml.JDOMDocumentDriver" class is an implementation of the XORM DatastoreDriver API that allows an XML file to be used as a datastore.
• A database driver was added for MySQL.
• Methods on javax.jdo.JDOHelper now return the correct values regardless of the state of a XORM object.
• New boolean property "org.xorm.option.ThreadLocalTransactions" will allow multiple transactions per PersistenceManager. This is not enabled by default and is not the behavior specified for JDO, but it can be useful when you want to use a PersistenceManager with an HTTP session, for example.
• More flexible handling of pooled JDBC connections. The properties "org.xorm.datastore.sql.CheckReturnedConnection=true" forces a check if the connection is closed every time it is returned to the pool; otherwise "org.xorm.datastore.sql.IdleCheck={milliseconds}" will cause the connection to be checked before it is given out by the pool if it hasn't been used in the specified amount of time. This value defaults to 5 minutes; "-1" means never check, "0" means always check.
• By default, the parser will now validate your JDO and database XML files against their DTDs. To disable this (for example, if your installed JAXP parser doesn't support validation), set "org.xorm.option.ValidateXML=false".
• XORM will now complain at initialization if you try to set up mappings in the JDO file for non-existent fields (properties) of your persistent classes.
• The getObjectId() method and the XORM datastore object ID class now conforms to the JDO specification. There are static helper methods on org.xorm.XORM to extract the primary key from an ObjectId instance.
• Using the DataQuery query language, you can pass in an ObjectId as a parameter and the query generator will extract the primary key and use that value in the generated SQL.
• Closing a PersistenceManager now ensures that all active transactions are rolled back and database connections are released.
• Database lookups that occur outside a transaction with nontransactionalRead enabled are optimized for read-only access where the database supports it.
• The cache implementation is now configurable via the factory property "org.xorm.cache.TableCacheClass". This defaults to "org.xorm.cache.SoftReferenceCache".
• XORM's JDO parser is now in a separate package and can be used as a utility class by external users for convenient access to the JDO XML structures. See the Javadocs for details.
• Datastore updates now only update dirty fields.
• JDO InstanceCallbacks can be implemented to enable callbacks on abstract classes.
• Most error messages are now localizable.
• All failures of a datastore driver will now result in JDODataStoreException (if the condition was handled by rolling back the transaction) or JDOFatalDataStoreException (if the condition could not be recovered from). Previously, certain errors were being logged but did not cause exceptions to be propagated.
• New XORM instances can be constructed using a PersistenceManagerFactory reference instead of a PersistenceManager reference if that is more convenient.
• Added a number of JUnit test cases.
• Many other bug fixes, performance enhancements and changes to internal structures.

Beta 1 (27 August 2002)

Initial public release.