ObjectDB Database Search

Well ! I think i pointed out a HUGE performance issue with mapped -by attribute (yeah again :( ). Here is the test case : 1- Create 100 000 entities with for each 1 entity with @OneToOne(mappedBy ... , go the MyEntity class and remove " mapped -by". You obtain 1 second max of query fetch. So my performance

Hello Support-Team, we have a problem with the enhancer. In the persistence.xml are two mapping -files: META-INF/orm.xml META-INF/ormreq.xml We start the enhancer and the entities of orm.xml ... Why the second mapping -file is ignored?   The unit test has following result, because not

Hi, In version 2.4.2, when an object in a list is reversed mapped to the owning object, queries are returning objects of types that were not specified in the query. In the attached example the last test fails because the query returns both TeamA and TeamB objects where only TeamA was specified in

accessing an object (a persistent map field according to the stack trace) when the connection to the database is closed. support Support

Hello, we want to execute following query: SELECT tc FROM TC tc WHERE ?1 MEMBER OF tc.testMacros.values() But we get an internal ObjectDB exception. It is possible to implement a query for this case at all?   @Entity public class TC { @OneToMany Map testMacros = new HashMap(); }   btc_es

Exception when querying Map property with @embedded & Enhancer enabled

Cascade delete with unidirectional mapping

Currently, collections can be edited but maps cannot be edited. For a database model that has a lot of static data that need to be entered into the database on multiple edits this presents as an inconvenience. It would be great, therefore, if we can edit maps straight from the explorer. Flying Banana Jiacong Xu

As demonstrated in this forum thread , a mapped by collection field with lazy fetch mode is not initialized in results of a query that uses JOIN FETCH on that collection field (when enhancement is used). support Support   Build 2.4.1_06 fixes this issue (fields are now initialized

: Annotation Target: Method, Field Specifies 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

, mapping to an intermediate table called the join table . Every many-to-many association ... , is specified on the owning side. The JoinTable annotation specifies a mapping to a database table ... collection is a Map , the cascade element applies to the map value. Defaults to no operations

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 ... must always exist. May be used in schema generation to infer that the mapped foreign key column

Interfaces: Annotation Target: Method, Field Supports composite map keys that reference entities ... Annotation Elements MapKeyJoinColumn[] value (Required) The map key join columns that are used to map to the entity that is the map key. Since: Jakarta Persistence (JPA) 1.0 ForeignKey foreignKey (Optional

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 entity classes

of an entity class or mapped superclass is the composite primary key of the entity. The type of the annotated ... with equality of the mapped primary key of the database table. The AttributeOverride annotation may be used to override the column mappings declared within the embeddable class. The MapsId annotation

. Since: Jakarta Persistence (JPA) 1.0 Expression get ( MapAttribute map ) Create a path corresponding to the referenced map -valued attribute. Parameters: map - map -valued attribute Returns: expression

( boolean createSchemas ) Create database objects mapped by entities belonging to the persistence unit ... dropSchemas ) Drop database objects mapped by entities belonging to the persistence unit, undoing ... the database tables mapped by entities belonging to the persistence unit, and then re-import

Type used to indicate a specific mapping of Date or Calendar . Deprecated: Newly-written code ... Persistable Types article explains how to use TemporalType . Enum Constants DATE Map as java.sql.Date Since: Jakarta Persistence (JPA) 1.0 TIME Map as java.sql.Time Since: Jakarta Persistence (JPA) 1.0

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

maps a unique foreign key relationship, either a foreign key column or columns with a unique constraint, or a relationship via a shared primary key. The JoinColumn annotation may be used to map the foreign key column or columns. Alternatively, an optional OneToOne association is sometimes mapped

) 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

) 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 or

. 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 / OneToMany

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

Jakarta Persistence (JPA) Method in jakarta.persistence.AttributeNode Map getKeySubgraphs() Return a map of subgraphs associated with this attribute node's map key. Returns: a Map of subgraphs associated with this attribute node's map key or an empty Map if none have been defined. Since: Jakarta Persistence (JPA) 1.0

: Annotation Target: Type Specifies a composite primary key type whose fields or properties map ... equality consistently with equality of the mapped primary key of the database table. The primary key fields ... properties with matching names and types. The mapping of fields or properties of the entity to fields or

, Serializable 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

: Annotation Target: Type Specifies the inheritance mapping strategy for the entity class hierarchy ... if no inheritance type is specified for an entity class hierarchy, the SINGLE_TABLE mapping strategy ... (JPA) 1.0 Annotation Elements InheritanceType strategy The inheritance mapping strategy

the mapping for an EmbeddedId primary key, an attribute within an EmbeddedId primary key, or ... ; ... @MapsId("empid") // maps the empid attribute of embedded id @ManyToOne Employee emp; } If a ManyToOne ... attribute corresponds. If not explicitly specified, the relationship maps the primary key of the entity

ConstructorResult annotation to map a column of the SELECT list of a SQL query. The name element references ... (JPA) 1.0 Class type (Optional) The Java type 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. Default: void/class

) EntityManager::refresh(Object, java.util. Map ) EntityManager::refresh(Object, LockModeType, java.util. Map ) EntityManager::lock(Object, LockModeType) EntityManager::lock(Object, LockModeType, java.util. Map ) Since: Jakarta Persistence (JPA) 1.0 Public Constructors EntityNotFoundException () Constructs

: Annotation Used in conjunction with the SqlResultSetMapping or NamedNativeQuery annotation to map ... should select all the columns that are mapped to the entity object. This should include foreign key ... [] fields Maps the columns specified in the SELECT list of the query to the properties or fields

is an enum type. An enum can be mapped as either a string or an integer , where EnumType enumerates the available options. The mapping may be explicitly specified by this annotation. If a persistent field or ... used in mapping an enum type. Default: ORDINAL Since: Jakarta Persistence (JPA) 1.0 Additional JDK

: Annotation Target: Method, Field The simplest type of mapping of a persistent field or property ... . The database column mapped by the persistent field or property may be specified using the Column ... and is disregarded for primitive types; it may be used in schema generation to infer that the mapped column

Jakarta Persistence (JPA) Method in jakarta.persistence.criteria.Path Expression get (    MapAttribute map ) Create a path corresponding to the referenced map -valued attribute. Parameters: map - map -valued attribute Returns: expression corresponding to the referenced attribute. Since: Jakarta Persistence (JPA) 1.0

Jakarta Persistence (JPA) Method in jakarta.persistence.criteria.CriteriaBuilder Expression values (    M map ) Create an expression that returns the values of a map . Parameters: map - map Returns: collection expression. Since: Jakarta Persistence (JPA) 1.0

Jakarta Persistence (JPA) Method in jakarta.persistence.criteria.CriteriaBuilder Expression keys (    M map ) Create an expression that returns the keys of a map . Parameters: map - map Returns: set expression. Since: Jakarta Persistence (JPA) 1.0

[] joinColumns 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

Jakarta Persistence (JPA) Method in jakarta.persistence.AttributeNode Map getSubgraphs() Return a map of subgraphs associated with this attribute node. Returns: a Map of subgraphs associated with this attribute node or an empty Map if none have been defined. Since: Jakarta Persistence (JPA) 1.0

Jakarta Persistence (JPA) Annotation Type jakarta.persistence.JoinColumns Implemented Interfaces: Annotation Target: Method, Field Specifies the mapping for composite foreign keys. This annotation ... Annotation Elements JoinColumn[] value The join columns that map the relationship. Since: Jakarta

) If the attribute references a Map type, this element can be used to specify a subgraph for the Key in the case of an Entity key type. A keySubgraph can not be specified without the Map attribute

to map the SELECT clause of a SQL query to a constructor. Applies a constructor for the target class ... ColumnResult[] columns (Required) The mapping of columns in the SELECT list to the arguments

mapping descriptor. The target type for a converter is determined by the actual type argument of the first ... must automatically apply the converter to every mapped attribute of the specified target type belonging to any

Jakarta Persistence (JPA) Annotation Type jakarta.persistence.DiscriminatorColumn Implemented Interfaces: Annotation Target: Type Specifies the discriminator column for the SINGLE_TABLE and JOINED inheritance mapping strategies . The mapping strategy and discriminator column are only specified

embeddable class . Must be specified if the collection is to be mapped by means of a collection table. The CollectionTable annotation specifies a mapping to a database table. Example: @Entity public class

Jakarta Persistence (JPA) Annotation Type jakarta.persistence.EntityListeners Implemented Interfaces: Annotation Target: Type Specifies the callback listener classes to be used for an entity or mapped superclass. This annotation may be applied to an entity class or mapped superclass. The specified

Persistence (JPA) 1.0 MapJoin correlate ( MapJoin parentMap ) Create a subquery map join object correlated to a map join object of the enclosing query. Parameters: parentMap - join object of the containing

Since: Jakarta Persistence (JPA) 1.0 LIST List-valued attribute Since: Jakarta Persistence (JPA) 1.0 MAP Map -valued attribute Since: Jakarta Persistence (JPA) 1.0 SET Set-valued attribute Since: Jakarta

) Since: Jakarta Persistence (JPA) 3.2 Public Instance Methods Map getHints () A map keyed by hint name

should be declared by the root entity class in an entity class hierarchy, or by one of its mapped superclasses. The Version field or property should be mapped to the primary table of the entity