ObjectDB Database Search

(TimePeriod id) { this.id = id; }   @ OneToMany (cascade=javax.persistence.CascadeType.ALL,fetch=javax

Given that the default seems to be FetchType.LAZY for all collections @ OneToMany and @ManyToMany. Such as a configuration option. Instead of having to explicitly set fetch in annotation code in every relationship. webel Dr Darren Kelly No. There is no such configuration option, since having EAGER

Dear all, I have entities Invoice and InvoiceItem, their relation is defined: public class Invoice implements Serializable { ... @ OneToMany (mappedBy="invoice", fetch=FetchType.EAGER,              orphanRemoval=true, cascade=CascadeType

id; @ OneToMany (mappedBy = "customer",fetch= FetchType.EAGER,       

) private int id; @ManyToOne @JoinColumn(name="parent") protected Nodes parent; @ OneToMany (mappedBy

Hello, I am getting a "java.lang.IllegalArgumentException: Can not set java.util.TreeSet field Message.children to java.util.HashSet" when persisting a Message object with a parent/children relationship: @ManyToOne private Message parent; @ OneToMany (mappedBy = "parent") private TreeSet children

annotations like " OneToMany " and "ManyToOne", but the result is the same. What am I supposed

adding an annotation to a reference:   @ OneToMany (cascade=CascadeType.PERSIST)   

bookTitle; @ OneToMany (cascade= CascadeType.ALL, fetch= FetchType.EAGER) private List chapters; The Chapter

class MyEntity { @ OneToMany (mappedBy="myentity") ArrayList others = new ArrayList (); void

the relationships OneToMany and ManyToMany? I want to see a working example :-) Robin_2005 Kompan Serge

(I had raised this issue in the past and have finally had time to come back to it and strip down the classes to a minimum). The problem seems to lie in having bidirectional links (viz, I have @ OneToMany Map children and @ManyToOne Entry parent in my classes. I've attached the offending classes

Hi, I have a question about detaching objects after issuing query with JOIN FETCH. Let's say I have two classes: public class A { @ManyToOne B bClass } public class B { @ OneToMany (fetch = FetchType.LAZY, cascade = CascadeType.ALL) List aClasses; } Now, I want to fetch all B classes

allowIdWaitMe; @OneToOne(fetch = FetchType.EAGER) private Language mainLanguage; @ OneToMany (fetch

Hi, I have found a strange behavior when merging entities with "mapped by" set on @ OneToMany relation. Even if object is fetched with find on the same transaction, merge is very slow. It's because on merge every single relation marked as LAZY is fetch from database. Attached two examples

hi,   what is the purpose of annotating a field with a RDB relationship shuch as OneToMany . ManyToMany etc? sprintf Reuben Alfred Using these annotations is optional in ObjectDB but required by standard JPA. You still need these annotations in ObjectDB to specify cascading / fetch policy and other settings. support Support

I'm having an issue with my application, and I'm hoping you guys will be able to help. Please forgive typos and obvious errors, I'm having to retype from a non-internet connected network. A contrived example is: @Entity public class Salesman { private String name; @ OneToMany (fetch=FetchType.EAGER

String mailAddress; @OneToOne private Settings settings; private String phoneNumber; @ OneToMany

own defined as @ OneToMany (fetch=FetchType.LAZY) List bookList; (And in this example, there is only 1 object in

;  private Municipio lugarNacimiento;         @ OneToMany (mappedBy

to remove the object ... ? In my opinion, one child ( a list ) with OneToMany and orphanRemoval

// enhanced entity public final class Test { // non enhanced entity Internal @ OneToMany (fetch

I have created following entity class with custom fields @Entity public class AfwDataKey { @Id @GeneratedValue @Column(name = "KEY_ID") private long id; private Long timestamp; @ManyToOne @Column(name = "KEY_DESCRIPTOR") private AfwKeyDescriptor keyDescriptor; @ OneToMany (fetch = FetchType.LAZY

"}),}) public class Unit implements Serializable, Comparable { ... @ OneToMany (mappedBy = "unit", cascade

; ... @ OneToMany (fetch=FetchType.LAZY) public Set workflow = new HashSet (); When we remove an object

Hello. I have a class Thing that contains OneToMany list of classes Photo. Photo contains  @Lob @Basic(fetch = FetchType.LAZY) private byte[] content; And after some queries with Thing (but without loading content of the photos) I get java.lang.OutOfMemoryError: Java heap space

; @ OneToMany (targetEntity = Noticia.class, mappedBy = "categorias", cascade = CascadeType.PERSIST

javax.persistence.FlushModeType; import javax.persistence. OneToMany ; import javax.persistence

: FAILS on @ OneToMany with @TableGenerator/strategy = GenerationType.TABLE (www.objectdb.com

Hello, is there a way that lifecycle events like prepersist or preupdate are also fired for embeddable classes, not just for entities? My case looks as follows: @Entity public class Foo { @Id @GeneratedValue private Long id; private String description; @ OneToMany (cascade = CascadeType.ALL, fetch

(); emf.close(); } @Entity public static class A { @ OneToMany (mappedBy="a", cascade=CascadeType

hints? The Mapping of class Modell and its member: @Entity class Modell { ... @ OneToMany (fetch

Dear Sirs, I have an object A, that has a OneToMany FetchType.EAGER List of objects B, that has a field with a reference to an object C. I have this code: ClassA objectA = em.find(ClassA.class, 1); for (ClassB objectB : objectA.getListB()) {     ClassC objectC = objectB

myEntity2;       @ OneToMany     private List list; } btc_es BTC

markedDeleted = false;   @ManyToOne   private Project project;   @javax.persistence. OneToMany

.handleOrphans(Entity.java:170) This happens when I try to read a @ OneToMany list collection

This issue maybe related to issue #110 (http://www.objectdb.com/database/issue/110). Because that issue has been closed as "fixed", I am reporting this new issue. This is my class definition: @Entity public abstract class Person {     @ OneToMany (fetch=FetchType.EAGER, cascade

") @GeneratedValue(strategy = GenerationType.AUTO) private Long id; @ OneToMany (fetch=FetchType.LAZY,cascade

= GenerationType.AUTO) private Long id; @ OneToMany (fetch=FetchType.LAZY,cascade=CascadeType.ALL, mappedBy

    @GeneratedValue     private long id;     @ OneToMany

; } @ OneToMany (cascade=javax.persistence.CascadeType.ALL,fetch=javax.persistence.FetchType.EAGER

;           @ OneToMany (cascade=CascadeType.PERSIST)  

to in the first exception is stored in a HashMap object within the parent entity: @ OneToMany

;       @ OneToMany (cascade= CascadeType.ALL, fetch= FetchType.EAGER

;   private String name = null;         @ OneToMany

id = 1;         @ OneToMany (fetch=FetchType.EAGER)   

.persistence. OneToMany ; import javax.persistence.Persistence; import javax.persistence.Tuple; import javax

;    @ OneToMany (mappedBy="a")         ArrayList list

and annotations: @ OneToMany (fetch = FetchType.EAGER, mappedBy = "jobInfoId")  // relation

= Payment.Periodicity.QUARTERLY;     @ OneToMany (mappedBy = "customer", fetch