ObjectDB Database Search

;ElementCollection , EAGER for Basic ). You may try using an @ElementCollection(fetch= FetchType .EAGER) and see if it is fast as @Basic support Support I tested it already with @ElementCollection(fetch= FetchType ... = FetchType .EAGER) , which may be more appropriate for maps that contain external relationships. support Support

It is possible to use lazy loading on fields of attached entities by several threads? Example: class EntityZ { @OneToOne(fetch = FetchType .LAZY) EntityX fieldX; @OneToOne(fetch = FetchType .LAZY) EntityY fieldY; @ElementCollection (fetch = FetchType .LAZY) List list; } We want to load the entity

    private long id;     @OneToMany(fetch = FetchType .EAGER ... ;@ManyToOne(fetch = FetchType .EAGER)     private Ticket ticket = null;     ... = FetchType .EAGER, cascade=CascadeType.ALL, orphanRemoval=true) @MapKey(name="state") @MapKeyEnumerated

to @OneToMany(fetch= FetchType .EAGER), the properties can be read. It seems to me that ObjectDB doesn't ... A { @Id @GeneratedValue Long id; @OneToMany(fetch= FetchType .LAZY, cascade=CascadeType.ALL) List list

you! But now I have to set fetchtype and cascadetype explicit (which is no problem), otherwise the List will alway be empty after detaching. @OneToMany(fetch = FetchType .EAGER, cascade = CascadeType

.persistence.Basic; import javax.persistence.Entity; import javax.persistence. FetchType ; import javax ... getSingleton() { return container; } } @ManyToOne(fetch= FetchType .LAZY) @Id private Container container

") public class Inspiration implements Serializable { (...) @ElementCollection(fetch = FetchType ... ") @ElementCollection(fetch = FetchType .EAGER) private List reviewSnippets; ...   Finally

allowIdWaitMe; @OneToOne(fetch = FetchType .EAGER) private Language mainLanguage; @OneToMany(fetch = FetchType .LAZY) private List languages; public final int getGid() { return gid; } public final void

Serializable, Convertable { (...) @ElementCollection(fetch = FetchType .EAGER) List productSets; @Embeddable public class ProductSet implements Serializable { @ManyToMany(fetch = FetchType .EAGER, cascade

Hello, I have question regarding OEM licence enhancement. @OneToMany(fetch = FetchType .EAGER, cascade = CascadeType.ALL) private SomeClass[] props; @OneToMany(fetch = FetchType .EAGER, cascade = CascadeType.ALL) private Map vars = new TreeMap (); Are these classes(SomeClass, SomeClass2), when not

siteAuth; private DialogAction currentDialogAction; @ManyToMany(fetch = FetchType .EAGER, cascade ... .PERSIST}) private Album mainAlbum; @OneToMany(mappedBy="person", fetch = FetchType .EAGER, cascade

LAZY to EAGER :     private @OneToMany(fetch= FetchType .EAGER) List flags; According ... make a difference for ObjectDB, but to remove this error / warning try: private @Basic(fetch= FetchType .EAGER) List flags; support Support

(name = "KEY_DESCRIPTOR") private AfwKeyDescriptor keyDescriptor; @OneToMany(fetch = FetchType .LAZY ... = FetchType .LAZY, cascade = CascadeType.ALL) private AfwCodedDataBlock codedDataBlock; private int level

; @OneToMany(fetch= FetchType .EAGER)     private ArrayList myCollection = new ArrayList ... ;            @OneToMany(fetch= FetchType .EAGER

.EntityManager; import javax.persistence.EntityManagerFactory; import javax.persistence. FetchType ; import javax ... ; int    id;     @OneToMany(cascade = CascadeType.ALL, fetch = FetchType

{ @MapsId @ManyToOne(fetch = FetchType .LAZY) private Merchant merchant; @MapsId @ManyToOne(fetch = FetchType .LAZY) private List stores; // Setter/Getter } So I wanted to add index on Customer for merchant

; @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, mappedBy="project",fetch = FetchType .LAZY)   ... = CascadeType.ALL, orphanRemoval = true, mappedBy="project",fetch = FetchType .LAZY)    

class Container {     @ElementCollection(fetch = FetchType .EAGER)     List   testlist1 = new LinkedList ();     @ElementCollection(fetch = FetchType .EAGER)    

through a collection field in another class that uses eager fetch: @OneToMany(fetch = FetchType .EAGER ... valid:     @OneToMany(fetch = FetchType .EAGER, cascade=CascadeType.PERSIST

(cascade=javax.persistence.CascadeType.ALL, fetch =   javax.persistence. FetchType .EAGER ... ;    fetch=javax.persistence. FetchType .EAGER)    @javax.persistence.JoinColumn

.FIELD) @Column (name = "uid") private String uid; @OneToOne (fetch = FetchType .EAGER, cascade ... = FetchType .EAGER, cascade = {CascadeType.REFRESH, CascadeType.DETACH }) private HashMap mappingMap = new

  v2.8.8_2 I have an entity that has 2 collection fields: @OneToMany(fetch = FetchType .EAGER)      Collection position;      @OneToMany(fetch = FetchType .EAGER)      Collection rotation ;   Now if I persist them so the values are: position

@GeneratedValue     private long id;     @ManyToMany(fetch = FetchType . EAGER , cascade ... = FetchType . EAGER , cascade={CascadeType. DETACH ,CascadeType. MERGE ,CascadeType. REFRESH }, mappedBy

() { return name; } public void setName(String name) { this.name = name; } @OneToMany(fetch= FetchType

(); private String text; @OneToMany(/*fetch= FetchType .LAZY, cascade=CascadeType.ALL, */mappedBy

.persistence. FetchType .EAGER) public List getPoints() { return points; }   public void setPoints

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

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

javax.persistence.CascadeType.*; import static javax.persistence. FetchType .*; @Entity public class

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,       

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

="parent",fetch= FetchType .EAGER) protected List Sons; function of checking: private static void

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

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

;(...)     @ManyToMany(targetEntity = Product.class, fetch = FetchType .LAZY)   

= Offer.class, mappedBy = "product", fetch = FetchType .LAZY, cascade = CascadeType.ALL) private Set offers

; @ElementCollection(fetch= FetchType .EAGER)     private List members = new ArrayList ();   

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

(targetEntity = Product.class, fetch = FetchType .LAZY) private List products; There is only 680

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

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

, cascade=CascadeType.ALL, fetch= FetchType .EAGER) private Object payload; @OneToOne(orphanRemoval=true, cascade=CascadeType.ALL, fetch= FetchType .EAGER) private Map metadata; ... In this case the "payload

, CascadeType.PERSIST}, mappedBy="account", fetch = FetchType .LAZY) @JoinColumn(name = "project_id", unique=true ... ;     mappedBy="account", fetch = FetchType .LAZY)      

.EntityManager; import javax.persistence.EntityManagerFactory; import javax.persistence. FetchType ; import ... {   @OneToMany(fetch = FetchType .LAZY, cascade = CascadeType.ALL, orphanRemoval = true)  

definitions are (for the null references above): ... @OneToMany(fetch= FetchType .LAZY) @Index public List actions = new ArrayList (); ... @OneToMany(fetch= FetchType .LAZY) @Index public List childNodes

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

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

I'm having an issue eager loading a nested map. I've attached @ManyToMany(fetch= FetchType .EAGER) attributes to no avail. If the map is viewed in the debugger or force iterated in the code it loads ok. The attached code attempts to replicate the scenario. Its not an exact match but is the best I

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