标签: cascade

我有两个表:orders和orders_items.两者共享字段orderID.

我想删除orderID = 500的两个表中的所有行,但我只需要在一个查询中执行此操作.这可能吗？

我一直在分析一个与特别慢的删除操作相关的系统中反复发生的"错误报告"(性能问题).长话短说:CASCADE DELETE关键似乎主要是负责任的,我想知道(a)这是否有意义,以及(b)为什么会这样.

我们有一个架构,比如说,小部件,那些位于相关表和相关相关表的大图的根部,等等.要非常清楚,主动不鼓励从此表中删除; 这是"核选择",用户并没有相反的幻想.然而,有时候必须这样做.

架构看起来像这样:

Widgets
   |
   +--- Anvils [1:1]
   |    |
   |    +--- AnvilTestData [1:N]
   |
   +--- WidgetHistory (1:N)
        |
        +--- WidgetHistoryDetails (1:N)

列定义如下所示:

Widgets (WidgetID int PK, WidgetName varchar(50))
Anvils (AnvilID int PK, WidgetID int FK/IX/UNIQUE, ...)
AnvilTestData (AnvilID int FK/IX, TestID int, ...Test Data...)
WidgetHistory (HistoryID int PK, WidgetID int FK/IX, HistoryDate datetime, ...)
WidgetHistoryDetails (HistoryID int FK/IX, DetailType smallint, ...)

真的,没什么可怕的.A Widget可以是不同的类型,a Anvil是特殊类型,因此关系是1:1(或更准确地说是1:0..1).然后是大量的数据 - 可能随着时间的推移AnvilTestData每次Anvil收集数千行,处理硬度,腐蚀,精确重量,锤子兼容性,可用性问题以及卡通头的冲击测试.

然后每个人Widget都有各种类型交易的漫长而枯燥的历史 …

也许这是一个天真的问题...但我认为我们应该总是有级联删除和更新.但我想知道它是否有问题,何时不应该这样做？我现在真的想不到一个你不想进行级联删除的情况,但我确信有一个......但更新应该如何进行呢？

那么任何人都可以列出级联删除和更新的优缺点吗？谢谢.

这就是我想要做的.

1. 创建与子项具有OneToOne关系的父级
2. 父级必须使用延迟加载来获取子级
3. 如果父母被移除,那么孩子也是如此
4. 如果孩子被移除,父母不应受到影响
5. 级联更新和删除必须转换为DDL

班级家长

@OneToOne(mappedBy = "parent", cascade = CascadeType.ALL)
public Child getChild()

班级孩子

@OneToOne(fetch = FetchType.LAZY)
@OnDelete(action = OnDeleteAction.CASCADE)
@JoinColumn(name="parent_id")
public Parent getParent()

我有点1,3,4完全工作,第5点部分工作,仍然需要解决如何翻译更新部分indo DDL.

第2点是这里的一个大问题,我目前的解决方案是父母不会懒惰加载孩子.然而,孩子懒得加载父母,但是反转注释会使级联变得混乱(第3,4和5点).

我现在很困惑,希望我错过了一些明显的东西,所以任何帮助都会非常感激.

编辑: Adeel Ansari要求的代码

'fetch = FetchType.LAZY'已添加到类Parent,否则与上面相同.

IParentDAO parentDAO = DAOFactory.getFactory().getParentDAO();

parentDAO.beginTransaction();
//findByPrimaryKey uses 'org.hibernate.Session.get(Class clazz, Serializable id)'
parentDAO.findByPrimaryKey(1l);
parentDAO.commitTransaction();

生成的hibernate查询,一个获取Parent,一个获取Child:

Hibernate: select parent0_.id as id0_0_ from parents parent0_ where parent0_.id=?
Hibernate: select child0_.id as id1_0_, child0_.parent_id as parent2_1_0_ from childs child0_ where …

我有一个关于Hibernate的一般性问题,我正在与之斗争.

我有A级和B级,其中B依赖于A.

在我的代码中,当我调用em.persist(objOfTypeA)时,我希望插入并插入到表AAA和BBB中.如果我手动预先判断A获取A的ID并将其填入每个对象的列表中然后保留该列表,那么事情就有效了.但是我希望Hibernate 会神奇地发生这种情况.

难道我做错了什么？或者我只是期待太多的Hibernate？

谢谢

@Entity
@Table(name = "AAA")
@Veto
public class A {

    @Id
    @GeneratedValue
    @Column(name = "Id")
    private Long id;


    @NotNull
    @Column(name = "Name")
    private Long name;

    ...

    @OneToMany(mappedBy="a", fetch=FetchType.LAZY, cascade={CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REMOVE})
    private List<B> b;
...
}

@Entity
@Table(name = "BBB")
@Veto
public class B {

    @Id
    @GeneratedValue
    @Column(name="Id")
    private Long id;

    @NotNull
    @Column(name="AId")
    private Long aId;

    @NotNull
    @Column(name = "Name")
    private Long name;

    @JoinColumn(name = "AId", referencedColumnName="Id", updatable = false, insertable = false) …

我正在尝试在SQL Server中的同一个表之间创建多对多关系.

我有一个表Object的列ObjectId和Name.

这种关系遵循以下规则:

• 一个孩子可以有很多父母
• 父母可以有很多孩子
• ObjectA可以是ObjectB的子节点,ObjectB可以是ObjectA的子节点
• 但是一个物体本身不能成为直接的孩子

所以我创建第二个表格ObjectRelation的列ParentId和ChildId,当然我希望这些关系通过级联删除.

但是当我在SQL Server中尝试这个时,我得到了错误

在表'tblADMembership'上引入FOREIGN KEY约束'FK_ObjectRelation_Object1'可能会导致循环或多个级联路径.指定ON DELETE NO ACTION或ON UPDATE NO ACTION,或修改其他FOREIGN KEY约束.

在SQL Server Compact中我得到了

引用关系将导致不允许循环引用.

我做了一些研究,我理解为什么会出现这些错误,但有没有办法解决这个问题,这也适用于SQL Server Compact(所以没有存储过程)？或者有更好的方法来建立这种关系吗？

@Entity
@Table(name = "Section_INST")
public class Section {

@javax.persistence.Id
@GeneratedValue(strategy = GenerationType.SEQUENCE,generator = "Section_ID_GENERATOR")
@SequenceGenerator(name = "Section_ID_GENERATOR",sequenceName = "Section_ID_SEQUENCER" , initialValue = 1 , allocationSize = 1)
@Column(name = "Section_ID")
private int Id;

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

@OneToOne(optional = false,cascade = CascadeType.PERSIST)
@JoinColumn(name = "Exch_ID")
private Exchange exchange;

//---Constructor and Getter Setters-----
}


@Entity
@Table(name = "EXCHANGE_INST")
public class Exchange {

@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE,generator = "Exchange_ID_GENERATOR")
@SequenceGenerator(name = "Exchange_ID_GENERATOR",sequenceName = "Exchange_ID_SEQUENCER" , initialValue = 1 , allocationSize …

我有以下示例:

Table A
   -some_id

Table B
   -another_id

Table C
   -some_id_fk
   -another_id_fk

我想在级联排Table C如果双方some_id并another_id从各自的表被删除.

当删除两个外键时,如何在表C中自行级联？

如果仅删除其中一个FK,则受影响的行应在引用该外键的列中更改为空值.

我想删除两个表中的行,这两个表通过一组可延迟的约束相互依赖.为了简化这篇文章,我模拟了一个简单的数据库模式.

我希望在SQL事务/数据库补丁中删除某些表中的条目'delete_from_me'.问题是,我想在松开链接本身之前根据第二个表'constraining_table'中的选择进行删除.

这是两个表的描述:

tab-quarantine=> \d delete_from_me
       Table "public.delete_from_me"
  Column   |       Type        | Modifiers 
-----------+-------------------+-----------
 id        | character varying | not null
 extension | character varying | not null
Indexes:
    "delete_from_me_pkey" PRIMARY KEY, btree (id)

tab-quarantine=> \d constraining_table 
   Table "public.constraining_table"
 Column |       Type        | Modifiers 
--------+-------------------+-----------
 image  | character varying | not null
 type   | character varying | not null
Foreign-key constraints:
    "constraining_table_image_fkey" FOREIGN KEY (image) REFERENCES delete_from_me(id)
         ON UPDATE CASCADE
         ON DELETE RESTRICT DEFERRABLE

这是我刚刚在那里抨击的一些示例数据:

tab-quarantine=> SELECT * FROM delete_from_me; …

我对Hibernate很陌生,一直试图确定它将为你做什么以及它需要你做什么.

一个重要的是处理具有数据库中尚不存在的依赖项的对象.例如,我有一个Project对象,其中包含一个Manufacturer字段,该字段接受Manufacturer对象作为其值.在数据库中,我有一个带有mfr_id列的产品表,该列是对manufacturer表的引用(一种相当典型的单向一对多关系).

如果分配给产品对象的制造商与已经存在于数据库中的制造商有关,则没有问题.但是,当我尝试保存或更新引用尚未持久化的制造商的对象时,操作将失败并出现异常.

线程"Application"中的异常org.hibernate.TransientObjectException:对象引用未保存的瞬态实例 - 在刷新之前保存瞬态实例

我当然可以手动检查产品制造商的状态,看看它的ID字段是否为空,如果是,则将其保存,但这似乎是一个麻烦的解决方案.如果尚未保留相关的依赖项,Hibernate是否支持自动持久的依赖项？如果是这样,我该如何启用该行为？我正在使用与Netbeans捆绑的Hibernate版本(我相信3.5)和用于指定映射行为的内联注释.以下是我的产品和制造商类,减少了处理依赖关系的部分.(产品扩展为Sellable,映射到可销售的表,使用JOINED作为继承策略.该表包含标识产品的主键)

@Entity
@Table (
        name="products",
        schema="sellable"
)
public abstract class Product extends Sellable {
    private Manufacturer                        manufacturer;

    @ManyToOne (fetch = FetchType.EAGER)
    @JoinColumn (name = "mfr_id")
    public Manufacturer getManufacturer () {
        return this.manufacturer;
    }

    /**
     * 
     * @param manufacturer 
     */
    public Product setManufacturer (Manufacturer manufacturer) {
        this.manufacturer   = manufacturer;
        return this;
    }
}

依赖制造商

@Entity
@Table (
        name="manufacturers",
        schema="sellable",
        uniqueConstraints = @UniqueConstraint(columnNames="mfr_name") 
)
public class Manufacturer implements Serializable {
    private Integer         mfrId       = null;
    private …