W Maven-Spring-Hibernate-MySql działającym w aplikacji internetowej Tomcat używam hibernate ddl do generowania mojego schematu DB z MySQL5InnoDBDialect.

Schemat jest generowany w porządku, z wyjątkiem opcji kaskadowej dla kluczy obcych. Na przykład mam tę strukturę:

Obiekt użytkownika, który przechowuje obiekt szczegółów użytkownika, oba udostępniają ten sam klucz:

@Entity
@Table(name = "Users")
public class User implements Serializable {

    private static final long serialVersionUID = -359364426541408141L;

    /*--- Members ---*/

    /**
     * The unique generated ID of the entity.
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "User_Id")
    protected long id;

    @Getter
    @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.EAGER, mappedBy = "user", optional = true)
    protected UserDetails userDetails;

...

}

A szczegóły użytkownika:

@Entity
@Table(name = "UserDetails")
public class UserDetails implements Serializable {

    private static final long serialVersionUID = 957231221603878419L;

    /*--- Members ---*/

    /**
     * Shared Key
     */
    @Id
    @GeneratedValue(generator = "User-Primary-Key")
    @GenericGenerator(name = "User-Primary-Key", strategy = "foreign", parameters = { @Parameter(name = "property", value = "user") })
    @Column(name = "User_Id")
    protected long id;

    @Getter
    @Setter
    @OneToOne(optional = false, fetch = FetchType.LAZY)
    @PrimaryKeyJoinColumn
    private User user;

...

}

Podczas generowania schematu kluczowi obcemu z tabeli szczegółów użytkowników do tabeli użytkowników brakuje kaskadowania.

Oto tworzenie schematu szczegółów użytkownika:

CREATE TABLE `userdetails` (
  `User_Id` bigint(20) NOT NULL,
  `Creation_Time` bigint(20) NOT NULL,
  `EMail` varchar(128) DEFAULT NULL,
  `Enabled` bit(1) NOT NULL,
  `First_Name` varchar(15) DEFAULT NULL,
  `Last_Name` varchar(25) DEFAULT NULL,
  `Password` varchar(64) NOT NULL,
  `User_Name` varchar(15) NOT NULL,
  PRIMARY KEY (`User_Id`),
  UNIQUE KEY `User_Name` (`User_Name`),
  UNIQUE KEY `EMail` (`EMail`),
  KEY `FKAE447BD7BF9006F5` (`User_Id`),
  CONSTRAINT `FKAE447BD7BF9006F5` FOREIGN KEY (`User_Id`) REFERENCES `users` (`User_Id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8$

Jak widzisz, w sekcji „KLUCZ ZAGRANICZNY” nie ma napisu „NA DELETE CASCADE”.

Ten problem jest również opisanytutaj itutaj także.

Próbowałem więc dodać adnotację @OnDelete nad członkiem userDetails bez powodzenia ..

Następnie stworzyłem własny dialekt, który nadpisuje narzędzie CascadeDelete:

public class MySql5Dialect extends MySQL5InnoDBDialect {

    public MySql5Dialect() {
    super();
    }

    @Override
    public String getTableTypeString() {
    return " ENGINE=InnoDB DEFAULT CHARSET=utf8";
    }

    @Override
    public boolean supportsCascadeDelete() {
    return true;
    }

}

Ale nadal bez zmian. Moja opcja kaskadowania klucza obcego nadal jest ustawiona na „RESTRICT” po wygenerowaniu schematu:

Czy istnieje sposób na rozwiązanie tego problemu (oczywiście nie ręcznie)?

AKTUALIZACJA

NastępującyAngel Villalainsugestia: Umieszczam adnotację @OnDelete powyżej elementu „user” klasy UserDetails, a to załatwiło sprawę relacji OneToOne, kasowanie jest kaskadowane, ale OnUpdate jest ustawione na ograniczenie (nadal), co prowadzi mnie do mojego pierwsze pytanie - co to znaczy? Mam na myśli, że „OnDelete” jest całkiem proste - kiedy usuwam rodzica, usuń również dziecko, ale jakie jest znaczenie opcji „OnUpdate”? Jak wpływa to na moją aplikację, gdy ustawiono ograniczenie / kaskadę?

Moje drugie pytanie dotyczy kaskadowania w relacji OneToMany. Moja klasa użytkownika zawiera wiele dostawców UserProvider. Poniższy kod pochodzi zUżytkownik klasa:

@OneToMany(fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true)
@JoinTable(name = "Users_Providers", joinColumns = @JoinColumn(name = "User_Id"), inverseJoinColumns = @JoinColumn(name = "Provider_Id"))
protected Set<UserProvider> userProviders = new HashSet<>(0);

A to jest relacja odwrotna odUserProvider klasa:

@ManyToOne(fetch = FetchType.LAZY)
@JoinTable(name = "Users_Providers", joinColumns = @JoinColumn(name = "Provider_Id", insertable = false, updatable = false), inverseJoinColumns = @JoinColumn(name = "User_Id"))
@OnDelete(action = OnDeleteAction.CASCADE)
protected User user;

Więc po użyciu adnotacji @OnDelete spodziewałem się zobaczyć opcję onDelete z kaskadą w tabeli łączenia, ale nie jest to :( Czy użyłem jej poprawnie?

Ostatnie pytanie - co z relacją jednokierunkową, taką jak @ElementCollection? MójDane użytkownika klasa przechowuje ElementCollection ról (każdemu użytkownikowi można przypisać jedną lub więcej ról):

@ElementCollection(fetch = FetchType.EAGER, targetClass = Role.class)
@CollectionTable(name = "Users_Roles", joinColumns = @JoinColumn(name = "User_Id", referencedColumnName = "User_Id"))
@Column(name = "Role")
protected Set<Role> roles = new HashSet<Enums.Role>(0);

Rola to tylko enum, a nie encja, dlatego nie mogę wskazać z powrotem roli do jednostki macierzystej. W tym przypadku, czy istnieje sposób na kaskadowanie onDelete?