Group items tagged

one direction must be defined as the owner and the other must use the mappedBy attribute to define its mapping

you will end up getting duplicate rows

If the mappedBy is not used, then the persistence provider will assume there are two independent relationships

As with all bi-directional relationships it is your object model's and application's responsibility to maintain the relationship in both direction

Mapping a Join Table with Additional Columns

solution is to create a class that models the join table

requires a composite primary key

To make your life simpler, I would recommend adding a generated Id attribute to the association class

Another usage is if you have a Map relationship between two objects, with a third unrelated object or data representing the Map key

Single table inheritance is the default

mapped superclass is

but allow common mappings to be define for its subclasses

Single Table Inheritance

single table is used to store all of the instances of the entire inheritance hierarchy

table will have a column for

in the hierarchy

is used to determine which class the particular row belongs to

abstract

Project

extends Project

extends Project

@DiscriminatorValue("S")

@DiscriminatorValue("L")

@DiscriminatorColumn(name="PROJ_TYPE")

@Inheritance

@Table(name="PROJECT")

single table inheritance

Joined, Multiple Table Inheritance

mirrors the object model in the data model

table is defined for each class in the inheritance hierarchy to store only the local attributes of that class

Each table in the hierarchy must also store the object's id (primary key), which is

share the same id attribute

joined inheritance

@Inheritance(strategy=

@DiscriminatorColumn(name="PROJ_TYPE")

@Table(name="PROJECT")

abstract

Project

@DiscriminatorValue("L")

@Table(name=

Project

@DiscriminatorValue("S")

@Table(name=

Project

Table Per Class Inheritance

Advanced

table is defined for

in the inheritance hierarchy to store

of that class and

table per class inheritance

@Inheritance(strategy=

abstract

Project

@Table(name="LARGEPROJECT")

LargeProject

Project

@Table(name="SMALLPROJECT")

SmallProject

Project

Mapped Superclasses

similar to table per class inheritance, but does not allow querying, persisting, or relationships to the superclass

mapped superclass

@MappedSuperclass

abstract

Project

@Column(name="NAME")

@Table(name="LARGEPROJECT")

LargeProject

Project

@AttributeOverride

"PROJECT_NAME"

"name"

@Table("SMALLPROJECT")

SmallProject

Project

cannot have a relationship to a mapped superclass

after the database DELETE has occurred

before the transaction is committed

after the database UPDATE has occurred

before the transaction is committed

after the database UPDATE has occurred

before the transaction is committed

after the database INSERT has occurred

before the transaction is committed

FIELD

PROPERTY

Either all annotations must be on the fields, or all annotations on the get methods, but not both (unless the @AccessType annotation is used)

if placed on a get method, then the class is using PROPERTY access

For FIELD access the class field value will be accessed directly to store and load the value from the database

field can be private or any other access type

For PROPERTY access the class get and set methods will be used to store and load the value from the database

PROPERTY has the advantage of allowing the application to perform conversion of the database value when storing it in the object

be careful to not put any side-affects in the get/set methods that could interfere with persistence

Common Problems

Odd behavior

One common issue that can cause odd behavior is

For this reason it is generally recommended to

causing duplicate inserts, missed updates, or a corrupt object model

if you are going to use property access, ensure your property methods are free of side effects

If persist() is called on the

and the

is also new, it will also be persisted

. If remove() is called on the parent then the child will also be removed

. If merge() is called on the parent, then the child will also be merged

If refresh() is called on the parent then the child will also be refreshed

Merge

When the transaction is committed, or if the persistence context is flushed, then the object will be updated in the database.

used to merge the changes made to a detached object into the persistence context

it merges the changes into the persistence context (transaction)

When the transaction is committed, or if the persistence context is flushed, then the object will be inserted into the database

if the value is a Basic but the key is an Entity a

mapping is used.

if the key is a Basic but the value is an Entity a

mapping is still used

a three way join table, can be mapped using a

used to define a map relationship where the

In JEE managed mode, such as an EntityManager injected into a SessionBean, the EntityManager reference, represents a new persistence context for each transaction. This means objects read in one transaction become detached after the end of the transaction, and should no longer be used, or need to be merged into the next transaction. In managed mode, you never create or close an EntityManager.

do not support nested transactions

resultClass=Employee.class

class Employee

createNamedQuery("findAllEmployeesInCity")

List<Employee>

@NamedNativeQuery

resultSetMapping="employee-address"

@SqlResultSetMapping(name="employee-address", entities={ @EntityResult(entityClass=Employee.class), @EntityResult(entityClass=Address.class)} )

When the application inserts or updates an object, it will set these fields and they will be stored in the database. JPA events could also be used to record the audit information, or to write to a separate audit table.

Example AuditedObject class

@MappedSuperclass public Class AuditedObject {

@Column("AUDIT_USER"); protected String auditUser; @Column("AUDIT_TIMESTAMP"); protected Calendar auditTimestamp;

@PrePersist @PreUpdate public void updateAuditInfo() { setAuditUser((String)AuditedObject.currentUser.get()); setAuditTimestamp(Calendar.getInstance()); }

Example of injecting an EntityManager and EntityManagerFactory in a SessionBean

@Stateless

@PersistenceContext(unitName="acme") private EntityManager entityManager;