ObjectDB Database Search

, the Metamodel is empty - none of the entities referenced in the mapping file are present in the Metamodel ... ;          The entities are mapped in the ORM.xml file correctly, as ... guidelines call for the xml mapping files only, and this is an important requirement. ObjectDB

Is there a way to create an Index with @Index on the key of a map ? wua Andreas Wurm Indexes on map keys as well as queries on map keys are currently not supported. But as a workaround you can use a collection of embedded objects, as demonstrated below: package test; import java.util.*; import

a .odb file.  The class contains a field that is as follows: private Map m_objectToPersist; I'm ... persistence capable classes). Support of map values which are collections is non standard ... .  SomeOtherTypeOfBeanList , and use  Map ). support Support

Hi, Is it ok to put list or map of embeddable objects in entity? I mean, for example : @Entity ... bList;     @Embedded     Map cMap; (...) } where Class_B and Class_C ... ; Thanks in advance for help. kborkowski Karol Borkowski Collections and maps of any persistable type

map types is not stable, we lost them sometimes after JVM restarted. Eager fetch is properly set ... is we confirm that the collection or map are stored successfully by using explorer tools when the JVM ... () of collection or map before closing the EntityManager, data can be retrieved successfully: 

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

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

. However, inverse ( mapped by) references that have to be loaded eagerly currently do not ... a separate client-server round trip. Future versions of ObjectDB should load eager mapped by (inverse) fields in bulk as well. support Support Bulk load of eager mapped by (inverse) singular references is now supported in build 2.4.4_13. support Support

, SIZE, MEMBER OF, IN) are currently not supported for mapped by (inverse) collections. These operations are supported for direct (not mapped by) collections. Navigation and JOIN is supported for both direct and mapped by collections. The following test case demonstrates a problematic query

Interfaces: Annotation Target: Method, Field Specifies the enum type for a map key whose basic type ... relationship of type Map , in conjunction with the ElementCollection , OneToMany , or ManyToMany annotation ... Map getEmployees() { ... } ... } See Also: ElementCollection OneToMany ManyToMany Since: Jakarta

Interfaces: Annotation Target: Method, Field This annotation must be specified for persistent map keys of type Date and 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 Map in conjunction

Interfaces: Annotation Target: Type Specifies a mapping of the columns of a result set of a native SQL ... mapping , and used to refer to it in the methods of the Query and StoredProcedureQuery APIs. Since: Jakarta Persistence (JPA) 1.0 EntityResult[] entities Specifies the result set mapping to entities

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 ... (JPA) 2.0 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

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 initial

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

: 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