When creating or modifying a domain object, you need to extend the database to store the new data.

If you are creating a completely new domain object, you will need to add a new table.

If you're extending an existing domain object, we recommended that you use the joined inheritance strategy. With this strategy, the base class's data is stored in the base table and your extended class's data is stored in another table. To implement this, you need to:

1. Add a table to store the extension class's data.
2. Add a discriminator column in the base domain object's table. This discriminator column is used by the persistence layer to identify, for each row, which table contains the row's extended class's data field.

For an example on how this is done, refer to step 2 of Core Tutorial 3.

Any new or extended domain object has both an interface defining the methods and a class containing the implementation. To ensure the domain object's data is persisted and loaded correctly, the implementation class will need to contain the appropriate JPA annotations. At a minimum, you need to include:

• @Entity and @Table annotations at the class level.
• @Basic and @Column annotations on the getter methods to specify how field data is mapped to table columns.
• Annotation required to load data from related tables (e.g., @OneToMany, etc.)

If you're extending an existing domain object, you'll also need to set the value that will be stored in the base table's discriminator column.

The following code snippet shows the table annotations for an extension of the OrderImpl class.

@Entity
@Table(name = ExtOrderImpl.TABLE_NAME)
@DiscriminatorValue("extOrder")
@PrimaryKeyJoinColumn(name="UIDPK", referencedColumnName="UIDPK")
public class ExtOrderImpl extends OrderImpl implements ExtOrder {
    ...
    public static final String TABLE_NAME = "TORDEREXT";

For more information, see the OpenJPA documentation on metedata mapping.

If you're extending an existing domain class, JPA needs to be made aware that the base class accepts extensions. This means overriding the JPA metadata for the base class.

Metadata files are located in core\ep-core\src\main\resources\META-INF. For an example of how to extend or override them, refer to step 3 of Core Tutorial 3.

New domain classes must be registered through the core bean factories. You can add new bean definitions in the core extension's ep-core-plugin.xml to include entries for the new classes.

For an example on how this is done, refer to Replacing Core Beans in step 1 of Core Tutorial 3.

After you make this change, running mvn clean install from the command line against the core extension project will compile your classes, perform bytecode enhancement, rebuild the jar, and install it in your repository.

Most domain classes contain data that needs to be persisted, and all persistent classes need to be bytecode-enhanced. This requires the Maven enhance plugin. For more information, see Enhancing core library extension classes. Once this is done, the enhancer will be invoked automatically during the process-classes goal in the package phase of the Maven build.