Softpedia >Windows >Programming >Other Programming Files >DataNucleus >  Changelog

DataNucleus Changelog

What's new in DataNucleus 5.0.0-M2

Sep 20, 2016
  • New:
  • Add in-memory evaluation support for YearMonth.getYear, YearMonth.getMonthValue, MonthDay.getDayOfMonth, MonthDay.getMonthValue, Period.getMonths, Period.getDays, Period.getYears etc.;
  • JPQL : Support YEAR, MONTH, DAY, HOUR, MINUTE, SECOND with java.time types;
  • Provide ability for a store plugin to set the default TypeConverter to use for a java field type;
  • Support conversion from YearMonth to java.sql.Date;
  • Support persistence of java.time.ZonedDateTime as Timestamp / String;
  • Add in-memory evaluation support for Optional.get, Optional.isPresent;
  • Support conversion from Duration to Double (secs.nanos);
  • Support conversion from MonthDay to java.sql.Date;
  • Support conversion of java.time.Instant to java.util.Date.
  • Improvement:
  • List of "simple" result classes is very restrictive. Extend to include other commonly used "simple" classes;
  • Query parsing can be improved to better cater for quoting and end of line characters;
  • java.awt.Color should be in DFG.

New in DataNucleus 5.0.0-M1 (Sep 20, 2016)

  • New:
  • Add support for JPQL "INSERT" queries (vendor extension);
  • Allow to specify default nullability for fields using a configuration property;
  • Support for non-JDK containers;
  • Support for single element collections (java.util.Optional);
  • Allow JPQL to exclude subclasses of the candidate;
  • Extend NUCCORE-1344 to allow LEFT JOIN FETCH.
  • Bugfixes:
  • IN predicate unexpectedly gets transformed to EQ predicate;
  • Persistable elements contained in Collection/Map that is serialised (whole field) are not detached/attached correctly;
  • JDOQL/JPQL parse of BigInteger value is parsed internally to be Long and loses precision;
  • L2 cache of persistable arrays creates incorrect array type for caching;
  • Metadata processing moves ColumnMetaData to ElementMetaData is not embedded/serialised but should also allow for full field type converter case;
  • AbstractMemberMetaData.getClassName(false) can return fully qualified name in some situations;
  • JPQLSingleStringParser has missing trimRight handling (typo in trimLeft).
  • Improvement:
  • ClassMetaData has "members" that should be genericised to AbstractMemberMetaData, and lookup of member name improved;
  • CompleteClassTable : has check on duplicated column name, but that should not apply when supporting "nested" embedded;
  • Determine Collection element and Map key/value type from TypeVariable when using ParametrizedType within ParameterizedType.

New in DataNucleus 4.1.10 (Sep 20, 2016)

  • New:
  • Add mechanism whereby if there is metadata for a class that is not in the classpath we can just ignore it.
  • Bugfixes:
  • SerializableByteBufferConverter should use wrap/remaining to convert to bytes but doesn't.
  • Improvement:
  • java.awt.Color should be in DFG.

New in DataNucleus 4.1.9 (Sep 20, 2016)

  • Improvement:
  • List of "simple" result classes is very restrictive. Extend to include other commonly used "simple" classes;
  • Dont log about AutoStartMechanism if set to None.

New in DataNucleus 4.1.8 (Sep 20, 2016)

  • Bugfixes:
  • AbstractMemberMetaData.getClassName(false) can return fully qualified name in some situations.

New in DataNucleus 4.1.7 (Sep 20, 2016)

  • Bugfixes:
  • Persistable elements contained in Collection/Map that is serialised (whole field) are not detached/attached correctly.
  • New: Allow JPQL to exclude subclasses of the candidate.
  • Improvement:
  • ClassMetaData has "members" that should be genericised to AbstractMemberMetaData, and lookup of member name improved;
  • CompleteClassTable : has check on duplicated column name, but that should not apply when supporting "nested" embedded;
  • Determine Collection element and Map key/value type from TypeVariable when using ParametrizedType within ParameterizedType.

New in DataNucleus 4.1.6 (Sep 20, 2016)

  • Bugfixes:
  • Metadata processing moves ColumnMetaData to ElementMetaData is not embedded/serialised but should also allow for full field type converter;
  • JPQLSingleStringParser has missing trimRight handling (typo in trimLeft).

New in DataNucleus 4.1.5 (Sep 20, 2016)

  • Bugfixes:
  • IN predicate unexpectedly gets transformed to EQ predicate.
  • New:
  • Extend NUCCORE-1344 to allow LEFT JOIN FETCH.

New in DataNucleus 4.1.4 (Sep 20, 2016)

  • Bugfixes:
  • JDOQL/JPQL parse of BigInteger value is parsed internally to be Long and loses precision;
  • Unable to use version tag on ORM file without having to define the strategy again.

New in DataNucleus 4.1.3 (Sep 20, 2016)

  • Bugfixes:
  • StringUtils.getStringFromStackTrace is broken since 4.0.
  • New:
  • Add ability to set JDOQL/JPQL strictness on query compilation.

New in DataNucleus 4.1.0 (Jan 19, 2015)

  • Minor upgrade to bytecode enhancement contract to allow for separation of enhancement API
  • Rewrite of handling of container field update code.

New in DataNucleus 4.0.0 (Mar 3, 2014)

  • Cassandra : support for Cassandra 1.2+
  • SchemaTool : support for create/delete of a schema (where the datastore supports it)
  • RDBMS : ability to use single connection per PM/EM (rather than 1 for transactional operations, and 1 for non-transactional operations)

New in DataNucleus 3.3.4 (Nov 20, 2013)

  • JDO API, JPA API, REST APIs repackaged, and JSON API added
  • JPA/JDO : support for application-identity root classes without own table and without identity field(s)
  • JDO3.1 : support for "complete-table" now standarised
  • JDO : Support for bulk update/delete via typesafe API (vendor extension)
  • JDO : Support for bean validation (JSR303)
  • JPA : support for singleton EMF pattern
  • JPA : support for merge of transient object with identity that mirrors persistent object.
  • Noticeable performance change with non-transactional write operations
  • Ability to specify classes as "read-only"
  • RDBMS : Initial support for SQLite
  • RDBMS : Initial support for Multi-Tenancy via discriminator
  • RDBMS : Support for JDBC driver custom properties
  • MongoDB : Support for MongoDB
  • MongoDB : support for "increment" and "identity" value generation
  • MongoDB : support for embedded persistable fields, collections, arrays and maps
  • MongoDB : support for SchemaTool
  • MongoDB : support for version persistence, and optimistic checking
  • MongoDB : support for datastore identity
  • MongoDB : support for basic queries in-datastore
  • HBase : support for SchemaTool
  • HBase : support for version persistence and optimistic checking
  • HBase : support for datastore identity
  • HBase : support for relationships and reachability
  • HBase : support for "increment" value generation (Peter Rainer)
  • HBase : support for embedded persistable fields
  • HBase : support for basic queries in-datastore
  • Excel/OOXML : support for SchemaTool
  • Excel/OOXML : support for maps
  • Excel/OOXML : support for "increment" value generation
  • ODF : support for embedded persistable fields
  • ODF : support for maps
  • ODF : support for SchemaTool
  • ODF : upgrade to ODFDOM-Java 0.8.7+
  • ODF : support for "increment" value generation
  • NeoDatis : support for unique constraints.
  • Excel, ODF, XML, HBase, MongoDB : support for querying of interfaces
  • Cache : upgrade to EHCache 1.6+
  • Cache : support for Xmemcached
  • Cache : support for Cacheonix
  • Works with JBoss 6.0

New in DataNucleus 3.3.1 (Jul 31, 2013)

  • JPA : support for JPA2.1 FROM "ON" clauses in string-based and Criteria queries
  • JPA : support for JPA2.1 UPDATE/DELETE Criteria queries
  • JPA : support for JPA2.1 ForeignKey, and Index
  • JPA : support for JPA2.1 JPQL "FUNCTION"
  • JPA : support for JPA2.1 EntityGraphs
  • JPA : support for JPA 2.1 create/drop/load scripts
  • JPA : runs against a JPA 2.1 API jar
  • JDO : support for create/drop/load scripts
  • JDOQL/JPQL : support for ordering directives for NULL placement

New in DataNucleus 3.3.0 Release (Jun 27, 2013)

  • JPA : support for JPA2.1 FROM "ON" clauses in string-based and Criteria queries
  • JPA : support for JPA2.1 UPDATE/DELETE Criteria queries
  • JPA : support for JPA2.1 ForeignKey, and Index
  • JPA : support for JPA2.1 JPQL "FUNCTION"
  • JPA : support for JPA2.1 EntityGraphs
  • JPA : runs against a JPA 2.1 API jar

New in DataNucleus 3.2.3 (Jun 22, 2013)

  • This third maintenance release improves support for several inheritance related conditions for RDBMS, improves flexibility for parsing of XML metadata, adds a fix to MongoDB support of certain types, improves handling of discriminators with RDBMS, adds support for generalised SQL function execution in RDBMS queries, and fixes several other minor issues.

New in DataNucleus 3.3.0-M1 (Jun 11, 2013)

  • Support for using JPA 2.1 API jar was added.
  • Support for JPA 2.1 ForeignKey/Index schema constructs was added.
  • Support for JPA 2.1 Criteria UPDATE/DELETE queries was added.
  • Support for using JPA 2.1 FROM "ON" constructs with Criteria was added.
  • Support for vendor extension @Index annotation was dropped (replaced by official JPA 2.1 annotation).
  • Some other improvements were made

New in DataNucleus 3.2.0 (Mar 11, 2013)

  • Fix to in-memory evaluation when using a variable that has no possible value
  • Move operation queue for SCOs to ExecutionContext so that it can control the whole flush process
  • Disable ObjectProvider pooling since it currently causes issues when in a highly multithreaded environment
  • Add check on attempted persistence of final fields
  • JPA : allow for user overriding a JNDI datasource with a URL-based datasource
  • RDBMS : fix to bulk update when setting fields to NULL
  • RDBMS : Cater for fields of a type that have a TypeConverter but no Mapping defined, falling back to the TypeConverter
  • Neo4j : Support for bulk delete
  • MongoDB : Support for bulk delete
  • HBase : Support for bulk delete
  • Version 3.2 includes the following major changes over 3.1:
  • The enhancer and ASM are now merged into datanucleus-core
  • L2 caching of embedded/serialised fields now defaults to ON
  • ExecutionContext objects are now pooled, together with various other improvements for performance
  • Enhancer now includes an option to enhance classes as detachable regardless of metadata
  • Neo4j : now uses a single connection per PM/EM
  • Neo4j : now supports bulk delete
  • MongoDB : now uses a single connection per PM/EM
  • MongoDB : now supports bulk delete
  • HBase : supports various extensions for bloom filters, compression, in-memory etc (Nicolas Seyvet)
  • HBase : now supports bulk delete
  • RDBMS : support added for the Virtuoso database (Emmanuel Poitier)
  • RDBMS : support added for Tomcat connection pool (Marshall Reeske)
  • OSGi : improved deployability due to dependency version restrictions
  • JPA : validated to work with JBoss 7 (thanks to Nicolas Seyvet and Scott Marlow)
  • JPA : access of non-detached field will result in IllegalAccessException instead of the previous JDO exception
  • JPA : support for JPA2.1 FROM "ON" clauses
  • JPA : support for bulk usage of persist(), remove(), merge() and detach() (pass in Collection or array of entities)
  • JPA : support for JPA2.1 "Generate Schema" feature
  • If a type is supported to be persistent then it defaults to persistent now (no need to mark all non-standard typed fields as persistent).
  • Add ability to disable the L2 cache on a PM/EM-basis where the PMF/EMF has it enabled.
  • Cache : provides support for javax.cache v0.61
  • Many bug fixes, and minor feature additions.

New in DataNucleus 3.1.0-M3 (Dec 14, 2012)

  • Only for use with JDK1.6+ (though many plugins will work with JDK1.5)
  • javax.time support now present in datanucleus-core
  • Support for atomic non-transactional updates (use of field setters, or SCO mutating methods)
  • Support for monitoring API providing statistics about DataNucleus calls to the datastore etc
  • JMX : "datanucleus-management" plugin is now merged into datanucleus-core as part of monitoring API
  • Cache : javax.cache support now present in datanucleus-core
  • Cache : JCache support now present in datanucleus-cache
  • Enhancer : works with JDK1.7 too, using ASM v4
  • JPA2.1 Stored Procedure API supported for RDBMS
  • JPA2.1 Type Converter API supported for RDBMS, Excel, ODF, HBase, MongoDB and JSON datastores
  • JPA : Fully working JTA integration
  • JPA : Support for specifying named query annotations on non-Entity classes (vendor extension)
  • JDO : Support for specifying named query annotations on non-PersistenceCapable classes (vendor extension)
  • JDO : Complete support for non-durable identity with RDBMS, Excel, ODF, MongoDB, HBase
  • REST : Much improved handling, also allowing full (JDOQL or JPQL) querying now
  • REST : Support for bulk delete
  • REST : Support for datastore identity
  • SchemaTool : support for delete+create mode of operation
  • Neo4j : persistence to Neo4j graph datastore
  • HBase : support for multitenancy
  • HBase : support JDO/JPA table/column naming strategies
  • MongoDB : support JDO/JPA table/column naming strategies
  • MongoDB : support for embedded objects with inheritance
  • MongoDB : add support to in-datastore querying for COUNT, as well as parameters
  • ODF : support JDO/JPA table/column naming strategies
  • Excel : support JDO/JPA table/column naming strategies
  • RDBMS : "xmltypeoracle" plugin merged into RDBMS plugin

New in DataNucleus 3.0.0-M5 (Jun 14, 2011)

  • JDO API, JPA API, REST APIs repackaged, and JSON API added
  • JPA/JDO : support for application-identity root classes without own table and without identity field(s)
  • JDO3.1 : support for "complete-table" now standarised
  • JDO : Support for bulk update/delete via typesafe API (vendor extension)
  • JPA : support for singleton EMF pattern
  • Noticeable performance change with non-transactional write operations
  • Ability to specify classes as "read-only"
  • MongoDB : Initial support for MongoDB
  • MongoDB : support for "increment" and "identity" value generation
  • MongoDB : support for embedded persistable fields, collections, arrays and maps
  • MongoDB : support for SchemaTool
  • MongoDB : support for version persistence, and optimistic checking
  • MongoDB : support for datastore identity
  • MongoDB : support for basic queries in-datastore
  • HBase : support for SchemaTool
  • HBase : support for version persistence and optimistic checking
  • HBase : support for datastore identity
  • HBase : support for relationships and reachability
  • HBase : support for "increment" value generation (Peter Rainer)
  • HBase : support for embedded persistable fields
  • HBase : support for basic queries in-datastore
  • Excel/OOXML : support for SchemaTool
  • Excel/OOXML : support for maps
  • Excel/OOXML : support for "increment" value generation
  • ODF : support for embedded persistable fields
  • ODF : support for maps
  • ODF : support for SchemaTool
  • ODF : upgrade to ODFDOM-Java 0.8.7+
  • ODF : support for "increment" value generation
  • NeoDatis : support for unique constraints.
  • Excel, ODF, XML, HBase, MongoDB : support for querying of interfaces
  • Cache : upgrade to EHCache 1.6+
  • Cache : support for Xmemcached
  • Works with JBoss 6.0

New in DataNucleus 2.1.0 (May 20, 2010)

  • Add ability to skip the check on unused input parameters to queries
  • Fix issue with detachment when finding an object already detached but not far enough
  • Add support for compilation of queries with parameters in subqueries linking back to the main query
  • Fix to L2 caching of StringBuffer fields to cache a copy
  • Fix to handle input query with special characters (tab, eol, etc)
  • Extend query compilation to store whether the query result is distinct
  • Support specification of interface fields where there isn't currently an available implementation
  • Fix to use of dynamic fetch groups in multiple threads
  • Fix to support non-standard SQL statements (stored procs, statements not starting with SELECT/INSERT/UPDATE/MERGE/DELETE)
  • Fix to the query in-memory evaluator to support aggregate names in upper or lower case
  • Fix to a couple of situations where a versioned object can be returned to the user without the version set
  • Fix to reset the version of an object on rollback()
  • Fix to SCOListIterator
  • RDBMS : Fix to generation of indexes for reference fields when having a FK per implementation so that the index is created for the implementations FK only
  • RDBMS : Fix JDOQL2 to not select CLOB fields when using UNION or DISTINCT for Derby
  • RDBMS : Fix JDOQL2 to add parentheses around ORed clauses
  • RDBMS : Fix JDOQL2 to pick the correct statement when using methods in subqueries
  • RDBMS : Fix JDOQL2 "alpha-namer" to handle more than 26 table groups
  • RDBMS : Fix JDOQL2 to handle comparisons of interface field with an implementation
  • RDBMS : Support use of CHECK constraint when persisting boolean as numeric
  • RDBMS : Change HSQLDB use of LIMIT to append to the end of the statement
  • RDBMS : Support for use of SQLXML type with DB2 (contrib)
  • RDBMS : Fix to JDOQL2 for use of input parameters with multiple columns
  • JPA : Add support for JPQL "case" expressions
  • JPA : Add support for generation of JPA2 static metamodel classes
  • JPA : Change to handling of "columnDefinition" to expect the type to be included
  • Enhancer : when using JDK1.6 and having the enhancer in the CLASSPATH default to not enabling the annotation processor to enhance the class(es) being compiled

New in DataNucleus 2.0.4 (Apr 23, 2010)

  • Fix to support non-standard SQL statements (stored procs, statements not starting with SELECT/INSERT/UPDATE/MERGE/DELETE)
  • Fix to the query in-memory evaluator to support aggregate names in upper or lower case
  • Fix to a couple of situations where a versioned object can be returned to the user without the version set
  • Fix to reset the version of an object on rollback()
  • Fix to SCOListIterator
  • RDBMS : Fix to generation of indexes for reference fields when having a FK per implementation so that the index is created for the implementations FK only
  • JDOQL2 : Fix to use of input parameters with multiple columns
  • Enhancer : when using JDK1.6 and having the enhancer in the CLASSPATH default to not enabling the annotation processor to enhance the class(es) being compiled

New in DataNucleus 2.0.2 (Mar 17, 2010)

  • Fix to the auto-generation of PK classes by the enhancer for some field types.
  • Fixes to generic compilation of collection.contains when using variables
  • Support for in-memory query evaluation of Enum.toString() and Enum.ordinal()
  • Fixes to in-memory query evaluation of boolean predicates, and loading of fields
  • Fix to use of result class with constructor with arguments when one argument is null
  • Support for use of encrypted passwords in persistence properties
  • RDBMS : Fix to handling of FKs when specified on fields
  • Support for persisting java.awt.Color/Point/Rectangle and java.util.BitSet field types as String
  • RDBMS : JDOQL2 - Fixes to use of Extent for no concrete classes, subclass-table inheritance, and persistence interface cases
  • RDBMS : JDOQL2 - Support for use of variables
  • RDBMS : JDOQL2 - Support for Collection.contains on embedded fields
  • RDBMS : JDOQL2 - Support for binding parameter type via Collection.contains, Map.containsXXX methods
  • RDBMS : JDOQL2 - Detect result clauses that are multi-valued and throw exception
  • RDBMS : JDOQL2 - Fixes to allow many complex queries that failed with "JDOQL" to work with this new implementation.
  • RDBMS : JDOQL2 - Fix to String.matches escape clause
  • JPA : Support for CONCAT methods with Criteria Query
  • JPA : Support for COALESCE methods with Criteria Query
  • JPA : Support for function() method with Criteria Query
  • JPA : Support for joins specified using string name with Criteria Query
  • JPA : Support for negated predicates with Criteria Query
  • JPA : Support for subqueries with Criteria Query
  • Excel : Support persistence of Enum fields
  • Excel : Support for persistence of relation fields (as per ODF plugin)
  • Excel : Fixes to persistence of Date/Calendar types
  • Excel : Fixes to handling of SCO fields so they are wrapped correctly
  • Excel : Upgrade Apache POI requirement to 3.6+
  • ODF : Fixes to handling of SCO fields so they are wrapped correctly
  • ODF : Fixes to persistence of Date/Calendar types
  • ODF : Support persistence of Enum fields
  • XML : Fix to persistence of Enum fields

New in DataNucleus 2.0.1 (Mar 17, 2010)

  • Support for JPA2 Criteria query API (doesn't yet support subqueries, and some less useful query builder methods)
  • Change all primitive wrapper constructor usage to use class valueOf() for efficiency
  • Fix to annotation processing to ignore all unsupported class annotations, and to correctly handle methods called get(), is()
  • Complete generic compile of JPQL TRIM and LIKE keywords, and support COALESCE, NULLIF keywords
  • Add support for in-memory query evaluation of COALESCE/NULLIF keywords
  • Update in-memory query evaluator to load fields where needed
  • Minor fixes to JDO getObjectById to pass new tests in JDO2.3 TCK
  • Minor changes to JDO timeout setter methods to pass new tests in JDO2.3 TCK
  • Fix to L2 cache retrieval of relation field to use the value
  • Fix to use of @Persistent and @Extension on a field, so that the settings are respected
  • Clean up of generic query compilation expressions to not use SymbolTable before bind()
  • XML : Fix to handling of empty XML file when searching for an object
  • RDBMS : respect "indexed" value of false when creating indexes
  • RDBMS : fix to SQL embed extension so we have SQL_boolean, SQL_numeric static functions
  • RDBMS : support for JPQL COALESCE, NULLIF functions
  • RDBMS : fix to JPQL to not add dup joins when defined in FROM clause and also from result
  • RDBMS : JPQL - support for ESCAPE on LIKE, and support for all TRIM options
  • Add support for persisting some java types as Long where no native handling
  • HBase : better handling of update to not delete records
  • DB4O : upgrade to 7.12 and above

New in DataNucleus 2.0.0 (Mar 17, 2010)

  • Align to recent changes in JDO2.3 timeout API
  • Fix to Spatial handling of JTS types
  • Support for many spatial methods with the rewritten RDBMS JDOQL/JPQL query mechanism

New in DataNucleus 2.0 Milestone 4 (Mar 17, 2010)

  • Require use of a JPA2 jar when used for JPA persistence
  • Change handling of JDO @PrimaryKey to not require @Persistent for non-default persistent fields
  • Change generic compilation of subqueries, particularly for JPQL, to allow for multi-level primary expression
  • Change generic compilation of JPQL "LOCATE" to handle multi-level primary expressions
  • Fix to JDO PersistenceManagerProxy for named queries (typo)
  • Provide framework for bulk object retrieval (available to datastore-specific plugins)
  • Fix handling of query parameters to allow for use of parameters in subqueries
  • Respect "RetainValues" setting for objects that are deleted (so field values can be retained after the transaction commits, and the object is deleted).
  • Add support for PMF/EMF singleton pattern, via persistence property
  • Add support for case-insensitive persistence properties (previously all were case sensitive)
  • JPA2 : Support for "Metamodel" API
  • JPA2 : Support for TypedQuery
  • JPA2 : Support for Bean Validation
  • JPA : Fix to runtime enhancer
  • Enhancer : add ability to turn on/off capabilities
  • Enhancer : add ability to generate PK classes (including composite)
  • Enhancer : add ability to turn off generation of default constructor
  • Enhancer : add short form of "persistenceUnit" argument
  • RDBMS : Change to use "JPQL2" implementation by default since it passes the JPA1 TCK
  • RDBMS : Fix to JDOQL2/JPQL2 for case where multiple classes share a table and use a discriminator
  • RDBMS : Support for embedded fields in JDOQL2/JPQL2
  • RDBMS : Query range not working for Oracle now fixed
  • RDBMS : Fix to FROM join in JPQL2 for second and subsequent joins
  • RDBMS : Add support to JPQL2 for subquery FROM clauses with multiple joins
  • RDBMS : Fix support in JPQL2 for "COUNT (DISTINCT ...)"
  • RDBMS : Support for JPA2 "TYPE" in JPQL2 implementation
  • RDBMS : Support for "StringExpression == EnumLiteral" in JDOQL2/JPQL2
  • RDBMS : Change to "persistenceUnit" option of SchemaTool to allow short form
  • RDBMS : Fix for read of null BLOB with Oracle
  • Spatial : fix to M2 dependencies to make some optional
  • HBase : add security handling to cater for issues in HBase itself
  • Maven2 plugin : Support for enhancement generating PKs, and turn on/off default constructor

New in DataNucleus 2.0 Milestone 3 (Mar 17, 2010)

  • Allow override of basic settings of DFG, default persistent for java types
  • Fix to L2 cache handling to evict deleted object
  • Level 2 Cache is now enabled by default (soft)
  • Level 1 Cache default is now changed to soft
  • Support for max size on weak/soft Level 2 caches
  • Generic compile updated for JPQL "EMPTY"/"LIKE"/"SIZE" to allow for multi-level primaries
  • Generic compile updated for JPQL "FROM" to chain nodes correctly
  • Generic compile updated for JPQL Object/Sum/Avg/Min/Max/Count to allow for case-insensitive
  • Generic compile updated for JPQL to allow for case-insensitive aliases
  • Generic compile updated for JPQL to fix escape sequence
  • Generic compile of JPQL subqueries to correctly allow for ALL/ANY/SOME/EXISTS forms
  • Generic compile support for AS aliases in result clause
  • Generic compile support for "new XXX().method" constructs
  • Generic compile support for JPQL "IN" taking multi-value parameters (JPA2)
  • Generic compile fix for JPQL "MOD"
  • Generic compile fix for JPQL "NOT" being applied incorrectly
  • Generic compile support for JPQL "TYPE" syntax (JPA2)
  • Generic compile fix for specification of result class in single-string form not being respected
  • Ignore all unsupported annotations
  • Rewrite of query in-memory method invocations handler to match the RDBMS style type-method
  • Fix to handling of non-transactional objects at pm close to move through lifecycle correctly
  • Support for JDO Query.cancel(Thread)
  • JPA : fix to mark transaction for rollback only on error
  • JPA : Support @Column length correctly
  • RDBMS : JDOQL2 support for String concatenation, and support for parameter defined as supertype but passed in as subtype
  • RDBMS : JDOQL2/JPQL2 support for Oracle NLS sorting
  • RDBMS : JDOQL2/JPQL2 support for result of type DyadicExpression
  • RDBMS : JDOQL2/JPQL2 support for result expression aliases
  • RDBMS : JDOQL2/JPQL2 fix handling of result new object to handle objects with composite PKs
  • RDBMS : JDOQL2/JPQL2 fix to handling of boolean expressions in ==/!=
  • RDBMS : JDOQL2/JPQL2 fix to handling of mappings using non-default datastore mapping (e.g Date persisted as VARCHAR)
  • RDBMS : JPQL2 fix to handling of ANY/ALL/SOME/EXISTS
  • RDBMS : JPQL2 fix to bulk update to allow DyadicExpression/PrimaryExpression in SET clause
  • RDBMS : Fix to Schematool to remove possible dups with bidirectional relations
  • RDBMS : Support for user-defined primary key constraints on join tables
  • RDBMS : Fix to support persisting Boolean as SMALLINT/TINYINT
  • JSON : support for Amazon S3 datastores
  • HBase : upgrade to HBase 0.20
  • HBase : performance improvements, including connection pooling and create schema only once
  • HBase : support for column families
  • Excel : Use lazy loading when retrieving candidate instances
  • ODF : Fix to delete of an object
  • ODF : Use lazy loading when retrieving candidate instances
  • ODF : Support for persistence of null fields and retrieval as null
  • ODF : Support for persistence/retrieval of Date fields
  • XML : Use lazy loading when retrieving candidate instances

New in DataNucleus 1.1.6 (Mar 17, 2010)

  • Bug fix to PersistenceManager proxy in multithreaded environments
  • Bug fix to interface mapping strategy "xcalia"
  • LDAP : Add support for enums
  • RDBMS : Bug fix to instanceof when handling possible subclasses
  • RDBMS : Bug fix to detection of discriminator when handling superclasses

New in DataNucleus 2.0 Milestone 2 (Mar 17, 2010)

  • Addition of control over the Locale used for logging messages
  • Add support for "embedded='true'" to mean embed the field - so the user doesn't have to specify the 'embedded' element also
  • Bug fix to handling of embedded collections
  • Fix to generic query compilation for words starting "new"
  • Fix to JDOQL compilation of subquery FROM clause
  • Fix to the attach of nested embedded objects
  • Improvements to the query results cache to allow pinning/unpinning and to not validate
  • Fix to JTA handling introduced in M1 release
  • Add support for "detachAllOnRollback"
  • Removal of unnecessary flush on 1-1 relation
  • Bug fix to usage when invoked path has "+" symbol
  • Addition of plugin for persistence of primary JodaTime types, and simple querying for RDBMS
  • Cache : Support for pinning/unpinning of query results with Memcache/javax.cache
  • Enhancer : Bug fix to return code from enhancer when run from command line
  • JPA : Support for JPA "extended persistence context"
  • JPA : Fix to use of @EmbeddedId in extended persistence context
  • JPA : Support for optional attribute of @ManyToOne
  • LDAP : Support for persistence of recursive object graph to hierarchical structure
  • RDBMS : Addition of support for persistence to Oracle TimesTen datastore (Anton Troshin)
  • RDBMS : JDOQL2 support for "SELECT this" queries, and DISTINCT
  • RDBMS : JDOQL2 support for temporal queries
  • RDBMS : JDOQL2 support for subqueries
  • RDBMS : JPQL2 support for subqueries
  • RDBMS : JPQL2 support for bulk update/delete by query
  • RDBMS : SQL API fixes to cater for composite PKs and ordering of expressions
  • RDBMS : Improvements to choice of whether to use UNION or discriminator for inheritance detection
  • RDBMS : Some fixes to handling of temporal types to add more flexibility

New in DataNucleus 2.0 Milestone 1 (Mar 17, 2010)

  • Addition of plugin for persistence to HBase (HADOOP) datastores
  • Allow query execution in separate thread to allow for cancel/timeout hooks
  • Change default for non-transactional read/write to true for JDO
  • Support atomic non-transactional write persist/delete operations
  • Support for in-memory evaluation of queries with variables
  • Support for in-memory evaluation of queries with List.get(), and ranges using parameters
  • Drop support for various extensions that were standardised during version 1.1 timeframe
  • Split query cache into 3 components : generic compilation, datastore compilation and query results. Added API for managing caching of query results (using JDO or JPA).
  • Internal changes to implementation of StoreManager making it even easier to provide support for new datastores
  • Bug fix for annotation of unmapped columns in JDO
  • Refactor all legacy query classes into own package for removal during 2.0 timeline
  • Bug fix to JDO Metadata "index" when unique flag not defined
  • RDBMS : Fix to COMPLETE_TABLE inheritance when used with JDOQL2
  • RDBMS : Change default auto-start mechanism to "None"
  • RDBMS : JDOQL2 support for input params with multiple columns
  • RDBMS : JDOQL2 support for List.get()
  • RDBMS : JDOQL2 support for range defined with input parameters
  • RDBMS : JDOQL2/JPQL2 support for views
  • RDBMS : Revised handling of nullability on joins
  • RDBMS : Support for table creation with columns having default of NULL
  • RDBMS : Support for specifying the order of columns in DDL
  • Much internal refactoring has also been performed to remove unneeded components or to simplify the API's for things needed in the 2.0 timeline. Any use of internal API's by applications will likely need changes.

New in DataNucleus 1.1.5 (Mar 17, 2010)

  • Support minor changes to JDO2.3 API post 2.3-early-access
  • Bug fix to generic compilation of invoke expressions
  • Bug fix to use of "persistence.xml" in a path with spaces in it
  • Bug fix to JPA query repeated setting of the first postion
  • RDBMS : Bug fix to SchemaTool, broken in 1.1.4
  • RDBMS : Bug fix to querying when enum is null
  • RDBMS : Add support for persisting all date types as a String in a consistent way
  • RDBMS : Revision to nullability handling and joins
  • RDBMS : updates to very minor corner-case possibilities of connection leaks

New in DataNucleus 1.1.4 (Mar 17, 2010)

  • Make the query cache pluggable, allowing use of external caching products
  • Add support for use of Memcache, javax.cache, and EHCache for the query cache
  • Addition of upfront checks on whether the datastore supports particular features so allowing quick fail
  • Bug fix to datastores which don't provide non-transactional connections
  • Simplification of specification of L2 caching, for consistency with L1 cache and Query cache.
  • Improvement to classloading for RDBMS "requests" for use in OSGi containers
  • Change JPA default for discriminator value to use "class name" when no value specified.
  • Improvements to fallback process for persisting a type as a String
  • Add control over cascade delete of map keys, and minor change in default
  • Bug fix to JPQL "LOWER"/"UPPER" compilation
  • Bug fix to List.set() methods when using cascade delete
  • Respect JPA "fetch" setting on 1-1 relations
  • Support JPA "columnDefinition" in a minimalistic way
  • RDBMS : Change fetch process to allow fetching of related (1-1, N-1) objects in same SQL
  • RDBSM : Change to Oracle BLOB/CLOB handling to use new SQL API instead of legacy code.
  • XML : Bug fix to addition of elements to collection of persistent object
  • LDAP : Bug fix to JNDI connection pooling
  • LDAP : Support for persisting embedded elements as child entries
  • LDAP : Support for inheritance in relationships

New in DataNucleus 1.1.3 (Mar 17, 2010)

  • Add support for REST API
  • Add support for Memcache and javax.cache (JSR107) L2 caches
  • Add support for choosing which JDOQL/JPQL implementation to use.
  • Generic compilation of bulk update statements
  • Support for generic compilation of JPQL "KEY", "VALUE", "ENTRY", "SIZE", "LIKE", "SUBSTRING", "LENGTH", "CONCAT", "TRIM", "LOWER", "UPPER", "LOCATE" keywords as well as fixes to compilation of "NOT BETWEEN", "JOIN FETCH" keywords
  • Fixes to generic compilation of JPQL "Object(a)", from clause
  • Fixes to input parameter handling for generic JPQL/JDOQL queries, including much improved type checking
  • Add support for allowing multiple JPA inheritance strategies in an inheritance tree (JPA extension).
  • Bug fix to replication for embedded-only classes
  • Bug fix to allow handling of multi-level generic annotations
  • Fix to detachAllOnCommit to mean we don't have DN wrappers in detached objects so objects are ready for use in clients.
  • Fix to JPAReplicationManager for multiple objects
  • Fix to use of jtaDataSource for RESOURCE_LOCAL contexts
  • Support for JDO2.3 transaction locking semantics
  • Support for JPA2 @Cacheable
  • Bug fix for specification of generation strategy in orm.xml
  • Bug fix for PK join columns in orm.xml
  • JDOQL2 : Support for Oracle-specific mappings
  • Provision of alternative JPQL implementation for RDBMS "JPQL2"
  • JPQL2 : Support FROM clause join syntaxis
  • JPQL2 : Support case-insensitive identifiers
  • JPQL2 : Support for CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP
  • JPQL2/JDOQL2 : Cater for input parameters with multiple PK fields
  • Support for dynamic schema updates for interface implementation in 1-N collections
  • Minor bug fixes to SchemaTool
  • Bug fix to the enhancer to close any file that was opened
  • Bug fix to the enhancer for classes with custom PKs using long fields
  • Upgrade to NeoDatis 1.9 final
  • Upgrade to Apache JDO 2.3 "early access" jar
  • Move to use of Geronimo "JPA1" jar for more flexible license

New in DataNucleus 1.1.2 (Mar 17, 2010)

  • Improvements to fix issues in beforeCompletion/afterCompletion for JTA
  • Support for null values in HashMap
  • Generic query compiler support for implicit variables, method invocation on parameters
  • Generic query compiler support for JPQL "MEMBER OF", EXISTS, ALL, ANY, SUM, as well as resolution of entity names.
  • Generic query compiler support for JDOQL "ascending"/"descending" has been fixed
  • Bug fix to caching of generic query compilations to make thread safe.
  • JDO2.3 : Support for future ability to specify read object locking on transaction and on query
  • Level 2 cache : fixes to caching of Object[], Collection, as well as to ordered lists and the state of returned objects from the L2 cache
  • Managed Relations : support for delete of an object that is present in a collection
  • Support for backwards compatibility with column identifiers consistent with JPOX
  • Support for load of all classes below the root of a persistence-unit, and support for "exclude-unlisted-classes".
  • Fixes to allow correct enhancement of Scala classes
  • Fix support for JPA @Temporal, and complete support for TemporalType on Query API
  • Fix to JPA XML "generated-value" to handle case-sensitivity correctly
  • ODF : Support use of ORM files
  • LDAP : Support use of ORM files
  • Excel : Support use of ORM files
  • RDBMS : JDOQL2 - support for Collection.contains, Map.containsKey, Map.containsValue, Map.get, Map.containsEntry
  • RDBMS : JDOQL2 - support for cast, range, grouping, resultClass, new XXX()
  • RDBMS : JDOQL2 - ArrayLiteral/CollectionLiteral size, contains methods
  • RDBMS : JDOQL2 - support for String.equals(...)
  • RDBMS : JDOQL2 - fixes to aggregate types, case and whether to use UNIONs
  • RDBMS : JDOQL2 - detection of whether a query can be precompiled, and mechanism to convert a parameter into its literal form when not precompilable
  • RDBMS : Fix DB2 schema generation NPE
  • RDBMS : Use of SERIAL8 in Informix for sequence
  • RDBMS : Ability to generate schema with multiple PMFs at the same time
  • RDBMS : Improvement to locking with Derby
  • RDBMS : Fix to indexed="true" for discriminator and version columns
  • XML : Fix to the retrieval of objects when the candidate has no "xpath" specified

New in DataNucleus 1.0.5 (Mar 17, 2010)

  • Bug fix so that any remaining non-transactional update when closing the PM always goes to the datastore
  • Bug fix to JTA handling of afterCompletion()
  • Bug fix to the enhancer Ant task to allow fork=false
  • RDBMS: Bug fix to the SchemaTool Ant task to allow fork=false
  • XML : Fix to retrieval of objects where a class has no "xpath" specified.
  • Improvement to efficiency of EHCache contains() handling.
  • Bug fix to the reading of @FetchPlan annotation

New in DataNucleus 1.1.1 (Mar 17, 2010)

  • Added support for generic compilation of long form of Math.XXX, JDOHelper.XXX
  • Added support for parameter.method, parameter.field syntaxis in generic queries
  • Improved in-memory evaluation of queries to skip candidates that fail sub-expressions due to impossible conditions (unimplemented features, or casts etc)
  • Bug fix to always put objects in the L2 cache after a query
  • Bug fix to class loading when user has supplied their own loader
  • Bug fix to JTA with JCA in afterCompletion (Guido Anzuoni)
  • Bug fix to execution of generically compiled queries with parameters so that subsequent invocations use the new parameter values
  • Bug fix to runtime enhancement and use of @Extension with JPA to avoid ClassCastException
  • Improvements to ordered lists to handle some operations that require indexed positions
  • Improvement to object-value-generator to cache the generators
  • Bug fix to JPA @Basic annotation allowing for tagging of custom type fields as persistent
  • RDBMS "JDOQL2" : Improved support for various String methods
  • RDBMS "JDOQL2" : Add support for Math.XXX, JDOHelper.XXX
  • RDBMS "JDOQL2" : Support for static class fields
  • RDBMS "JDOQL2" : Support chained method invocations
  • RDBMS "JDOQL2" : Bug fix to use of parameters when the statement involves unions
  • RDBMS "JDOQL2" : Support for input Extent
  • RDBMS "JDOQL2" : Support for enums
  • RDBMS : Rewrite all backing store "iterator" statements to use new SQL API
  • RDBMS : Separate all native (SQL) statements into their own log category

New in DataNucleus 1.1.0 (Mar 17, 2010)

  • Add support for JDK1.6+ enhancement during the compilation.
  • Add support for persistence to Open Document Format (ODF) spreadsheets.
  • Version 1.1 includes the following over 1.0
  • Requires JDK1.5+
  • Support for in-memory evaluation of JDOQL/JPQL subqueries
  • Support for JDO2 PersistenceManager proxy
  • Support for JDO2.3 Metadata API
  • Support for JDO2.3 Enhancer API
  • Support for JDO2.3 query timeout/cancel API
  • Support for JDO2.2 transaction isolation control
  • JPA2 preview support for datastore cache, @OrderColumn, standardised properties, and various new query methods
  • RDBMS : rewrite of locate, fetch and some select SQL using a new SQL API
  • RDBMS : start of an alternative JDOQL implementation using a new SQL API
  • RDBMS : Support for persistence of interface fields into a single column
  • ODF : Support for persistence/querying of OpenDocument format spreadsheets
  • XML : Added support for 1-1, 1-N, M-N relations
  • XML : Added many improvements in configurability
  • LDAP : Support for various new mapping configurations.
  • LDAP : Support for native querying
  • Support for enhancement as part of the compilation process (JDK1.6+)
  • Dropped support for NucleusSQL query language
  • Dropped support for BCEL enhancer

New in DataNucleus 1.1 Milestone 4 (Mar 17, 2010)

  • Upgrade to NeoDatis 1.9RC1
  • Upgrade to latest JDO 2.3 snapshot including Metadata API
  • Add accessor for available query extensions
  • Support for in-memory evaluation of JDOQL/JPQL subqueries
  • Support for JDO2.3 Metadata API
  • Bug fix to allow registration of persistent classes when loaded by ClassLoader
  • Support for QueryResult toArray/subList
  • RDBMS : Make "request" operations pluggable allowing override of INSERT/UPDATE/DELETE etc
  • RDBMS : Replacement of field fetch process using new SQL API
  • RDBMS : Replacement of object locate process using new SQL API
  • RDBMS : Provision of potential replacement JDOQL implementation, using new SQL API
  • XML : Fix for fields marked transient to not be persisted
  • XML : Provide default XmlID/XmlIDREF based on relation metadata information
  • XML : Fix to implement fetch of fields
  • XML : Support for use of schema/table/column
  • XML : Bug fix for XmlIDREF for collection fields
  • LDAP : Support for hierarchical mapping of relations
  • LDAP : Support for wrappers of primitives
  • LDAP : Support for map/array/collection of Strings/primitives to multivalued LDAP components
  • Dropped support for BCEL enhancer

New in DataNucleus 1.0.4 (Mar 17, 2010)

  • Upgrade to NeoDatis 1.9RC1
  • Bug fix to allow registration of persistent classes when loaded by ClassLoader
  • Support for QueryResult toArray/subList

New in DataNucleus 1.1 Milestone 3 (Mar 17, 2010)

  • Upgrade to Apache POI 3.2
  • Upgrade to JDO 2.3 (snapshot)
  • New autostarter taking in metadata filenames
  • Support for pm.getObjectById(String) mimicking custom behaviour of Xcalia (for people migrating from Xcalia)
  • Support for JDO2 PersistenceManager proxy
  • Support for JPA2 @OrderColumn
  • RDBMS : Support for persisting interface/object fields using a single column. (for compatibility with Kodo/Xcalia, for people migrating from those implementations)
  • Support for JDO2.3 Enhancer API
  • LDAP : Support for native queries rather than performing all in-memory.
  • LDAP : Improvements to distinguishedName handling
  • Support for String.startsWith/endsWith/indexOf with parameter/primary expressions
  • Catch leading/trailing blanks in persistence properties
  • Support for OpenJPA/Kodo style datastore identity (for people migrating from Kodo)
  • Support for Xcalia style datastore identity (for people migrating from Xcalia)
  • Fix for unary minus in generic query mechanism
  • Remove enhancer "verify" mode since no longer used
  • Provide access to class bytes after enhancement via enhancer API
  • Fix to replication in some cases where object didnt exist in datastore 2
  • Fix to RDBMS large result "count" method to ignore ordering

New in DataNucleus 1.0.3 (Mar 17, 2010)

  • Upgrade to Apache POI 3.2
  • Support for String.startsWith/endsWith/indexOf with parameter/primary expressions
  • Catch leading/trailing blanks in persistence properties
  • Support for OpenJPA/Kodo style datastore identity (for people migrating from Kodo)
  • Support for Xcalia style datastore identity (for people migrating from Xcalia)
  • LDAP : Support for native queries rather than performing all in-memory.
  • Fix for unary minus in generic query mechanism
  • Remove enhancer "verify" mode since no longer used
  • Provide access to class bytes after enhancement via enhancer API
  • Fix to replication in some cases where object didnt exist in datastore 2
  • Fix to RDBMS large result "count" method to ignore ordering

New in DataNucleus 1.1 Milestone 2 (Mar 17, 2010)

  • Upgrade to ASM 3.1
  • Upgrade to db4o 7.4 java5
  • Upgrade to JDO2.2 final
  • Provide an API for datastore replication for JDO and JPA
  • Improvements to L2 caching to fix problems with objects being garbage collected and returning old version of objects
  • Fixes to how fields are marked as loaded
  • Fix to handling of collections with non-RDBMS datastores so they aren't treated as serialised
  • Improvement to detach flag DETACH_UNLOAD_FIELDS to also remove the values from the object
  • Fix SQL syntax for non-ANSI joins (e.g Oracle 8i)
  • Remove support for NucleusSQL for RDBMS datastores
  • Support for sequences with H2 datastore
  • Extend RDBMS "update lock" to also apply to object existence check
  • Fix to handling of URLs with DB4O plugin
  • Fix to JPA handling of PostLoad callbacks
  • Fix to LDAP plugin so that the existence check doesnt retrieve any attributes
  • Fix to handling of XMLIdRef annotation with XML plugin

New in DataNucleus 1.0.2 (Mar 17, 2010)

  • Upgrade to ASM 3.1
  • Upgrade to JDO 2.2 final jar
  • Bug fixes to L2 caching of object version, and handling of garbage collected objects
  • Removal of a JDK1.5 method so people with JDK1.3/4 can use it
  • Fix to how fields are marked as loaded with application identity
  • Fix to replication of SCO fields
  • Fix to URL handling with DB4O plugin
  • Fix to XMLIDRef handling in XML plugin

New in DataNucleus 1.1 Milestone 1 (Mar 17, 2010)

  • Moved to JDK1.5+ requirement
  • Removal of Java5 plugin, and addition of JPA plugin
  • Support for JDO2.2 transaction isolation specification mechanism
  • Support for JPQL "" added to generic query compilation
  • Support for JDOQL "(cast)" added to generic query compilation
  • Support for JPQL bulk delete for db4o, NeoDatis, Excel, XML, LDAP and JSON datastores
  • Support db4o 7.0 or later only
  • Log any invalid/unsupported persistence properties
  • Remove support for NucleusSQL for RDBMS datastores
  • Performance improvement to Excel and XML datastores to not repeatedly open/close the datastore
  • When checking for RDBMS table existence use DatabaseMetaData.getTables for performance
  • Fix logging of initialisation of Derby datastores to remove logged exception
  • Fix logging of initialisation of RDBMS SEQUENCE_TABLE to remove logged exception
  • Fix bug in loading of unloaded fields to cater for corner case
  • Fix bug in persistence of 1-N bidir List using cascade delete
  • Fix available transaction isolation levels for HSQL, H2 datastores
  • Fix bug in DB4O and NeoDatis JDOQL handling of "{alias}.b" syntax
  • Fix bug in Extents with subclasses for Excel, XML, LDAP and JSON datastores
  • Fix bug in LDAP persistence of boolean fields

New in DataNucleus 1.0.1 (Mar 17, 2010)

  • Support for JDO2.2 transaction isolation specification mechanism
  • Support for JPQL bulk delete for db4o, NeoDatis, Excel, XML, LDAP and JSON datastores
  • Log any invalid/unsupported persistence properties
  • Performance improvement to Excel and XML datastores to not repeatedly open/close the datastore
  • When checking for RDBMS table existence use DatabaseMetaData.getTables for performance
  • Fix logging of initialisation of Derby datastores to remove logged exception
  • Fix bug in loading of unloaded fields to cater for corner case
  • Fix bug in DB4O and NeoDatis JDOQL handling of "{alias}.b" syntax
  • Fix bug in Extents with subclasses for Excel, XML, LDAP and JSON datastores
  • Fix bug in LDAP persistence of boolean fields

New in DataNucleus 1.0 Final (Mar 17, 2010)

  • Migration to JDO 2.2 standardised dynamic Fetch Groups from DataNucleus custom groups
  • Support for chained method operations with in-memory query evaluation
  • Support for generic compilation of query subqueries
  • Bug fix so JPA persistence.jar doesnt need to be in CLASSPATH when not using JPA
  • Support RDBMS dynamic schema upgrades when new implementations of an interface are encountered.
  • Bug fix for loading of implementations of interfaces and subsequent handling
  • Add support for datastore identity with Excel datastores
  • Bug fix to Excel datastores for persistence of null field values, and for retrieval of Float, Double, Integer, Long, BigDecimal, BigInteger
  • Add support for cascade delete with NeoDatis datastores
  • Add support for specified indexes with NeoDatis datastores
  • Bug fix for cascade delete with db4o datastores

New in DataNucleus 1.0 Milestone 4 (Mar 17, 2010)

  • Upgrade to JDO 2.2 (snapshot), NeoDatis 1.9-beta-3, Apache POI 3.1
  • Added cache for compiled queries for XML, db4o, Excel, NeoDatis, JSON and LDAP
  • Added support for NeoDatis embedded server
  • Added full support for JPQL query compilation using generic compiler
  • Added support for in-memory JPQL query evaluation of all spec required functions.
  • Added support for in-memory JDOQL query evaluation of all spec required methods, with the exception of Collection.contains, Map.containsKey, Map.containsValue, Map.get
  • Support for JDO2.2 @Cacheable allowing control over classes/fields to be cached
  • Added pluggable support for generic query methods/functions
  • Added support for use of implicit/explicit parameters with generic JDOQL/JPQL
  • Added support for use of DISTINCT with generic JDOQL/JPQL
  • Expanded the support for in-memory evaluation of aggregates to cater for all types of fields
  • Bug fix to runtime bytecode enhancement allowing its use with annotated classes, and added optimisation to specify the packages to be runtime enhanced providing big speedups
  • Fixes to allow complete use of Access Platform in a java security environment
  • Support for JPA2 @ElementCollection/@CollectionTable
  • Support for performing db4o/NeoDatis JDOQL/JPQL queries totally in-memory where required
  • Bug fix to allow use of RDBMS datastores that store in lowercase without the need to provide a persistence property to specify this
  • Bug fix to RDBMS persistence of complicated hierarchy with container+inheritance and multiple relations between container and element, avoiding FK violation
  • Bug fix to L2 caching for multithreaded operations

New in DataNucleus 1.0 Milestone 3 (Mar 17, 2010)

  • Rewritten Level 2 caching, allowing full control over which classes are cached and which fields of which classes are cached. Fixed bugs relating to deleted objects previously being cached, and caching of SCO fields
  • Rewritten JPQL compiler for use by all datastores.
  • Addition of an in-memory JPQL evaluator, supporting basic JPQL syntax so far.
  • Support for JDO2.2 "ReadOnly"
  • Change in-memory evaluation of JDOQL/JPQL queries to allow evaluation of specific components of the query (rather than the whole query)
  • Support for in-memory JDOQL/JPQL evaluation of "/", "%", "", "=", etc
  • Support for in-memory JDOQL evaluation of all common methods (String.matches, String.toUpperCase, etc)
  • Bug fix to List.remove(int) when using optimistic transaction
  • Bug fix to in-memory JDOQL evaluation of grouping/result clauses
  • Support for JPQL querying of db4o datastores
  • Support for JPQL querying of NeoDatis ODB datastores
  • Support for JPQL querying of XML documents
  • Support for JPQL querying of Excel documents
  • Support for JPQL querying of LDAP datastores
  • Support for JPQL querying of JSON datastores
  • Removed original JDOQL querying for db4o - now replaced by generic process, with inbuilt support for more JDOQL syntax.
  • Support for persistence of wider range of Object types to Excel datastores, using new generic "String-based" persistence
  • Optimisation of location of an object in Excel datastores resulting in reduced object instantiation
  • Support for connection-pooling of LDAP connections (contrib Stefan Seelmann)
  • Support for JDOQL querying of NeoDatis ODB datastores
  • Support for multiple levels of "xpath" on XML datastores
  • Bug fix to GROUP BY on RDBMS datastores when the query has multiple components of a UNION
  • Bug fix on RDBMS datastores to re-enable creation of constraints
  • Bug fix on RDBMS datastores when using subclass-table inheritance and single subclass

New in DataNucleus 1.0 Milestone 2 (Mar 17, 2010)

  • Support for persistence to DB4O as an embedded server (contrib from Joe Batt)
  • Support for some early draft JPA 2 methods relating to caching and querying
  • Support for persistence to NeoDatis
  • Support for persistence to JSON (RESTful)
  • Improvements to persistence to XML, including allowing defining of the root for each class.
  • Significant improvements in support for XA transactions with the JDO JCA adapter, used extensively by JFire
  • Provision of a public API for accessing schema information for RDBMS
  • Bug fixes to L2 caching of SCO fields
  • Bug fix to detachment when a field was previously attached unchanged.
  • Bug fix to support @Persistent "recursionDepth" which was previously ignored.
  • Memory footprint improvements for StateManager.
  • Optimisation of some aspects of relationship management to prevent unnecessary loading of fields when not needed
  • Bug fix to use of autoincrement fields with PostgreSQL when used in non-default schema
  • Bug fix to use of "JDOHelper.getObjectId" within JDOQL for composite PK app id cases
  • Bug fix to the enhancement of jdoMakeDirty for detached cases to allow for inheritance

New in DataNucleus 1.0 Milestone 1 (Mar 17, 2010)

  • Support for persistence to and simple JDOQL querying of LDAP
  • Support for persistence to and simple JDOQL querying of Excel
  • Support for persistence to and simple JDOQL querying of XML
  • Support for SQL querying of db4o
  • Several bug fixes, and much restructuring of the JPOX codebase