ObjectDB Database Search

= ChatAttachment.class, fetch = FetchType. EAGER ) private List attachments; private boolean isSystem; private

if neither objectdb nor JPA offers it). ouba64 Ouba Mahamane Lazy / Eager can only be set locally

rating in scale from 1.0 to 10.0 @ElementCollection(fetch = FetchType. EAGER ) List filterDescription

.com/forum/2032   support Support Setting the fetch type of the List to eager via annotation solved the problem. Thanks. Sweetwater Marc

Lai Yang Maybe you are trying to load the entire tree into memory. Try replacing EAGER with LAZY

public class Invoice { @OneToMany(mappedBy = "invoice", fetch= FetchType. EAGER , orphanRemoval=true

the new book added by B?. And does this change if FetchType.LAZY changes to FetchType. EAGER ? In a SQL

= FetchType. EAGER , cascade = CascadeType.ALL) private Map vars = new TreeMap

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

= ChatAttachment.class, fetch = FetchType. EAGER ) private List attachments; private boolean isSystem; private

do to keep the information? Unknown unknown Access it before closing the EntityManager or load it eagerly ( FetchType. EAGER

solutions in the ObjectDB case seem to be: 1. Use explicit FetchType. EAGER on all desired collections

= CascadeType.ALL, orphanRemoval = true, fetch = FetchType. EAGER )     @OrderBy

Hello! I'm very eager into starting migrating projects on Java 8. Before doing that, I would like to know if ObjectDB is tested and works without problems on Java 8. I would definitely not prefer to start discovering hidden bugs / strange behavior in my production apps. I look forward to hearing

= 6249921651146397564L; @OneToOne(cascade=CascadeType.REFRESH, fetch=FetchType. EAGER ) private TestEntity

{ @Id @GeneratedValue private long id; @OneToMany(fetch = FetchType. EAGER , cascade={CascadeType

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

my eagerness to test I think I need to do an audit on all criteria queries. Works well. Fetched

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

Hi Support,   We have a entity with an @Id entity which we then put into a list and store in an different entity inside a field defined as:   @OneToOne(orphanRemoval=true, cascade=CascadeType.ALL, fetch=FetchType. EAGER ) private Object payload; the list that we put in the 'payload

Hi, I came across a weird behavior when using fetch=FetchType.LAZY in a complex code. However I am  unable to reproduce the behavior in a simple code. The behavior is like below: 1. When I am using in object declaration @OneToMany(fetch=FetchType. EAGER , cascade = CascadeType.ALL) private

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

little as possible, would be appreciated.   milesdyson214 David Tyler Update...I got a bit eager

Hello. I have a Parent and Child entities. // in the parent @OneToMany(mappedBy = "parent", fetch = FetchType. EAGER , cascade = CascadeType.ALL) private List children; // in the child @ManyToOne private Parent parent; Somewhere I do this: parent.getChildren().remove(0); manager.merge(parent

the lazy settings look fine. Examining why eager load is used in your application will require posting

result loading. Loading the query results could be very slow if eager fetch is used extensively

. EAGER )     private List           

Hi, Given : @Entity(name = "Inspiration") public class Inspiration implements Serializable {     ....     @ManyToOne(fetch = FetchType. EAGER )     protected Atelier atelier;     .... } I have a query : SELECT i FROM Inspiration i WHERE i

I have the following property in my class "OtherType" with "MySuperType" (an interface) as the generic list type: @ElementCollection(fetch = FetchType. EAGER ) private List types  = null; Now I can use "instanceof" within a query in order to select only elements of the specific type

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

; @Basic(optional=false) private String name; @OneToOne(cascade= CascadeType.ALL, fetch= FetchType. EAGER

our code for 2.3.7_18, we had @OneToOne(cascade=CascadeType.ALL, fetch=FetchType. EAGER

long id;     @ElementCollection(fetch = FetchType. EAGER )     private

= FetchType. EAGER , orphanRemoval=true, cascade= CascadeType.ALL) private List itemList = new ArrayList

;  @OneToOne(fetch= EAGER , cascade=PERSIST) public Ostrich ostrich;     @ManyToMany

= FetchType. EAGER )     private List insurances = new ArrayList ();     public

case. Attached you can also find my database for testing hope that helps, we'd need an eager fix

applying nested eager fetch when enhancement is disabled. Fixed the "Annotated methods must follow the JavaBeans naming convention" exception ( issue #325 ).

Added support of DATE(...) and TIME(...) methods in queries. Added new Explorer and Server exe (for Windows 7 and 64 bits). Fixed handling a Calendar parameter value in criteria queries. Fixed using type operator and literals in client server queries ( issue #605 ). Fixed eager fetch issues. Fixed

String key;     @ElementCollection(fetch=FetchType. EAGER )    

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

objects in criteria queries . Improved Explorer performance by disabling EAGER fetch. Fixed critical

Added support for using ObjectDB with JBoss AS 6.0 / 6.1 . Fixed several bugs in handling eager fetch. Fixed a pessimistic locking bug . Fixed a bug in using primary key fields in queries. Fixed a bug in queries on deleted objects before commit / flush.

an entity after a failed find followed by persist. Fixed a memory leakage in eager load of large object

.run(Thread.java:662) These were unexpected as the objects should be eager loaded and existed

the problem. I've now added a FetchType of EAGER to the member to ensure a load takes place regardless

; @ElementCollection(fetch = EAGER )     @Column(name = "DATA_VALUE")   

Added an option to slow backup (see  feature request #2681 ). Added an option to view old type versions in the Explorer (-Dobjectdb.ui.debug=true) Improved the Doctor (see  issue #2691 ). Improved performance following a large eager fetch ( issue #2694 ). Restricted waiting time

trouble with eager loading but either way there should definitely be an object there. No exceptions

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