# Package com.sleepycat.persist.evolve

Utilities for managing class evolution of persistent objects.

# Class Evolution

For persistent data that is not short lived, changes to persistent classes are almost inevitable. Some changes are compatible with existing types, and data conversion for these changes is performed automatically and transparently. Other changes are not compatible with existing types. Mutations can be used to explicitly manage many types of incompatible changes.

Not all incompatible class changes can be handled via mutations. For example, complex refactoring may require a transformation that manipulates multiple entity instances at once. Such changes are not possible with mutations but can be made by performing a store conversion.

The different categories of type changes are described below.

## Key Field Changes

Unlike entity data, key data is not versioned. Therefore, the physical key format for an index is fixed once the index has been opened, and the changes allowed for key fields are very limited. The only changes allowed for key fields are:

- The name of a key field may be changed, as long as this change is accompanied by a `Renamer` mutation.
- A primitive type may be changed to its corresponding primitive wrapper type. This is a compatible change.
- For primary key fields and fields of a composite key class, a primitive wrapper type may be changed to its corresponding primitive type. This is allowed because these key fields with reference types may never have null values. This is a compatible change.

Any other changes to a key field are incompatible and may be made only by performing a store conversion.

Key ordering, including the behavior of a custom `Comparable`, is also fixed, since keys are stored in order in the index. The specifications for key ordering may not be changed, and the developer is responsible for not changing the behavior of a `Comparable` key class. WARNING:: Changing the behavior of a `Comparable` key class is likely to make the index unusable.

## Compatible Type Changes

Entity data, unlike key data, is versioned. Therefore, some changes can be made compatibly and other changes can be handled via mutations. Compatible changes are defined below. To make a compatible class change, a mutation is not required; however, the class version must be assigned a new (greater) integer value.

Changes to a class hierarchy are compatible in some cases. A new class may be inserted in the hierarchy. A class may be deleted from the hierarchy as long as one of the following is true: 1) it contains no persistent fields, 2) any persistent fields are deleted with field Deleter mutations, or 3) the class is deleted with a class Deleter mutation. Classes in an existing hierarchy may not be reordered compatibly, and fields may not moved from one class to another compatibly; for such changes a class Converter mutation is required.

Changes to field types in entity class definitions are compatible when they conform to the Java Language Specification definitions for Widening Primitive Conversions and Widening Reference Conversions. For example, a smaller integer type may be changed to a larger integer type, and a reference type may be changed to one of its supertypes. Automatic widening conversions are performed as described in the Java Language Specification.

Primitive types may also be compatibly changed to their corresponding primitive wrapper types, or to the wrapper type for a widened primitive type. However, changing from a primitive wrapper type to a primitive type is not a compatible change since existing null values could not be represented.

Integer primitive types (byte, short, char, int, long) and their primitive wrapper types may be compatibly changed to the BigInteger type.

Enum values may be added compatibly, but may not be deleted or renamed. As long as new values are declared after existing values, the default sort order for enum key fields will match the declaration order, i.e, the default sort order will match the enum ordinal order. If a new value is inserted (declared before an existing value), it will be sorted after all existing values but before newly added values. However, these ordering rules are only guaranteed for enums containing up to 631 values and only if existing values are not reordered. If more than 631 values are declared or the declarations of existing values are reordered, then the default sort order will be arbitrary and will not match the declaration (ordinal) order.

In addition, adding fields to a class is a compatible change. When a persistent instance of a class is read that does not contain the new field, the new field is initialized by the default constructor.

All other changes to instance fields are considered incompatible. Incompatible changes may be handled via mutations, as described next.

Note that whenever a class is changed, either compatibly or incompatibly, a new (higher) class version number must be assigned. See `Entity.version()` and `Persistent.version()` for information on assigning class version numbers.

## Mutations

There are three types of mutations: `Renamer`, `Deleter` and `Converter`.

A class or field can be renamed using a `Renamer`. Renaming is not expensive, since it does not involve conversion of instance data.

A class or field can be deleted using a `Deleter`.

- Deleting an entity class causes removal of the primary and secondary indices for the store, on other words, removal of all store entities for that class and its subclasses. Removal is performed when the store is opened. A `Deleter` should be used for an entity class in all of the following circumstances:
  - When removing the entity class itself.
  - When removing `Entity` from the class to make it non-persistent.
  - When removing `Entity` from the class and adding `Persistent`, to use it as an embedded persistent class but not an entity class. The version of the class must be incremented in this case.
- Deleting a non-entity class does not itself cause deletion of instance data, but is needed to inform DPL that the deleted class will not be used. Instances of the deleted class must be handled (discarded or converted to another class) by `Deleter` or `Converter` mutations for the field or enclosing class that contain embedded instances of the deleted class. A `Deleter` should be used for a non-entity class in all of the following circumstances:
  - When removing the persistent class itself.
  - When removing `Persistent` from the class to make it non-persistent.
  - When removing `Persistent` from the class and adding `Entity`, to use it as an entity class but not an embedded persistent class. The version of the class must be incremented in this case.
- Deleting a field causes automatic conversion of the instances containing that field, in order to discard the field values.

Other incompatible changes are handled by creating a `Converter` mutation and implementing a `Conversion.convert` method that manipulates the raw objects and/or simple values directly. The `convert` method is passed an object of the old incompatible type and it returns an object of a current type.

Conversions can be specified in two ways: for specific fields or for all instances of a class. A different `Converter` constructor is used in each case. Field-specific conversions are used instead of class conversions when both are applicable.

Note that a class conversion may be not specified for an enum class. A field conversion, or a class conversion for the class declaring the field, may be used.

Note that each mutation is applied to a specific class version number. The class version must be explicitly specified in a mutation for two reasons:

1. This provides safety in the face of multiple unconverted versions of a given type. Without a version, a single conversion method would have to handle multiple input types, and would have to distinguish between them by examining the data or type information.
2. This allows arbitrary changes to be made. For example, a series of name changes may reuse a given name for more than one version. To identify the specific type being converted or renamed, a version number is needed.

See `Entity.version()` and `Persistent.version()` for information on assigning class version numbers.

Mutations are therefore responsible for converting each existing incompatible class version to the current version as defined by a current class definition. For example, consider that class-version A-1 is initially changed to A-2 and a mutation is added for converting A-1 to A-2. If later changes in version A-3 occur before converting all A-1 instances to version A-2, the converter for A-1 will have to be changed. Instead of converting from A-1 to A-2 it will need to convert from A-1 to A-3. In addition, a mutation converting A-2 to A-3 will be needed.

When a `Converter` mutation applies to a given object, other mutations that may apply to that object are not automatically performed. It is the responsibility of the `Converter` to return an object that conforms to the current class definition, including renaming fields and classes. If the input object has nested objects or superclasses that also need conversion, the converter must perform these nested conversions before returning the final converted object. This rule avoids the complexity and potential errors that could result if a converter mutation were automatically combined with other mutations in an arbitrary manner.

The `EntityStore.evolve` method may optionally be used to ensure that all instances of an old class version are converted to the current version.

## Other Metadata Changes

When a class that happens to be an entity class is renamed, it remains an entity class. When a field that happens to be a primary or secondary key field is renamed, its metadata remains intact as well.

When the `SecondaryKey` annotation is added to an existing field, a new index is created automatically. The new index will be populated by reading the entire primary index when the primary index is opened.

When the `SecondaryKey` annotation is included with a new field, a new index is created automatically. The new field is required to be a reference type (not a primitive) and must be initialized to null (the default behavior) in the default constructor. Entities will be indexed by the field when they are stored with a non-null key value.

When a field with the `SecondaryKey` annotation is deleted, or when the `SecondaryKey` annotation is removed from a field without deleting it, the secondary index is removed (dropped). Removal occurs when the store is opened.

The `SecondaryKey.relate` property may NOT be changed. All other properties of a `SecondaryKey` may be changed, although avoiding changes that cause foreign key integrity errors is the responsibility of the application developer. For example, if the `SecondaryKey.relatedEntity()` property is added but not all existing secondary keys reference existing primary keys for the related entity, foreign key integrity errors may occur.

The `PrimaryKey` annotation may NOT be removed from a field in an entity class.

The `PrimaryKey.sequence()` property may be added, removed, or changed to a different name.

The `Persistent.proxyFor()` property may NOT be added, removed, or changed to a different class.

## Warnings on Testing and Backups

The application developer is responsible for verifying that class evolution works properly before deploying with a changed set of persistent classes. The DPL will report errors when old class definitions cannot be evolved, for example, when a mutation is missing. To test that no such errors will occur, application test cases must include instances of all persistent classes.

Converter mutations require special testing. Since the application conversion method is allowed to return instances of any type, the DPL cannot check that the proper type is returned until the data is accessed. To avoid data access errors, application test cases must cover converter mutations for all potential input and output types.

When secondary keys are dropped or entity classes are deleted, the underlying databases are deleted and cannot be recovered from the store. This takes place when the store is opened. It is strongly recommended that a backup of the entire store is made before opening the store and causing class evolution to proceed.

## Store Conversion

When mutations are not sufficient for handling class changes, a full store conversion may be performed. This is necessary for two particular types of class changes:

- A change to a physical key format, for example, a change from type `int` to type `long`.
- A conversion that involves multiple entities at once, for example, combining two separate entity classes into a new single entity class.

To perform a full store conversion, a program is written that performs the following steps to copy the data from the old store to a new converted store:

1. The old store is opened as a `RawStore` and the new store is opened as an `EntityStore`.
2. All entities are read from the old store. Entities are read using a `RawStore` to allow access to entities for which no compatible class exists.
3. The `RawObject` entities are then converted to the format desired. Raw objects can be arbitrarily manipulated as needed. The updated raw objects must conform to the new evolved class definitions.
4. The updated raw entities are converted to live objects by calling the `EntityModel.convertRawObject` method of the new store. This method converts raw objects obtained from a different store, as long as they conform to the new evolved class definitions.
5. The new live objects are written to the new `EntityStore` using a `PrimaryIndex` as usual.

To perform such a conversion, two separate stores must be open at once. Both stores may be in the same `Environment`, if desired, by giving them different store names. But since all data is being rewritten, there are performance advantages to creating the new store in a new fresh environment: the data will be compacted as it is written, and the old store can be removed very quickly by deleting the old environment directory after the conversion is complete.

- Interface Summary
  Interface | Description
  --- | ---
  Conversion | Converts an old version of an object value to conform to the current class or field definition.
  EvolveListener | The listener interface called during eager entity evolution.

- Class Summary
  Class | Description
  --- | ---
  Converter | A mutation for converting an old version of an object value to conform to the current class or field definition.
  Deleter | A mutation for deleting an entity class or field.
  EntityConverter | A subclass of Converter that allows specifying keys to be deleted.
  EvolveConfig | Configuration properties for eager conversion of unevolved objects.
  EvolveConfigBeanInfo |
  EvolveEvent | The event passed to the EvolveListener interface during eager entity evolution.
  EvolveInternal | Internal access class that should not be used by applications.
  EvolveStats | Statistics accumulated during eager entity evolution.
  Mutation | The base class for all mutations.
  Mutations | A collection of mutations for configuring class evolution.
  Renamer | A mutation for renaming a class or field without changing the instance or field value.

- Exception Summary
  Exception | Description
  --- | ---
  DeletedClassException | While reading from an index, an instance of a deleted class version was encountered.
  IncompatibleClassException | A class has been changed incompatibly and no mutation has been configured to handle the change or a new class version number has not been assigned.

Copyright (c) 1996, 2020 Oracle and/or its affiliates. All rights reserved.