1.2.1

• DefaultDatastoreKey was modified to implement java.io.Serializable interface to allow serialization.

1.2.0

• Fixed an issue where persisting Array properties (List/Set) with indexing turned off was throwing an Exception. Google Cloud Datastore mandates that the indexing be ON for Array properties, but the items in the Array property may be excluded from indexing. The effected Mappers, ListMapper and SetMapper were updated accordingly.
• Updated Catatumbo to use the latest version, 0.8.3, of Google Cloud Java Client for Datastore API.

1.1.3

• Fixed an issue with the way Catatumbo was determining the accessor method names for the fields of an entity. In some rare cases, the expected method names were not matching the method names produced by popular IDEs. For example, if you have a field named aUser, Catatumbo was expecting setAUser and getAuser methods, while the IDEs generate setaUser and getaUser. This fix makes Catatumbo to be compliant with IDEs and JavaBeans standards. See Issue #96 for more details.

1.1.2

• Updated the below Exceptions to extend EntityManagerException:
  • MappingException
  • NoSuitableMapperException
  • IndexingException
  • NoSuitableIndexerException
• Updated Catatumbo to use the latest version, 0.8.0, of Google Cloud Java Client for Datastore API.

1.1.1

• Enhanced the support for List/Set/Map to allow mapping of embedded objects. For example, a list of Address objects can now be mapped to/from the Cloud Datastore.
• Added support for creation of Secondary Indexes on the fields of an Entity. Secondary Indexes are useful, for example, to index a field in all lower case or upper case, to allow for case-insensitive querying and sorting. The Catatumbo framework handles this transparently by creating an additional property in the Cloud Datastore, without polluting the model classes. Added the below two new annotations to support this feature:
  • SecondaryIndex - specifies if a secondary index should be created for an entity's field.
  • PropertyIndexer - This optional annotation allows specifying which indexer implementation is to be used for creating the secondary index.
• Updated Catatumbo to use the latest version, 0.7.0, of Google Cloud Java Client for Datastore API.

1.0.2

• Fixed an issue where in some cases a MappingException was thrown when mapping float/Float types.
• Deprecated the incorrectly spelled method name (getGneratedKeys) in DatastoreBatch.Response and DatastoreTransaction.Response interfaces. Created new method, getGeneratedKeys with the correct spelling.

1.0.1

• Removed the restriction on what data types can exist in a model class (Entity, Embeddable, MappedSuperClass). Model classes can now have fields of any type (e.g. java.time.LocalDate from Java 8), as long as there is a registered mapper to handle the data type.
• Fixed an issue where the return value from DatastoreAccess#update methods may not reflect the changes that the property mappers might have made.

1.0.0

• Added support for mapping embedded objects of an entity to a single property in the Cloud Datastore (referred to as Embedded Entities in Google Cloud Datastore's terminology).
  • Enhanced the Embedded annotation to optionally specify a property name and whether or not to index the embedded property.
  • Introduced two new annotations, @exploded and @Imploded, to specify the storage strategy for embedded objects. These annotations can be applied to an embedded object of an Entity. With Exploded strategy, which is the default, all primitive fields of the embedded object are stored as individual properties in the Cloud Datastore. On the contrary, with the Imploded strategy, the embedded object is stored as a single property in the Cloud Datastore.
• Enhanced the support for mapping Lists, Sets and Maps (together referred to as Collections)
  • The framework now supports all basic types to be part of a collection, provided the collection is parameterized (Generics).
  • Raw collections and wildcard collections continue to support the previously supported data types, Boolean, Long, String, Double and DatastoreKey.
  • Added support for mapping SortedSets and SortedMaps.
• Added Support for persisting BigDecimal types.
  • Default strategy maps BigDecimal types to Floating Point properties in the Cloud Datastore
  • Added an option to store BigDecimals as "true" Decimals in the Cloud Datastore without any loss of precision. This option is useful to store currency and any other decimal types. A new annotation, @decimal, was introduced to support this feature. Using this annotation, the precision and scale are pre-defined on the entity fields. This is accomplished by mapping the BigDecimal types to Integer properties. The framework transparently manages the conversion of data.
• Added support for defining custom Mappers to map fields of the model to/from Cloud Datastore. A new annotation, @propertymapper, was introduced. Using this annotation, developers can specify the name of the class that implements the Mapper interface.
• Added the ability to override the default mappers based on the field type. MapperFactory exposes a method to set/override the default mappers.
• Added the ability to connect and work with a Local Datastore (a.k.a Datastore Emulator). Added new methods to the EntityManagerFactory to return EntityManager for Local Datastore.
• Enhanced the Mappers for Short, Float, Integer, etc, to raise a MappingException, if the value read from the Datastore is not within the bounds of the corresponding type.
• Updated Catatumbo to use the latest version, 0.5.0, of Google Cloud Java Client for Datastore API.
• Removed the deprecated method, DatastoreAccess#executeQuery(). This method was first deprecated after 0.1.0 version.
• Fixed an issue where the Unmarshaller was not calling the Setter method of the model class when the value read from the Datastore is null.

0.6.1

• Implemented support for Entity Listeners. Entity Listeners help your application to react to certain events that occur in the persistence mechanism. For example, you could define a Callback method to trap the PreUpdate event and update certain fields of the entity, such as Last Modified Timestamp. The following annotations were introduced to support this feature:
  • EntityListeners
  • EntityListener
  • ExcludeDefaultListeners
  • ExcludeSuperclassListeners
  • PreInsert
  • PostInsert
  • PreUpdate
  • PostUpdate
  • PreUpsert
  • PostUpsert
  • PreDelete
  • PostDelete
• Added support for mapping and persisting of Enum types. Entities, MappedSuperClasses and Embeddables can now define properties with an Enum type and Catatumbo takes care of mapping and persistence. Enum types are stored into the Datastore as String that is same as the name of the Enum constant.
• Added support for mapping of java.util.Map and its implementations. Maps are stored as Embedded Entity in the Google Cloud Datastore. Keys in the Maps are expected to be of type String. Values in the Map can be of the following types:
  • Boolean
  • String
  • Long
  • Double
  • DatastoreKey
• Added support for mapping and persisting java.util.Set and its implementations. Sets are stored as Array properties in the Google Cloud Datastore. Sets may contain the following types of items:
  • Boolean
  • String
  • Long
  • Double
  • DatastoreKey
• Enhanced the support for persisting java.util.List. The framework now supports List and any of its implementations.
• Updated the Caching mechanism for EntityMetadata to use an unbounded cache instead of a fixed LRUCache.
• Updated Catatumbo to use the latest version, 0.4.0, of Google Cloud Java Client for Datastore API.

0.5.1

• Implemented support for Batch Writes
• Enhanced the EntityManager to allow callbacks to run a set of code inside a transaction
• Enhanced DatastoreTransaction interface to support insert and upsert (Update or Insert) with deferred ID allocation