जेपीए समग्र कुंजी + अनुक्रम

Question

क्या यह एक समग्र कुंजी घोषित करने के लिए सादे जेपीए या जेपीए + हाइबरनेट एक्सटेंशन में संभव है, जहां समग्र कुंजी का एक तत्व अनुक्रम है?

यह मेरा समग्र वर्ग है:

@Embeddable 
public class IntegrationEJBPk implements Serializable { 

    //... 


    @ManyToOne(cascade = {}, fetch = FetchType.EAGER) 
    @JoinColumn(name = "APPLICATION") 
    public ApplicationEJB getApplication() { 
     return application; 
    } 


    @Column(name = "ENTITY", unique = false, nullable = false, insertable = true, updatable = true) 
    public String getEntity() { 
     return entity; 
    } 

    @GeneratedValue(strategy = GenerationType.AUTO, generator = "INTEGRATION_ID_GEN") 
    @SequenceGenerator(name = "INTEGRATION_ID_GEN", sequenceName = "OMP_INTEGRATION_CANONICAL_SEQ") 
    @Column(name = "CANONICAL_ID", unique = false, nullable = false, insertable = true, updatable = true) 
    public String getCanonicalId() { 
     return canonicalId; 
    } 

    @Column(name = "NATIVE_ID", unique = false, nullable = false, insertable = true, updatable = true) 
    public String getNativeId() { 
     return nativeId; 
    } 

    @Column(name = "NATIVE_KEY", unique = false, nullable = false, insertable = true, updatable = true) 
    public String getNativeKey() { 
     return nativeKey; 
    } 

    //... 
} 

मैं पहले से ही application, entity, nativeId और nativeKey के लिए मानों की आपूर्ति। मैं नीचे से एक की तरह एक इकाई का निर्माण करना चाहते हैं:

IntegrationEJB i1 = new IntegrationEJB(); 
i1.setIntegrationId(new IntegrationEJBPk()); 
i1.getIntegrationId().setApplication(app1); 
i1.getIntegrationId().setEntity("Entity"); 
i1.getIntegrationId().setNativeId("Nid"); 
i1.getIntegrationId().setNativeKey("NK"); 

और जब मैं em.persist(i1 कहते हैं), मैं चाहता हूँ कि canonicalId उत्पन्न होता है और एकीकरण डाला जाता है।

क्या यह संभव है? यदि हां, तो सरल तरीका क्या है? (मैं एप्लिकेशन द्वारा प्रदत्त कुंजी या मूल एसक्यूएल का उपयोग नहीं करना पसंद करता हूं)। इस तरह

Answer 1

मेरा मानना ​​है कि सादे जेपीए के साथ यह संभव नहीं है।

Answer 2

प्रयास करें:

@TableGenerator(name = "canonicalKeys", allocationSize = 1, initialValue = 1) 
@GeneratedValue(strategy = GenerationType.TABLE, generator = "canonicalKeys") 
@Column(name = "CANONICAL_ID", unique = false, nullable = false, insertable = true, updatable = true) 
public String getCanonicalId() { 
    return canonicalId; 
} 

बजाय एक दृश्य का उपयोग कर आप एक तालिका का उपयोग कर सकते की इस तरह।

Answer 3

मुझे लगता है कि यह आपकी example जैसी समग्र प्राथमिक कुंजी का निर्माण करता है। मैं अपने खुद के डेटाबेस में एक ऐसी ही समस्या पर poking रहा था मैंने सोचा अगर हो सकता है आप एसक्यूएल सीधे की तरह कह सकते हैं:

select nextval ('hibernate_sequence')

मैं हालांकि ;-)

Answer 4

@GeneratedValue का उपयोग करना है कि धोखा दे दिया जाएगा लगता है संयुक्त पीके के लिए जेपीए 2 spec के साथ निर्दिष्ट नहीं है।

जेपीए कल्पना से:

11.1.17 GeneratedValue एनोटेशन

GeneratedValue एनोटेशन प्राथमिक कुंजी के मूल्यों के लिए पीढ़ी रणनीतियों के विनिर्देश के लिए प्रदान करता है। जनरेटेड वैल्यू एनोटेशन प्राथमिक कुंजी प्रॉपर्टी या किसी इकाई या मैप किए गए सुपरक्लास पर आईडी एनोटेशन के संयोजन के साथ लागू किया जा सकता है। [9 7] जेनरेटेड वैल्यू एनोटेशन का उपयोग केवल सरल प्राथमिक कुंजी के लिए समर्थित होना आवश्यक है। का उपयोग जेनरेटेड वैल्यू एनोटेशन व्युत्पन्न प्राथमिक कुंजी के लिए समर्थित नहीं है।

नोट है कि एक अलग परिदृश्य के अंतर्गत, आप एक सरल पीके (@Id) @GeneratedValue का उपयोग करता है के साथ एक मूल इकाई हो सकता है, और फिर एक बच्चे इकाई एक समग्र पीके कि से उत्पन्न आईडी भी शामिल है कि है माता-पिता, प्लस एक और कॉलम।

• बच्चे को माता-पिता को एक @ManyToOne संबंध दें, ताकि उसे एफके कॉलम में जेनरेट की गई आईडी प्राप्त हो।
• फिर बच्चे को एक समग्र पीके दें, इकाई के खिलाफ निर्दिष्ट @IdClass के माध्यम से, साथ ही इकाई के भीतर दो @Id कॉलम दें।

@Entity 
public class ParentEntity { 

 @Id 
     @GenerateValue(IDENTITY) // If using DB auto-increment or similar 
     int id; 

     // ... 
} 

@Entity 
@IdClass(ChildId.class) 
public class ChildEntity { 
    // The child table will have a composite PK: 
    // (parent_ID, child_name) 
     @Id 
     @ManyToOne 
     int parentEntity; 

 @Id 
     String childName; 

     String favoriteColor; // plus other columns 

     // ... 

} 

// child Id attributes have the same name as the child entity 
// however the types change to match the underlying PK attributes 
// (change ParentEntity to int) 
public class ChildId implements Serializable { 

 int parentEntity; 
     String childName; 

     public ChildId() { //... } 

     // Add extra constructor & remove setter methods so Id objects are immutable 
     public ChildId(int parentEntity, String childName) { //... } 


     public int getParentEntity() { //... } 
     // make Id objects immutable: 
     // public void setParentEntity(int parentEntity) { //... } 
     public String getChildName() { //... } 
     // public void setChildName(String childName) { //... } 
}