Release History

Version 2.2 - 2008-04-04

• Integrate with, and add binaries for, the (not formally released) Apache JDO 1.1 API and RI. This provides a bytecode enhancer that works with Java 5.
• Added support for inverse many-to-many sets and maps.
• Added support for several of the new JDO 2.0 query features, such as projection, aggregation, and grouping.
• Allow TJDOSQL queries to produce result objects in the JDO 2.0 style, using setResultClass() or returning Object[].
• Added support for selecting the JDBC result set type to be used by JDO queries.
• Added support for setting the JDBC fetch size.
• Switched all logging to use Jakarta Commons Logging.
• Converted all logging of SQL timing and SQLWarnings to a centralized JDBC trace facility, configurable with "com.triactive.jdo.JdbcTrace".
• Added a new method to SchemaManager to determine which classes are stored in a given schema.
• Added an option to detect and log any significant differences in system time between the current host and the database. Also, a new method to SchemaManager that provides application access to the current database timestamp.
• Added support for using bulk DELETE statements under the covers where applicable. This noticeably improves performance when clearing most large collections, or deleting objects having large collections.
• Auto-close any PersistenceManagers or Query results that the application fails to close before they're garbage collected, and log a complaint.
• Added a utility (com.triactive.jdo.enhance.Enhancer.main()) with an option that will produce a list of all the JDO classes without actually enhancing them.
• Modified column naming to allow a class named Foo to have a field named fooID.
• Modified the way schema information is managed to reduce memory footprint when many schemas use the same or similar data models.
• Modified the way catalog metadata and JDO_TABLE are accessed to improve performance.
• Bugs #932207 and #1011400 : Improve SQL generation on navigation through collections in queries (contains() method).
• Bug #953435: Allow -s srcPath option to be passed down to the reference enhancer.
• Bug #955399: Properly handle more than 25 keys.
• Bug #955427: Properly handle more than 25 indexes.
• Bug #987969: Eliminated superfluous use of Unix-style new lines in SQL and message text.
• Bug #1096706: BufferedResultIterator.close() allows no more iteration and releases the buffer.
• Bug #1099152: Fixed retrieval of Oracle CLOBs containing non-ASCII characters.
• Fixed Set.add() on DBMS's that rollback after duplicate key errors.
• Fixed clear() on inverse sets and maps where the owner field is nullable.
• Fixed evictAll() to ensure that it evicts both PClean and PNontrans instances.
• Ensure that code in an InstanceCallback can call e.g. tx.setSynchronization().

Version 2.1 - 2004-03-31

• Added support for Transient Transactional instances (§5.7).
• Added support for non-persistent transactional fields (i.e. persistence-modifier="transactional" §6.4.2).
• Added support for byte[] fields, which are mapped to a suitable binary or BLOB column.
• Added support for fields of type java.util.Hashtable.
• Added support for Oracle 9i. All TJDO functionality is available on 9i and all tests pass, but columns manually created using the new 9i TIMESTAMP types are not yet supported.
• Refactored SCO handling for better spec compliance. Resident SCO collections now hold strong references to any instantiated objects they contain, which allows a PersistenceManager to be more effectively used as an object cache.
• Fully implemented the class loading lookup procedure defined in the spec (§12.5).
• Bug #876033: Query.compile() throws NullPointerException.
• Bug #850129: Poor query performance.
• Bug #836494: PMF should remain configurable until a PM has been generated.
• Bug #840882: Made all SCO wrapper classes Serializable. Deserializing an object with SCO fields produces normal "unwrapped" values in those fields.
• Fixed rare index out-of-bounds exception lurking in DatabaseAdapter.getTypeInfo(int[]).
• Progress made on passing more TCK tests.

Version 2.0 - 2003-11-10

• Modified to bring TJDO up to the 1.0.1 spec. This includes:
  • Package-level .jdo files.
  • Use of the 1.0.1 jdo.jar and Reference Enhancer.
  • PersistenceManagerFactory.close()
  • PersistenceManager.retrieve(..., boolean DFGonly)
  • javax.jdo.JDOObjectNotFoundException
  • Fixed bugs #648234, #724827, #809589.
• Add support for fields of type HashSet.
• Added the ability to pass transient and persistent Sets as parameters into Querys.
• Added options to control whether or not tables and/or constraints get validated (available through com.triactive.jdo.validateTables and com.triactive.jdo.validateConstraints system properties).
• Implement RestoreValues mode, pm.refresh(), and pm.retrieve().
• Implement pm.evictAll().
• Added "clear-on-delete" extension for collection fields to allow for the use of cascaded or triggered deletes by the database.
• Modified inverse sets to allow the use of non-nullable owner fields. Likewise for inverse maps and the owner and/or key fields. Removing an object from such a collection, unless it's just being moved from one collection to another, results in its deletion from the database.
• Added com.triactive.jdo.useValidatingXmlParser system property to specify whether to use a validating parser or not. This defaults to true.
• Made entries not get inserted into JDO_TABLE if the table entry doesn't exist and auto-create tables is turned off. If an entry needs to be inserted but auto-create is turned off, a MissingSchemaTableEntryException is thrown.
• Errors occurring at TX commit or rollback are always JDOFatalDataStoreException. Modified handling of JDODataStoreException vs. JDOFatalDataStoreException to recognize that the latter simply means that the active DB transaction has been aborted.
• Allow pmf.setRestoreValues(true) to work, and defer the exception until the PMF is frozen (as done for other unsupported options).
• Querys with no explicit candidate collection default to the extent of the candidate class.
• Fixed a bug where P_NONTRANS objects might not be refreshed when transitioning to transactional.
• Deleting an object already in a deleted state is a no-op.
• Fixed invocation of jdoPostLoad() to ensure that it gets called after any state transition has completed.
• Allow transient transactional fields to be declared, although they aren't yet supported.
• Dirty object is not be flushed to storage if it is deleted before being flushed.
• Allow the IgnoreCache query flag to be set, although it has no effect (which is explicitly permitted by the JDO spec).
• pm.getObjectId() etc. should return null if passed a null or non-PersistenceCapable object.
• makePersistent() was not throwing an exception when passed an object already managed by another PM.
• Never call jdoPreStore() while in the midst of deleting an object and/or calling jdoPreDelete().
• Fixed NullPointerException in getColumnList().
• Allow driver name to be null, since it is allowed for the user to specify just a JDBC URL.
• Wasn't properly setting the non-transactional data source to ConnectionFactory2, if it's available.
• Make sure auto-commit mode is on for new connections that are being used non-transactionally. A newly acquired connection is supposed to be in auto-commit mode already but some drivers and connection poolers don't get it right.
• Fixed problem where metadata contains <extension></extension> with no content.
• Eliminated a potential deadlock that could occur under heavy DB load. The cause was a conflicting access order between acquiring a DB connection and locking the StoreManager; most code would acquire the Connection first but a couple of places were doing it the other way around.
• Bug #768618: Fixed infinite loop in Set.toArray(). The SCO implementations of Set and Map have been modified not to extend AbstractSet and AbstractMap to avoid this sort of problem in the future.
• Bug #724828: In Firebird, DDL is executed at the end of a transaction. Therefore DatabaseMetaData methods will not see tables created concurrently in a separate transaction until the current transaction completes. To detect name collisions, such as classes with the same name in different packages, it is necessary to also check the TJDO schema table.
• Fixed problem where trying to close a null query result throws a NullPointerException.
• Fixed a subtle bug involving inserting objects that modify themselves in their jdoPreStore().
• When loading class metadata, ensure that the class in question gets initialized up front so that its static initialization block registers with JDOImplHelper. This eliminates a rare race condition in which TJDO consults JDOImplHelper before the JVM has initialized the class.
• Bug #820984: Use SQLConstants.MAX_IDENTIFIER_LENGTH as the effective max table and/or column name length if the JDBC driver doesn't provide these.
• Patch #746484: Append the BINARY qualifier to the CHAR and VARCHAR types to specify case-sensitive treatment.
• Fixed NullPointerException in newObjectID().

Version 2.0 Beta3 - 2003-03-17

• Support for PostgreSQL 7.3.
• Support for MySQL 3.23.55-max.
• Support for MS SQL Server 7.0 SP4 and 2000 SP2.
• Support for DB2 version 7.2.3.
• Support for SAP DB 7.4.3.
• DB2J (Cloudscape 5) is now fully supported.
• Added support for connection pooling to the unit tests using Jakarta DBCP.
• Bug 676897: Fixed view creation failure when a view has a dependency on another view.
• Bug 631870: InverseMap can't have not null owner (thanks to David Jencks).
• Query parser now parses octal sequences properly.
• Fixed possible NullPointerException that could occur if the first access to a Set field came from a Query filter.
• Fixed NullPointerException that can occur in StateManagerImpl.getFlagsSetTo(boolean[],int[],boolean).
• Fixed setConnectionFactory2() and setConnectionFactory2Name().
• Remove leading and trailing underscores from Java identifiers when converting them to SQL identifiers (thanks to J. David Beutel).
• Fixed class enhancer wrapper exception when attempting to enhance many classes (~150 or more) at once.
• Fixed query ordering for Oracle boolean columns.
• Fixed ClassCastException in ClassViewExtent.closeAll().
• Fixed identifier quote string problem with MySQL running in non-ansi mode.

Version 2.0 Beta2 - 2003-01-20

• Added support for Firebird (thanks to David Jencks). Much of the query generation code was reworked to adhere to SQL standards and for readability.
• Added support for PostgreSQL (thanks to Levente Sántha). See notes about JDBC driver requirements in the DBMS compatibility page.
• Added support for Cloudscape 5.0/DB2J (thanks to Matthew Cooper).
• Put more SQL-92 keywords into the reserved words list (thanks to David Jencks).
• Bug 639848: Fixed exception in Extent.closeAll() (thanks to Matthew Cooper and David Beutel).
• Bug 634261: Fixed Set.remove() to return the correct value (thanks to Mike Martin).
• Bug 664091: Fixed retrieving a connection in JBoss (thanks to Brian Smith).

Version 2.0 Beta - 2002-09-08

• TJDO has been upgraded to version 1.0 of the JDO spec. In doing this many changes were incurred:
  1. All metadata files must now include the following DOCTYPE declaration:

           <!DOCTYPE jdo SYSTEM "jdo.dtd">
           

  2. All persistent fields in PersistenceCapable classes MUST be declared persistent in the metadata according to section 18.4 of the 1.0 spec. More specifically, any persistent fields that are not default persistent types (such as Object, etc...) must have the attribute persistence-modifier="persistent".
  3. In metadata files, any class elements with identity-type="none" should be changed to identity-type="nondurable".
  4. Changed the view extensions in the metadata files to match the JDO DTD. Previously, the view-definition and view-imports elements had the definition and imports as nested content. According to the DTD, only extension elements are allowed as content in extension elements. Therefore, the view definition and imports needs to be moved into the value attribute of the extension element.
  5. The default-fetch-group attribute for fields of type java.sql.Date and java.sql.TimeStamp needs to be explicitly declared in the metadata for PersistenceCapable classes.
  6. All PersistenceCapable classes MUST have a default constructor.

• The query compiler has been completely rewritten. It now incorporates a full parser/compiler for JDOQL in place of the anemic token translator used by previous versions. This means no more restrictions on usage of white space, parentheses, boolean values, null arguments, etc.

  Features:

  1. Supports the entire filter expression syntax as described in section 23 of the JDO spec. Note that due to database restrictions the ~ and % operators are still not supported, although they are properly parsed and detected.
  2. All syntax errors are caught and produce meaningful exceptions.
  3. Uses a purpose-built, recursive-descent style parser that is very fast (it's hard to measure exactly how fast because most compilations take less than 1 ms).
  4. Constant subexpression elimination (constant folding).
  5. Automatically manages differences in operator precedence between Java and SQL. For example, "a == 0 | b == 0 && c == 0" now correctly compiles to "WHERE (A = 0 OR B = 0) AND C = 0" (an admittedly contrived example, better written with || and parentheses instead of |).
  6. Invokes filter methods via reflection, making it trivial to add new method extensions if needed (many new ones were in fact added, see next).
• The following new methods are now supported in Query filter strings.
  • String.charAt(int index)
  • String.length()
  • String.startsWith(String substr, int toffset)
  • String.substring(int begin)
  • String.substring(int begin, int end)
  • String.toLowerCase()
  • String.toUpperCase()
  These are all non-standard TriActive extensions to JDOQL. See Query Extensions for details.
• Support has been added for persistent fields of type java.math.BigInteger or java.math.BigDecimal.

Version 1.3

• Query result collections were modified to improve performance slightly for any methods that operate on the collection as a whole, namely contains(), containsAll(), and toArray().
• Bug fix: Querying over a view sometimes caused pathologically slow performance if the view object contained an interface field. The store manager has to query JDO_TABLE whenever an OID refers to a class whose table isn't yet initialized. Many such calls in succession would result in many redundant SQL queries. A change was made to trigger initialization of the table after the first such call.

Version 1.2

• Support has been added for direct SQL as an alternate query language. This allows you to delegate some kinds of searching and/or computation to the database server where performance is critical, at the expense of portability. See direct SQL queries for details.
• Schema management has been changed with regard to foreign key indices: a foreign key index now is not created if another index or primary key already exists that begins with the foreign key columns. In such a case, creating another index is deemed to be superfluous. The assumption is that the database is smart enough to use the existing index with the larger key even when looking for a match on only a portion of that key. See schema management for details.

Version 1.1

• If not done automatically by the database, TJDO now maintains indices for all foreign key columns. Indices are automatically validated as a part of schema validation and will be auto-created if auto-create mode is enabled. See schema management for details.

  When running the new version against an existing schema you may need to run through and validate all tables at least once with auto-create mode on in order to create any missing indices. If you don't and any indices are missing a SchemaValidationException will be thrown.

  Due to a bug in the Oracle JDBC driver, this feature now introduces a restriction on class naming; see unsupported features.

• The String.indexOf() method is now (partially) supported in Query filter strings. This is a non-standard TriActive extension to the Query filter language that can be used to perform the equivalent of LIKE '%xyz%' in SQL.

  For example, the subexpression:

      str.indexOf("xyz") >= 0
      

  will literally generate "WHERE STR LIKE '%xyz%'" in the resulting SQL.

  However, usage of indexOf() is very limited in that it can only be used in this exact context; i.e. to test for the existence of an embedded substring. In other words, it can only be used as the X in a "X >= 0" subexpression. It cannot be used to otherwise obtain or filter on the index position of a substring; any occurrence of indexOf() must always be followed by the characters ">= 0" or an exception will be thrown.

• The performance of schema validation has been improved by obtaining column info metadata for multiple tables in a single query rather than one query per table.
• Bug Fix: Referencing a parameter more than once in a query filter string throws an InvalidQueryParameterTypeException.
• Bug Fix: In view definitions, any macro referencing a table that is not also referenced in the column definition list could potentially cause an InvalidStateException due to that table not being initialized.