Internal Website Search

exception. The same query in Explorer runs blazing fast (22ms) but I think it's because Explorer lazy ... ( setMaxResults ). Does that number affect? You may try running the query with a lazy fetch hint (as done by ... () objects? I will try lazy fetch hint, but as I understand it will run 50 queries find(Product

for you ... I have implemented a lazy left join fetch feature for all my collection beans. But ... in ... of lazy initialization. Left join is not enough mature in objectdb to use in a production environment ... with it. - Lazy load of all collections seems to be better than All eager strategy

. (Especially if using LAZY fetch sub object). Do I always just get the list of objects as it looks ... own defined as @OneToMany(fetch=FetchType. LAZY ) List bookList; (And in this example, there is only 1 object in ... the new book added by B?. And does this change if FetchType. LAZY changes to FetchType.EAGER? In a SQL

although the element collection is actually not load because it is a lazy field. Why we run into ... content still requires memory space. Lazy setting in JPA is considered as a hint to the implementation, but the implementation can still load content eagerly. ObjectDB follows the lazy setting hint

; @ManyToOne(fetch=FetchType. LAZY ) @MapsId("cont") private EContainer container; public EContainer ... () { return prnt; } } @EmbeddedId private ECompoundKeyMapSubItemId id; @ManyToOne(fetch=FetchType. LAZY ... =FetchType. LAZY ) private EContainer otherContainerRelationship; @Basic private String otherRelationshipKey

; static class A {         //@OneToMany(fetch = FetchType. LAZY , cascade ... = FetchType. LAZY , cascade = CascadeType.ALL)         private List ... ;      @ManyToOne(fetch = FetchType. LAZY , cascade = { CascadeType.ALL })  

. Then allow import of that file into another database. 2. Lazy loading of data, especially in table view ... : 2. Lazy loading of data Data is already loaded lazily. There is a problem when opening a table or

is LAZY ). There is a difference between using reflection mode and enhancement mode. In enhancement ... , but LAZY is only a tip for the implementation. support Support

only fields that have been loaded before detachment (e.g. defined as eager rather than lazy , or ... LAZY to EAGER :     private @OneToMany(fetch=FetchType.EAGER) List flags; According

{ .... @ManyToMany( fetch = FetchType. LAZY , cascade = CascadeType.PERSIST) private List transportationEvents ... _ORPHAN) private List conclusions = new ArrayList (); @ManyToMany( fetch = FetchType. LAZY , cascade

your server). The GC does seem very lazy , but it is unclear if this is the issue, as you have not reported ... ; OutOfMemoryError is thrown then this could be the normal ( lazy ) behaviour. Have you tried

;   @OneToMany(fetch = FetchType. LAZY , cascade = CascadeType.ALL, mappedBy = "parent ... ; @Id   @GeneratedValue   private long id;   @ManyToOne(fetch = FetchType. LAZY

{   @Id   @GeneratedValue   private long id;   @OneToMany(fetch = FetchType. LAZY ... long id;   @ManyToOne(fetch = FetchType. LAZY , cascade = { CascadeType.PERSIST, CascadeType.MERGE

are EAGER by default. They will be loaded lazily only if they are annotated as LAZY  explicitly ... ;colletions are to be lazy fetched. You can try this in a query.  "select n from Node n left outer

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

are executed in the Explorer in a special lazy mode, which is faster in returning the results ... ;  query.setHint("objectdb.result-fetch", " LAZY "); support Support Thank you, is where any

; ... @OneToMany(fetch=FetchType. LAZY ) public Set workflow = new HashSet (); When we remove an object ... remaining sceleton is still in the database and loaded by a subsequent lazy loading ? hgzwicker Hans

{ @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

(mappedBy = "customer", fetch= FetchType. LAZY ) private List itemList; @OneToMany(mappedBy = "customer", fetch= FetchType. LAZY ) private List otherItemList; ... getters and setters } Only address is filled

. LAZY , cascade = CascadeType.ALL) List aClasses; } Now, I want to fetch all B classes with all A classes skipping lazy loading: select b from B b join fetch b.aClasses After closing entity manager, B

" Boolean value wrapper BooleanValue entity. This is @OneToOne with explicit LAZY fetch. - A BooleanValue ... ' which is a "deep" Float value wrapper FloatQuantity entity. This is @OneToOne with explicit LAZY fetch

, what when we will have few milion records, how to handle this. Everything is set to lazy loading, we tried indexing ... the Explorer result data is always loaded lazily). You may execute queries in the application with lazy

of my entities from the database, I am working in a lazy loading context, I get an OutOfMemory Exception ... of accessing particular instances in the aforementioned lists (stored in said hashmaps) in a lazy loading

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

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

to LAZY . By doing that you instruct ObjectDB to return object IDs rather than full objects in query

Hi, I'm trying to persists objects defined as follows: @Entity @Inheritance(strategy = InheritanceType.SINGLE_TABLE) public abstract class AbstractContainer { ... @OneToMany(fetch = FetchType. LAZY , mappedBy="parent") private Set abstractContainers = com.google.common.collect.Sets

hint and check if it helps:  query.setHint("objectdb.result-fetch", " lazy

a (mostly) LAZY -only fetch policy across the system. Most of my EJB methods for querying are configurable

, rather than the annotated fields, as shown on the first post. Sorry, excuse lazy copy-and-paste

.       harald77 Harald The null and 0 values may be the result of lazy loading

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

("objectdb.result-fetch", " LAZY ");     return q.getResultList(); } btc_es BTC

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

. LAZY ) public Set getEmployees() { return employees; } public void setEmployees(Set employees

) @ElementCollection private Map values = new HashMap (); @OneToOne (fetch = FetchType. LAZY , cascade

". If you use version 2.3.4 then the output is "username". I think lazy fetching of primitive fields is a bit

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

: @OneToMany(cascade = {CascadeType.ALL}, fetch = FetchType. LAZY /*, mappedBy = "person"*/) private Set

we defined a composite index for class Action: @Index(name="ssst",members={"startDate","state","subType","type"}) and an index for the OneToMany @OneToMany(fetch=FetchType. LAZY ) @Index public List objectsInCharge = new ArrayList (); on running a query like select count(a) from Action a JOIN

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

Hi there, The upgrade to 2.4.1_02 fixed the initial problem, however there still seems to be an issue. To me it appears that Embeddable might be being lazy loaded, but I cannot be sure. I have attached a testcase demonstrating this issue. Its failing on the merge. Thanks P. pedwards Paul Edwards

objectdb.java.util.ArrayList cannot be disabled, as it is an essential feature that enables lazy partial

{ @ManyToOne (targetEntity = DataTypeImpl.class, cascade = {CascadeType.ALL }, fetch = FetchType. LAZY

, but I think still being better than using non- lazy data. elnll002 Facundo Curti

;    @OneToOne(fetch = FetchType. LAZY , cascade = CascadeType.ALL)     ... ;       @ManyToOne(fetch= FetchType. LAZY )       ... ;  @OneToOne(fetch = FetchType. LAZY , cascade = CascadeType.ALL)      

on an attempt to use a lazy collection that has not been loaded in a detached entity object. Build 2.3.1_03 ... is included now in build 2.3.2_01. Lazy collections will always hold a strong reference to the containing

{   @OneToMany(fetch = FetchType. LAZY , cascade = CascadeType.ALL, orphanRemoval = true)  

Added support of lazy loading of mapped by (inverse) singular relationships ( issue #768 ). Added support for using ObjectDB with TomEE / OpenEJB . Improved loading of eager mapped by (inverse) relationships ( issue #769 ). Improved performance of database file extending. Fixed a bug in ignoring

Fixed a bug in lazy loading of instances of non enhanced classes. Fixed a bug in using the Replayer with no updates to the database. Fixed an activation bug.