Php 教义2：正确使用

嗯，可能是因为今天是星期一，可能是因为一些和我一起工作的人在干扰我的大脑，但我需要问一个完全是新手的问题，这可能会解决一些头疼的问题

使用Doctrine2映射，我们可以在EntityManager和数据库中设置级联参数

在这种情况下，我们有一个

用户

和

客户端

。一个

用户

属于

客户端

，但一个

客户端

可以有多个

用户

当我们删除

客户端

时，必须将其

用户

的

客户端id

设置为

空

当我们删除

用户

时，它只删除该

用户

用户实体

manyToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        inversedBy: users
        joinColumn:
            name: client_id
            referencedColumnName: id
            onDelete: SET NULL
        cascade: ["persist"]

oneToMany:
    users:
        targetEntity: AppBundle\Entity\User
        mappedBy: client
        cascade: ["persist", "remove"]

oneToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        cascade: ["persist", "remove"]
        inversedBy: shop
        joinColumn:
            name: client_id
            referencedColumnName: id

oneToOne:
    shop:
        targetEntity: AppBundle\Entity\Shop
        mappedBy: client
        cascade: ["persist", "remove"]

manyToMany:
    phones:
        targetEntity: AppBundle\Entity\Phone
        cascade: ["persist", "remove"]
        joinTable:
            name: client_has_phone
            joinColumns:
                client_id:
                    referencedColumnName: id
                    onDelete: CASCADE
            inverseJoinColumns:
                phone_id:
                    referencedColumnName: id
                    onDelete: CASCADE

oneToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        cascade: ["persist", "remove"]
        mappedBy: shop

oneToOne:
    shop:
        targetEntity: AppBundle\Entity\Shop
        inversedBy: client
        joinColumn:
            name: shop_id
            referencedColumnName: id
            onDelete: SET NULL
        cascade: ["persist"]

客户实体

manyToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        inversedBy: users
        joinColumn:
            name: client_id
            referencedColumnName: id
            onDelete: SET NULL
        cascade: ["persist"]

oneToMany:
    users:
        targetEntity: AppBundle\Entity\User
        mappedBy: client
        cascade: ["persist", "remove"]

oneToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        cascade: ["persist", "remove"]
        inversedBy: shop
        joinColumn:
            name: client_id
            referencedColumnName: id

oneToOne:
    shop:
        targetEntity: AppBundle\Entity\Shop
        mappedBy: client
        cascade: ["persist", "remove"]

manyToMany:
    phones:
        targetEntity: AppBundle\Entity\Phone
        cascade: ["persist", "remove"]
        joinTable:
            name: client_has_phone
            joinColumns:
                client_id:
                    referencedColumnName: id
                    onDelete: CASCADE
            inverseJoinColumns:
                phone_id:
                    referencedColumnName: id
                    onDelete: CASCADE

oneToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        cascade: ["persist", "remove"]
        mappedBy: shop

oneToOne:
    shop:
        targetEntity: AppBundle\Entity\Shop
        inversedBy: client
        joinColumn:
            name: shop_id
            referencedColumnName: id
            onDelete: SET NULL
        cascade: ["persist"]

这种映射应该可以通过从EntityManager中使用

删除
和从数据库中使用
删除
来处理上述情况，对吗

我们有另一个例子，使用
oneToOne
关系。在这种情况下，我们有一个
客户
和一个
商店
实体。一个
客户
只能有一个
商店
和一个反之亦然

当我们删除
客户
时，其
商店
也必须删除

当我们删除
商店
时，它必须将其关系设置为
NULL
，但由于我们在
商店
上没有相反的一面，所以什么也没有发生，我们在
客户
上有它，因此拥有
客户id的是
商店

商店实体

manyToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        inversedBy: users
        joinColumn:
            name: client_id
            referencedColumnName: id
            onDelete: SET NULL
        cascade: ["persist"]

oneToMany:
    users:
        targetEntity: AppBundle\Entity\User
        mappedBy: client
        cascade: ["persist", "remove"]

oneToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        cascade: ["persist", "remove"]
        inversedBy: shop
        joinColumn:
            name: client_id
            referencedColumnName: id

oneToOne:
    shop:
        targetEntity: AppBundle\Entity\Shop
        mappedBy: client
        cascade: ["persist", "remove"]

manyToMany:
    phones:
        targetEntity: AppBundle\Entity\Phone
        cascade: ["persist", "remove"]
        joinTable:
            name: client_has_phone
            joinColumns:
                client_id:
                    referencedColumnName: id
                    onDelete: CASCADE
            inverseJoinColumns:
                phone_id:
                    referencedColumnName: id
                    onDelete: CASCADE

oneToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        cascade: ["persist", "remove"]
        mappedBy: shop

oneToOne:
    shop:
        targetEntity: AppBundle\Entity\Shop
        inversedBy: client
        joinColumn:
            name: shop_id
            referencedColumnName: id
            onDelete: SET NULL
        cascade: ["persist"]

客户实体

manyToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        inversedBy: users
        joinColumn:
            name: client_id
            referencedColumnName: id
            onDelete: SET NULL
        cascade: ["persist"]

oneToMany:
    users:
        targetEntity: AppBundle\Entity\User
        mappedBy: client
        cascade: ["persist", "remove"]

oneToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        cascade: ["persist", "remove"]
        inversedBy: shop
        joinColumn:
            name: client_id
            referencedColumnName: id

oneToOne:
    shop:
        targetEntity: AppBundle\Entity\Shop
        mappedBy: client
        cascade: ["persist", "remove"]

manyToMany:
    phones:
        targetEntity: AppBundle\Entity\Phone
        cascade: ["persist", "remove"]
        joinTable:
            name: client_has_phone
            joinColumns:
                client_id:
                    referencedColumnName: id
                    onDelete: CASCADE
            inverseJoinColumns:
                phone_id:
                    referencedColumnName: id
                    onDelete: CASCADE

oneToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        cascade: ["persist", "remove"]
        mappedBy: shop

oneToOne:
    shop:
        targetEntity: AppBundle\Entity\Shop
        inversedBy: client
        joinColumn:
            name: shop_id
            referencedColumnName: id
            onDelete: SET NULL
        cascade: ["persist"]

据我所知，此映射将中断，因为它将在删除
Shop
时删除
Client
记录，这不应该发生，因为我们只希望删除
Shop
，而不是同时删除两者

最后，但并非最不重要的是，我们有一个
oneToMany
单向关系，它变成了一个
manyToMany
连接表，它可能有一个带有额外字段的实体，但我们将使用一个简单的关系

Client
有
Phone
，但由于它是一个
多个
关系，这意味着n
Client
可以有n
Phone
，反之则是一个名为
Client\u has\u Phone
的联接表

当我们删除一个
电话
时，我们希望从连接表
客户机\u has\u电话
中删除该关系。当我们删除一个
客户机时也会发生同样的情况，这种关系将永远消失

客户实体

manyToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        inversedBy: users
        joinColumn:
            name: client_id
            referencedColumnName: id
            onDelete: SET NULL
        cascade: ["persist"]

oneToMany:
    users:
        targetEntity: AppBundle\Entity\User
        mappedBy: client
        cascade: ["persist", "remove"]

oneToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        cascade: ["persist", "remove"]
        inversedBy: shop
        joinColumn:
            name: client_id
            referencedColumnName: id

oneToOne:
    shop:
        targetEntity: AppBundle\Entity\Shop
        mappedBy: client
        cascade: ["persist", "remove"]

manyToMany:
    phones:
        targetEntity: AppBundle\Entity\Phone
        cascade: ["persist", "remove"]
        joinTable:
            name: client_has_phone
            joinColumns:
                client_id:
                    referencedColumnName: id
                    onDelete: CASCADE
            inverseJoinColumns:
                phone_id:
                    referencedColumnName: id
                    onDelete: CASCADE

oneToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        cascade: ["persist", "remove"]
        mappedBy: shop

oneToOne:
    shop:
        targetEntity: AppBundle\Entity\Shop
        inversedBy: client
        joinColumn:
            name: shop_id
            referencedColumnName: id
            onDelete: SET NULL
        cascade: ["persist"]

这个映射在EntityManager和数据库中都应该是正常的

我想就此给出一些建议，因为我确信事情会像我上面解释的那样进行，但可能我错了，
原则
文档没有得到很好的解释（至少在这一部分）

而且，考虑到案例和示例映射，如果有错误，我想给出一个工作代码，以便改进我们的内容并告诉我的同事

谢谢。
这是三个问题合一，但你要问的是：

cascade=remove
将删除正在删除的
客户端的所有
用户
s，否则看起来可以

考虑这一点：
商店实体

manyToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        inversedBy: users
        joinColumn:
            name: client_id
            referencedColumnName: id
            onDelete: SET NULL
        cascade: ["persist"]

oneToMany:
    users:
        targetEntity: AppBundle\Entity\User
        mappedBy: client
        cascade: ["persist", "remove"]

oneToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        cascade: ["persist", "remove"]
        inversedBy: shop
        joinColumn:
            name: client_id
            referencedColumnName: id

oneToOne:
    shop:
        targetEntity: AppBundle\Entity\Shop
        mappedBy: client
        cascade: ["persist", "remove"]

manyToMany:
    phones:
        targetEntity: AppBundle\Entity\Phone
        cascade: ["persist", "remove"]
        joinTable:
            name: client_has_phone
            joinColumns:
                client_id:
                    referencedColumnName: id
                    onDelete: CASCADE
            inverseJoinColumns:
                phone_id:
                    referencedColumnName: id
                    onDelete: CASCADE

oneToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        cascade: ["persist", "remove"]
        mappedBy: shop

oneToOne:
    shop:
        targetEntity: AppBundle\Entity\Shop
        inversedBy: client
        joinColumn:
            name: shop_id
            referencedColumnName: id
            onDelete: SET NULL
        cascade: ["persist"]

客户实体

manyToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        inversedBy: users
        joinColumn:
            name: client_id
            referencedColumnName: id
            onDelete: SET NULL
        cascade: ["persist"]

oneToMany:
    users:
        targetEntity: AppBundle\Entity\User
        mappedBy: client
        cascade: ["persist", "remove"]

oneToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        cascade: ["persist", "remove"]
        inversedBy: shop
        joinColumn:
            name: client_id
            referencedColumnName: id

oneToOne:
    shop:
        targetEntity: AppBundle\Entity\Shop
        mappedBy: client
        cascade: ["persist", "remove"]

manyToMany:
    phones:
        targetEntity: AppBundle\Entity\Phone
        cascade: ["persist", "remove"]
        joinTable:
            name: client_has_phone
            joinColumns:
                client_id:
                    referencedColumnName: id
                    onDelete: CASCADE
            inverseJoinColumns:
                phone_id:
                    referencedColumnName: id
                    onDelete: CASCADE

oneToOne:
    client:
        targetEntity: AppBundle\Entity\Client
        cascade: ["persist", "remove"]
        mappedBy: shop

oneToOne:
    shop:
        targetEntity: AppBundle\Entity\Shop
        inversedBy: client
        joinColumn:
            name: shop_id
            referencedColumnName: id
            onDelete: SET NULL
        cascade: ["persist"]

现在，当
Shop
被删除时，DB的
ON DELETE
设置
NULL
，当
客户端被删除时，Doctrine的
cascade=remove
将删除
Shop

我觉得还可以