尝试在Django中加入OneToOne关系
在Django中，可以通过使用OneToOneField来实现一对一关系。一对一关系是指两个模型之间存在唯一的关联关系，其中一个模型的实例只能与另一个模型的实例关联。
在Django中加入OneToOne关系的步骤如下：
- 定义两个需要关联的模型，例如模型A和模型B。
- 在其中一个模型中，使用OneToOneField字段来定义与另一个模型的关联关系。例如，在模型A中，可以添加一个OneToOneField字段，指向模型B。
- 在模型B中，可以使用ForeignKey字段来定义与模型A的关联关系，从而实现双向关联。
下面是一个示例：
from django.db import models
class ModelA(models.Model):
# 模型A的字段
...
class ModelB(models.Model):
model_a = models.OneToOneField(ModelA, on_delete=models.CASCADE)
# 模型B的字段
...在上面的示例中，模型B通过OneToOneField字段model_a与模型A建立了一对一关系。on_delete=models.CASCADE表示当模型A的实例被删除时，与之关联的模型B的实例也会被删除。
OneToOne关系的优势在于可以将两个模型之间的关联关系明确化，并且可以通过模型的属性直接访问关联的对象。这种关系常用于用户扩展、配置扩展等场景。
在腾讯云的产品中，可以使用云数据库MySQL、云服务器等产品来支持Django应用的部署和数据库存储。具体产品介绍和链接如下：
- 云数据库MySQL：腾讯云提供的高可用、可扩展的云数据库服务，适用于存储Django应用的数据。详情请参考：云数据库 MySQL
- 云服务器：腾讯云提供的弹性计算服务，可用于部署Django应用。详情请参考：云服务器
希望以上信息能对您有所帮助！
相关·内容
1回答
实体：
实体Miejsce
class Miejsce
{
/**
*
* @var Lokalizacja $lokalizacja
* @ORM\OneToOne(targetEntity="Miejsce\LokalizacjaBundle\Entity\Lokalizacja",cascade={"persist"})
* @ORM\JoinColumn(name="id", referencedColumnName="miejsce_id")
*/
protected $lokalizacja;
实体Lo
浏览 1提问于2014-01-31得票数 0
回答已采纳
1回答
对于单表继承，我有一个问题，我不确定我是否正确地解释了文档。
First:我在这里没有详细地复制代码/实体映射(甚至没有使用正确的语法)，因为我认为这个问题可以更抽象地进行沟通。如果这完全不能接受的话，我会添加完整的代码--但是它是很长的，我想我的问题可以不用它来回答。
如果有帮助的话，我可以画一个ER图来尝试和交流我想要做的事情。如果你读了下面的内容，并认为‘嘿，这应该有效’-然后告诉我，我会上传真正的代码
第二：，我在任何地方都不使用延迟加载。在访问实体之前，我要确保先编写DQL来加载将要访问的所有相关实体--因此，下面的问题对我的应用程序来说是非常重要的)
设置：
我有一些实体--它们构
浏览 3提问于2011-06-17得票数 3
回答已采纳
2回答
Django模型条件关系
、、、
新手问题: Django + Postgres + PostGIS
我正在尝试在Django中设置一个项目模型，它需要根据几何类型有条件地与几何模型相关。几何图形类型为:点、线或多边形。问题是我如何在项目模型中定义这种关系，以便我不必将不同的几何类型保存在同一个表中(因此有3个不同的几何模型)
=======================Here是我的模型============================
PRJ_GEOM = (
(1, "point"),
(2, "line"),
(3, "
浏览 2提问于2016-09-16得票数 1
回答已采纳
我是Django的新手，我想我对ORM有了基本的了解。然而，有一种特殊的情况，我看不到一个合理的解决方案。我有一个遗留数据库，我正在尝试为其编写一个Django应用程序。这两个表的sql结构是：
mysql> describe event;
+-----------+------------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-----------+------------------+------+-----+---
浏览 1提问于2011-09-15得票数 2
1回答
假设我有一个模型Profile，它通过带有unique=True关系的ForeignKey或OneToOne关系与标准User模型相关：
class Profile(models.Model):
user = (either a ForeignKey/OneToOne relationship)
...
如果我理解了文档，列的数据库表示将是user_id，来自Django自动添加_id。此user_id将包含一系列整数。
再次假设我在shell中实例化了此模型的一个对象，并尝试访问user属性：
a_profile = Profile()
a_profile.user
根据
浏览 0提问于2018-03-06得票数 0
3回答
我有一个与延迟加载OneToOne关联映射有关的问题。
案例1外键在子表中(地址)
@Entity
public class User {
..........
@OneToOne(mappedBy="user")
private Address address;
@Entity
public class Address{
.........
@OneToOne
@JoinColumn(name = "user_id")
private User user;
在上面的地址中，延迟加载不起作用。
案例2外
浏览 2提问于2015-10-09得票数 0
回答已采纳
我试图将对象的实例限制为仅供该对象通过OneToOneField引用的用户查看。我正在使用DetailView上的“DetailView”混音来将request.user与OnetoOne关系中的用户进行比较。我在django irc上得到了一些帮助，这导致我尝试并实现了get_object，但是我仍然被困住了(我是Django &Python新手)。
模型：
class Event(models.Model):
client = models.OneToOneField(settings.AUTH_USER_MODEL)
the View:
class EventD
浏览 2提问于2017-01-13得票数 3
回答已采纳
我有树实体：Client、ClientConfigurationA和ClientConfigurationB。 我试着做一些类似的东西： @Entity
@Table(name = "CLIENT")
public class Client {
@Id
private int id;
@OneToOne(mappedBy = "client")
private ClientConfiguration configuration
// some getter and setter
}
@MappedSuperCla
浏览 24提问于2019-05-29得票数 1
2回答
我已经创建了一个模型并在Django中迁移，其中一个字段具有唯一的键约束。现在，我正在尝试删除唯一的约束，用新的更改生成另一个迁移文件，但是它说“似乎什么都没有改变”。
我尝试使用命令python manage.py schemamigration --auto。
PS:我在字段中使用OnetoOne关系。
浏览 0提问于2018-02-26得票数 0
在Django中，我创建了一个新模型：
from django.db import models
from django.contrib.auth import user
class Workers(models.Model):
user = models.OneToOneField(User, primary_key=True)
work_group = models.CharField(max_length=20)
card_num = models.IntegerField()
def __unicode__(self):
浏览 1提问于2012-10-17得票数 85
回答已采纳
4回答
注意:主题是冗长但详细的，如果您使用Doctrine2和oneToOne关系，可能会派上用场。
最近我在理论上遇到了一个问题：
我创建了具有UserData双向关系的用户和oneToOne对象：
User:
...
oneToOne:
userdata:
targetEntity: UserData
mappedBy: user
UserData:
...
oneToOne:
user:
targetEntity: User
inversedBy: userdata
因此，UserData是拥有user_id列的一方：
浏览 7提问于2012-03-24得票数 23
我正在学习Udemy上使用Hibernate (和JPA)的持久性，演示者解释了前面讨论的关联(单向OneToOne、双向OneToOne、单向OneToMany、双向OneToMany)的替代方案，称为@JoinTable JPA注释。
他提到，有时“许多”实体中只有一小部分与特定类型的“一个”实体相关联，我们不希望“多”实体上的一个字段体现与“一个”实体的关联，因为在大多数情况下，该字段将保持为空。他接着为@JoinTable 推荐了。
我的问题是，考虑到@JoinTable选项对Java实体的影响，为什么不对“一个”实体使用单向@OneToMany注释，并将“多”实体保留为-原样呢？除了
浏览 2提问于2020-06-23得票数 0
回答已采纳
伙计们！
我有一个@OneToOne或@OneToMany问题。
这里有一个production表和一个price_list表。
production表中的产品具有price_list表中的价格。
但是price_list有一个产品的历史价格和当前价格，这意味着一个产品可以映射多个price_list记录。目前的价格是由字段status标记的，等于1。我的问题是如何使用@OneToOne或@OneToMany快速找到当前的价格，谢谢！
浏览 2提问于2017-04-07得票数 0
回答已采纳
我有一个带有OneToOne关系联系人和学生的两个表的springboot引导项目，学生有主键studentID和外键contactID，联系人有主键contactID。
@Data
@Table(name = "contacts")
public class Contact {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long ContactID;
@JsonBackReference
@OneToOne(mappedBy = "
浏览 5提问于2022-07-14得票数 0
我在上看了一段视频，老师说：
我们应该设置primary_key=True以防止模型在OneToOne关系中有重复的行(Ex:防止用户拥有多个配置文件)。
我知道这个说法是错的！AFAIK，OneToOne字段只是一个unique参数设置为True的ForeignKey。但我对Django文档感到好奇，并查阅了这些文档，可以肯定，它们在示例中使用的是primary=True。
class Place(models.Model):
name = models.CharField(max_length=50)
address = models.CharField(max_l
浏览 5提问于2021-09-04得票数 4
回答已采纳
在Django中，如果我有一个模型，比如一个与包含用户的(Django Auth)组相关的建筑物( OneToOne )，我如何找到用户所属的所有建筑物(也许这些建筑物就是用户工作的所有建筑物)？构建与Group是一对一的，因此构建有一个称为“group”的组外键字段。
我试过了
Building.objects.filter(group__contains=user)
Building.objects.filter(group_user_set__contains=user)
我没有得到匹配项，而应该有匹配项。
浏览 2提问于2013-01-26得票数 4
2回答
我的models.py：
from django.db import models
from django.contrib.auth.models import User
class SkillCategory(models.Model):
title = models.CharField(max_length=255)
def __unicode__(self):
return self.title
class Meta:
verbose_name_plural = "Skill Categories"
cl
浏览 2提问于2013-10-08得票数 0
回答已采纳
1回答
我正在用Hibernate框架用Kotlin语言编写代码。
表结构(OneToOne)：
我在BusinessTrip侧的实体：
@Entity
@Table(name = "business_trip")
open class BusinessTripEntity(
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "ID", nullable = false)
open var id: Long?,
@OneToOne(
浏览 6提问于2022-11-09得票数 0
假设我有一个本体和交叉游戏(抽搐脚趾)：
游戏
id crosses_player_id noughts_player_id...
players
id alignment game_id
由于只有两个球员，我认为没有必要创建一个单独的表，所以我这样做了：
@Entity
@Table(name = "games")
public class Game {
@Id @GeneratedValue
private int id;
@OneToOne(mappedBy = "game")
@JoinColum
浏览 5提问于2020-02-08得票数 0
3回答
在我的模型中，您可以看到我的SpecializedProfile与UserProfile具有OneToOne关系，与django用户模型具有OneToOne关系。
我想为包含UserProfile和django用户模型内联的SpecializedProfile创建一个admin，这样我就可以一次创建一个SpecializedProfile，而不需要转到UserProfile页面和用户页面。
这是我的模型：
class UserProfile(models.Model):
user_auth = models.OneToOneField(User, related_name="p
浏览 11提问于2014-11-01得票数 1
我有两个模型Owner和Entity与OneToOne关系。 class Owner(models.Model):
name = models.CharField(max_length=255)
.....
def __str__(self):
return self.name
class Entity(models.Model):
owner = models.OneToOneField(Owner, blank=True, null=True, on_delete=models.CASCADE)
name = models.Cha
浏览 21提问于2019-01-09得票数 0
回答已采纳
我试图理解两个实体之间的OneToOne映射。
我无法理解如何在mappedBy中指定OneToOne属性，使其成为双向关系。
UserID可嵌入类型：
@Embeddable
public class UserID implements Serializable {
private static final long serialVersionUID = 1L;
private int ssnID;
private int uniqueNum;
// getters and setters..
}
VehicleID可嵌入类型：
@Embeddable
p
浏览 2提问于2017-12-28得票数 0
回答已采纳
在Django项目中，我遇到了一个有趣的问题，我正在寻找最好和最健壮的解决方案。我希望有一个父对象，该对象由多个可以共享父对象的子类子类组成。
例如，我有以下类：
class Person(models.Model):
name = models.CharField(max_length=123)
class Farmer(Person):
pass
class Preacher(Person):
pass
有没有办法让一个人既是农民又是传道人？
如果这是不可能的或不合理的，那么更好的解决方案是在它们之间建立一个OneToOne关系，如下所示：
class Pers
浏览 1提问于2015-10-02得票数 1
回答已采纳
2回答
我有一个实体Article。在我的实体中，我有一个字段articleComment，在ArticleComment实体中有一个字段article。
代码如下：
class Article
{
/**
* @ORM\OneToOne(targetEntity="Project\MyBundle\Entity\ArticleComment", mappedBy="article", cascade={"persist"})
*/
private $articleComment;
// etc...
}
浏览 0提问于2015-09-29得票数 0
class Transaction implements Serializable {
@OneToOne(mappedBy = "transaction")
@JoinColumn(name = "invoice_id", nullable = false)
private InvoiceDetails invoice;
// some other columns, getter and setter
}
class InvoiceDetails implements Serializable {
@OneToO
浏览 6提问于2018-07-18得票数 0
回答已采纳
如下所示，我希望在另一个模型的管理更改视图(Event)中将一个模型()显示为TabularInline。然而，考勤并没有直接指向事件的ForeignKey。相反，它与OneToOne与注册有关系，后者反过来指向事件。有什么简单的方法来实现这一点吗？
从代码中可以看到，我尝试使用一个方法访问事件，并将它作为fk_name传递到TabularInline类，但是它抛出了一个错误：“myapp.Attendance”没有名为‘get_fk’的字段。
myapp/models.py
from django.db import models
class Event(models.Model):
浏览 5提问于2017-06-18得票数 2
6回答
让我们假设有一行代码可以使用Django ORM执行查询，其中包含一个非常长的“查找名称”：
QuerySet.filter(myfk__child__onetoone__another__manytomany__relation__monster__relationship__mycustomlookup=':P')
我想打破这条线，跟随，特别是
我知道我们可以做这样的事情：
QuerySet.filter(
**{
'myfk__child__onetoone__another'
'__manyto
浏览 6提问于2017-03-02得票数 15
回答已采纳
在 JPA示例中，有一个代码：
@OneToOne(cascade=CascadeType.ALL)
private Deity mother;
@OneToOne(cascade=CascadeType.ALL)
private Deity father;
@OneToMany(cascade=CascadeType.ALL)
private Set<Deity> children;
为什么与父母的关系是通过@OneToOne注释实现的，而不是在@ManyToOne关系中实现的？如果子类和父类是分开的，则父类具有@OneToMany Collection<Child&g
浏览 4提问于2009-10-19得票数 1
回答已采纳
我正在创建一个Django网络应用程序。我有一个名为vote的应用程序。我想“注册”这个应用程序通过一个OneToOne-关系到其他应用程序。例如，我有一个文章应用程序，我想“注册”投票：
vote = models.OneToOneField(Vote, on_delete=models.CASCADE, default=None, null=True)
我在文章中更改了保存方法：
def save(self, *args, **kwargs):
self.vote = Vote.objects.create()
super().save(*args, **kwargs)
问
浏览 0提问于2019-02-03得票数 2
回答已采纳
1回答
我在读的书。关于"@OneToOne单向“，作者以以下Customer，Address为例：
@Entity
public class Customer{
@Id @GeneratedValue
private Long id;
private String name;
private Address address;
//few other columns, getters/setters
}
@Entity
public class Address{
@Id @GeneratedValue
private Long id;
priv
浏览 3提问于2010-09-26得票数 1
回答已采纳
1回答
我正在尝试集成两个django应用程序，每个应用程序都有各自的作者工作。为此，我尝试对AbstractUser进行子类，而不是用户。我在跟踪和。我已经删除了我所有应用程序中的所有迁移文件，除了它们各自的init.py (包括位于我的站点包中的PyBB库中的迁移)。我还将Mysql数据库更改为空白数据库，以便重新启动，并且我正在尝试子类AbstractUser，如下所示。
我的Models.py：
from django.contrib.auth.models import User
from django.contrib.auth.models import AbstractUser
fro
浏览 1提问于2016-09-19得票数 0
我有两个实体有一个关系OneToOne，如下所示：
@Entity
@Table(name = "FOO")
Foo{
@OneToOne(fetch = FetchType.LAZY, mappedBy = "foo")
@Cascade({org.hibernate.annotations.CascadeType.ALL})
@JoinColumn(name = "BAR_ID")
private Bar bar;
// getters and setters
}
@Entity
@Conf
浏览 1提问于2017-03-27得票数 0
回答已采纳
1回答
我希望在同一个表中的两个实体字段之间有直接关系。
其想法是添加我的实体manager_id，它将指向user表中的另一个用户(我尝试过使用OneToOne )。
当用户调用操作时，例如，将消息发送给谁的user_id将被作为
$user->getManager()->getId()；
错误日志显示：
没有为字段ID找到映射.
class User
{
/**
* @ORM\Id
* @ORM\Column(type="integer")
* @ORM\GeneratedValue(strategy="AUTO
浏览 0提问于2019-07-23得票数 1
回答已采纳
我的django项目使用django-问讯台应用程序。此应用程序具有Ticket模型。
我的应用程序得到了一个Client模型，它应该与ticket有一对多的关系--例如，我可以列出关于特定客户的所有ticket。
通常我会将models.ForeignKey(Client)添加到Ticket中，但它是一个外部应用程序，我不想修改它(未来的更新问题等)。
我使用ManyToMany或OneToOne没有问题，但不知道如何使用ManyToOne (从外部应用程序到我的应用程序的一个客户端的许多票证)
浏览 1提问于2014-04-10得票数 5
我有一个Profile模型，它与User模型有OneToOne关系。我还有一个Group模型，它将users字段作为ManyToMany到User。
我正试图在Django Admin中实现一件简单的事情:能够创建一个有一些新用户的组，并允许为这些新用户填写一些配置文件字段。
我试了几件事
class ProfileInline(admin.StackedInline):
model = Profile
class UserInline(admin.StackedInline):
model = Group.users.through
inlines = [ Prof
浏览 4提问于2014-10-24得票数 0
回答已采纳
假设我有一个人
class Person{
@Id Integer id;
@OneToOne
@JoinColumn(name = "person_id")
Job myJob;
}
和作业
class Job{
@Id Integer id;
Integer person_id;
@OneToOne
@PrimaryKeyJoinColumn(name = "person_id")
Person currentWorker;
}
在获取时，我无法将Person和Job映射到其他实体。
浏览 1提问于2012-05-21得票数 4
回答已采纳
所以我试过的东西似乎都不起作用。我想要这样的东西：
class A {
B foo;
B bar;
}
class B {
A baz;
}
我在A班的尝试如下：
@OneToOne(targetEntity = B.class)
@JoinColumn(name = "foo_id")
@Cascade(CascadeType.ALL)
public B getFoo() {
return foo;
}
@OneToOne(targetEntity = B.class)
@JoinColumn(name = "bar_id&
浏览 2提问于2017-07-03得票数 1
回答已采纳
4回答
下面两个声明的确切区别是什么
B是拥有方
@Entity
class A {
@Id int id;
@OneToOne
B b;
}
@Entity
class B {
@Id int id;
@OneToOne(mappedBy="b")
A a;
}
A是拥有方
@Entity
class A {
@Id int id;
@OneToOne(mappedBy="a")
B b;
}
@Entity
class B {
@Id int id;
@OneToOne
A a;
}
浏览 1提问于2012-06-10得票数 9
回答已采纳
我有USER(id)和CONTACT(user_id，first，last)表。CONTACT.user_id是用户表的外键。
在User.java中：
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
@OneToOne(cascade = CascadeType.ALL)
@PrimaryKeyJoinColumn
private Contact contact;
在Contact.java中
@Id
@Column(name="USER_ID")
private Integ
浏览 1提问于2015-02-24得票数 1
1回答
我有一个django项目，其中我使用了一个插入自己模型的第三方扩展(类似于ExtensionApp.Model1和ExtensionApp.Model2)。
我需要做一些调整(特别是在那里添加几个新字段)。现在我所做的是在我自己的应用程序模型中将OneToOne字段添加到ExtensionApp.Model1，在那里我可以添加我需要的内容。我只是不想触及这个扩展应用的核心。
但我觉得这是不是正确的做法呢？有没有办法在现有的第三方app模型中添加新的字段？我知道有代理模型()，但它们允许添加新方法，而不是字段。
浏览 0提问于2020-06-08得票数 1
我正在为我的新django网站创建一个用户配置文件类，并且我正在尝试决定如何在我的模型中表示用户的物理地址。
创建一个新的模型子类并使用OneToOne键引用它是不是更好的做法
class UserProfile(models.Model):
...
address = models.OneToOneField(AddressModel)
...
class AddressModel(models.Model)
street_address = models.CharField(max_length=30)
city = models.CharField(
浏览 0提问于2011-08-03得票数 2
回答已采纳
1回答
我尝试将此查询转换为jpa我的sql原生查询。
SELECT *
FROM tripinfo ti
inner join car c on ti.carid = c.id
left join customerdetail cd on ti.customerid = cd.id
left join station s on ti.fromstxid = s.id
where ti.starttime is null or ti.stoptime is null
我的jpa查询
SELECT ti
FROM TripInfo ti
join ti.car
left join CustomerDe
浏览 0提问于2014-06-14得票数 0
我只用@OneToOne对我的字段进行了注释，当我检查数据库(使用液化库生成)时，发现数据库列上有唯一的约束。
这是否意味着@OneToOne本身就意味着独特性，例如。一座建筑只能在一座城市，而其他建筑不能在同一座城市？
当我想说在同一座城市里可能还有其他建筑物时，我该怎么办？
添加@JoinColumn(唯一= false)，
只使用@JoinColumn(唯一= false)而不使用@oneToOne，
还是使用@ManyToOne？
还是不带任何注解？
我不想在城市类中放置一个建筑物字段，因为我永远不会调用city.getBuildings()；。下面的任何内容是
浏览 3提问于2016-01-14得票数 3
我借鉴了答案的一些想法，扩展了在使用Django站点框架进行初始迁移期间创建的默认站点对象。新模型SiteSettings与站点模型建立OneToOne关系以添加附加字段。然后使用信号创建SiteSettings对象。
当我为SiteSettings模型进行第一次迁移时，一切看起来都很好。创建了一个与默认站点对象具有OneToOne关系的OneToOne对象。
然而，我没有注意到的是，在我的本地应用程序中并没有为此创建一个迁移文件。我能够进行移民并进行很好的迁移，所以我不知道迁移到哪里去了。它没有列在我的迁移表中。
不管怎么说，因为它起作用了我没注意到。然后，我在一两天后继续向SiteSett
浏览 5提问于2022-09-28得票数 0
回答已采纳
4回答
我的数据模型中有两个名为User和UserProfile的实体。下面是它们的映射方式。
来自用户实体的代码：
@OneToOne(cascade=CascadeType.ALL)
@PrimaryKeyJoinColumn
public UserProfile getUserProfile(){
return this.userProfile;
}
public void setUserProfile(UserProfile userProfile){
this.userProfile=userProfile;
}
来自UserProfile实体的代码：
@OneTo
浏览 2提问于2009-10-07得票数 11
注意:如果你想通过告诉我你不喜欢django.contrib.auth来“回答”这个问题，请继续。这不会有什么帮助。我很清楚在这个问题上意见的广度和强度。
现在，问题是：
约定是创建一个OneToOne to User的模型UserProfile。
在我能想到的每一种方式中，更有效和更有效的方法是将User细分为一个打算为系统中的每个人使用的类-一个称为Person(User)的类。
我没有看到一个连贯的解释，为什么前者是常规的，而后者被视为黑客。不久前，为了获得使用get_profile()的能力，我改用了OneToOne方法，从那以后我就后悔了。除非能让我理解这种方法的优点，否则我正在考虑
浏览 6提问于2011-03-28得票数 10
1回答
我想知道使用Hibernate进行数据库设计的最佳实践。
我有一个用户实体，它将有很多不同设置的。对于每一组设置，我要么将它们作为额外列添加到User表中，要么创建一个单独的实体，并将它们与@OneToOne关系连接。据我的理解，@OneToMany和@ManyToOne关系通常应该在单独的表中进行，因为您不应该有可选的列。
但是对于@OneToOne的关系还不太清楚。我认为使用@OneToOne是有理由的，因为在默认情况下，ORMs将选择所有单个属性，而拥有大量的列将减缓这个过程。
我所说的一个例子可以用
@Entity
public class User{
@OneToOne
priva
浏览 2提问于2017-07-28得票数 1
回答已采纳
我刚开始阅读JPA及其在Hibernate中的实现。为了更好地理解细节，我需要一些基本的澄清。
什么时候使用@OneToOne？
如果实体管理器需要处理相关对象的持久性，我可以使用@OneToOne。关键是，我总是可以在不指定@OneToOne的情况下生存，但是管理关系并确保所引用的对象不处于瞬态状态是我的责任。
这是真的吗？
何时使用，还是不使用@ManyToOne？
比如说，我正在定义一个雇员类，并且需要定义与雇主类的关系。在这种情况下，我是否需要按照下面的方式指定@ManyToOne？
@实体公共类雇主{ String name；} @Entity class Emplo
浏览 3提问于2010-07-16得票数 12
回答已采纳
我尝试创建一个带有继承的OneToOne关系：
abstract class A { }
class A1 extends A { }
class A2 extends A { }
class F {
/**
* @ORM\OneToOne( ? )
*/
private $object; // Could be of type A1 or A2
}
我想这样做：
$f = $em->getRepository('MyBundle:F')->findExample();
$object = $f->getObject();
浏览 0提问于2016-08-01得票数 0
1回答
我正在尝试用Django做一个LMS系统，现在我需要上传多个pdf文件到课程中。在Django模型中，我可以上传一个带有OnetoOne字段的文件，但不能上传更多。当我尝试为同一个类添加另一个材料时，它会显示Upload materials with this Uploaded class already exists.，这是我的模型代码。 class UploadMaterials(models.Model):
name = models.CharField(max_length=255)
uploaded_class = models.OneToOneField(Clas
浏览 54提问于2021-05-08得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
