教义插入 - 一对一的关系，无需reference_id

Question

我有两个实体，名为user和user_authentication。它们定义了单向关系。关系类型是一对一的。表示，用户实体与用户认证实体具有一对一的关系。

教义实体如下所示

/**
* User
*
* @ORMTable(name="user")
* @ORMEntity
*/
class User {
/**
* @var integer
*
* @ORMColumn(name="id", type="integer", nullable=false)
* @ORMId
* @ORMGeneratedValue(strategy="IDENTITY")
*/
private $id;
/**
* @var string
*
* @ORMColumn(name="first_name", type="string", length=40, nullable=false)
*/
private $firstName;
/**
* @var string
*
* @ORMColumn(name="last_name", type="string", length=40, nullable=true)
*/
private $lastName;
/**
* @var string
*
* @ORMColumn(name="gender", type="string", nullable=false)
*/
private $gender;
/**
* @var string
*
* @ORMColumn(name="availability", type="string", nullable=false)
*/
private $availability;

/**
* @ORMOneToOne(targetEntity="UserEntityUsersAuthentication", mappedBy="User", cascade={"persist"})
* @ORMJoinColumn(name="id", referencedColumnName="user_id")
*/
protected $authentication;

}

和

/**
* UsersAuthentication
*
* @ORMTable(name="users_authentication")
* @ORMEntity
*/
class UsersAuthentication {
/**
* @var integer
*
* @ORMColumn(name="id", type="integer", nullable=false)
* @ORMId
* @ORMGeneratedValue(strategy="IDENTITY")
*/
private $id;
/**
* @var integer
*
* @ORMColumn(name="user_id", type="integer", nullable=false)
*/
private $userId;
/**
* @var string
*
* @ORMColumn(name="email", type="string", length=255, nullable=false)
*/
private $email;
/**
* @var integer
*
* @ORMColumn(name="phone", type="integer", nullable=false)
*/
private $phone;
/**
* @var string
*
* @ORMColumn(name="password", type="string", length=64, nullable=false)
*/
private $password;
/**
* @var string
*
* @ORMColumn(name="token", type="string", length=128, nullable=false)
*/
private $token;
/**
* @var string
*
* @ORMColumn(name="type", type="string", nullable=false)
*/
private $type;
/**
* @var DateTime
*
* @ORMColumn(name="last_login", type="datetime", nullable=true)
*/
private $lastLogin;
}

我想一次性在用户和user_authentication中插入数据。例如，如下面的代码中所述，但它不起作用。

// Create new User entity.
$user = new User();
(isset($data->firstName))?$user->setFirstName($data->firstName):'';
(isset($data->lastName))?$user->setLastName($data->lastName):'';
(isset($data->gender))?$user->setGender($data->gender):'';        
(isset($data->availability))?$user->setAvailability($data->availability):'';

$userAuthEntity = new UsersAuthentication(); 
$userAuthEntity->setLastLogin($date);
(isset($data->email))?$userAuthEntity->setEmail($data->email):'';
(isset($data->password))?$userAuthEntity->setPassword($data->password):'';
(isset($data->phone))?$userAuthEntity->setPhone($data->phone):'';
(isset($data->type))?$userAuthEntity->setType($data->type):'';
$user->addAuthentication($userAuthEntity);
$this->entityManager->persist($user);
$this->entityManager->flush();

它给了我以下错误： SQLSTATE[23000]：完整性约束冲突：1048 列"user_id"不能为空

我正在尝试做的甚至可能吗？

====

======================================================阅读@rKeet和@zen答案后，我按照@rKeet的建议添加了双向映射，并将我的addUser代码更新为以下内容，并且它起作用了。荣誉。

$user = new User();
$user->setFirstName($data->firstName) : '';
$user->setLastName($data->lastName) : '';
$user->setGender($data->gender) : '';
$user->setAvailability($data->availability) : '';

$UA = new UsersAuthentication();
$UA->setActive(1);
$UA->setCreatedDate($date);
$UA->setEmail($data->email);
$UA->setModifiedDate($date);
$UA->setPassword($this->authManager->generate_hash($data->password));
$UA->setPhone($data->phone);
$UA->setType($data->type);
$UA->setUser($user);
$user->setAuthentication($UA);
$this->entityManager->persist($user);
$this->entityManager->flush();

Answer 1

您目前正在做的是以一种看起来像单向但也不是单向的方式设置双向一对一关系。

User对象上的"owner"属性是对Authentication对象的引用。您通过设置User在数据库中保存列来定义它。

您还希望同时创建这两个记录。因此，禅宗的阿斯纳韦尔是正确的：你必须让它级联持续存在。我假设您还想在删除用户时删除身份验证，因此您还必须级联持久化。(毕竟是一对一的(。

因此，然后设置它，您将在用户端拥有以下内容：

/**
* @var Authentcation
*
* @ORMOneToOne(targetEntity="UserEntityUsersAuthentication", inversedBy="user", cascade={"persist", "remove"})
* @ORMJoinColumn(name="id", referencedColumnName="user_id")
*/
protected $authentication;

在身份验证端，您将拥有：

/**
* @var User
*
* @ORMOneToOne(targetEntity="UserEntityUser", mappedBy="authentication", nullable=false)
*/
protected $user;

通知：

• 业主一方有inversedBy而不是mappedBy(父母/孩子之类的事情 - 很重要！在这里阅读(
• 在cascade选项中添加了"删除">
• 更改了inversedBy中的属性映射，引用属性，而不是列！(在身份验证端相同(
• 在$authentication属性上添加了身份验证类型(这适用于 PHP Storm 等 IDE(
• 将$userId属性更改为双向关系的另一端
• 将$userId更改为$user，因为它将保存User对象
• 设置返回目标映射而不是列映射

---

上面我已经让它工作了，但你应该反过来有关系。仅仅因为：没有身份验证，用户也可以存在，但没有用户，身份验证就不能存在。

因此，更好的关系设置是：

// User class
/**
* @var Authentication
*
* @ORMOneToOne(targetEntity="UserEntityUsersAuthentication", mappedBy="user", cascade={"persist", "remove"})
*/
protected $authentication;
// Authentication class
/**
* @var User
*
* @ORMOneToOne(targetEntity="UserEntityUser", inversedBy="authentication", nullable=false)
* @ORMJoinColumn(name="user_id", referencedColumnName="id")
*/
protected $user;

这也显示在Doctrine的链接双向文档中。下面是这个例子：

/** @Entity */
class Customer
{
// ...
/**
* One Customer has One Cart.
* @OneToOne(targetEntity="Cart", mappedBy="customer")
*/
private $cart;
// ...
}
/** @Entity */
class Cart
{
// ...
/**
* One Cart has One Customer.
* @OneToOne(targetEntity="Customer", inversedBy="cart")
* @JoinColumn(name="customer_id", referencedColumnName="id")
*/
private $customer;
// ...
}

Answer 2

如果您使用的是单向关系，那么在User模型中，您需要设置

/**
* @ORMOneToOne(targetEntity="UserEntityUsersAuthentication", cascade={"persist"})
*/
protected $authentication;

并且您需要删除UsersAuthentication实体中的userId属性。