# Package javax.persistence

Java Persistence is the API for the management for persistence and object/relational mapping.

See: Description

Interface Summary
AttributeConverter<X,Y>: A class that implements this interface can be used to convert entity attribute state into database column representation and back again.
AttributeNode<T>: Represents an attribute node of an entity graph.
Cache: Interface used to interact with the second-level cache.
EntityGraph<T>: This type represents the root of an entity graph that will be used as a template to define the attribute nodes and boundaries of a graph of entities and entity relationships.
EntityManager: Interface used to interact with the persistence context.
EntityManagerFactory: Interface used to interact with the entity manager factory for the persistence unit.
EntityTransaction: Interface used to control transactions on resource-local entity managers.
Parameter<T>: Type for query parameter objects.
PersistenceUnitUtil: Utility interface between the application and the persistence provider managing the persistence unit.
PersistenceUtil: Utility interface between the application and the persistence provider(s).
Query: Interface used to control query execution.
StoredProcedureQuery: Interface used to control stored procedure query execution.
Subgraph<T>: This type represents a subgraph for an attribute node that corresponds to a Managed Type.
Tuple: Interface for extracting the elements of a query result tuple.
TupleElement<X>: The `TupleElement` interface defines an element that is returned in a query result tuple.
TypedQuery<X>: Interface used to control the execution of typed queries.

Class Summary
Persistence: Bootstrap class that is used to obtain an `EntityManagerFactory` in Java SE environments.

Enum Summary
AccessType: Used with the `Access` annotation to specify an access type to be applied to an entity class, mapped superclass, or embeddable class, or to a specific attribute of such a class.
CacheRetrieveMode: Used as the value of the `javax.persistence.cache.retrieveMode` property to specify the behavior when data is retrieved by the `find` methods and by queries.
CacheStoreMode: Used as the value of the `javax.persistence.cache.storeMode` property to specify the behavior when data is read from the database and when data is committed into the database.
CascadeType: Defines the set of cascadable operations that are propagated to the associated entity.
ConstraintMode: Used to control the application of a constraint.
DiscriminatorType: Defines supported types of the discriminator column.
EnumType: Defines mapping for enumerated types.
FetchType: Defines strategies for fetching data from the database.
FlushModeType: Flush mode setting.
GenerationType: Defines the types of primary key generation strategies.
InheritanceType: Defines inheritance strategy options.
LockModeType: Lock modes can be specified by means of passing a `LockModeType` argument to one of the `EntityManager` methods that take locks (`lock`, `find`, or `refresh`) or to the `Query.setLockMode()` or `TypedQuery.setLockMode()` method.
ParameterMode: Specifies the mode of a parameter of a stored procedure query.
PersistenceContextType: Specifies whether a transaction-scoped or extended persistence context is to be used in `PersistenceContext`.
PessimisticLockScope: Defines the values of the `javax.persistence.lock.scope` property for pessimistic locking.
SharedCacheMode: Specifies how the provider must use a second-level cache for the persistence unit.
SynchronizationType: Specifies whether the persistence context is always automatically synchronized with the current transaction or whether the persistence context must be explicitly joined to the current transaction by means of the `EntityManager.joinTransaction()` method.
TemporalType: Type used to indicate a specific mapping of `java.util.Date` or `java.util.Calendar`.
ValidationMode: The validation mode to be used by the provider for the persistence unit.

Exception Summary
EntityExistsException: Thrown by the persistence provider when `EntityManager.persist(Object)` is called and the entity already exists.
EntityNotFoundException: Thrown by the persistence provider when an entity reference obtained by `EntityManager.getReference` is accessed but the entity does not exist.
LockTimeoutException: Thrown by the persistence provider when an pessimistic locking conflict occurs that does not result in transaction rollback.
NonUniqueResultException: Thrown by the persistence provider when `Query.getSingleResult()` or `TypedQuery.getSingleResult()` is executed on a query and there is more than one result from the query.
NoResultException: Thrown by the persistence provider when `Query.getSingleResult()` or `TypedQuery.getSingleResult()`is executed on a query and there is no result to return.
OptimisticLockException: Thrown by the persistence provider when an optimistic locking conflict occurs.
PersistenceException: Thrown by the persistence provider when a problem occurs.
PessimisticLockException: Thrown by the persistence provider when an pessimistic locking conflict occurs.
QueryTimeoutException: Thrown by the persistence provider when a query times out and only the statement is rolled back.
RollbackException: Thrown by the persistence provider when `EntityTransaction.commit()` fails.
TransactionRequiredException: Thrown by the persistence provider when a transaction is required but is not active.

Annotation Types Summary
Access: Used to specify an access type to be applied to an entity class, mapped superclass, or embeddable class, or to a specific attribute of such a class.
AssociationOverride: Used to override a mapping for an entity relationship.
AssociationOverrides: Used to override mappings of multiple relationship properties or fields.
AttributeOverride: Used to override the mapping of a `Basic` (whether explicit or default) property or field or `Id` property or field.
AttributeOverrides: Used to override mappings of multiple properties or fields.
Basic: The simplest type of mapping to a database column.
Cacheable: Specifies whether an entity should be cached if caching is enabled when the value of the `persistence.xml` caching element is `ENABLE_SELECTIVE` or `DISABLE_SELECTIVE`.
CollectionTable: Specifies the table that is used for the mapping of collections of basic or embeddable types.
Column: Specifies the mapped column for a persistent property or field.
ColumnResult: Used in conjunction with the `SqlResultSetMapping` annotation or `ConstructorResult` annotation to map a column of the SELECT list of a SQL query.
ConstructorResult: Used in conjunction with the `SqlResultSetMapping` annotation to map the SELECT clause of a SQL query to a constructor.
Convert: Specifies the conversion of a Basic field or property.
Converter: Specifies that the annotated class is a converter and defines its scope.
Converts: Used to group `Convert` annotations.
DiscriminatorColumn: Specifies the discriminator column for the `SINGLE_TABLE` and `JOINED` `Inheritance` mapping strategies.
DiscriminatorValue: Specifies the value of the discriminator column for entities of the given type.
ElementCollection: Specifies a collection of instances of a basic type or embeddable class.
Embeddable: Specifies a class whose instances are stored as an intrinsic part of an owning entity and share the identity of the entity.
Embedded: Specifies a persistent field or property of an entity whose value is an instance of an embeddable class.
EmbeddedId: 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.
Entity: Specifies that the class is an entity.
EntityListeners: Specifies the callback listener classes to be used for an entity or mapped superclass.
EntityResult: Used in conjunction with the `SqlResultSetMapping` annotation to map the SELECT clause of a SQL query to an entity result.
Enumerated: Specifies that a persistent property or field should be persisted as a enumerated type.
ExcludeDefaultListeners: Specifies that the invocation of default listeners is to be excluded for the entity class (or mapped superclass) and its subclasses.
ExcludeSuperclassListeners: Specifies that the invocation of superclass listeners is to be excluded for the entity class (or mapped superclass) and its subclasses.
FieldResult: Used in conjunction with the `EntityResult` annotation to map columns specified in the SELECT list of a SQL query to the properties or fields of an entity class.
ForeignKey: Used to specify the handling of foreign key constraints when schema generation is in effect.
GeneratedValue: Provides for the specification of generation strategies for the values of primary keys.
Id: Specifies the primary key of an entity.
IdClass: Specifies a composite primary key class that is mapped to multiple fields or properties of the entity.
Index: Used in schema generation to specify creation of an index.
Inheritance: Specifies the inheritance strategy to be used for an entity class hierarchy.
JoinColumn: Specifies a column for joining an entity association or element collection.
JoinColumns: Specifies the mapping for composite foreign keys.
JoinTable: Specifies the mapping of associations.
Lob: Specifies that a persistent property or field should be persisted as a large object to a database-supported large object type.
ManyToMany: Specifies a many-valued association with many-to-many multiplicity.
ManyToOne: Specifies a single-valued association to another entity class that has many-to-one multiplicity.
MapKey: Specifies the map key for associations of type `java.util.Map` when the map key is itself the primary key or a persistent field or property of the entity that is the value of the map.
MapKeyClass: Specifies the type of the map key for associations of type `java.util.Map`.
MapKeyColumn: Specifies the mapping for the key column of a map whose map key is a basic type.
MapKeyEnumerated: Specifies the enum type for a map key whose basic type is an enumerated type.
MapKeyJoinColumn: Specifies a mapping to an entity that is a map key.
MapKeyJoinColumns: Supports composite map keys that reference entities.
MapKeyTemporal: This annotation must be specified for persistent map keys of type `Date` and `Calendar`.
MappedSuperclass: Designates a class whose mapping information is applied to the entities that inherit from it.
MapsId: Designates a `ManyToOne` or `OneToOne` relationship attribute that provides the mapping for an `EmbeddedId` primary key, an attribute within an `EmbeddedId` primary key, or a simple primary key of the parent entity.
NamedAttributeNode: A `NamedAttributeNode` is a member element of a `NamedEntityGraph`.
NamedEntityGraph: Used to specify the path and boundaries for a find operation or query.
NamedEntityGraphs: Used to group `NamedEntityGraph` annotations.
NamedNativeQueries: Specifies multiple native SQL named queries.
NamedNativeQuery: Specifies a named native SQL query.
NamedQueries: Specifies multiple named Java Persistence query language queries.
NamedQuery: Specifies a static, named query in the Java Persistence query language.
NamedStoredProcedureQueries: Specifies multiple named stored procedure queries.
NamedStoredProcedureQuery: Specifies and names a stored procedure, its parameters, and its result type.
NamedSubgraph: A `NamedSubgraph` is a member element of a `NamedEntityGraph`.
OneToMany: Specifies a many-valued association with one-to-many multiplicity.
OneToOne: Specifies a single-valued association to another entity that has one-to-one multiplicity.
OrderBy: Specifies the ordering of the elements of a collection valued association or element collection at the point when the association or collection is retrieved.
OrderColumn: Specifies a column that is used to maintain the persistent order of a list.
PersistenceContext: Expresses a dependency on a container-managed `EntityManager` and its associated persistence context.
PersistenceContexts: Declares one or more `PersistenceContext` annotations.
PersistenceProperty: Describes a single container or persistence provider property.
PersistenceUnit: Expresses a dependency on an `EntityManagerFactory` and its associated persistence unit.
PersistenceUnits: Declares one or more `PersistenceUnit` annotations.
PostLoad: Specifies a callback method for the corresponding lifecycle event.
PostPersist: Specifies a callback method for the corresponding lifecycle event.
PostRemove: Specifies a callback method for the corresponding lifecycle event.
PostUpdate: Specifies a callback method for the corresponding lifecycle event.
PrePersist: Specifies a callback method for the corresponding lifecycle event.
PreRemove: Specifies a callback method for the corresponding lifecycle event.
PreUpdate: Specifies a callback method for the corresponding lifecycle event.
PrimaryKeyJoinColumn: Specifies a primary key column that is used as a foreign key to join to another table.
PrimaryKeyJoinColumns: Groups `PrimaryKeyJoinColumn` annotations.
QueryHint: Used to supply a query property or hint to the `NamedQuery` or `NamedNativeQuery` annotation.
SecondaryTable: Specifies a secondary table for the annotated entity class.
SecondaryTables: Specifies multiple secondary tables for an entity.
SequenceGenerator: Defines a primary key generator that may be referenced by name when a generator element is specified for the `GeneratedValue` annotation.
SequenceGenerators: Used to group `SequenceGenerator` annotations.
SqlResultSetMapping: Specifies the mapping of the result of a native SQL query or stored procedure.
SqlResultSetMappings: Is used to define one or more `SqlResultSetMapping` annotations.
StoredProcedureParameter: Specifies a parameter of a named stored procedure query.
Table: Specifies the primary table for the annotated entity.
TableGenerator: Defines a primary key generator that may be referenced by name when a generator element is specified for the `GeneratedValue` annotation.
TableGenerators: Used to group `TableGenerator` annotations.
Temporal: This annotation must be specified for persistent fields or properties of type `java.util.Date` and `java.util.Calendar`.
Transient: Specifies that the property or field is not persistent.
UniqueConstraint: Specifies that a unique constraint is to be included in the generated DDL for a primary or secondary table.
Version: Specifies the version field or property of an entity class that serves as its optimistic lock value.

## Package javax.persistence Description

Java Persistence is the API for the management for persistence and object/relational mapping.