ObjectDB Database Search

the list of the names of the mapping files that the persistence provider must load to determine the mappings for the entity classes. The mapping files must be in the standard XML mapping format, be uniquely named and be resource-loadable from the application classpath. Each mapping file name corresponds

: the resulting join Inherited from: From Since: JPA 2.0 MapJoin join ( MapAttribute   map ) Create an inner join to the specified Map -valued attribute. Parameters: map - target of the join Return: the resulting join Inherited from: From Since: JPA 2.0 MapJoin join ( MapAttribute   map , 

JPA Interface MappedSuperclassType Type Parameters: - The represented mapped superclass type Super ... ) Return the attribute that corresponds to the id attribute declared by the entity or mapped ... to the version attribute declared by the entity or mapped superclass. Parameters: type - the type

) The name of the foreign key column for the map key. The table in which it is found depends upon the context. If the join is for a map key for an element collection, the foreign key column is in the collection table for the map value. If the join is for a map key for a ManyToMany entity relationship

) The name of the table that contains the column. Defaults: If the map key is for an element collection, the name of the collection table for the map value. If the map key is for a OneToMany or ManyToMany entity relationship using a join table, the name of the join table for the map . If the map key

of the relationship. A OneToMany association usually maps a foreign key column or columns in the table of the associated entity. This mapping may be specified using the JoinColumn annotation. Alternatively, a unidirectional OneToMany association is sometimes mapped to a join table using the JoinTable annotation

to a map key that is a managed type. This allows for construction of multi-node entity graphs ... that corresponds to a map key that is a managed type with inheritance. This allows for construction of multi ... to the graph that corresponds to a map key that is a managed type. This allows for construction of multi-node

) Add a node to the graph that corresponds to a map key that is a managed type. This allows ... to the graph that corresponds to a map key that is a managed type with inheritance. This allows ... to the graph that corresponds to a map key that is a managed type. This allows for construction of multi-node

Since: JPA 3.2 PersistenceConfiguration mappingFile (String name) Add the path of an XML mapping file loaded as a resource to the configuration. Parameters: name - the resource path of the mapping file ... mapping files. Return: all configured mapping file resource paths Since: JPA 3.2 String name

) Add a node to the graph that corresponds to a map key that is a managed type. This allows ...  type) Add a node to the graph that corresponds to a map key that is a managed type ... ( MapAttribute  attribute) Add a node to the graph that corresponds to a map key that is a managed

JPA Method in jakarta.persistence.AttributeNode Map getKeySubgraphs () Return a map of subgraphs associated with this attribute node's map key. Return: a {@link Map } of subgraphs associated with this attribute node's map key or an empty {@code Map } if none have been defined Since: JPA 2.1

JPA Interface MapAttribute Type Parameters: - The type the represented Map belongs to - The type of the key of the represented Map - The type of the value of the represented Map Super Interfaces ... .util. Map -valued attributes. Since: JPA 2.0 Public Methods Class getKeyJavaType () Return the Java

mapping using a foreign key mapping strategy, the name of the table of the source entity or embeddable. If the join is for a unidirectional OneToMany mapping using a foreign key mapping strategy, the name of the table of the target entity. If the join is for a ManyToMany mapping or for a OneToOne or

that corresponds to the id attribute declared by the entity or mapped superclass. Parameters: type ... declared by the entity or mapped superclass. Parameters: type - the type of the represented declared ... attribute of the entity or mapped superclass. Parameters: type - the type of the represented id

. If the join is for a OneToOne or ManyToOne mapping using a foreign key mapping strategy, the foreign key ... OneToMany mapping using a foreign key mapping strategy, the foreign key is in the table of the target entity. If the join is for a ManyToMany mapping or for a OneToOne or bidirectional ManyToOne

, that is, they may be specified via persistence.xml or (String, Map ) . See Also: EntityManagerFactory ... objects mapped by entities belonging to the persistence unit. If a DDL operation fails, the behavior ... already exist Since: JPA 3.2 void drop (boolean dropSchemas) Drop database objects mapped by

the type of the map key for associations of type java.util. Map . The map key can be a basic type, an embeddable class, or an entity. If the map is specified using Java generics, the MapKeyClass annotation ... 2.0 Public Annotation Attributes Class value default null (Required) The type of the map key. Since: JPA 2.0

a mapping of the columns of a result set of a native SQL query or stored procedure. Example: {@snippet ... ConstructorResult [] classes default {} Specifies the result set mapping to constructors. Since: JPA 2.1 ColumnResult [] columns default {} Specifies the result set mapping to scalar values. Since: JPA 1.0

a many-valued association with many-to-many multiplicity, mapping to an intermediate table called ... annotation specifies a mapping to a database table. The ManyToMany annotation may be used ... that must be cascaded to the target of the association. When the target collection is a java.util. Map

default {} The join column(s) being mapped to the persistent attribute(s). The joinColumns elements must be specified if a foreign key mapping is used in the overriding of the mapping of the relationship. The joinColumns element must not be specified if a join table is used in the overriding of the mapping of the relationship. Since: JPA 1.0

the mapping of an association to an intermediate join table. It is applied to the owning side of an association. A join table is typically used in the mapping of many-to-many and unidirectional one-to-many associations. It may also be used to map bidirectional many-to-one/one-to-many associations

of the owning side. A OneToOne association usually maps a unique foreign key relationship ... . The JoinColumn annotation may be used to map the foreign key column or columns. Alternatively, an optional OneToOne association is sometimes mapped to a join table using the JoinTable annotation

JPA Method in jakarta.persistence.AttributeNode Map getSubgraphs () Return a map of subgraphs associated with this attribute node. Return: a {@link Map } of subgraphs associated with this attribute node or an empty {@code Map } if none have been defined Since: JPA 2.1

the enum type for a map key whose basic type is an enumerated type. The MapKeyEnumerated annotation can be applied to an element collection or relationship of type java.util. Map , in conjunction ... Public Annotation Attributes EnumType value default EnumType.ORDINAL (Optional) The type used in mapping a map key enum type. Since: JPA 2.0

that is the owner of the relationship. A ManyToOne association usually maps a foreign key column or columns. This mapping may be specified using the JoinColumn annotation. Alternatively, an optional OneToOne association is sometimes mapped to a join table using the JoinTable annotation. The ManyToOne

.TemporalType Type used to indicate a specific mapping of java.util.Date or java.util.Calendar . Since: JPA 1.0 The JPA Persistable Types article explains how to use TemporalType . Enum Constants DATE Map as java.sql.Date Since: JPA 1.0 TIME Map as java.sql.Time Since: JPA 1.0 TIMESTAMP Map as java.sql

createEntityManagerFactory (String persistenceUnitName,  Map  properties) Create and return ... void generateSchema (String persistenceUnitName,  Map   map ) Create database schemas ... : persistenceUnitName - the name of the persistence unit map - properties for schema generation

how to use Path . Public Methods Expression get ( MapAttribute   map ) Create a path corresponding to the referenced map -valued attribute. Parameters: map - map -valued attribute Return: expression

composite map keys that reference entities. The MapKeyJoinColumns annotation groups ... the persistence provider. Since: JPA 2.1 MapKeyJoinColumn [] value default null (Required) The map key join columns that are used to map to the entity that is the map key. Since: JPA 2.0

have its own table. Instead, the state of an instance is stored in the table or tables mapped by the owning entity. The persistent fields and properties of an embeddable class are mapped using the same mapping annotations used to map plain, and may themselves hold instances of embeddable types. An embeddable

This annotation must be specified for persistent map keys of type java.util.Date and java.util.Calendar . It may only be specified for map keys of these types. The MapKeyTemporal annotation can be applied to an element collection or relationship of type java.util. Map in conjunction with the ElementCollection

that the annotated persistent field or property of an entity class or mapped superclass is the composite ... and hashCode , defining value equality consistently with equality of the mapped primary key of the database table. The AttributeOverride annotation may be used to override the column mappings declared

with the SqlResultSetMapping or NamedNativeQuery annotation to map the SELECT clause of a SQL query to an entity result. If this annotation is used, the SQL statement should select all the columns that are mapped ... default {} Maps the columns specified in the SELECT list of the query to the properties or fields

.class The class of each query result. If a result set mapping is specified, the specified result class must agree with the type inferred from the result set mapping . If a resultClass is not explicitly specified, then it is inferred from the result set mapping , if any, or defaults to Object or Object

@JoinTable The join table that maps the relationship. The joinTable element must be specified if a join table is used in the overriding of the mapping of the relationship. The joinTable element must not be specified if a foreign key mapping is used in the overriding of the relationship. Since: JPA 2.0

of the persistent field or property of the associated entity that is used as the map key. Default: If the name element is not specified, the primary key of the associated entity is used as the map key. If the primary key is a composite primary key and is mapped as IdClass , an instance of the primary key class is used as the key. Since: JPA 1.0

to the same name as the primary key column of the primary table of the superclass ( JOINED mapping strategy); the same name as the primary key column of the primary table ( SecondaryTable mapping ); or the same name as the primary key column for the table for the referencing entity ( OneToOne mapping ). Since: JPA 1.0

of mapping of a persistent field or property to a single database column. The Basic annotation ... , the default values of the Basic annotation apply. The database column mapped by the persistent field ... generation to infer that the mapped column is not null . If not specified, defaults to true . Since: JPA 1.0

JPA Annotation ColumnResult Implemented Interfaces: Annotation Used in conjunction with the SqlResultSetMapping , NamedNativeQuery , or ConstructorResult annotation to map a column of the SELECT ... to which the column type is to be mapped . If the type element is not specified, the default JDBC type mapping for the column is used. Since: JPA 2.1

JPA Annotation Attribute in jakarta.persistence.AttributeOverride Column column default null (Required) The column that is being mapped to the persistent attribute. The mapping type will remain the same as is defined in the embeddable class or mapped superclass. Since: JPA 1.0

JPA Method in jakarta.persistence.EntityManager Map getProperties () The properties and hints and their associated values which are in effect for this entity manager. Modifying the contents of the returned map does not change the configuration in effect. Return: a map of properties and hints currently in effect Since: JPA 2.0

annotation when the element type of the collection is an enum type. An enum can be mapped as either a plain or an plain, where EnumType enumerates the available options. The mapping may be plain by ... Enumerated . Public Annotation Attributes EnumType value default ORDINAL (Optional) The type used in mapping an enum type. Since: JPA 1.0

JPA Method in jakarta.persistence.EntityManagerFactory Map getNamedEntityGraphs (   Class  entityType ) A map keyed by plain, containing every named plain whose entity type ... } meaning all entity graphs - the specified upper bound on the entity graph types Return: a map keyed by graph name Since: JPA 3.2

JPA Method in jakarta.persistence.EntityManagerFactory Map getNamedQueries (   Class  resultType ) A map keyed by plain, containing plain to every named query whose result type ... .class} meaning all queries - the specified upper bound on the query result types Return: a map keyed by query name Since: JPA 3.2

.InheritanceType Enumerated the options for mapping entity inheritance. See Also: Inheritance.strategy ... , with only the columns mapped to persistent fields and properties declared by the entity class. Each class in the hierarchy has its own table, but that table does not contain columns mapped to inherited fields or

relationship mappings other than the cases described here, the referenced column is in the table of the target entity. When used with a unidirectional OneToMany foreign key mapping , the referenced column ... is part of the inverse join definition. When used in a CollectionTable mapping , the referenced column is in the table

primary key type whose fields or properties map to the plain fields or properties of the annotated entity ... , and implement equals and hashCode , defining value equality consistently with equality of the mapped ... , and the specified primary key type must have fields or properties with matching names and types. The mapping

the inheritance mapping strategy for the entity class hierarchy which descends from the annotated entity class ... class hierarchy, the SINGLE_TABLE mapping strategy is used. Example: {@snippet ... .SINGLE_TABLE The inheritance mapping strategy for the entity inheritance hierarchy. Since: JPA 1.0

of the result set mappings to be used in mapping result sets returned by the stored procedure Return ... result set mapping of the given name does not exist (or the query execution will fail) Since: JPA 1.0

JPA Annotation Attribute in jakarta.persistence.MapKeyJoinColumns MapKeyJoinColumn [] value default null (Required) The map key join columns that are used to map to the entity that is the map key. Since: JPA 2.0