关联的学说2继承映射

问题描述

| 注意：如果我想要的是不可能的，将接受“不可能”的答案 在有关继承映射的Doctrine 2文档中，它说有两种方法： 单表继承（STI） 类表继承（CTI） 对于两者，都有警告： 如果您将STI / CTI实体用作多对一或一对一实体，则永远不要将继承层次结构较高级别的类之一用作“ targetEntity”，仅将那些没有子类的类用作“ targetEntity”。否则，Doctrine无法创建该实体的代理实例，并将始终热切加载该实体。 因此，如何继续使用与基类（抽象类）关联的继承？ （并保持表现当然） 例 用户有许多“ 0”（抽象类扩展了“ 1”或“ 2”）。 我想做的事 ：

class User {
    /**
     * @var array(Pet) (array of Dog or Cat)
     */
    private $pets;
}

由于Doctrine文档中的警告，我应该这样做：

class User {
    /**
     * @var array(Dog)
     */
    private $dogs;
    /**
     * @var array(Cat)
     */
    private $cats;
}

这很烦人，因为我失去了继承的好处！ 注意：我没有为数据库映射添加Doctrine注释，但是您可以理解我的意思

解决方法

我很累，但这似乎无济于事。 您错过了该警告的重要部分： 如果您将STI / CTI实体用作多对一或一对一实体 在您的示例中情况并非如此！如果您没有省略该学说注释，您可能已经注意到。 关联User :: pets是OneToMany，而不是[One | Many] ToOne。一个用户有很多宠物。 反向关联是OneToOne，但它的对象是User，没有继承。 Robin的答案应该是一个很好的提示-您可以记录sql查询并查看该理论实际上对您的数据库有何作用！ 性能不佳的情况如下：

abstract class Pet { ... }

class Cat extends Pet { ... } 

class Dog extends Pet { ... }

class Collar {
   /**
    * @Column(length=\"16\")
    */

   protected $color;
   /**
    * ManyToOne(targetEntity=\"Pet\")
    */
   protected $owner;
}

现在，如果您想遍历所有蓝领，Doctrine就会遇到麻烦。它不知道$ owner将是什么类，因此它不能使用代理。相反，它被迫热切地加载$ owner来确定它是猫还是狗。 对于OneToMany或ManyToMany关系而言，这不是问题，因为在这种情况下，延迟加载可以正常工作。代替代理，您将获得一个PersistentCollection。而且PersistentCollection始终只是PersistentCollection。在您真正要求它们之前，它并不关心它自己的内容。因此，延迟加载可以正常工作。,我认为您误会了，所引用的手册部分标题为“性能影响”，它们并不是在告诉您您不能这样做，只是告诉您，如果您这样做会影响性能。做。这对于延迟加载很有意义-对于STI实体的异构集合，您必须先进入数据库并加载该实体，然后才能知道它将是什么类，因此延迟加载是不可能的/毫无意义的。我目前正在自己​​学习《教义2》，因此我模拟了您的示例，以下内容可以正常使用：

namespace Entities;

/**
 * @Entity
 * @Table(name=\"pets\")
 * @InheritanceType(\"SINGLE_TABLE\")
 * @DiscriminatorColumn(name=\"pet_type\",type=\"string\")
 * @DiscriminatorMap({\"cat\" = \"Cat\",\"dog\" = \"Dog\"})
 */
class Pet
{
    /** @Id @Column(type=\"integer\") @generatedValue */
    private $id;

    /** @Column(type=\"string\",length=300) */
    private $name;

    /** @ManyToOne(targetEntity=\"User\",inversedBy=\"id\") */
    private $owner;
}


/** @Entity */
class Dog extends Pet
{

    /** @Column(type=\"string\",length=50) */
    private $kennels;
}

/** @Entity */
class Cat extends Pet
{
    /** @Column(type=\"string\",length=50) */
    private $cattery;
}

/**
 * @Entity
 * @Table(name=\"users\")
 */
class User
{

    /** @Id @Column(type=\"integer\") @generatedValue */
    private $id;

    /** @Column(length=255,nullable=false) */
    private $name;


    /** @OneToMany(targetEntity=\"Pet\",mappedBy=\"owner\") */
    private $pets;
}

...和测试脚本....

if (false) {
    $u = new Entities\\User;
    $u->setName(\"Robin\");

    $p = new Entities\\Cat($u,\'Socks\');
    $p2 = new Entities\\Dog($u,\'Rover\');

    $em->persist($u);
    $em->persist($p);
    $em->persist($p2);
    $em->flush();
} else if (true) {
    $u = $em->find(\'Entities\\User\',1);
    foreach ($u->getPets() as $p) {
        printf(\"User %s has a pet type %s called %s\\n\",$u->getName(),get_class($p),$p->getName());
    }
} else {
    echo \"  [1]\\n\";
    $p = $em->find(\'Entities\\Cat\',2);
    echo \"  [2]\\n\";
    printf(\"Pet %s has an owner called %s\\n\",$p->getName(),$p->getOwner()->getName());
}

我所有的猫和狗都加载为正确的类型： 如果查看生成的SQL，您会注意到，当OneToMany targetEntity为\“ pet \”时，您将获得如下SQL：

SELECT t0.id AS id1,t0.name AS name2,t0.owner_id AS owner_id3,pet_type,t0.cattery AS cattery4,t0.kennels AS kennels5 FROM pets t0 
WHERE t0.owner_id = ? AND t0.pet_type IN (\'cat\',\'dog\')

但是将其设置为Cat时，您会得到以下信息：

SELECT t0.id AS id1,t0.cattery AS cattery3,t0.owner_id 
AS owner_id4,pet_type FROM pets t0 WHERE t0.owner_id = ? AND t0.pet_type IN (\'cat\')

HTH。