Package jakarta.persistence

package jakarta.persistence

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

Related Packages

Package	Description
jakarta.persistence.criteria	Jakarta Persistence Criteria API
jakarta.persistence.metamodel	Jakarta Persistence Metamodel API
jakarta.persistence.query
jakarta.persistence.spi	SPI for Jakarta Persistence providers
jakarta.persistence.sql

Class	Description
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.
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.
AssociationOverride	Used to override a mapping for an entity relationship.
AssociationOverrides	Used to override mappings of multiple relationship properties or fields.
AttributeConverter<X,Y>	Interface implemented by custom attribute converters.
AttributeNode<T>	Represents an attribute node of an entity graph.
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 of a persistent field or property to a single database column.
Cache	Interface used to interact with the second-level cache.
Cacheable	Specifies whether an entity should be cached, if caching is enabled, and when the value of the persistence.xml caching element is SharedCacheMode.ENABLE_SELECTIVE or SharedCacheMode.DISABLE_SELECTIVE.
CacheRetrieveMode	Specifies how the EntityManager interacts with the second-level cache when data is read from the database via the EntityManager.find(Class, Object, Map) methods and execution of queries.
CacheStoreMode	Specifies how the EntityManager interacts with the second-level cache when data is read from the database and when data is written to the database.
CascadeType	Defines the set of cascadable operations that are propagated to the associated entity.
CheckConstraint	Used to specify a SQL check constraint on a column or table when schema generation is in effect.
CollectionTable	Specifies the table that is used for the mapping of collections of basic or embeddable types.
Column	Specifies the column mapped by the annotated persistent property or field.
ColumnResult	Used in conjunction with the SqlResultSetMapping, NamedNativeQuery, or ConstructorResult annotation to map a column of the SELECT list of a SQL query to a scalar (non-entity) value.
ConnectionConsumer<C>	An executable action which makes use of a native database connection.
ConnectionFunction<C,T>	A function which makes use of a native database connection to compute a result.
ConstraintMode	Used to control the application of a constraint.
ConstructorResult	Used in conjunction with the SqlResultSetMapping or NamedNativeQuery annotation to map the SELECT clause of a SQL query to the constructor of an arbitrary Java class.
Convert	Specifies how the values of a field or property are converted to a basic type, enabling a converter defined autoApply=false, overriding the use of a converter defined autoApply=true, or overriding the use of a converter specified by a field or property of an embedded type or inherited mapped superclass.
Converter	Declares that the annotated class is a converter and specifies whether the converter is automatically applied.
Converts	Used to group Convert annotations.
DiscriminatorColumn	Specifies the discriminator column for the SINGLE_TABLE and JOINED inheritance mapping strategies.
DiscriminatorType	Defines supported types of the discriminator column.
DiscriminatorValue	Specifies the value of the discriminator column for the annotated entity type.
ElementCollection	Declares a collection of instances of a basic type or embeddable class.
Embeddable	Declares a type whose instances are stored as an intrinsic part of an owning entity, sharing the identity of the entity.
Embedded	Declares a persistent field or property of an entity whose value is an instance of an embeddable class.
EmbeddedId	Specifies that the annotated persistent field or property of an entity class or mapped superclass is the composite primary key of the entity.
Entity	Declares that the annotated class is an entity.
EntityAgent	Provides entity operations that are performed independently of a persistence context.
EntityExistsException	Thrown by the persistence provider when: a detached instance of an entity type is passed to EntityManager.persist(Object), or an instance of an entity type with an identifier already assigned by the application is passed to EntityAgent.insert(Object), and a record with the assigned identifier value already exists in the database.
EntityGraph<T>	An entity graph is a template that captures the boundaries of an operation or query.
EntityHandler	Declares operations common to EntityManager and EntityAgent.
EntityListenerRegistration	Represents the registration of an entity lifecycle event listener with the EntityManagerFactory.
EntityListeners	Specifies the entity listener classes associated with the annotated class.
EntityManager	Interface used to interact with the persistence context.
EntityManagerFactory	Interface used to interact with the persistence unit, and to create new instances of EntityManager and EntityAgent.
EntityNotFoundException	Thrown by the persistence provider when: EntityHandler.get(Class, Object) cannot return an instance of the requested entity type because there is no matching record in the database, an entity reference obtained by calling EntityManager.getReference(Class, Object) is accessed but the reference has no corresponding record in the database, an entity is passed to EntityManager.refresh(Object) or EntityAgent.refresh(Object) and its record no longer exists in the database, an entity is passed to EntityManager.lock(Object, LockModeType), a pessimistic lock mode is requested, and the record no longer exists in the database.
EntityResult	Used in conjunction with the SqlResultSetMapping or NamedNativeQuery annotation to map the SELECT clause of a SQL query to an entity result.
EntityTransaction	Interface used to control transactions involving resource-local entity managers and entity agents.
Enumerated	Specifies that a persistent property or field should be persisted as an enumerated type.
EnumeratedValue	Specifies that an annotated field of a Java enum type is the source of database column values for an enumerated mapping.
EnumType	Enumerates available options for mapping enumerated types.
ExcludeDefaultListeners	Specifies that the invocation of default listeners is to be excluded for the entity class (or mapped superclass) and its subclasses.
ExcludedFromVersioning	Specifies that mutation of the annotated field or property does not result in incrementation of the version field or property of the entity.
ExcludeSuperclassListeners	Specifies that the invocation of superclass listeners is to be excluded for the entity class (or mapped superclass) and its subclasses.
FetchType	Defines policies for fetching data from the database.
FieldResult	Used in conjunction with the EntityResult annotation to map a column specified in the SELECT list of a SQL query to a property or field of an entity class.
FindOption	An option influencing the behavior of EntityHandler.find(Class, Object), EntityHandler.findMultiple(Class, List, FindOption...), EntityHandler.get(Class, Object), or EntityHandler.getMultiple(Class, List, FindOption...).
FlushModeType	Enumerates flush modes recognized by the EntityManager.
ForeignKey	Specifies the handling of foreign key constraints when schema generation is in effect.
GeneratedValue	Specifies a generation strategy for generated primary keys.
GenerationType	Enumerates the defined primary key generation strategies.
Graph<T>	Declares operations common to EntityGraph and Subgraph, most importantly, operations for adding and removing attribute nodes and for creating subgraphs.
Id	Identifies the primary key field or property of an entity class.
IdClass	Specifies a composite primary key type whose fields or properties map to the identifier fields or properties of the annotated entity class.
Index	Used in schema generation to specify creation of an index.
Inheritance	Specifies the inheritance mapping strategy for the entity class hierarchy which descends from the annotated entity class.
InheritanceType	Enumerates the options for mapping entity inheritance.
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 an association to an intermediate join table.
Lob	Specifies that the annotated persistent property or field should be persisted as a large object to a database-native large object (LOB) type.
LockModeType	Enumerates the kinds of optimistic or pessimistic lock which may be obtained on an entity instance.
LockOption	An option influencing the behavior of EntityManager.lock(Object, LockModeType).
LockTimeoutException	Thrown by the persistence provider when a pessimistic locking conflict occurs that does not result in transaction rollback.
ManyToMany	Specifies a many-valued association with many-to-many multiplicity, mapping to an intermediate table called the join table.
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 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 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	Deprecated. Newly written code should use the date/time types defined in java.time.
MappedSuperclass	Declares a class which is not itself an entity, but whose mappings are inherited by the entities which extend 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	Declares an attribute node as a member element of a NamedEntityGraph.
NamedEntityGraph	Declares a named entity graph or subgraph of a named entity graph.
NamedEntityGraphAttributeNode	Declares that the annotated attribute is an attribute node in a named entity graph.
NamedEntityGraphAttributeNodes	Groups NamedEntityGraphAttributeNode annotations.
NamedEntityGraphs	Used to group NamedEntityGraph annotations.
NamedEntityGraphSubgraph	Declares that the annotated association is the root of a subgraph of a named entity graph.
NamedEntityGraphSubgraphs	Groups NamedEntityGraphSubgraph annotations.
NamedNativeQueries	Declares multiple native SQL named queries.
NamedNativeQuery	Declares a named native SQL query and, optionally, the mapping of the result of the native SQL query.
NamedNativeStatement	Declares a named statement written in native SQL.
NamedNativeStatements	Declares multiple named native SQL statements.
NamedQueries	Declares multiple named Jakarta Persistence query language queries.
NamedQuery	Declares a named query written in the Jakarta Persistence Query Language.
NamedStatement	Declares a named statement written in the Jakarta Persistence Query Language.
NamedStatements	Declares multiple named Jakarta Persistence query language statements.
NamedStoredProcedureQueries	Specifies multiple named stored procedure queries.
NamedStoredProcedureQuery	Declares and names a stored procedure, its parameters, and its result type.
NamedSubgraph	Declares a subgraph as a member element of a NamedEntityGraph.
NonUniqueResultException	Thrown by the persistence provider when Query.getSingleResult(), TypedQuery.getSingleResult(), Query.getSingleResultOrNull(), or TypedQuery.getSingleResultOrNull() is executed and the query has more than one result.
NoResultException	Thrown by the persistence provider when Query.getSingleResult() or TypedQuery.getSingleResult() is executed and there is no query result to return.
OneToMany	Specifies a many-valued association with one-to-many multiplicity.
OneToOne	Specifies a single-valued association to another entity class that has one-to-one multiplicity.
OptimisticLockException	Thrown by the persistence provider when an optimistic locking conflict occurs.
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.
Parameter<T>	Represents a parameter of a query.
ParameterMode	Specifies the mode of a parameter of a stored procedure query.
Persistence	Bootstrap class used to obtain an EntityManagerFactory in Java SE environments.
Persistence.BeanManagementProperties	Properties used to control the integration with CDI.
Persistence.CacheProperties	Properties used to configure the second-level cache.
Persistence.ConnectionProperties	Properties used to connect to the database via JDBC in Java SE.
Persistence.DatabaseProperties	Properties used to specify the database platform when JDBC metadata is not available.
Persistence.JdbcProperties	Properties used to optimize the interaction with JDBC.
Persistence.SchemaManagementProperties	Properties used to control the schema management tooling.
Persistence.UnitProperties	Properties used to override elements the configuration of a persistence unit in persistence.xml.
Persistence.ValidationProperties	Properties used to control the integration with Bean Validation.
PersistenceConfiguration	Represents a configuration of a persistence unit, allowing programmatic creation of an EntityManagerFactory.
PersistenceContext	Expresses a dependency on a container-managed EntityManager and its associated persistence context.
PersistenceContexts	Declares one or more PersistenceContext annotations.
PersistenceContextType	Specifies the lifecycle of a container-managed persistence context in a Jakarta EE container environment.
PersistenceException	Thrown by the persistence provider when a problem occurs.
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.
PersistenceUnitTransactionType	Enumerates the possible approaches to transaction management in Jakarta Persistence.
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).
PessimisticLockException	Thrown by the persistence provider when a pessimistic locking conflict occurs.
PessimisticLockScope	Controls how a pessimistic lock applied to an entity affects associated collections and relationships.
PostDelete	Declares a callback method for the corresponding lifecycle event.
PostInsert	Declares a callback method for the corresponding lifecycle event.
PostLoad	Declares a callback method for the corresponding lifecycle event.
PostPersist	Declares a callback method for the corresponding lifecycle event.
PostRemove	Declares a callback method for the corresponding lifecycle event.
PostUpdate	Declares a callback method for the corresponding lifecycle event.
PostUpsert	Declares a callback method for the corresponding lifecycle event.
PreDelete	Declares a callback method for the corresponding lifecycle event.
PreInsert	Declares a callback method for the corresponding lifecycle event.
PreMerge	Declares a callback method for the corresponding lifecycle event.
PrePersist	Declares a callback method for the corresponding lifecycle event.
PreRemove	Declares a callback method for the corresponding lifecycle event.
PreUpdate	Declares a callback method for the corresponding lifecycle event.
PreUpsert	Declares 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	Specifies the mapping for a composite foreign key which is also a primary key.
Query	Declares common operations for controlling the execution of statements and queries written in the Jakarta Persistence query language or in native SQL.
QueryHint	Used to supply a query property or hint to the NamedQuery or NamedNativeQuery annotation.
QueryTimeoutException	Thrown by the persistence provider when a query times out and only the statement is rolled back.
Reference	A reference to a named statement or query declared via the NamedQuery or NamedNativeQuery annotations, or using StaticQuery or StaticNativeQuery.
RefreshOption	An option influencing the behavior of EntityManager.refresh(Object).
RollbackException	Thrown by the persistence provider when a resource-local transaction cannot be committed, that is, when EntityTransaction.commit() fails.
SchemaManagementAction	Represents an action that can be performed by the schema management tooling.
SchemaManager	Allows programmatic schema creation, schema validation, data cleanup, and data loading, and schema cleanup for entities belonging to a certain persistence unit.
SchemaValidationException	Thrown when schema validation fails.
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.
SharedCacheMode	Enumerates policies which control how the provider determines if an entity type is eligible for storage in the second-level cache.
SqlResultSetMapping	Specifies an explicit mapping of the columns of a result set of a native SQL query or stored procedure to entity classes, scalar values, and Java class constructors.
SqlResultSetMappings	Used to define one or more SqlResultSetMapping annotations.
Statement	Interface used to control the execution of executable statements.
StatementReference	A reference to an executable named statement for an operation that returns a row count.
StoredProcedureParameter	Declares a parameter of a named stored procedure query.
StoredProcedureQuery	Interface used to control execution of a stored procedure query.
Subgraph<T>	This type represents a subgraph for an attribute node that corresponds to a managed type.
SynchronizationType	Specifies whether the persistence context associated with an EntityManager is always automatically synchronized with the current transaction.
Table	Specifies the primary table mapped by the annotated entity type.
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	Deprecated. Newly written code should use the date/time types defined in java.time.
TemporalType	Deprecated. Newly written code should use the date/time types defined in java.time.
Timeout	Specifies a timeout for a database request.
TransactionRequiredException	Thrown by the persistence provider when a transaction is required but is not active.
Transient	Specifies that the annotated property or field is not persistent.
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.
TypedQueryReference<R>	A reference to a typed named query declared via the NamedQuery or NamedNativeQuery annotations, or using StaticQuery or StaticNativeQuery.
UniqueConstraint	Specifies that a unique constraint is to be included in the generated DDL for a primary or secondary table.
ValidationMode	The validation mode to be used by the provider for the persistence unit.
Version	Declares the version field or property of an entity class, which is used to detect optimistic locking conflicts, ensuring the integrity of optimistic transactions.