Add a transformer supplied by the provider that will be called for every
new class definition or class redefinition that gets loaded by the loader
returned by the PersistenceInfo.getClassLoader method.
The AssociationOverride annotation is used to override a many-to-one or
one-to-one mapping of property or field for an entity relationship.
The AssociationOverride annotation may be applied to an entity that extends a
mapped superclass to override a many-to-one or one-to-one mapping defined by
the mapped superclass.
The AttributeOverride annotation is used to override the mapping of a Basic
(whether explicit or default) property or field or Id property or field.
The AttributeOverride annotation may be applied to an entity that extends a
mapped superclass or to an embedded field or property to override a basic
mapping defined by the mapped superclass or embeddable class.
A persistence provider supplies an instance of this interface to the
PersistenceUnitInfo.addTransformer method.
The supplied transformer instance will get called to transform entity class
files when they are loaded or redefined.
The DiscriminatorColumn annotation can be specified on an entity class
(including on an abstract entity class).
If the DiscriminatorColumn annotation is missing, and a discriminator column
is required, the name of the discriminator column defaults to "DTYPE" and the
discriminator type to STRING.
The Embeddable annotation is used to specify a class whose instances are
stored as an intrinsic part of an owning entity and share the identity of the
entity.
The Embedded annotation is used to specify a persistent field or property of
an entity whose value is an instance of an embeddable class.
The AttributeOverride and/ or AttributeOverrides annotations may be used to
override the column mappings declared within the embeddable class, which are
mapped to the entity table.
Implementations are not required to support embedded objects that are mapped
across more than one table (e.g., split across primary and secondary tables
or multiple secondary tables).
The EmbeddedId annotation is applied to a persistent field or property of an
entity class or mapped superclass to denote a composite primary key that is
an embeddable class.
The EntityNotFoundException is thrown by the persistence provider when an
entity reference obtained by getReference is accessed but the entity does not
exist.
The ExcludeDefaultListeners annotation specifies that the invocation of
default listeners is to be excluded for the entity class (or mapped
superclass) and its subclasses.
The ExcludeSuperclassListeners annotation specifies that the invocation of
superclass listeners is to be excluded for the entity class (or mapped
superclass) and its subclasses.
When queries are executed within a transaction, if FlushModeType.AUTO is set
on the Query object, or if the flush mode setting for the persistence context
is AUTO (the default) and a flush mode setting has not been specified for the
Query object, the persistence provider is responsible for ensuring that all
updates to the state of all entities in the persistence context which could
potentially affect the result of the query are visible to the processing of
the query.
The IdClass annotation is applied to an entity class or a mapped superclass
to specify a composite primary key class that is mapped to multiple fields or
properties of the entity.
The names of the fields or properties in the primary key class and the
primary key fields or properties of the entity must correspond and their
types must be the same.
The NonUniqueResultException is thrown by the persistence provider when
Query.getSingleResult is invoked and there is more than one result from the
query.
Interface implemented by the persistence provider.
This interface is used to create an EntityManagerFactory.
It is invoked by the container in Java EE environments and by the Persistence
class in Java SE environments.
The enum javax.persistence.spi.PersistenceUnitTransactionType defines whether
the entity managers created by the factory will be JTA or resource-local
entity managers.
The PrimaryKeyJoinColumn annotation specifies a primary key column that is
used as a foreign key to join to another table.
The PrimaryKeyJoinColumn annotation is used to join the primary table of an
entity subclass in the JOINED mapping strategy to the primary table of its
superclass; it is used within a SecondaryTable annotation to join a secondary
table to a primary table; and it may be used in a OneToOne mapping in which
the primary key of the referencing entity is used as a foreign key to the
referenced entity.
The SequenceGenerator annotation defines a primary key generator that may be
referenced by name when a generator element is specified for the
GeneratedValue annotation.
The TableGenerator annotation defines a primary key generator that may be
referenced by name when a generator element is specified for the
GeneratedValue annotation.