ObjectDB Database Search

; @ OneToMany (cascade=CascadeType.PERSIST, fetch=FetchType.EAGER)         ... ;     }         @ OneToMany (cascade=CascadeType ... only at the database id.   Second issue. The docs at: http://www.objectdb.com/api/java/jpa/ OneToMany state

has a OneToMany relationship to DataElement. Every relationship is eagerly fetched   Problem ... extends BaseCostElement { @ OneToMany (mappedBy = "parent" , fetch = FetchType. EAGER ) private List ... extends BaseCostElement { @ OneToMany (mappedBy = "parent" , fetch = FetchType. EAGER ) private List

a Parent class which contains List , marked with @ OneToMany . After persisting a Parent object, (in ... 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

annotating the map with @ OneToMany (fetch=FetchType.EAGER). Outside the DAO method only fields ... signingDate;     @ OneToMany (fetch=FetchType.EAGER, cascade=CascadeType ... class GuestHolder { // Persistent Fields: @Id @GeneratedValue Long id; @ OneToMany (fetch=FetchType

class A {         @ OneToMany (cascade=CascadeType.ALL)    ... ; static class A {         //@ OneToMany (fetch = FetchType.LAZY, cascade = CascadeType.ALL, mappedBy = "parent")         @ OneToMany (fetch

If I put the mappedBy element to the @ OneToMany , the owned side (the many side) will never persist ! for example @Entity public class Employee { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) public Long id; public String name; @ OneToMany (targetEntity=Address.class,mappedBy="employee

Serializable { (...) @ OneToMany (cascade = CascadeType.ALL) List entityCList; } Where EntityC is some ... ;@ OneToMany (cascade = CascadeType.ALL)     List embeddableBList; } It is not

hi, i'm still testing objectdb together with spring-data-jpa. i made a test which should simulate 4 requests 1. save entity 2. read an existing entity, add onetomany relation 3. read an existing entity, add another onetomany relation 4. read entity, get relations. i have the feeling this is not

;     optional=false, orphanRemoval=true) private Address address; @ OneToMany (mappedBy = "customer", fetch= FetchType.LAZY) private List itemList; @ OneToMany (mappedBy = "customer

{         @ OneToMany (cascade=CascadeType.PERSIST)    ... , to demonstrate the issue: @Entity public class Invoice { @ OneToMany (mappedBy = "invoice", fetch

invoices without items! Only invoices with items. When I remove mappedBy from @ OneToMany annotation ... public class Invoice { @ OneToMany (mappedBy = "invoice", fetch= FetchType.EAGER, orphanRemoval=true

String code;     @ OneToMany (mappedBy = "user") @MapKey     private Map ... code;         @ OneToMany (mappedBy = "project") @MapKey   

/ OneToMany state: "When the collection is a java.util.Map, the cascade element and the orphanRemoval ... .ALL on a OneToMany map, then the cascade ONLY applies to the values, NOT to the key. This means all keys

an unmapped @ OneToMany list is not still viewable, although a mapped @ OneToMany list is, which I

OK, I have a number of classes which are all subclasses of Entry (e.g., Folder, Link, Book). In the Folder class, there is a @ OneToMany Map children If I store something in that map ... ;         @ OneToMany (cascade=CascadeType.PERSIST)    

Hi, We have a problem where our database size grows over time more than expected. We've traced it down to the following issue: I have some entities that are using OneToMany relationship ... ;   @ OneToMany (cascade=CascadeType.ALL, fetch=FetchType.EAGER, orphanRemoval=true)  

In the following, Element is a base entity class, with a bi-directional @ManyToOne-@ OneToMany relationship Element owner - List ownedElements , and Example is a subclass entity with a relationship ... ();         @ OneToMany (mappedBy = "owner",     

.MapKeyTemporal; import javax.persistence. OneToMany ; import javax.persistence.Persistence; import javax ... ; @ OneToMany   @MapKeyTemporal(TemporalType.DATE)   private Map addressHistory = new HashMap

Hi, I'm trying to persists objects defined as follows: @Entity @Inheritance(strategy = InheritanceType.SINGLE_TABLE) public abstract class AbstractContainer { ... @ OneToMany (fetch = FetchType.LAZY ... ObjectDB tries to serialize the collection using ordinary Java serialization ignoring the @ OneToMany

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

serialVersionUID = 1L; @ManyToOne @Index private City city; @ OneToMany (mappedBy = "owner") private List ... serialVersionUID = 33L; @ OneToMany (mappedBy = "city") private List persons; @ManyToOne @Index private Person

the fetch join? If so should I do to all fields of List , ie OneToMany or ... do to all fields of List , ie OneToMany or should also be done for joins ? Grateful. rafael_moreira Rafael

LAZY to EAGER :     private @ OneToMany (fetch=FetchType.EAGER) List flags; According ... that the @ OneToMany works here? Thank you Flashbaer Flashbaer Joachim Beig Eclipse is right. It shouldn't

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

.persistence.Id; import javax.persistence. OneToMany ; import javax.persistence.Persistence; public ... ; int    id;     @ OneToMany (cascade = CascadeType.ALL, fetch = FetchType

;   @ OneToMany (orphanRemoval = true)         private Set ... , addresses=[Address{name='name_2'}, Address{name='name_3'}]} I'm try use  @ OneToMany (cascade

.persistence.MapKey; import javax.persistence. OneToMany ; import javax.persistence.Persistence; import javax ... {   @Id   @GeneratedValue   private long id;   @ OneToMany (fetch = FetchType.LAZY

.persistence. OneToMany ; import javax.persistence.Persistence; import org.junit.AfterClass; import org ... ;   @ OneToMany (fetch = FetchType.LAZY, cascade = CascadeType.ALL, mappedBy = "parent

how much collection1 items we have in the bag ? ( and no matter kind of JPA annotation @ OneToMany , @ManyToMany ... we have in the bag? ( and no matter kind of JPA annotation @ OneToMany , @ManyToMany

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

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

.persistence. OneToMany ; import javax.persistence.Table; import javax.persistence.Temporal; import javax ... ; @Embedded private Direccion direccion; @ OneToMany (mappedBy = "idAlumno") private List

am using in object declaration @ OneToMany (fetch=FetchType.EAGER, cascade = CascadeType.ALL) private ... @ OneToMany (fetch=FetchType.LAZY, cascade = CascadeType.ALL) private LinkedList referencedObj

(I've tried @ OneToMany , @Embedded and @ElementList) A role is a performer (I've tried inside that class ... of composers, list of tags and each of them are entity with @ OneToMany and are working fine (when I

we have a Parent and Child class with onetomany relation @Entity class Parent { @Id Long id; @ OneToMany (orphanRemoval = true, cascade = CascadeType.ALL) List children; } @Embeddable class Child{ @Id

    private long id;     @ OneToMany (fetch = FetchType.EAGER ... the Explorer. itsme Martin Petzold I have now changed to and it is working: @ OneToMany (fetch

  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

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

; @ OneToMany (mappedBy="ci") private List content; abstract class CIdata (@Inheritance(strategy=InheritanceType

will alway be empty after detaching. @ OneToMany (fetch = FetchType.EAGER, cascade = CascadeType

;   @ OneToMany (mappedBy="defect")     @OrderBy("seqRel, noteSeq

Do the following annotations @ OneToMany @ManyToOne @ManyToMany @OneToOne imply @Index   ? Thanks, Carl   FastModel Ben Schreiber Actually these annotations (except @ManyToMany ) should apply @Unique on the @One side. But ObjectDB doesn't apply these indexes automatically

Hi, We have a simple class that by itself contains (among others) a property pointing to a collection: class Bla {     @ OneToMany (cascade = CascadeType.ALL)     private List metaAttributes = new ArrayList (); } Now we do a simple em.persist(BlaInstance

as follows; @ OneToMany (cascade=CascadeType.ALL, mappedBy="z_component") @MapKey(name="z_schemeName ... static class A {         @ OneToMany (targetEntity = B.class, mappedBy ... .RemoteTestRunner.main(RemoteTestRunner.java:197)   As before a Map structure was being accessed. @ OneToMany

; } @Override public void setId(Long id) { this.id = id; } @ OneToMany (cascade={CascadeType.MERGE ... ; @ OneToMany (cascade={CascadeType.MERGE, CascadeType.PERSIST},        

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

    public static class MyEntity {         @ OneToMany (cascade=CascadeType ... {         @ OneToMany (cascade=CascadeType.PERSIST, fetch = FetchType.EAGER)  

Hello, I have a CUIT entity, with a OneToMany List field called razonesSociales (that can be null): @ OneToMany (mappedBy = "cuit") private List razonesSociales; When I run this query it works ok: SELECT COUNT(item.sysID) FROM CUIT item WHERE  ( (item.sysStatus.sysID=1)  AND 

, CascadeType.DETACH }) private ModelElementImpl element; @ OneToMany (fetch = FetchType.EAGER, cascade ... ModelElementImpl element; @ OneToMany (fetch = FetchType.EAGER, cascade = {CascadeType.REFRESH

Given a mappedBy association: e.g: @ OneToMany (mappedBy="department") public List employees;   creating a new mapped class, e.g. new Employee, won't result in this object being available in the same transaction: ie: for (Employee e : department.employee) won't include the new object