Hibernate Registro pai e excluido junto com todos registros filhos [Resolvido]

Assuntos Gerais
#1

Boa noite amigos, estou com dificuldades ao entender o funcionamento do hibernate a respeito de chaves estrangeiras
eu tenho duas tabelas uma vinculada a outra “CIDADE e UF” quando eu deleto um registro da table uf cujo tem outros registro na table cidade vinculados a uf que desejo excluir ele não da erro alguma simplesmente excluir o registro pai e todos os registros filhos não sei como corrigir isso amigos.
estou utilizando o MySQL Server 5.5

aqui vai o SQL das tables

-- -----------------------------------------------------
-- Table `mg3_server`.`uf`
-- -----------------------------------------------------
CREATE  TABLE IF NOT EXISTS `mg3_server`.`uf` (
  `iduf` INT NOT NULL AUTO_INCREMENT ,
  `uf_codigo` VARCHAR(5) NOT NULL ,
  `uf_nome` VARCHAR(45) NOT NULL ,
  `uf_sigla` VARCHAR(45) NOT NULL ,
  PRIMARY KEY (`iduf`) )
ENGINE = InnoDB;


-- -----------------------------------------------------
-- Table `mg3_server`.`cidade`
-- -----------------------------------------------------
CREATE  TABLE IF NOT EXISTS `mg3_server`.`cidade` (
  `idcidade` INT NOT NULL ,
  `cod_tbuf` INT NOT NULL ,
  `cidade_sigla_uf` VARCHAR(45) NULL ,
  `cidade_nome` VARCHAR(75) NULL ,
  PRIMARY KEY (`idcidade`) ,
  INDEX `fk_cod_tbuf` (`cod_tbuf` ASC) ,
  CONSTRAINT `fk_cod_tbuf`
    FOREIGN KEY (`cod_tbuf` )
    REFERENCES `mg3_server`.`uf` (`iduf` )
    ON DELETE RESTRICT
    ON UPDATE RESTRICT)
ENGINE = InnoDB;

aqui segue o código da classe de mapeamento da table cidade e uf


//classe cidade

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package controller;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.io.Serializable;
import javax.persistence.*;

/**
 *
 * @author WILLIAN
 */
@Entity
@Table(name = "cidade", catalog = "mg3_server", schema = "")
@NamedQueries({
    @NamedQuery(name = "Cidade.findAll", query = "SELECT c FROM Cidade c"),
    @NamedQuery(name = "Cidade.findByIdcidade", query = "SELECT c FROM Cidade c WHERE c.idcidade = :idcidade"),
    @NamedQuery(name = "Cidade.findByCidadeSiglaUf", query = "SELECT c FROM Cidade c WHERE c.cidadeSiglaUf = :cidadeSiglaUf"),
    @NamedQuery(name = "Cidade.findByCidadeNome", query = "SELECT c FROM Cidade c WHERE c.cidadeNome = :cidadeNome")})
public class Cidade implements Serializable {
    @Transient
    private PropertyChangeSupport changeSupport = new PropertyChangeSupport(this);
    private static final long serialVersionUID = 1L;
    @Id
    @Basic(optional = false)
    @Column(name = "idcidade")
    private Integer idcidade;
    @Column(name = "cidade_sigla_uf")
    private String cidadeSiglaUf;
    @Column(name = "cidade_nome")
    private String cidadeNome;
    @JoinColumn(name = "cod_tbuf", referencedColumnName = "iduf")
    @ManyToOne(optional = false)
    private Uf codTbuf;

    public Cidade() {
    }

    public Cidade(Integer idcidade) {
        this.idcidade = idcidade;
    }

    public Integer getIdcidade() {
        return idcidade;
    }

    public void setIdcidade(Integer idcidade) {
        Integer oldIdcidade = this.idcidade;
        this.idcidade = idcidade;
        changeSupport.firePropertyChange("idcidade", oldIdcidade, idcidade);
    }

    public String getCidadeSiglaUf() {
        return cidadeSiglaUf;
    }

    public void setCidadeSiglaUf(String cidadeSiglaUf) {
        String oldCidadeSiglaUf = this.cidadeSiglaUf;
        this.cidadeSiglaUf = cidadeSiglaUf;
        changeSupport.firePropertyChange("cidadeSiglaUf", oldCidadeSiglaUf, cidadeSiglaUf);
    }

    public String getCidadeNome() {
        return cidadeNome;
    }

    public void setCidadeNome(String cidadeNome) {
        String oldCidadeNome = this.cidadeNome;
        this.cidadeNome = cidadeNome;
        changeSupport.firePropertyChange("cidadeNome", oldCidadeNome, cidadeNome);
    }

    public Uf getCodTbuf() {
        return codTbuf;
    }

    public void setCodTbuf(Uf codTbuf) {
        Uf oldCodTbuf = this.codTbuf;
        this.codTbuf = codTbuf;
        changeSupport.firePropertyChange("codTbuf", oldCodTbuf, codTbuf);
    }

    @Override
    public int hashCode() {
        int hash = 0;
        hash += (idcidade != null ? idcidade.hashCode() : 0);
        return hash;
    }

    @Override
    public boolean equals(Object object) {
        // TODO: Warning - this method won't work in the case the id fields are not set
        if (!(object instanceof Cidade)) {
            return false;
        }
        Cidade other = (Cidade) object;
        if ((this.idcidade == null && other.idcidade != null) || (this.idcidade != null && !this.idcidade.equals(other.idcidade))) {
            return false;
        }
        return true;
    }

    @Override
    public String toString() {
        return "view.Cidade[ idcidade=" + idcidade + " ]";
    }

    public void addPropertyChangeListener(PropertyChangeListener listener) {
        changeSupport.addPropertyChangeListener(listener);
    }

    public void removePropertyChangeListener(PropertyChangeListener listener) {
        changeSupport.removePropertyChangeListener(listener);
    }
    
}


//classe uf

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package controller;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.io.Serializable;
import java.util.List;
import javax.persistence.*;

/**
 *
 * @author WILLIAN
 */
@Entity
@Table(name = "uf", catalog = "mg3_server", schema = "")
@NamedQueries({
    @NamedQuery(name = "Uf.findAll", query = "SELECT u FROM Uf u"),
    @NamedQuery(name = "Uf.findByIduf", query = "SELECT u FROM Uf u WHERE u.iduf = :iduf"),
    @NamedQuery(name = "Uf.findByUfCodigo", query = "SELECT u FROM Uf u WHERE u.ufCodigo = :ufCodigo"),
    @NamedQuery(name = "Uf.findByUfNome", query = "SELECT u FROM Uf u WHERE u.ufNome = :ufNome"),
    @NamedQuery(name = "Uf.findByUfSigla", query = "SELECT u FROM Uf u WHERE u.ufSigla = :ufSigla")})
public class Uf implements Serializable {
    @Transient
    private PropertyChangeSupport changeSupport = new PropertyChangeSupport(this);
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Basic(optional = false)
    @Column(name = "iduf")
    private Integer iduf;
    @Basic(optional = false)
    @Column(name = "uf_codigo")
    private String ufCodigo;
    @Basic(optional = false)
    @Column(name = "uf_nome")
    private String ufNome;
    @Basic(optional = false)
    @Column(name = "uf_sigla")
    private String ufSigla;
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "codTbuf")
    private List<Cidade> cidadeList;

    public Uf() {
    }

    public Uf(Integer iduf) {
        this.iduf = iduf;
    }

    public Uf(Integer iduf, String ufCodigo, String ufNome, String ufSigla) {
        this.iduf = iduf;
        this.ufCodigo = ufCodigo;
        this.ufNome = ufNome;
        this.ufSigla = ufSigla;
    }

    public Integer getIduf() {
        return iduf;
    }

    public void setIduf(Integer iduf) {
        Integer oldIduf = this.iduf;
        this.iduf = iduf;
        changeSupport.firePropertyChange("iduf", oldIduf, iduf);
    }

    public String getUfCodigo() {
        return ufCodigo;
    }

    public void setUfCodigo(String ufCodigo) {
        String oldUfCodigo = this.ufCodigo;
        this.ufCodigo = ufCodigo;
        changeSupport.firePropertyChange("ufCodigo", oldUfCodigo, ufCodigo);
    }

    public String getUfNome() {
        return ufNome;
    }

    public void setUfNome(String ufNome) {
        String oldUfNome = this.ufNome;
        this.ufNome = ufNome;
        changeSupport.firePropertyChange("ufNome", oldUfNome, ufNome);
    }

    public String getUfSigla() {
        return ufSigla;
    }

    public void setUfSigla(String ufSigla) {
        String oldUfSigla = this.ufSigla;
        this.ufSigla = ufSigla;
        changeSupport.firePropertyChange("ufSigla", oldUfSigla, ufSigla);
    }

    public List<Cidade> getCidadeList() {
        return cidadeList;
    }

    public void setCidadeList(List<Cidade> cidadeList) {
        this.cidadeList = cidadeList;
    }

    @Override
    public int hashCode() {
        int hash = 0;
        hash += (iduf != null ? iduf.hashCode() : 0);
        return hash;
    }

    @Override
    public boolean equals(Object object) {
        // TODO: Warning - this method won't work in the case the id fields are not set
        if (!(object instanceof Uf)) {
            return false;
        }
        Uf other = (Uf) object;
        if ((this.iduf == null && other.iduf != null) || (this.iduf != null && !this.iduf.equals(other.iduf))) {
            return false;
        }
        return true;
    }

    @Override
    public String toString() {
        return "view.Uf[ iduf=" + iduf + " ]";
    }

    public void addPropertyChangeListener(PropertyChangeListener listener) {
        changeSupport.addPropertyChangeListener(listener);
    }

    public void removePropertyChangeListener(PropertyChangeListener listener) {
        changeSupport.removePropertyChangeListener(listener);
    }
    
}
#2

@OneToMany(cascade = CascadeType.ALL, mappedBy = “codTbuf”)

O CascadeType.ALL fala que qualquer alteração feita através da tabela UF será refletida nesse relacionamento.
Por este motivo os registros filhos são excluídos.

#3

Como resolvo isso então ?

#4

@OneToMany(mappedBy = “codTbuf”)

Eu deixaria assim, não vejo motivo para alterar uma cidade através da instancia de uf, e criaria uma FK para que não ficasse registros órfãos na entidade cidade.

#5

Então amigo mas como vc viu ai o SQL das entidades eu uso como FK na entidade Cidade o codTbUF, não entendi a questão que criar outra FK para não deixar registros orfão.

#6

Se você já tem uma FK pra isso ótimo, então é só mudar a anotação mesmo.

#7

Obrigado amigo dela explicação e ajuda… deu certinho como eu queria…

#8