ObjectDB Database Search

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

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

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)    

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

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

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

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

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

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

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

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

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

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

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

;  private Municipio lugarNacimiento;         @ OneToMany (mappedBy

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

: 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

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

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

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

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

myEntity2;       @ OneToMany     private List list; } btc_es BTC

; } @ OneToMany (cascade = CascadeType.ALL) public Map map = new HashMap (); } @Entity public static class

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

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

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

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

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

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

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

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

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

= {CascadeType.REFRESH, CascadeType.DETACH }) private ModelElementImpl element; @ 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

@GeneratedValue private long id; private String reqLevelName = "DEF"; @ OneToMany (mappedBy

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

When I remove an object from a class it get's removed but the other objects that had that object as an attribute still keep it although I am using @ OneToMany (cascade=CascadeType.ALL) This is what it remains when I check the removed object from another object's attributes     Unknown

and therefore excluded (as optimisation) from automatic cascading. You can also try @ OneToMany (fetch

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

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

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

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

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

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

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

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

;           @ OneToMany (cascade=CascadeType.PERSIST)  

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

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