@OneToMany mit @JoinTable Fehler

Question

Ich versuche **@OneToMany** mit **@JoinTable** für solche scenerio

Ich bin mit JPA 2.1, Hibernate 5.0.4 und Oracle 11 XE zu verstehen. Wenn ich userDao.save(user) nennen (Code unten) Ich habe

bekam

java.sql.SQLIntegrityConstraintViolationException: ORA-00001: unique constraint (HIBERNATE.USER2ORDER_PK) violated 

Was mache ich falsch? Könnte mir jemand helfen, das zu verstehen?

DDL:

DROP TABLE HIBERNATE.T_USER2ORDERS; 
DROP TABLE HIBERNATE.T_ORDERS; 
DROP TABLE HIBERNATE.T_USERS; 
DROP SEQUENCE HIBERNATE.USERS_SEQ; 
DROP SEQUENCE HIBERNATE.ORDERS_SEQ; 

CREATE TABLE HIBERNATE.T_USERS (
    ID        NUMBER(15), 
    NAME        VARCHAR2(100 CHAR), 
    CONSTRAINT USER_PK PRIMARY KEY (ID) 
); 

CREATE TABLE HIBERNATE.T_ORDERS (
    ID        NUMBER(15), 
    ORDER_DETAILS      VARCHAR2(100 CHAR) NOT NULL, 
    CONSTRAINT UDETAILS_PK PRIMARY KEY (ID) 
); 

CREATE TABLE HIBERNATE.T_USER2ORDERS (
    ID_USER       NUMBER(15) NOT NULL, 
    ID_ORDER       NUMBER(15) NOT NULL, 
    CONSTRAINT USER2ORDER_PK PRIMARY KEY (ID_USER), 
    CONSTRAINT USER_FK FOREIGN KEY (ID_USER) REFERENCES T_USERS(ID), 
    CONSTRAINT ORDER_FK FOREIGN KEY (ID_ORDER) REFERENCES T_ORDERS(ID) 
); 

CREATE SEQUENCE HIBERNATE.USERS_SEQ START WITH 1 INCREMENT BY 1 NOCACHE NOCYCLE; 
CREATE SEQUENCE HIBERNATE.ORDERS_SEQ START WITH 1 INCREMENT BY 1 NOCACHE NOCYCLE; 

Dao:

@Repository 
@Transactional 
public class UserDaoImpl extends HibernateDaoSupport implements UserDao { 

    public static final Logger LOG = LoggerFactory.getLogger(UserDaoImpl.class); 

    @Autowired 
    public UserDaoImpl(SessionFactory sessionFactory) { 
     setSessionFactory(sessionFactory); 
    } 

    @Override 
    public Serializable save(UserModel user) { 
     return getHibernateTemplate().save(user); 
    } 
} 

UserModel:

@Entity 
@Table(name = "T_USERS") 
@SequenceGenerator(name = "users-sequence-generator", sequenceName = "USERS_SEQ", initialValue = 0, allocationSize = 1) 
public class UserModel { 

    @Id 
    @Column(name = "id") 
    @GeneratedValue(generator = "users-sequence-generator", strategy = GenerationType.SEQUENCE) 
    private Long id; 

    @Column(name = "name") 
    private String name; 

    @OneToMany(
      cascade = CascadeType.ALL, 
      orphanRemoval = true, 
      fetch = FetchType.EAGER) 
    @JoinTable(
     name="t_user2orders", 
     joinColumns = {@JoinColumn(name="id_user", referencedColumnName="id")}, 
     inverseJoinColumns = {@JoinColumn(name="id_order", referencedColumnName="id")} 
    ) 
    private Collection<OrderModel> orders = new LinkedHashSet<>(); 

    public Long getId() { 
     return id; 
    } 

    public void setId(Long id) { 
     this.id = id; 
    } 

    public String getName() { 
     return name; 
    } 

    public void setName(String name) { 
     this.name = name; 
    } 

    public Collection<OrderModel> getOrders() { 
     return orders; 
    } 

    public void setOrders(Collection<OrderModel> orders) { 
     this.orders = orders; 
    } 
} 

OrderModel:

@Entity 
@Table(name="T_ORDERS") 
@SequenceGenerator(name="orders-sequence-generator", sequenceName="ORDERS_SEQ", initialValue=0, allocationSize=1) 
public class OrderModel { 

    @Id 
    @Column(name="id") 
    @GeneratedValue(generator="orders-sequence-generator", strategy=GenerationType.SEQUENCE) 
    private Long id; 

    @Column(name="order_details") 
    private String orderDetails; 

    public Long getId() { 
     return id; 
    } 

    public void setId(Long id) { 
     this.id = id; 
    } 

    public String getOrderDetails() { 
     return orderDetails; 
    } 

    public void setOrderDetails(String orderDetails) { 
     this.orderDetails = orderDetails; 
    } 
} 

Answer 1

Dank den Vorschlägen von @tharindu_DG habe ich einen Fehler gefunden.

Eindeutige Einschränkung für T_USER2ORDERS war ungültig.

sein CONSTRAINT USER2ORDER_PK PRIMARY KEY (ID_USER) sollte stattdessen CONSTRAINT USER2ORDER_PK PRIMARY KEY (ID_ORDER)

Dank für die Hilfe.

Answer 2

Die eindeutige Einschränkung beim Zusammenführen der Tabelle USERS2ORDERS sollte einen Primärschlüssel als Kombination der beiden Felder user_id und order_id enthalten. Es wird jedoch empfohlen, einen Primärschlüssel als record_id zu haben, Sie wissen nicht, wann Sie ihn verwenden können.